]> git.ipfire.org Git - thirdparty/gcc.git/blame_incremental - gcc/c-common.c
projects / thirdparty / gcc.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
re PR tree-optimization/23329 (hack in may_propagate_copy should be able to removed)
[thirdparty/gcc.git] / gcc / c-common.c
... / ...
CommitLineData
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 "tm_p.h"
37#include "obstack.h"
38#include "cpplib.h"
39#include "target.h"
40#include "langhooks.h"
41#include "tree-inline.h"
42#include "c-tree.h"
43#include "toplev.h"
44#include "diagnostic.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/* If GCC knows the exact uint_least16_t and uint_least32_t types from
73 <stdint.h>, use them for char16_t and char32_t. Otherwise, use
74 these guesses; getting the wrong type of a given width will not
75 affect C++ name mangling because in C++ these are distinct types
76 not typedefs. */
77
78#ifdef UINT_LEAST16_TYPE
79#define CHAR16_TYPE UINT_LEAST16_TYPE
80#else
81#define CHAR16_TYPE "short unsigned int"
82#endif
83
84#ifdef UINT_LEAST32_TYPE
85#define CHAR32_TYPE UINT_LEAST32_TYPE
86#else
87#define CHAR32_TYPE "unsigned int"
88#endif
89
90#ifndef WCHAR_TYPE
91#define WCHAR_TYPE "int"
92#endif
93
94/* WCHAR_TYPE gets overridden by -fshort-wchar. */
95#define MODIFIED_WCHAR_TYPE \
96 (flag_short_wchar ? "short unsigned int" : WCHAR_TYPE)
97
98#ifndef PTRDIFF_TYPE
99#define PTRDIFF_TYPE "long int"
100#endif
101
102#ifndef WINT_TYPE
103#define WINT_TYPE "unsigned int"
104#endif
105
106#ifndef INTMAX_TYPE
107#define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
108 ? "int" \
109 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
110 ? "long int" \
111 : "long long int"))
112#endif
113
114#ifndef UINTMAX_TYPE
115#define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
116 ? "unsigned int" \
117 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
118 ? "long unsigned int" \
119 : "long long unsigned int"))
120#endif
121
122/* There are no default definitions of these <stdint.h> types. */
123
124#ifndef SIG_ATOMIC_TYPE
125#define SIG_ATOMIC_TYPE ((const char *) NULL)
126#endif
127
128#ifndef INT8_TYPE
129#define INT8_TYPE ((const char *) NULL)
130#endif
131
132#ifndef INT16_TYPE
133#define INT16_TYPE ((const char *) NULL)
134#endif
135
136#ifndef INT32_TYPE
137#define INT32_TYPE ((const char *) NULL)
138#endif
139
140#ifndef INT64_TYPE
141#define INT64_TYPE ((const char *) NULL)
142#endif
143
144#ifndef UINT8_TYPE
145#define UINT8_TYPE ((const char *) NULL)
146#endif
147
148#ifndef UINT16_TYPE
149#define UINT16_TYPE ((const char *) NULL)
150#endif
151
152#ifndef UINT32_TYPE
153#define UINT32_TYPE ((const char *) NULL)
154#endif
155
156#ifndef UINT64_TYPE
157#define UINT64_TYPE ((const char *) NULL)
158#endif
159
160#ifndef INT_LEAST8_TYPE
161#define INT_LEAST8_TYPE ((const char *) NULL)
162#endif
163
164#ifndef INT_LEAST16_TYPE
165#define INT_LEAST16_TYPE ((const char *) NULL)
166#endif
167
168#ifndef INT_LEAST32_TYPE
169#define INT_LEAST32_TYPE ((const char *) NULL)
170#endif
171
172#ifndef INT_LEAST64_TYPE
173#define INT_LEAST64_TYPE ((const char *) NULL)
174#endif
175
176#ifndef UINT_LEAST8_TYPE
177#define UINT_LEAST8_TYPE ((const char *) NULL)
178#endif
179
180#ifndef UINT_LEAST16_TYPE
181#define UINT_LEAST16_TYPE ((const char *) NULL)
182#endif
183
184#ifndef UINT_LEAST32_TYPE
185#define UINT_LEAST32_TYPE ((const char *) NULL)
186#endif
187
188#ifndef UINT_LEAST64_TYPE
189#define UINT_LEAST64_TYPE ((const char *) NULL)
190#endif
191
192#ifndef INT_FAST8_TYPE
193#define INT_FAST8_TYPE ((const char *) NULL)
194#endif
195
196#ifndef INT_FAST16_TYPE
197#define INT_FAST16_TYPE ((const char *) NULL)
198#endif
199
200#ifndef INT_FAST32_TYPE
201#define INT_FAST32_TYPE ((const char *) NULL)
202#endif
203
204#ifndef INT_FAST64_TYPE
205#define INT_FAST64_TYPE ((const char *) NULL)
206#endif
207
208#ifndef UINT_FAST8_TYPE
209#define UINT_FAST8_TYPE ((const char *) NULL)
210#endif
211
212#ifndef UINT_FAST16_TYPE
213#define UINT_FAST16_TYPE ((const char *) NULL)
214#endif
215
216#ifndef UINT_FAST32_TYPE
217#define UINT_FAST32_TYPE ((const char *) NULL)
218#endif
219
220#ifndef UINT_FAST64_TYPE
221#define UINT_FAST64_TYPE ((const char *) NULL)
222#endif
223
224#ifndef INTPTR_TYPE
225#define INTPTR_TYPE ((const char *) NULL)
226#endif
227
228#ifndef UINTPTR_TYPE
229#define UINTPTR_TYPE ((const char *) NULL)
230#endif
231
232/* The following symbols are subsumed in the c_global_trees array, and
233 listed here individually for documentation purposes.
234
235 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
236
237 tree short_integer_type_node;
238 tree long_integer_type_node;
239 tree long_long_integer_type_node;
240
241 tree short_unsigned_type_node;
242 tree long_unsigned_type_node;
243 tree long_long_unsigned_type_node;
244
245 tree truthvalue_type_node;
246 tree truthvalue_false_node;
247 tree truthvalue_true_node;
248
249 tree ptrdiff_type_node;
250
251 tree unsigned_char_type_node;
252 tree signed_char_type_node;
253 tree wchar_type_node;
254
255 tree char16_type_node;
256 tree char32_type_node;
257
258 tree float_type_node;
259 tree double_type_node;
260 tree long_double_type_node;
261
262 tree complex_integer_type_node;
263 tree complex_float_type_node;
264 tree complex_double_type_node;
265 tree complex_long_double_type_node;
266
267 tree dfloat32_type_node;
268 tree dfloat64_type_node;
269 tree_dfloat128_type_node;
270
271 tree intQI_type_node;
272 tree intHI_type_node;
273 tree intSI_type_node;
274 tree intDI_type_node;
275 tree intTI_type_node;
276
277 tree unsigned_intQI_type_node;
278 tree unsigned_intHI_type_node;
279 tree unsigned_intSI_type_node;
280 tree unsigned_intDI_type_node;
281 tree unsigned_intTI_type_node;
282
283 tree widest_integer_literal_type_node;
284 tree widest_unsigned_literal_type_node;
285
286 Nodes for types `void *' and `const void *'.
287
288 tree ptr_type_node, const_ptr_type_node;
289
290 Nodes for types `char *' and `const char *'.
291
292 tree string_type_node, const_string_type_node;
293
294 Type `char[SOMENUMBER]'.
295 Used when an array of char is needed and the size is irrelevant.
296
297 tree char_array_type_node;
298
299 Type `int[SOMENUMBER]' or something like it.
300 Used when an array of int needed and the size is irrelevant.
301
302 tree int_array_type_node;
303
304 Type `wchar_t[SOMENUMBER]' or something like it.
305 Used when a wide string literal is created.
306
307 tree wchar_array_type_node;
308
309 Type `char16_t[SOMENUMBER]' or something like it.
310 Used when a UTF-16 string literal is created.
311
312 tree char16_array_type_node;
313
314 Type `char32_t[SOMENUMBER]' or something like it.
315 Used when a UTF-32 string literal is created.
316
317 tree char32_array_type_node;
318
319 Type `int ()' -- used for implicit declaration of functions.
320
321 tree default_function_type;
322
323 A VOID_TYPE node, packaged in a TREE_LIST.
324
325 tree void_list_node;
326
327 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
328 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
329 VAR_DECLS, but C++ does.)
330
331 tree function_name_decl_node;
332 tree pretty_function_name_decl_node;
333 tree c99_function_name_decl_node;
334
335 Stack of nested function name VAR_DECLs.
336
337 tree saved_function_name_decls;
338
339*/
340
341tree c_global_trees[CTI_MAX];
342\f
343/* Switches common to the C front ends. */
344
345/* Nonzero if preprocessing only. */
346
347int flag_preprocess_only;
348
349/* Nonzero means don't output line number information. */
350
351char flag_no_line_commands;
352
353/* Nonzero causes -E output not to be done, but directives such as
354 #define that have side effects are still obeyed. */
355
356char flag_no_output;
357
358/* Nonzero means dump macros in some fashion. */
359
360char flag_dump_macros;
361
362/* Nonzero means pass #include lines through to the output. */
363
364char flag_dump_includes;
365
366/* Nonzero means process PCH files while preprocessing. */
367
368bool flag_pch_preprocess;
369
370/* The file name to which we should write a precompiled header, or
371 NULL if no header will be written in this compile. */
372
373const char *pch_file;
374
375/* Nonzero if an ISO standard was selected. It rejects macros in the
376 user's namespace. */
377int flag_iso;
378
379/* Nonzero if -undef was given. It suppresses target built-in macros
380 and assertions. */
381int flag_undef;
382
383/* Nonzero means don't recognize the non-ANSI builtin functions. */
384
385int flag_no_builtin;
386
387/* Nonzero means don't recognize the non-ANSI builtin functions.
388 -ansi sets this. */
389
390int flag_no_nonansi_builtin;
391
392/* Nonzero means give `double' the same size as `float'. */
393
394int flag_short_double;
395
396/* Nonzero means give `wchar_t' the same size as `short'. */
397
398int flag_short_wchar;
399
400/* Nonzero means allow implicit conversions between vectors with
401 differing numbers of subparts and/or differing element types. */
402int flag_lax_vector_conversions;
403
404/* Nonzero means allow Microsoft extensions without warnings or errors. */
405int flag_ms_extensions;
406
407/* Nonzero means don't recognize the keyword `asm'. */
408
409int flag_no_asm;
410
411/* Nonzero means to treat bitfields as signed unless they say `unsigned'. */
412
413int flag_signed_bitfields = 1;
414
415/* Warn about #pragma directives that are not recognized. */
416
417int warn_unknown_pragmas; /* Tri state variable. */
418
419/* Warn about format/argument anomalies in calls to formatted I/O functions
420 (*printf, *scanf, strftime, strfmon, etc.). */
421
422int warn_format;
423
424/* Warn about using __null (as NULL in C++) as sentinel. For code compiled
425 with GCC this doesn't matter as __null is guaranteed to have the right
426 size. */
427
428int warn_strict_null_sentinel;
429
430/* Zero means that faster, ...NonNil variants of objc_msgSend...
431 calls will be used in ObjC; passing nil receivers to such calls
432 will most likely result in crashes. */
433int flag_nil_receivers = 1;
434
435/* Nonzero means that code generation will be altered to support
436 "zero-link" execution. This currently affects ObjC only, but may
437 affect other languages in the future. */
438int flag_zero_link = 0;
439
440/* Nonzero means emit an '__OBJC, __image_info' for the current translation
441 unit. It will inform the ObjC runtime that class definition(s) herein
442 contained are to replace one(s) previously loaded. */
443int flag_replace_objc_classes = 0;
444
445/* C/ObjC language option variables. */
446
447
448/* Nonzero means allow type mismatches in conditional expressions;
449 just make their values `void'. */
450
451int flag_cond_mismatch;
452
453/* Nonzero means enable C89 Amendment 1 features. */
454
455int flag_isoc94;
456
457/* Nonzero means use the ISO C99 dialect of C. */
458
459int flag_isoc99;
460
461/* Nonzero means that we have builtin functions, and main is an int. */
462
463int flag_hosted = 1;
464
465
466/* ObjC language option variables. */
467
468
469/* Open and close the file for outputting class declarations, if
470 requested (ObjC). */
471
472int flag_gen_declaration;
473
474/* Tells the compiler that this is a special run. Do not perform any
475 compiling, instead we are to test some platform dependent features
476 and output a C header file with appropriate definitions. */
477
478int print_struct_values;
479
480/* Tells the compiler what is the constant string class for ObjC. */
481
482const char *constant_string_class_name;
483
484
485/* C++ language option variables. */
486
487
488/* Nonzero means don't recognize any extension keywords. */
489
490int flag_no_gnu_keywords;
491
492/* Nonzero means do emit exported implementations of functions even if
493 they can be inlined. */
494
495int flag_implement_inlines = 1;
496
497/* Nonzero means that implicit instantiations will be emitted if needed. */
498
499int flag_implicit_templates = 1;
500
501/* Nonzero means that implicit instantiations of inline templates will be
502 emitted if needed, even if instantiations of non-inline templates
503 aren't. */
504
505int flag_implicit_inline_templates = 1;
506
507/* Nonzero means generate separate instantiation control files and
508 juggle them at link time. */
509
510int flag_use_repository;
511
512/* Nonzero if we want to issue diagnostics that the standard says are not
513 required. */
514
515int flag_optional_diags = 1;
516
517/* Nonzero means we should attempt to elide constructors when possible. */
518
519int flag_elide_constructors = 1;
520
521/* Nonzero means that member functions defined in class scope are
522 inline by default. */
523
524int flag_default_inline = 1;
525
526/* Controls whether compiler generates 'type descriptor' that give
527 run-time type information. */
528
529int flag_rtti = 1;
530
531/* Nonzero if we want to conserve space in the .o files. We do this
532 by putting uninitialized data and runtime initialized data into
533 .common instead of .data at the expense of not flagging multiple
534 definitions. */
535
536int flag_conserve_space;
537
538/* Nonzero if we want to obey access control semantics. */
539
540int flag_access_control = 1;
541
542/* Nonzero if we want to check the return value of new and avoid calling
543 constructors if it is a null pointer. */
544
545int flag_check_new;
546
547/* The C++ dialect being used. C++98 is the default. */
548
549enum cxx_dialect cxx_dialect = cxx98;
550
551/* Nonzero if we want the new ISO rules for pushing a new scope for `for'
552 initialization variables.
553 0: Old rules, set by -fno-for-scope.
554 2: New ISO rules, set by -ffor-scope.
555 1: Try to implement new ISO rules, but with backup compatibility
556 (and warnings). This is the default, for now. */
557
558int flag_new_for_scope = 1;
559
560/* Nonzero if we want to emit defined symbols with common-like linkage as
561 weak symbols where possible, in order to conform to C++ semantics.
562 Otherwise, emit them as local symbols. */
563
564int flag_weak = 1;
565
566/* 0 means we want the preprocessor to not emit line directives for
567 the current working directory. 1 means we want it to do it. -1
568 means we should decide depending on whether debugging information
569 is being emitted or not. */
570
571int flag_working_directory = -1;
572
573/* Nonzero to use __cxa_atexit, rather than atexit, to register
574 destructors for local statics and global objects. '2' means it has been
575 set nonzero as a default, not by a command-line flag. */
576
577int flag_use_cxa_atexit = DEFAULT_USE_CXA_ATEXIT;
578
579/* Nonzero to use __cxa_get_exception_ptr in C++ exception-handling
580 code. '2' means it has not been set explicitly on the command line. */
581
582int flag_use_cxa_get_exception_ptr = 2;
583
584/* Nonzero means to implement standard semantics for exception
585 specifications, calling unexpected if an exception is thrown that
586 doesn't match the specification. Zero means to treat them as
587 assertions and optimize accordingly, but not check them. */
588
589int flag_enforce_eh_specs = 1;
590
591/* Nonzero means to generate thread-safe code for initializing local
592 statics. */
593
594int flag_threadsafe_statics = 1;
595
596/* Nonzero if we want to pretty-print template specializations as the
597 template signature followed by the arguments. */
598
599int flag_pretty_templates = 1;
600
601/* Nonzero means warn about implicit declarations. */
602
603int warn_implicit = 1;
604
605/* Maximum template instantiation depth. This limit is rather
606 arbitrary, but it exists to limit the time it takes to notice
607 infinite template instantiations. */
608
609int max_tinst_depth = 500;
610
611
612
613/* The elements of `ridpointers' are identifier nodes for the reserved
614 type names and storage classes. It is indexed by a RID_... value. */
615tree *ridpointers;
616
617tree (*make_fname_decl) (tree, int);
618
619/* Nonzero means the expression being parsed will never be evaluated.
620 This is a count, since unevaluated expressions can nest. */
621int skip_evaluation;
622
623/* Whether lexing has been completed, so subsequent preprocessor
624 errors should use the compiler's input_location. */
625bool done_lexing = false;
626
627/* Information about how a function name is generated. */
628struct fname_var_t
629{
630 tree *const decl; /* pointer to the VAR_DECL. */
631 const unsigned rid; /* RID number for the identifier. */
632 const int pretty; /* How pretty is it? */
633};
634
635/* The three ways of getting then name of the current function. */
636
637const struct fname_var_t fname_vars[] =
638{
639 /* C99 compliant __func__, must be first. */
640 {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
641 /* GCC __FUNCTION__ compliant. */
642 {&function_name_decl_node, RID_FUNCTION_NAME, 0},
643 /* GCC __PRETTY_FUNCTION__ compliant. */
644 {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
645 {NULL, 0, 0},
646};
647
648static tree c_fully_fold_internal (tree expr, bool, bool *, bool *);
649static tree check_case_value (tree);
650static bool check_case_bounds (tree, tree, tree *, tree *);
651
652static tree handle_packed_attribute (tree *, tree, tree, int, bool *);
653static tree handle_nocommon_attribute (tree *, tree, tree, int, bool *);
654static tree handle_common_attribute (tree *, tree, tree, int, bool *);
655static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
656static tree handle_hot_attribute (tree *, tree, tree, int, bool *);
657static tree handle_cold_attribute (tree *, tree, tree, int, bool *);
658static tree handle_noinline_attribute (tree *, tree, tree, int, bool *);
659static tree handle_always_inline_attribute (tree *, tree, tree, int,
660 bool *);
661static tree handle_gnu_inline_attribute (tree *, tree, tree, int, bool *);
662static tree handle_artificial_attribute (tree *, tree, tree, int, bool *);
663static tree handle_flatten_attribute (tree *, tree, tree, int, bool *);
664static tree handle_error_attribute (tree *, tree, tree, int, bool *);
665static tree handle_used_attribute (tree *, tree, tree, int, bool *);
666static tree handle_unused_attribute (tree *, tree, tree, int, bool *);
667static tree handle_externally_visible_attribute (tree *, tree, tree, int,
668 bool *);
669static tree handle_const_attribute (tree *, tree, tree, int, bool *);
670static tree handle_transparent_union_attribute (tree *, tree, tree,
671 int, bool *);
672static tree handle_constructor_attribute (tree *, tree, tree, int, bool *);
673static tree handle_destructor_attribute (tree *, tree, tree, int, bool *);
674static tree handle_mode_attribute (tree *, tree, tree, int, bool *);
675static tree handle_section_attribute (tree *, tree, tree, int, bool *);
676static tree handle_aligned_attribute (tree *, tree, tree, int, bool *);
677static tree handle_weak_attribute (tree *, tree, tree, int, bool *) ;
678static tree handle_alias_attribute (tree *, tree, tree, int, bool *);
679static tree handle_weakref_attribute (tree *, tree, tree, int, bool *) ;
680static tree handle_visibility_attribute (tree *, tree, tree, int,
681 bool *);
682static tree handle_tls_model_attribute (tree *, tree, tree, int,
683 bool *);
684static tree handle_no_instrument_function_attribute (tree *, tree,
685 tree, int, bool *);
686static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);
687static tree handle_returns_twice_attribute (tree *, tree, tree, int, bool *);
688static tree handle_no_limit_stack_attribute (tree *, tree, tree, int,
689 bool *);
690static tree handle_pure_attribute (tree *, tree, tree, int, bool *);
691static tree handle_novops_attribute (tree *, tree, tree, int, bool *);
692static tree handle_deprecated_attribute (tree *, tree, tree, int,
693 bool *);
694static tree handle_vector_size_attribute (tree *, tree, tree, int,
695 bool *);
696static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
697static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
698static tree handle_cleanup_attribute (tree *, tree, tree, int, bool *);
699static tree handle_warn_unused_result_attribute (tree *, tree, tree, int,
700 bool *);
701static tree handle_sentinel_attribute (tree *, tree, tree, int, bool *);
702static tree handle_type_generic_attribute (tree *, tree, tree, int, bool *);
703static tree handle_alloc_size_attribute (tree *, tree, tree, int, bool *);
704static tree handle_target_attribute (tree *, tree, tree, int, bool *);
705static tree handle_optimize_attribute (tree *, tree, tree, int, bool *);
706
707static void check_function_nonnull (tree, int, tree *);
708static void check_nonnull_arg (void *, tree, unsigned HOST_WIDE_INT);
709static bool nonnull_check_p (tree, unsigned HOST_WIDE_INT);
710static bool get_nonnull_operand (tree, unsigned HOST_WIDE_INT *);
711static int resort_field_decl_cmp (const void *, const void *);
712
713/* Reserved words. The third field is a mask: keywords are disabled
714 if they match the mask.
715
716 Masks for languages:
717 C --std=c89: D_C99 | D_CXXONLY | D_OBJC | D_CXX_OBJC
718 C --std=c99: D_CXXONLY | D_OBJC
719 ObjC is like C except that D_OBJC and D_CXX_OBJC are not set
720 C++ --std=c98: D_CONLY | D_CXXOX | D_OBJC
721 C++ --std=c0x: D_CONLY | D_OBJC
722 ObjC++ is like C++ except that D_OBJC is not set
723
724 If -fno-asm is used, D_ASM is added to the mask. If
725 -fno-gnu-keywords is used, D_EXT is added. If -fno-asm and C in
726 C89 mode, D_EXT89 is added for both -fno-asm and -fno-gnu-keywords.
727 In C with -Wc++-compat, we warn if D_CXXWARN is set. */
728
729const struct c_common_resword c_common_reswords[] =
730{
731 { "_Bool", RID_BOOL, D_CONLY },
732 { "_Complex", RID_COMPLEX, 0 },
733 { "_Imaginary", RID_IMAGINARY, D_CONLY },
734 { "_Decimal32", RID_DFLOAT32, D_CONLY | D_EXT },
735 { "_Decimal64", RID_DFLOAT64, D_CONLY | D_EXT },
736 { "_Decimal128", RID_DFLOAT128, D_CONLY | D_EXT },
737 { "_Fract", RID_FRACT, D_CONLY | D_EXT },
738 { "_Accum", RID_ACCUM, D_CONLY | D_EXT },
739 { "_Sat", RID_SAT, D_CONLY | D_EXT },
740 { "__FUNCTION__", RID_FUNCTION_NAME, 0 },
741 { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME, 0 },
742 { "__alignof", RID_ALIGNOF, 0 },
743 { "__alignof__", RID_ALIGNOF, 0 },
744 { "__asm", RID_ASM, 0 },
745 { "__asm__", RID_ASM, 0 },
746 { "__attribute", RID_ATTRIBUTE, 0 },
747 { "__attribute__", RID_ATTRIBUTE, 0 },
748 { "__builtin_choose_expr", RID_CHOOSE_EXPR, D_CONLY },
749 { "__builtin_offsetof", RID_OFFSETOF, 0 },
750 { "__builtin_types_compatible_p", RID_TYPES_COMPATIBLE_P, D_CONLY },
751 { "__builtin_va_arg", RID_VA_ARG, 0 },
752 { "__complex", RID_COMPLEX, 0 },
753 { "__complex__", RID_COMPLEX, 0 },
754 { "__const", RID_CONST, 0 },
755 { "__const__", RID_CONST, 0 },
756 { "__decltype", RID_DECLTYPE, D_CXXONLY },
757 { "__extension__", RID_EXTENSION, 0 },
758 { "__func__", RID_C99_FUNCTION_NAME, 0 },
759 { "__has_nothrow_assign", RID_HAS_NOTHROW_ASSIGN, D_CXXONLY },
760 { "__has_nothrow_constructor", RID_HAS_NOTHROW_CONSTRUCTOR, D_CXXONLY },
761 { "__has_nothrow_copy", RID_HAS_NOTHROW_COPY, D_CXXONLY },
762 { "__has_trivial_assign", RID_HAS_TRIVIAL_ASSIGN, D_CXXONLY },
763 { "__has_trivial_constructor", RID_HAS_TRIVIAL_CONSTRUCTOR, D_CXXONLY },
764 { "__has_trivial_copy", RID_HAS_TRIVIAL_COPY, D_CXXONLY },
765 { "__has_trivial_destructor", RID_HAS_TRIVIAL_DESTRUCTOR, D_CXXONLY },
766 { "__has_virtual_destructor", RID_HAS_VIRTUAL_DESTRUCTOR, D_CXXONLY },
767 { "__is_abstract", RID_IS_ABSTRACT, D_CXXONLY },
768 { "__is_base_of", RID_IS_BASE_OF, D_CXXONLY },
769 { "__is_class", RID_IS_CLASS, D_CXXONLY },
770 { "__is_convertible_to", RID_IS_CONVERTIBLE_TO, D_CXXONLY },
771 { "__is_empty", RID_IS_EMPTY, D_CXXONLY },
772 { "__is_enum", RID_IS_ENUM, D_CXXONLY },
773 { "__is_pod", RID_IS_POD, D_CXXONLY },
774 { "__is_polymorphic", RID_IS_POLYMORPHIC, D_CXXONLY },
775 { "__is_union", RID_IS_UNION, D_CXXONLY },
776 { "__imag", RID_IMAGPART, 0 },
777 { "__imag__", RID_IMAGPART, 0 },
778 { "__inline", RID_INLINE, 0 },
779 { "__inline__", RID_INLINE, 0 },
780 { "__label__", RID_LABEL, 0 },
781 { "__null", RID_NULL, 0 },
782 { "__real", RID_REALPART, 0 },
783 { "__real__", RID_REALPART, 0 },
784 { "__restrict", RID_RESTRICT, 0 },
785 { "__restrict__", RID_RESTRICT, 0 },
786 { "__signed", RID_SIGNED, 0 },
787 { "__signed__", RID_SIGNED, 0 },
788 { "__thread", RID_THREAD, 0 },
789 { "__typeof", RID_TYPEOF, 0 },
790 { "__typeof__", RID_TYPEOF, 0 },
791 { "__volatile", RID_VOLATILE, 0 },
792 { "__volatile__", RID_VOLATILE, 0 },
793 { "asm", RID_ASM, D_ASM },
794 { "auto", RID_AUTO, 0 },
795 { "bool", RID_BOOL, D_CXXONLY | D_CXXWARN },
796 { "break", RID_BREAK, 0 },
797 { "case", RID_CASE, 0 },
798 { "catch", RID_CATCH, D_CXX_OBJC | D_CXXWARN },
799 { "char", RID_CHAR, 0 },
800 { "char16_t", RID_CHAR16, D_CXXONLY | D_CXX0X | D_CXXWARN },
801 { "char32_t", RID_CHAR32, D_CXXONLY | D_CXX0X | D_CXXWARN },
802 { "class", RID_CLASS, D_CXX_OBJC | D_CXXWARN },
803 { "const", RID_CONST, 0 },
804 { "const_cast", RID_CONSTCAST, D_CXXONLY | D_CXXWARN },
805 { "continue", RID_CONTINUE, 0 },
806 { "decltype", RID_DECLTYPE, D_CXXONLY | D_CXX0X | D_CXXWARN },
807 { "default", RID_DEFAULT, 0 },
808 { "delete", RID_DELETE, D_CXXONLY | D_CXXWARN },
809 { "do", RID_DO, 0 },
810 { "double", RID_DOUBLE, 0 },
811 { "dynamic_cast", RID_DYNCAST, D_CXXONLY | D_CXXWARN },
812 { "else", RID_ELSE, 0 },
813 { "enum", RID_ENUM, 0 },
814 { "explicit", RID_EXPLICIT, D_CXXONLY | D_CXXWARN },
815 { "export", RID_EXPORT, D_CXXONLY | D_CXXWARN },
816 { "extern", RID_EXTERN, 0 },
817 { "false", RID_FALSE, D_CXXONLY | D_CXXWARN },
818 { "float", RID_FLOAT, 0 },
819 { "for", RID_FOR, 0 },
820 { "friend", RID_FRIEND, D_CXXONLY | D_CXXWARN },
821 { "goto", RID_GOTO, 0 },
822 { "if", RID_IF, 0 },
823 { "inline", RID_INLINE, D_EXT89 },
824 { "int", RID_INT, 0 },
825 { "long", RID_LONG, 0 },
826 { "mutable", RID_MUTABLE, D_CXXONLY | D_CXXWARN },
827 { "namespace", RID_NAMESPACE, D_CXXONLY | D_CXXWARN },
828 { "new", RID_NEW, D_CXXONLY | D_CXXWARN },
829 { "operator", RID_OPERATOR, D_CXXONLY | D_CXXWARN },
830 { "private", RID_PRIVATE, D_CXX_OBJC | D_CXXWARN },
831 { "protected", RID_PROTECTED, D_CXX_OBJC | D_CXXWARN },
832 { "public", RID_PUBLIC, D_CXX_OBJC | D_CXXWARN },
833 { "register", RID_REGISTER, 0 },
834 { "reinterpret_cast", RID_REINTCAST, D_CXXONLY | D_CXXWARN },
835 { "restrict", RID_RESTRICT, D_CONLY | D_C99 },
836 { "return", RID_RETURN, 0 },
837 { "short", RID_SHORT, 0 },
838 { "signed", RID_SIGNED, 0 },
839 { "sizeof", RID_SIZEOF, 0 },
840 { "static", RID_STATIC, 0 },
841 { "static_assert", RID_STATIC_ASSERT, D_CXXONLY | D_CXX0X | D_CXXWARN },
842 { "static_cast", RID_STATCAST, D_CXXONLY | D_CXXWARN },
843 { "struct", RID_STRUCT, 0 },
844 { "switch", RID_SWITCH, 0 },
845 { "template", RID_TEMPLATE, D_CXXONLY | D_CXXWARN },
846 { "this", RID_THIS, D_CXXONLY | D_CXXWARN },
847 { "throw", RID_THROW, D_CXX_OBJC | D_CXXWARN },
848 { "true", RID_TRUE, D_CXXONLY | D_CXXWARN },
849 { "try", RID_TRY, D_CXX_OBJC | D_CXXWARN },
850 { "typedef", RID_TYPEDEF, 0 },
851 { "typename", RID_TYPENAME, D_CXXONLY | D_CXXWARN },
852 { "typeid", RID_TYPEID, D_CXXONLY | D_CXXWARN },
853 { "typeof", RID_TYPEOF, D_ASM | D_EXT },
854 { "union", RID_UNION, 0 },
855 { "unsigned", RID_UNSIGNED, 0 },
856 { "using", RID_USING, D_CXXONLY | D_CXXWARN },
857 { "virtual", RID_VIRTUAL, D_CXXONLY | D_CXXWARN },
858 { "void", RID_VOID, 0 },
859 { "volatile", RID_VOLATILE, 0 },
860 { "wchar_t", RID_WCHAR, D_CXXONLY },
861 { "while", RID_WHILE, 0 },
862 /* These Objective-C keywords are recognized only immediately after
863 an '@'. */
864 { "compatibility_alias", RID_AT_ALIAS, D_OBJC },
865 { "defs", RID_AT_DEFS, D_OBJC },
866 { "encode", RID_AT_ENCODE, D_OBJC },
867 { "end", RID_AT_END, D_OBJC },
868 { "implementation", RID_AT_IMPLEMENTATION, D_OBJC },
869 { "interface", RID_AT_INTERFACE, D_OBJC },
870 { "protocol", RID_AT_PROTOCOL, D_OBJC },
871 { "selector", RID_AT_SELECTOR, D_OBJC },
872 { "finally", RID_AT_FINALLY, D_OBJC },
873 { "synchronized", RID_AT_SYNCHRONIZED, D_OBJC },
874 /* These are recognized only in protocol-qualifier context
875 (see above) */
876 { "bycopy", RID_BYCOPY, D_OBJC },
877 { "byref", RID_BYREF, D_OBJC },
878 { "in", RID_IN, D_OBJC },
879 { "inout", RID_INOUT, D_OBJC },
880 { "oneway", RID_ONEWAY, D_OBJC },
881 { "out", RID_OUT, D_OBJC },
882};
883
884const unsigned int num_c_common_reswords =
885 sizeof c_common_reswords / sizeof (struct c_common_resword);
886
887/* Table of machine-independent attributes common to all C-like languages. */
888const struct attribute_spec c_common_attribute_table[] =
889{
890 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
891 { "packed", 0, 0, false, false, false,
892 handle_packed_attribute },
893 { "nocommon", 0, 0, true, false, false,
894 handle_nocommon_attribute },
895 { "common", 0, 0, true, false, false,
896 handle_common_attribute },
897 /* FIXME: logically, noreturn attributes should be listed as
898 "false, true, true" and apply to function types. But implementing this
899 would require all the places in the compiler that use TREE_THIS_VOLATILE
900 on a decl to identify non-returning functions to be located and fixed
901 to check the function type instead. */
902 { "noreturn", 0, 0, true, false, false,
903 handle_noreturn_attribute },
904 { "volatile", 0, 0, true, false, false,
905 handle_noreturn_attribute },
906 { "noinline", 0, 0, true, false, false,
907 handle_noinline_attribute },
908 { "always_inline", 0, 0, true, false, false,
909 handle_always_inline_attribute },
910 { "gnu_inline", 0, 0, true, false, false,
911 handle_gnu_inline_attribute },
912 { "artificial", 0, 0, true, false, false,
913 handle_artificial_attribute },
914 { "flatten", 0, 0, true, false, false,
915 handle_flatten_attribute },
916 { "used", 0, 0, true, false, false,
917 handle_used_attribute },
918 { "unused", 0, 0, false, false, false,
919 handle_unused_attribute },
920 { "externally_visible", 0, 0, true, false, false,
921 handle_externally_visible_attribute },
922 /* The same comments as for noreturn attributes apply to const ones. */
923 { "const", 0, 0, true, false, false,
924 handle_const_attribute },
925 { "transparent_union", 0, 0, false, false, false,
926 handle_transparent_union_attribute },
927 { "constructor", 0, 1, true, false, false,
928 handle_constructor_attribute },
929 { "destructor", 0, 1, true, false, false,
930 handle_destructor_attribute },
931 { "mode", 1, 1, false, true, false,
932 handle_mode_attribute },
933 { "section", 1, 1, true, false, false,
934 handle_section_attribute },
935 { "aligned", 0, 1, false, false, false,
936 handle_aligned_attribute },
937 { "weak", 0, 0, true, false, false,
938 handle_weak_attribute },
939 { "alias", 1, 1, true, false, false,
940 handle_alias_attribute },
941 { "weakref", 0, 1, true, false, false,
942 handle_weakref_attribute },
943 { "no_instrument_function", 0, 0, true, false, false,
944 handle_no_instrument_function_attribute },
945 { "malloc", 0, 0, true, false, false,
946 handle_malloc_attribute },
947 { "returns_twice", 0, 0, true, false, false,
948 handle_returns_twice_attribute },
949 { "no_stack_limit", 0, 0, true, false, false,
950 handle_no_limit_stack_attribute },
951 { "pure", 0, 0, true, false, false,
952 handle_pure_attribute },
953 /* For internal use (marking of builtins) only. The name contains space
954 to prevent its usage in source code. */
955 { "no vops", 0, 0, true, false, false,
956 handle_novops_attribute },
957 { "deprecated", 0, 0, false, false, false,
958 handle_deprecated_attribute },
959 { "vector_size", 1, 1, false, true, false,
960 handle_vector_size_attribute },
961 { "visibility", 1, 1, false, false, false,
962 handle_visibility_attribute },
963 { "tls_model", 1, 1, true, false, false,
964 handle_tls_model_attribute },
965 { "nonnull", 0, -1, false, true, true,
966 handle_nonnull_attribute },
967 { "nothrow", 0, 0, true, false, false,
968 handle_nothrow_attribute },
969 { "may_alias", 0, 0, false, true, false, NULL },
970 { "cleanup", 1, 1, true, false, false,
971 handle_cleanup_attribute },
972 { "warn_unused_result", 0, 0, false, true, true,
973 handle_warn_unused_result_attribute },
974 { "sentinel", 0, 1, false, true, true,
975 handle_sentinel_attribute },
976 /* For internal use (marking of builtins) only. The name contains space
977 to prevent its usage in source code. */
978 { "type generic", 0, 0, false, true, true,
979 handle_type_generic_attribute },
980 { "alloc_size", 1, 2, false, true, true,
981 handle_alloc_size_attribute },
982 { "cold", 0, 0, true, false, false,
983 handle_cold_attribute },
984 { "hot", 0, 0, true, false, false,
985 handle_hot_attribute },
986 { "warning", 1, 1, true, false, false,
987 handle_error_attribute },
988 { "error", 1, 1, true, false, false,
989 handle_error_attribute },
990 { "target", 1, -1, true, false, false,
991 handle_target_attribute },
992 { "optimize", 1, -1, true, false, false,
993 handle_optimize_attribute },
994 { NULL, 0, 0, false, false, false, NULL }
995};
996
997/* Give the specifications for the format attributes, used by C and all
998 descendants. */
999
1000const struct attribute_spec c_common_format_attribute_table[] =
1001{
1002 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
1003 { "format", 3, 3, false, true, true,
1004 handle_format_attribute },
1005 { "format_arg", 1, 1, false, true, true,
1006 handle_format_arg_attribute },
1007 { NULL, 0, 0, false, false, false, NULL }
1008};
1009
1010/* Push current bindings for the function name VAR_DECLS. */
1011
1012void
1013start_fname_decls (void)
1014{
1015 unsigned ix;
1016 tree saved = NULL_TREE;
1017
1018 for (ix = 0; fname_vars[ix].decl; ix++)
1019 {
1020 tree decl = *fname_vars[ix].decl;
1021
1022 if (decl)
1023 {
1024 saved = tree_cons (decl, build_int_cst (NULL_TREE, ix), saved);
1025 *fname_vars[ix].decl = NULL_TREE;
1026 }
1027 }
1028 if (saved || saved_function_name_decls)
1029 /* Normally they'll have been NULL, so only push if we've got a
1030 stack, or they are non-NULL. */
1031 saved_function_name_decls = tree_cons (saved, NULL_TREE,
1032 saved_function_name_decls);
1033}
1034
1035/* Finish up the current bindings, adding them into the current function's
1036 statement tree. This must be done _before_ finish_stmt_tree is called.
1037 If there is no current function, we must be at file scope and no statements
1038 are involved. Pop the previous bindings. */
1039
1040void
1041finish_fname_decls (void)
1042{
1043 unsigned ix;
1044 tree stmts = NULL_TREE;
1045 tree stack = saved_function_name_decls;
1046
1047 for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
1048 append_to_statement_list (TREE_VALUE (stack), &stmts);
1049
1050 if (stmts)
1051 {
1052 tree *bodyp = &DECL_SAVED_TREE (current_function_decl);
1053
1054 if (TREE_CODE (*bodyp) == BIND_EXPR)
1055 bodyp = &BIND_EXPR_BODY (*bodyp);
1056
1057 append_to_statement_list_force (*bodyp, &stmts);
1058 *bodyp = stmts;
1059 }
1060
1061 for (ix = 0; fname_vars[ix].decl; ix++)
1062 *fname_vars[ix].decl = NULL_TREE;
1063
1064 if (stack)
1065 {
1066 /* We had saved values, restore them. */
1067 tree saved;
1068
1069 for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
1070 {
1071 tree decl = TREE_PURPOSE (saved);
1072 unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
1073
1074 *fname_vars[ix].decl = decl;
1075 }
1076 stack = TREE_CHAIN (stack);
1077 }
1078 saved_function_name_decls = stack;
1079}
1080
1081/* Return the text name of the current function, suitably prettified
1082 by PRETTY_P. Return string must be freed by caller. */
1083
1084const char *
1085fname_as_string (int pretty_p)
1086{
1087 const char *name = "top level";
1088 char *namep;
1089 int vrb = 2, len;
1090 cpp_string cstr = { 0, 0 }, strname;
1091
1092 if (!pretty_p)
1093 {
1094 name = "";
1095 vrb = 0;
1096 }
1097
1098 if (current_function_decl)
1099 name = lang_hooks.decl_printable_name (current_function_decl, vrb);
1100
1101 len = strlen (name) + 3; /* Two for '"'s. One for NULL. */
1102
1103 namep = XNEWVEC (char, len);
1104 snprintf (namep, len, "\"%s\"", name);
1105 strname.text = (unsigned char *) namep;
1106 strname.len = len - 1;
1107
1108 if (cpp_interpret_string (parse_in, &strname, 1, &cstr, CPP_STRING))
1109 {
1110 XDELETEVEC (namep);
1111 return (const char *) cstr.text;
1112 }
1113
1114 return namep;
1115}
1116
1117/* Return the VAR_DECL for a const char array naming the current
1118 function. If the VAR_DECL has not yet been created, create it
1119 now. RID indicates how it should be formatted and IDENTIFIER_NODE
1120 ID is its name (unfortunately C and C++ hold the RID values of
1121 keywords in different places, so we can't derive RID from ID in
1122 this language independent code. LOC is the location of the
1123 function. */
1124
1125tree
1126fname_decl (location_t loc, unsigned int rid, tree id)
1127{
1128 unsigned ix;
1129 tree decl = NULL_TREE;
1130
1131 for (ix = 0; fname_vars[ix].decl; ix++)
1132 if (fname_vars[ix].rid == rid)
1133 break;
1134
1135 decl = *fname_vars[ix].decl;
1136 if (!decl)
1137 {
1138 /* If a tree is built here, it would normally have the lineno of
1139 the current statement. Later this tree will be moved to the
1140 beginning of the function and this line number will be wrong.
1141 To avoid this problem set the lineno to 0 here; that prevents
1142 it from appearing in the RTL. */
1143 tree stmts;
1144 location_t saved_location = input_location;
1145 input_location = UNKNOWN_LOCATION;
1146
1147 stmts = push_stmt_list ();
1148 decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
1149 stmts = pop_stmt_list (stmts);
1150 if (!IS_EMPTY_STMT (stmts))
1151 saved_function_name_decls
1152 = tree_cons (decl, stmts, saved_function_name_decls);
1153 *fname_vars[ix].decl = decl;
1154 input_location = saved_location;
1155 }
1156 if (!ix && !current_function_decl)
1157 pedwarn (loc, 0, "%qD is not defined outside of function scope", decl);
1158
1159 return decl;
1160}
1161
1162/* Given a STRING_CST, give it a suitable array-of-chars data type. */
1163
1164tree
1165fix_string_type (tree value)
1166{
1167 int length = TREE_STRING_LENGTH (value);
1168 int nchars;
1169 tree e_type, i_type, a_type;
1170
1171 /* Compute the number of elements, for the array type. */
1172 if (TREE_TYPE (value) == char_array_type_node || !TREE_TYPE (value))
1173 {
1174 nchars = length;
1175 e_type = char_type_node;
1176 }
1177 else if (TREE_TYPE (value) == char16_array_type_node)
1178 {
1179 nchars = length / (TYPE_PRECISION (char16_type_node) / BITS_PER_UNIT);
1180 e_type = char16_type_node;
1181 }
1182 else if (TREE_TYPE (value) == char32_array_type_node)
1183 {
1184 nchars = length / (TYPE_PRECISION (char32_type_node) / BITS_PER_UNIT);
1185 e_type = char32_type_node;
1186 }
1187 else
1188 {
1189 nchars = length / (TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT);
1190 e_type = wchar_type_node;
1191 }
1192
1193 /* C89 2.2.4.1, C99 5.2.4.1 (Translation limits). The analogous
1194 limit in C++98 Annex B is very large (65536) and is not normative,
1195 so we do not diagnose it (warn_overlength_strings is forced off
1196 in c_common_post_options). */
1197 if (warn_overlength_strings)
1198 {
1199 const int nchars_max = flag_isoc99 ? 4095 : 509;
1200 const int relevant_std = flag_isoc99 ? 99 : 90;
1201 if (nchars - 1 > nchars_max)
1202 /* Translators: The %d after 'ISO C' will be 90 or 99. Do not
1203 separate the %d from the 'C'. 'ISO' should not be
1204 translated, but it may be moved after 'C%d' in languages
1205 where modifiers follow nouns. */
1206 pedwarn (input_location, OPT_Woverlength_strings,
1207 "string length %qd is greater than the length %qd "
1208 "ISO C%d compilers are required to support",
1209 nchars - 1, nchars_max, relevant_std);
1210 }
1211
1212 /* Create the array type for the string constant. The ISO C++
1213 standard says that a string literal has type `const char[N]' or
1214 `const wchar_t[N]'. We use the same logic when invoked as a C
1215 front-end with -Wwrite-strings.
1216 ??? We should change the type of an expression depending on the
1217 state of a warning flag. We should just be warning -- see how
1218 this is handled in the C++ front-end for the deprecated implicit
1219 conversion from string literals to `char*' or `wchar_t*'.
1220
1221 The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified
1222 array type being the unqualified version of that type.
1223 Therefore, if we are constructing an array of const char, we must
1224 construct the matching unqualified array type first. The C front
1225 end does not require this, but it does no harm, so we do it
1226 unconditionally. */
1227 i_type = build_index_type (build_int_cst (NULL_TREE, nchars - 1));
1228 a_type = build_array_type (e_type, i_type);
1229 if (c_dialect_cxx() || warn_write_strings)
1230 a_type = c_build_qualified_type (a_type, TYPE_QUAL_CONST);
1231
1232 TREE_TYPE (value) = a_type;
1233 TREE_CONSTANT (value) = 1;
1234 TREE_READONLY (value) = 1;
1235 TREE_STATIC (value) = 1;
1236 return value;
1237}
1238\f
1239/* Fully fold EXPR, an expression that was not folded (beyond integer
1240 constant expressions and null pointer constants) when being built
1241 up. If IN_INIT, this is in a static initializer and certain
1242 changes are made to the folding done. Clear *MAYBE_CONST if
1243 MAYBE_CONST is not NULL and EXPR is definitely not a constant
1244 expression because it contains an evaluated operator (in C99) or an
1245 operator outside of sizeof returning an integer constant (in C90)
1246 not permitted in constant expressions, or because it contains an
1247 evaluated arithmetic overflow. (*MAYBE_CONST should typically be
1248 set to true by callers before calling this function.) Return the
1249 folded expression. Function arguments have already been folded
1250 before calling this function, as have the contents of SAVE_EXPR,
1251 TARGET_EXPR, BIND_EXPR, VA_ARG_EXPR, OBJ_TYPE_REF and
1252 C_MAYBE_CONST_EXPR. */
1253
1254tree
1255c_fully_fold (tree expr, bool in_init, bool *maybe_const)
1256{
1257 tree ret;
1258 tree eptype = NULL_TREE;
1259 bool dummy = true;
1260 bool maybe_const_itself = true;
1261
1262 /* This function is not relevant to C++ because C++ folds while
1263 parsing, and may need changes to be correct for C++ when C++
1264 stops folding while parsing. */
1265 if (c_dialect_cxx ())
1266 gcc_unreachable ();
1267
1268 if (!maybe_const)
1269 maybe_const = &dummy;
1270 if (TREE_CODE (expr) == EXCESS_PRECISION_EXPR)
1271 {
1272 eptype = TREE_TYPE (expr);
1273 expr = TREE_OPERAND (expr, 0);
1274 }
1275 ret = c_fully_fold_internal (expr, in_init, maybe_const,
1276 &maybe_const_itself);
1277 if (eptype)
1278 ret = fold_convert (eptype, ret);
1279 *maybe_const &= maybe_const_itself;
1280 return ret;
1281}
1282
1283/* Internal helper for c_fully_fold. EXPR and IN_INIT are as for
1284 c_fully_fold. *MAYBE_CONST_OPERANDS is cleared because of operands
1285 not permitted, while *MAYBE_CONST_ITSELF is cleared because of
1286 arithmetic overflow (for C90, *MAYBE_CONST_OPERANDS is carried from
1287 both evaluated and unevaluated subexpressions while
1288 *MAYBE_CONST_ITSELF is carried from only evaluated
1289 subexpressions). */
1290
1291static tree
1292c_fully_fold_internal (tree expr, bool in_init, bool *maybe_const_operands,
1293 bool *maybe_const_itself)
1294{
1295 tree ret = expr;
1296 enum tree_code code = TREE_CODE (expr);
1297 enum tree_code_class kind = TREE_CODE_CLASS (code);
1298 location_t loc = EXPR_LOCATION (expr);
1299 tree op0, op1, op2, op3;
1300 tree orig_op0, orig_op1, orig_op2;
1301 bool op0_const = true, op1_const = true, op2_const = true;
1302 bool op0_const_self = true, op1_const_self = true, op2_const_self = true;
1303 bool nowarning = TREE_NO_WARNING (expr);
1304
1305 /* This function is not relevant to C++ because C++ folds while
1306 parsing, and may need changes to be correct for C++ when C++
1307 stops folding while parsing. */
1308 if (c_dialect_cxx ())
1309 gcc_unreachable ();
1310
1311 /* Constants, declarations, statements, errors, SAVE_EXPRs and
1312 anything else not counted as an expression cannot usefully be
1313 folded further at this point. */
1314 if (!IS_EXPR_CODE_CLASS (kind)
1315 || kind == tcc_statement
1316 || code == SAVE_EXPR)
1317 return expr;
1318
1319 /* Operands of variable-length expressions (function calls) have
1320 already been folded, as have __builtin_* function calls, and such
1321 expressions cannot occur in constant expressions. */
1322 if (kind == tcc_vl_exp)
1323 {
1324 *maybe_const_operands = false;
1325 ret = fold (expr);
1326 goto out;
1327 }
1328
1329 if (code == C_MAYBE_CONST_EXPR)
1330 {
1331 tree pre = C_MAYBE_CONST_EXPR_PRE (expr);
1332 tree inner = C_MAYBE_CONST_EXPR_EXPR (expr);
1333 if (C_MAYBE_CONST_EXPR_NON_CONST (expr))
1334 *maybe_const_operands = false;
1335 if (C_MAYBE_CONST_EXPR_INT_OPERANDS (expr))
1336 *maybe_const_itself = false;
1337 if (pre && !in_init)
1338 ret = build2 (COMPOUND_EXPR, TREE_TYPE (expr), pre, inner);
1339 else
1340 ret = inner;
1341 goto out;
1342 }
1343
1344 /* Assignment, increment, decrement, function call and comma
1345 operators, and statement expressions, cannot occur in constant
1346 expressions if evaluated / outside of sizeof. (Function calls
1347 were handled above, though VA_ARG_EXPR is treated like a function
1348 call here, and statement expressions are handled through
1349 C_MAYBE_CONST_EXPR to avoid folding inside them.) */
1350 switch (code)
1351 {
1352 case MODIFY_EXPR:
1353 case PREDECREMENT_EXPR:
1354 case PREINCREMENT_EXPR:
1355 case POSTDECREMENT_EXPR:
1356 case POSTINCREMENT_EXPR:
1357 case COMPOUND_EXPR:
1358 *maybe_const_operands = false;
1359 break;
1360
1361 case VA_ARG_EXPR:
1362 case TARGET_EXPR:
1363 case BIND_EXPR:
1364 case OBJ_TYPE_REF:
1365 *maybe_const_operands = false;
1366 ret = fold (expr);
1367 goto out;
1368
1369 default:
1370 break;
1371 }
1372
1373 /* Fold individual tree codes as appropriate. */
1374 switch (code)
1375 {
1376 case COMPOUND_LITERAL_EXPR:
1377 /* Any non-constancy will have been marked in a containing
1378 C_MAYBE_CONST_EXPR; there is no more folding to do here. */
1379 goto out;
1380
1381 case COMPONENT_REF:
1382 orig_op0 = op0 = TREE_OPERAND (expr, 0);
1383 op1 = TREE_OPERAND (expr, 1);
1384 op2 = TREE_OPERAND (expr, 2);
1385 op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
1386 maybe_const_itself);
1387 if (op0 != orig_op0)
1388 ret = build3 (COMPONENT_REF, TREE_TYPE (expr), op0, op1, op2);
1389 if (ret != expr)
1390 {
1391 TREE_READONLY (ret) = TREE_READONLY (expr);
1392 TREE_THIS_VOLATILE (ret) = TREE_THIS_VOLATILE (expr);
1393 }
1394 goto out;
1395
1396 case ARRAY_REF:
1397 orig_op0 = op0 = TREE_OPERAND (expr, 0);
1398 orig_op1 = op1 = TREE_OPERAND (expr, 1);
1399 op2 = TREE_OPERAND (expr, 2);
1400 op3 = TREE_OPERAND (expr, 3);
1401 op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
1402 maybe_const_itself);
1403 op1 = c_fully_fold_internal (op1, in_init, maybe_const_operands,
1404 maybe_const_itself);
1405 op1 = decl_constant_value_for_optimization (op1);
1406 if (op0 != orig_op0 || op1 != orig_op1)
1407 ret = build4 (ARRAY_REF, TREE_TYPE (expr), op0, op1, op2, op3);
1408 if (ret != expr)
1409 {
1410 TREE_READONLY (ret) = TREE_READONLY (expr);
1411 TREE_SIDE_EFFECTS (ret) = TREE_SIDE_EFFECTS (expr);
1412 TREE_THIS_VOLATILE (ret) = TREE_THIS_VOLATILE (expr);
1413 }
1414 ret = fold (ret);
1415 goto out;
1416
1417 case COMPOUND_EXPR:
1418 case MODIFY_EXPR:
1419 case PREDECREMENT_EXPR:
1420 case PREINCREMENT_EXPR:
1421 case POSTDECREMENT_EXPR:
1422 case POSTINCREMENT_EXPR:
1423 case PLUS_EXPR:
1424 case MINUS_EXPR:
1425 case MULT_EXPR:
1426 case POINTER_PLUS_EXPR:
1427 case TRUNC_DIV_EXPR:
1428 case CEIL_DIV_EXPR:
1429 case FLOOR_DIV_EXPR:
1430 case TRUNC_MOD_EXPR:
1431 case RDIV_EXPR:
1432 case EXACT_DIV_EXPR:
1433 case LSHIFT_EXPR:
1434 case RSHIFT_EXPR:
1435 case BIT_IOR_EXPR:
1436 case BIT_XOR_EXPR:
1437 case BIT_AND_EXPR:
1438 case LT_EXPR:
1439 case LE_EXPR:
1440 case GT_EXPR:
1441 case GE_EXPR:
1442 case EQ_EXPR:
1443 case NE_EXPR:
1444 case COMPLEX_EXPR:
1445 case TRUTH_AND_EXPR:
1446 case TRUTH_OR_EXPR:
1447 case TRUTH_XOR_EXPR:
1448 case UNORDERED_EXPR:
1449 case ORDERED_EXPR:
1450 case UNLT_EXPR:
1451 case UNLE_EXPR:
1452 case UNGT_EXPR:
1453 case UNGE_EXPR:
1454 case UNEQ_EXPR:
1455 /* Binary operations evaluating both arguments (increment and
1456 decrement are binary internally in GCC). */
1457 orig_op0 = op0 = TREE_OPERAND (expr, 0);
1458 orig_op1 = op1 = TREE_OPERAND (expr, 1);
1459 op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
1460 maybe_const_itself);
1461 if (code != MODIFY_EXPR
1462 && code != PREDECREMENT_EXPR
1463 && code != PREINCREMENT_EXPR
1464 && code != POSTDECREMENT_EXPR
1465 && code != POSTINCREMENT_EXPR)
1466 op0 = decl_constant_value_for_optimization (op0);
1467 /* The RHS of a MODIFY_EXPR was fully folded when building that
1468 expression for the sake of conversion warnings. */
1469 if (code != MODIFY_EXPR)
1470 op1 = c_fully_fold_internal (op1, in_init, maybe_const_operands,
1471 maybe_const_itself);
1472 op1 = decl_constant_value_for_optimization (op1);
1473 if (op0 != orig_op0 || op1 != orig_op1 || in_init)
1474 ret = in_init
1475 ? fold_build2_initializer (code, TREE_TYPE (expr), op0, op1)
1476 : fold_build2 (code, TREE_TYPE (expr), op0, op1);
1477 else
1478 ret = fold (expr);
1479 goto out;
1480
1481 case INDIRECT_REF:
1482 case FIX_TRUNC_EXPR:
1483 case FLOAT_EXPR:
1484 CASE_CONVERT:
1485 case NON_LVALUE_EXPR:
1486 case NEGATE_EXPR:
1487 case BIT_NOT_EXPR:
1488 case TRUTH_NOT_EXPR:
1489 case ADDR_EXPR:
1490 case CONJ_EXPR:
1491 case REALPART_EXPR:
1492 case IMAGPART_EXPR:
1493 /* Unary operations. */
1494 orig_op0 = op0 = TREE_OPERAND (expr, 0);
1495 op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
1496 maybe_const_itself);
1497 if (code != ADDR_EXPR && code != REALPART_EXPR && code != IMAGPART_EXPR)
1498 op0 = decl_constant_value_for_optimization (op0);
1499 if (op0 != orig_op0 || in_init)
1500 ret = in_init
1501 ? fold_build1_initializer (code, TREE_TYPE (expr), op0)
1502 : fold_build1 (code, TREE_TYPE (expr), op0);
1503 else
1504 ret = fold (expr);
1505 if (code == INDIRECT_REF
1506 && ret != expr
1507 && TREE_CODE (ret) == INDIRECT_REF)
1508 {
1509 TREE_READONLY (ret) = TREE_READONLY (expr);
1510 TREE_SIDE_EFFECTS (ret) = TREE_SIDE_EFFECTS (expr);
1511 TREE_THIS_VOLATILE (ret) = TREE_THIS_VOLATILE (expr);
1512 }
1513 goto out;
1514
1515 case TRUTH_ANDIF_EXPR:
1516 case TRUTH_ORIF_EXPR:
1517 /* Binary operations not necessarily evaluating both
1518 arguments. */
1519 orig_op0 = op0 = TREE_OPERAND (expr, 0);
1520 orig_op1 = op1 = TREE_OPERAND (expr, 1);
1521 op0 = c_fully_fold_internal (op0, in_init, &op0_const, &op0_const_self);
1522 op1 = c_fully_fold_internal (op1, in_init, &op1_const, &op1_const_self);
1523 if (op0 != orig_op0 || op1 != orig_op1 || in_init)
1524 ret = in_init
1525 ? fold_build2_initializer (code, TREE_TYPE (expr), op0, op1)
1526 : fold_build2 (code, TREE_TYPE (expr), op0, op1);
1527 else
1528 ret = fold (expr);
1529 *maybe_const_operands &= op0_const;
1530 *maybe_const_itself &= op0_const_self;
1531 if (!(flag_isoc99
1532 && op0_const
1533 && op0_const_self
1534 && (code == TRUTH_ANDIF_EXPR
1535 ? op0 == truthvalue_false_node
1536 : op0 == truthvalue_true_node)))
1537 *maybe_const_operands &= op1_const;
1538 if (!(op0_const
1539 && op0_const_self
1540 && (code == TRUTH_ANDIF_EXPR
1541 ? op0 == truthvalue_false_node
1542 : op0 == truthvalue_true_node)))
1543 *maybe_const_itself &= op1_const_self;
1544 goto out;
1545
1546 case COND_EXPR:
1547 orig_op0 = op0 = TREE_OPERAND (expr, 0);
1548 orig_op1 = op1 = TREE_OPERAND (expr, 1);
1549 orig_op2 = op2 = TREE_OPERAND (expr, 2);
1550 op0 = c_fully_fold_internal (op0, in_init, &op0_const, &op0_const_self);
1551 op1 = c_fully_fold_internal (op1, in_init, &op1_const, &op1_const_self);
1552 op2 = c_fully_fold_internal (op2, in_init, &op2_const, &op2_const_self);
1553 if (op0 != orig_op0 || op1 != orig_op1 || op2 != orig_op2)
1554 ret = fold_build3 (code, TREE_TYPE (expr), op0, op1, op2);
1555 else
1556 ret = fold (expr);
1557 *maybe_const_operands &= op0_const;
1558 *maybe_const_itself &= op0_const_self;
1559 if (!(flag_isoc99
1560 && op0_const
1561 && op0_const_self
1562 && op0 == truthvalue_false_node))
1563 *maybe_const_operands &= op1_const;
1564 if (!(op0_const
1565 && op0_const_self
1566 && op0 == truthvalue_false_node))
1567 *maybe_const_itself &= op1_const_self;
1568 if (!(flag_isoc99
1569 && op0_const
1570 && op0_const_self
1571 && op0 == truthvalue_true_node))
1572 *maybe_const_operands &= op2_const;
1573 if (!(op0_const
1574 && op0_const_self
1575 && op0 == truthvalue_true_node))
1576 *maybe_const_itself &= op2_const_self;
1577 goto out;
1578
1579 case EXCESS_PRECISION_EXPR:
1580 /* Each case where an operand with excess precision may be
1581 encountered must remove the EXCESS_PRECISION_EXPR around
1582 inner operands and possibly put one around the whole
1583 expression or possibly convert to the semantic type (which
1584 c_fully_fold does); we cannot tell at this stage which is
1585 appropriate in any particular case. */
1586 gcc_unreachable ();
1587
1588 default:
1589 /* Various codes may appear through folding built-in functions
1590 and their arguments. */
1591 goto out;
1592 }
1593
1594 out:
1595 /* Some folding may introduce NON_LVALUE_EXPRs; all lvalue checks
1596 have been done by this point, so remove them again. */
1597 nowarning |= TREE_NO_WARNING (ret);
1598 STRIP_TYPE_NOPS (ret);
1599 if (nowarning && !TREE_NO_WARNING (ret))
1600 {
1601 if (!CAN_HAVE_LOCATION_P (ret))
1602 ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
1603 TREE_NO_WARNING (ret) = 1;
1604 }
1605 if (ret != expr)
1606 protected_set_expr_location (ret, loc);
1607 return ret;
1608}
1609
1610/* If not optimizing, EXP is not a VAR_DECL, or EXP has array type,
1611 return EXP. Otherwise, return either EXP or its known constant
1612 value (if it has one), but return EXP if EXP has mode BLKmode. ???
1613 Is the BLKmode test appropriate? */
1614
1615tree
1616decl_constant_value_for_optimization (tree exp)
1617{
1618 tree ret;
1619
1620 /* This function is only used by C, for c_fully_fold and other
1621 optimization, and may not be correct for C++. */
1622 if (c_dialect_cxx ())
1623 gcc_unreachable ();
1624
1625 if (!optimize
1626 || TREE_CODE (exp) != VAR_DECL
1627 || TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE
1628 || DECL_MODE (exp) == BLKmode)
1629 return exp;
1630
1631 ret = decl_constant_value (exp);
1632 /* Avoid unwanted tree sharing between the initializer and current
1633 function's body where the tree can be modified e.g. by the
1634 gimplifier. */
1635 if (ret != exp && TREE_STATIC (exp))
1636 ret = unshare_expr (ret);
1637 return ret;
1638}
1639
1640/* Print a warning if a constant expression had overflow in folding.
1641 Invoke this function on every expression that the language
1642 requires to be a constant expression.
1643 Note the ANSI C standard says it is erroneous for a
1644 constant expression to overflow. */
1645
1646void
1647constant_expression_warning (tree value)
1648{
1649 if (warn_overflow && pedantic
1650 && (TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
1651 || TREE_CODE (value) == FIXED_CST
1652 || TREE_CODE (value) == VECTOR_CST
1653 || TREE_CODE (value) == COMPLEX_CST)
1654 && TREE_OVERFLOW (value))
1655 pedwarn (input_location, OPT_Woverflow, "overflow in constant expression");
1656}
1657
1658/* The same as above but print an unconditional error. */
1659void
1660constant_expression_error (tree value)
1661{
1662 if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
1663 || TREE_CODE (value) == FIXED_CST
1664 || TREE_CODE (value) == VECTOR_CST
1665 || TREE_CODE (value) == COMPLEX_CST)
1666 && TREE_OVERFLOW (value))
1667 error ("overflow in constant expression");
1668}
1669
1670/* Print a warning if an expression had overflow in folding and its
1671 operands hadn't.
1672
1673 Invoke this function on every expression that
1674 (1) appears in the source code, and
1675 (2) is a constant expression that overflowed, and
1676 (3) is not already checked by convert_and_check;
1677 however, do not invoke this function on operands of explicit casts
1678 or when the expression is the result of an operator and any operand
1679 already overflowed. */
1680
1681void
1682overflow_warning (tree value)
1683{
1684 if (skip_evaluation) return;
1685
1686 switch (TREE_CODE (value))
1687 {
1688 case INTEGER_CST:
1689 warning (OPT_Woverflow, "integer overflow in expression");
1690 break;
1691
1692 case REAL_CST:
1693 warning (OPT_Woverflow, "floating point overflow in expression");
1694 break;
1695
1696 case FIXED_CST:
1697 warning (OPT_Woverflow, "fixed-point overflow in expression");
1698 break;
1699
1700 case VECTOR_CST:
1701 warning (OPT_Woverflow, "vector overflow in expression");
1702 break;
1703
1704 case COMPLEX_CST:
1705 if (TREE_CODE (TREE_REALPART (value)) == INTEGER_CST)
1706 warning (OPT_Woverflow, "complex integer overflow in expression");
1707 else if (TREE_CODE (TREE_REALPART (value)) == REAL_CST)
1708 warning (OPT_Woverflow, "complex floating point overflow in expression");
1709 break;
1710
1711 default:
1712 break;
1713 }
1714}
1715
1716/* Warn about uses of logical || / && operator in a context where it
1717 is likely that the bitwise equivalent was intended by the
1718 programmer. We have seen an expression in which CODE is a binary
1719 operator used to combine expressions OP_LEFT and OP_RIGHT, which
1720 before folding had CODE_LEFT and CODE_RIGHT. */
1721
1722void
1723warn_logical_operator (location_t location, enum tree_code code,
1724 enum tree_code code_left, tree op_left,
1725 enum tree_code ARG_UNUSED (code_right), tree op_right)
1726{
1727 if (code != TRUTH_ANDIF_EXPR
1728 && code != TRUTH_AND_EXPR
1729 && code != TRUTH_ORIF_EXPR
1730 && code != TRUTH_OR_EXPR)
1731 return;
1732
1733 /* Warn if &&/|| are being used in a context where it is
1734 likely that the bitwise equivalent was intended by the
1735 programmer. That is, an expression such as op && MASK
1736 where op should not be any boolean expression, nor a
1737 constant, and mask seems to be a non-boolean integer constant. */
1738 if (!truth_value_p (code_left)
1739 && INTEGRAL_TYPE_P (TREE_TYPE (op_left))
1740 && !CONSTANT_CLASS_P (op_left)
1741 && !TREE_NO_WARNING (op_left)
1742 && TREE_CODE (op_right) == INTEGER_CST
1743 && !integer_zerop (op_right)
1744 && !integer_onep (op_right))
1745 {
1746 if (code == TRUTH_ORIF_EXPR || code == TRUTH_OR_EXPR)
1747 warning_at (location, OPT_Wlogical_op, "logical %<or%>"
1748 " applied to non-boolean constant");
1749 else
1750 warning_at (location, OPT_Wlogical_op, "logical %<and%>"
1751 " applied to non-boolean constant");
1752 TREE_NO_WARNING (op_left) = true;
1753 }
1754}
1755
1756
1757/* Print a warning about casts that might indicate violation
1758 of strict aliasing rules if -Wstrict-aliasing is used and
1759 strict aliasing mode is in effect. OTYPE is the original
1760 TREE_TYPE of EXPR, and TYPE the type we're casting to. */
1761
1762bool
1763strict_aliasing_warning (tree otype, tree type, tree expr)
1764{
1765 if (!(flag_strict_aliasing
1766 && POINTER_TYPE_P (type)
1767 && POINTER_TYPE_P (otype)
1768 && !VOID_TYPE_P (TREE_TYPE (type)))
1769 /* If the type we are casting to is a ref-all pointer
1770 dereferencing it is always valid. */
1771 || TYPE_REF_CAN_ALIAS_ALL (type))
1772 return false;
1773
1774 if ((warn_strict_aliasing > 1) && TREE_CODE (expr) == ADDR_EXPR
1775 && (DECL_P (TREE_OPERAND (expr, 0))
1776 || handled_component_p (TREE_OPERAND (expr, 0))))
1777 {
1778 /* Casting the address of an object to non void pointer. Warn
1779 if the cast breaks type based aliasing. */
1780 if (!COMPLETE_TYPE_P (TREE_TYPE (type)) && warn_strict_aliasing == 2)
1781 {
1782 warning (OPT_Wstrict_aliasing, "type-punning to incomplete type "
1783 "might break strict-aliasing rules");
1784 return true;
1785 }
1786 else
1787 {
1788 /* warn_strict_aliasing >= 3. This includes the default (3).
1789 Only warn if the cast is dereferenced immediately. */
1790 alias_set_type set1 =
1791 get_alias_set (TREE_TYPE (TREE_OPERAND (expr, 0)));
1792 alias_set_type set2 = get_alias_set (TREE_TYPE (type));
1793
1794 if (set1 != set2 && set2 != 0
1795 && (set1 == 0 || !alias_sets_conflict_p (set1, set2)))
1796 {
1797 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1798 "pointer will break strict-aliasing rules");
1799 return true;
1800 }
1801 else if (warn_strict_aliasing == 2
1802 && !alias_sets_must_conflict_p (set1, set2))
1803 {
1804 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1805 "pointer might break strict-aliasing rules");
1806 return true;
1807 }
1808 }
1809 }
1810 else
1811 if ((warn_strict_aliasing == 1) && !VOID_TYPE_P (TREE_TYPE (otype)))
1812 {
1813 /* At this level, warn for any conversions, even if an address is
1814 not taken in the same statement. This will likely produce many
1815 false positives, but could be useful to pinpoint problems that
1816 are not revealed at higher levels. */
1817 alias_set_type set1 = get_alias_set (TREE_TYPE (otype));
1818 alias_set_type set2 = get_alias_set (TREE_TYPE (type));
1819 if (!COMPLETE_TYPE_P (type)
1820 || !alias_sets_must_conflict_p (set1, set2))
1821 {
1822 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1823 "pointer might break strict-aliasing rules");
1824 return true;
1825 }
1826 }
1827
1828 return false;
1829}
1830
1831/* Warn for unlikely, improbable, or stupid DECL declarations
1832 of `main'. */
1833
1834void
1835check_main_parameter_types (tree decl)
1836{
1837 tree args;
1838 int argct = 0;
1839
1840 for (args = TYPE_ARG_TYPES (TREE_TYPE (decl)); args;
1841 args = TREE_CHAIN (args))
1842 {
1843 tree type = args ? TREE_VALUE (args) : 0;
1844
1845 if (type == void_type_node || type == error_mark_node )
1846 break;
1847
1848 ++argct;
1849 switch (argct)
1850 {
1851 case 1:
1852 if (TYPE_MAIN_VARIANT (type) != integer_type_node)
1853 pedwarn (input_location, OPT_Wmain, "first argument of %q+D should be %<int%>",
1854 decl);
1855 break;
1856
1857 case 2:
1858 if (TREE_CODE (type) != POINTER_TYPE
1859 || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
1860 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
1861 != char_type_node))
1862 pedwarn (input_location, OPT_Wmain, "second argument of %q+D should be %<char **%>",
1863 decl);
1864 break;
1865
1866 case 3:
1867 if (TREE_CODE (type) != POINTER_TYPE
1868 || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
1869 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
1870 != char_type_node))
1871 pedwarn (input_location, OPT_Wmain, "third argument of %q+D should probably be "
1872 "%<char **%>", decl);
1873 break;
1874 }
1875 }
1876
1877 /* It is intentional that this message does not mention the third
1878 argument because it's only mentioned in an appendix of the
1879 standard. */
1880 if (argct > 0 && (argct < 2 || argct > 3))
1881 pedwarn (input_location, OPT_Wmain, "%q+D takes only zero or two arguments", decl);
1882}
1883
1884/* True if pointers to distinct types T1 and T2 can be converted to
1885 each other without an explicit cast. Only returns true for opaque
1886 vector types. */
1887bool
1888vector_targets_convertible_p (const_tree t1, const_tree t2)
1889{
1890 if (TREE_CODE (t1) == VECTOR_TYPE && TREE_CODE (t2) == VECTOR_TYPE
1891 && (TYPE_VECTOR_OPAQUE (t1) || TYPE_VECTOR_OPAQUE (t2))
1892 && tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2)))
1893 return true;
1894
1895 return false;
1896}
1897
1898/* True if vector types T1 and T2 can be converted to each other
1899 without an explicit cast. If EMIT_LAX_NOTE is true, and T1 and T2
1900 can only be converted with -flax-vector-conversions yet that is not
1901 in effect, emit a note telling the user about that option if such
1902 a note has not previously been emitted. */
1903bool
1904vector_types_convertible_p (const_tree t1, const_tree t2, bool emit_lax_note)
1905{
1906 static bool emitted_lax_note = false;
1907 bool convertible_lax;
1908
1909 if ((TYPE_VECTOR_OPAQUE (t1) || TYPE_VECTOR_OPAQUE (t2))
1910 && tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2)))
1911 return true;
1912
1913 convertible_lax =
1914 (tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2))
1915 && (TREE_CODE (TREE_TYPE (t1)) != REAL_TYPE ||
1916 TYPE_PRECISION (t1) == TYPE_PRECISION (t2))
1917 && (INTEGRAL_TYPE_P (TREE_TYPE (t1))
1918 == INTEGRAL_TYPE_P (TREE_TYPE (t2))));
1919
1920 if (!convertible_lax || flag_lax_vector_conversions)
1921 return convertible_lax;
1922
1923 if (TYPE_VECTOR_SUBPARTS (t1) == TYPE_VECTOR_SUBPARTS (t2)
1924 && lang_hooks.types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1925 return true;
1926
1927 if (emit_lax_note && !emitted_lax_note)
1928 {
1929 emitted_lax_note = true;
1930 inform (input_location, "use -flax-vector-conversions to permit "
1931 "conversions between vectors with differing "
1932 "element types or numbers of subparts");
1933 }
1934
1935 return false;
1936}
1937
1938/* This is a helper function of build_binary_op.
1939
1940 For certain operations if both args were extended from the same
1941 smaller type, do the arithmetic in that type and then extend.
1942
1943 BITWISE indicates a bitwise operation.
1944 For them, this optimization is safe only if
1945 both args are zero-extended or both are sign-extended.
1946 Otherwise, we might change the result.
1947 Eg, (short)-1 | (unsigned short)-1 is (int)-1
1948 but calculated in (unsigned short) it would be (unsigned short)-1.
1949*/
1950tree shorten_binary_op (tree result_type, tree op0, tree op1, bool bitwise)
1951{
1952 int unsigned0, unsigned1;
1953 tree arg0, arg1;
1954 int uns;
1955 tree type;
1956
1957 /* Cast OP0 and OP1 to RESULT_TYPE. Doing so prevents
1958 excessive narrowing when we call get_narrower below. For
1959 example, suppose that OP0 is of unsigned int extended
1960 from signed char and that RESULT_TYPE is long long int.
1961 If we explicitly cast OP0 to RESULT_TYPE, OP0 would look
1962 like
1963
1964 (long long int) (unsigned int) signed_char
1965
1966 which get_narrower would narrow down to
1967
1968 (unsigned int) signed char
1969
1970 If we do not cast OP0 first, get_narrower would return
1971 signed_char, which is inconsistent with the case of the
1972 explicit cast. */
1973 op0 = convert (result_type, op0);
1974 op1 = convert (result_type, op1);
1975
1976 arg0 = get_narrower (op0, &unsigned0);
1977 arg1 = get_narrower (op1, &unsigned1);
1978
1979 /* UNS is 1 if the operation to be done is an unsigned one. */
1980 uns = TYPE_UNSIGNED (result_type);
1981
1982 /* Handle the case that OP0 (or OP1) does not *contain* a conversion
1983 but it *requires* conversion to FINAL_TYPE. */
1984
1985 if ((TYPE_PRECISION (TREE_TYPE (op0))
1986 == TYPE_PRECISION (TREE_TYPE (arg0)))
1987 && TREE_TYPE (op0) != result_type)
1988 unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0));
1989 if ((TYPE_PRECISION (TREE_TYPE (op1))
1990 == TYPE_PRECISION (TREE_TYPE (arg1)))
1991 && TREE_TYPE (op1) != result_type)
1992 unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1));
1993
1994 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
1995
1996 /* For bitwise operations, signedness of nominal type
1997 does not matter. Consider only how operands were extended. */
1998 if (bitwise)
1999 uns = unsigned0;
2000
2001 /* Note that in all three cases below we refrain from optimizing
2002 an unsigned operation on sign-extended args.
2003 That would not be valid. */
2004
2005 /* Both args variable: if both extended in same way
2006 from same width, do it in that width.
2007 Do it unsigned if args were zero-extended. */
2008 if ((TYPE_PRECISION (TREE_TYPE (arg0))
2009 < TYPE_PRECISION (result_type))
2010 && (TYPE_PRECISION (TREE_TYPE (arg1))
2011 == TYPE_PRECISION (TREE_TYPE (arg0)))
2012 && unsigned0 == unsigned1
2013 && (unsigned0 || !uns))
2014 return c_common_signed_or_unsigned_type
2015 (unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
2016
2017 else if (TREE_CODE (arg0) == INTEGER_CST
2018 && (unsigned1 || !uns)
2019 && (TYPE_PRECISION (TREE_TYPE (arg1))
2020 < TYPE_PRECISION (result_type))
2021 && (type
2022 = c_common_signed_or_unsigned_type (unsigned1,
2023 TREE_TYPE (arg1)))
2024 && !POINTER_TYPE_P (type)
2025 && int_fits_type_p (arg0, type))
2026 return type;
2027
2028 else if (TREE_CODE (arg1) == INTEGER_CST
2029 && (unsigned0 || !uns)
2030 && (TYPE_PRECISION (TREE_TYPE (arg0))
2031 < TYPE_PRECISION (result_type))
2032 && (type
2033 = c_common_signed_or_unsigned_type (unsigned0,
2034 TREE_TYPE (arg0)))
2035 && !POINTER_TYPE_P (type)
2036 && int_fits_type_p (arg1, type))
2037 return type;
2038
2039 return result_type;
2040}
2041
2042/* Warns if the conversion of EXPR to TYPE may alter a value.
2043 This is a helper function for warnings_for_convert_and_check. */
2044
2045static void
2046conversion_warning (tree type, tree expr)
2047{
2048 bool give_warning = false;
2049
2050 int i;
2051 const int expr_num_operands = TREE_OPERAND_LENGTH (expr);
2052 tree expr_type = TREE_TYPE (expr);
2053
2054 if (!warn_conversion && !warn_sign_conversion)
2055 return;
2056
2057 /* If any operand is artificial, then this expression was generated
2058 by the compiler and we do not warn. */
2059 for (i = 0; i < expr_num_operands; i++)
2060 {
2061 tree op = TREE_OPERAND (expr, i);
2062 if (op && DECL_P (op) && DECL_ARTIFICIAL (op))
2063 return;
2064 }
2065
2066 switch (TREE_CODE (expr))
2067 {
2068 case EQ_EXPR:
2069 case NE_EXPR:
2070 case LE_EXPR:
2071 case GE_EXPR:
2072 case LT_EXPR:
2073 case GT_EXPR:
2074 case TRUTH_ANDIF_EXPR:
2075 case TRUTH_ORIF_EXPR:
2076 case TRUTH_AND_EXPR:
2077 case TRUTH_OR_EXPR:
2078 case TRUTH_XOR_EXPR:
2079 case TRUTH_NOT_EXPR:
2080 /* Conversion from boolean to a signed:1 bit-field (which only
2081 can hold the values 0 and -1) doesn't lose information - but
2082 it does change the value. */
2083 if (TYPE_PRECISION (type) == 1 && !TYPE_UNSIGNED (type))
2084 warning (OPT_Wconversion,
2085 "conversion to %qT from boolean expression", type);
2086 return;
2087
2088 case REAL_CST:
2089 case INTEGER_CST:
2090
2091 /* Warn for real constant that is not an exact integer converted
2092 to integer type. */
2093 if (TREE_CODE (expr_type) == REAL_TYPE
2094 && TREE_CODE (type) == INTEGER_TYPE)
2095 {
2096 if (!real_isinteger (TREE_REAL_CST_PTR (expr), TYPE_MODE (expr_type)))
2097 give_warning = true;
2098 }
2099 /* Warn for an integer constant that does not fit into integer type. */
2100 else if (TREE_CODE (expr_type) == INTEGER_TYPE
2101 && TREE_CODE (type) == INTEGER_TYPE
2102 && !int_fits_type_p (expr, type))
2103 {
2104 if (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (expr_type)
2105 && tree_int_cst_sgn (expr) < 0)
2106 warning (OPT_Wsign_conversion,
2107 "negative integer implicitly converted to unsigned type");
2108 else if (!TYPE_UNSIGNED (type) && TYPE_UNSIGNED (expr_type))
2109 warning (OPT_Wsign_conversion, "conversion of unsigned constant "
2110 "value to negative integer");
2111 else
2112 give_warning = true;
2113 }
2114 else if (TREE_CODE (type) == REAL_TYPE)
2115 {
2116 /* Warn for an integer constant that does not fit into real type. */
2117 if (TREE_CODE (expr_type) == INTEGER_TYPE)
2118 {
2119 REAL_VALUE_TYPE a = real_value_from_int_cst (0, expr);
2120 if (!exact_real_truncate (TYPE_MODE (type), &a))
2121 give_warning = true;
2122 }
2123 /* Warn for a real constant that does not fit into a smaller
2124 real type. */
2125 else if (TREE_CODE (expr_type) == REAL_TYPE
2126 && TYPE_PRECISION (type) < TYPE_PRECISION (expr_type))
2127 {
2128 REAL_VALUE_TYPE a = TREE_REAL_CST (expr);
2129 if (!exact_real_truncate (TYPE_MODE (type), &a))
2130 give_warning = true;
2131 }
2132 }
2133
2134 if (give_warning)
2135 warning (OPT_Wconversion,
2136 "conversion to %qT alters %qT constant value",
2137 type, expr_type);
2138
2139 return;
2140
2141 case COND_EXPR:
2142 {
2143 /* In case of COND_EXPR, if both operands are constants or
2144 COND_EXPR, then we do not care about the type of COND_EXPR,
2145 only about the conversion of each operand. */
2146 tree op1 = TREE_OPERAND (expr, 1);
2147 tree op2 = TREE_OPERAND (expr, 2);
2148
2149 if ((TREE_CODE (op1) == REAL_CST || TREE_CODE (op1) == INTEGER_CST
2150 || TREE_CODE (op1) == COND_EXPR)
2151 && (TREE_CODE (op2) == REAL_CST || TREE_CODE (op2) == INTEGER_CST
2152 || TREE_CODE (op2) == COND_EXPR))
2153 {
2154 conversion_warning (type, op1);
2155 conversion_warning (type, op2);
2156 return;
2157 }
2158 /* Fall through. */
2159 }
2160
2161 default: /* 'expr' is not a constant. */
2162
2163 /* Warn for real types converted to integer types. */
2164 if (TREE_CODE (expr_type) == REAL_TYPE
2165 && TREE_CODE (type) == INTEGER_TYPE)
2166 give_warning = true;
2167
2168 else if (TREE_CODE (expr_type) == INTEGER_TYPE
2169 && TREE_CODE (type) == INTEGER_TYPE)
2170 {
2171 /* Don't warn about unsigned char y = 0xff, x = (int) y; */
2172 expr = get_unwidened (expr, 0);
2173 expr_type = TREE_TYPE (expr);
2174
2175 /* Don't warn for short y; short x = ((int)y & 0xff); */
2176 if (TREE_CODE (expr) == BIT_AND_EXPR
2177 || TREE_CODE (expr) == BIT_IOR_EXPR
2178 || TREE_CODE (expr) == BIT_XOR_EXPR)
2179 {
2180 /* If both args were extended from a shortest type,
2181 use that type if that is safe. */
2182 expr_type = shorten_binary_op (expr_type,
2183 TREE_OPERAND (expr, 0),
2184 TREE_OPERAND (expr, 1),
2185 /* bitwise */1);
2186
2187 if (TREE_CODE (expr) == BIT_AND_EXPR)
2188 {
2189 tree op0 = TREE_OPERAND (expr, 0);
2190 tree op1 = TREE_OPERAND (expr, 1);
2191 bool unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0));
2192 bool unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1));
2193
2194 /* If one of the operands is a non-negative constant
2195 that fits in the target type, then the type of the
2196 other operand does not matter. */
2197 if ((TREE_CODE (op0) == INTEGER_CST
2198 && int_fits_type_p (op0, c_common_signed_type (type))
2199 && int_fits_type_p (op0, c_common_unsigned_type (type)))
2200 || (TREE_CODE (op1) == INTEGER_CST
2201 && int_fits_type_p (op1, c_common_signed_type (type))
2202 && int_fits_type_p (op1,
2203 c_common_unsigned_type (type))))
2204 return;
2205 /* If constant is unsigned and fits in the target
2206 type, then the result will also fit. */
2207 else if ((TREE_CODE (op0) == INTEGER_CST
2208 && unsigned0
2209 && int_fits_type_p (op0, type))
2210 || (TREE_CODE (op1) == INTEGER_CST
2211 && unsigned1
2212 && int_fits_type_p (op1, type)))
2213 return;
2214 }
2215 }
2216 /* Warn for integer types converted to smaller integer types. */
2217 if (TYPE_PRECISION (type) < TYPE_PRECISION (expr_type))
2218 give_warning = true;
2219
2220 /* When they are the same width but different signedness,
2221 then the value may change. */
2222 else if ((TYPE_PRECISION (type) == TYPE_PRECISION (expr_type)
2223 && TYPE_UNSIGNED (expr_type) != TYPE_UNSIGNED (type))
2224 /* Even when converted to a bigger type, if the type is
2225 unsigned but expr is signed, then negative values
2226 will be changed. */
2227 || (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (expr_type)))
2228 warning (OPT_Wsign_conversion, "conversion to %qT from %qT "
2229 "may change the sign of the result",
2230 type, expr_type);
2231 }
2232
2233 /* Warn for integer types converted to real types if and only if
2234 all the range of values of the integer type cannot be
2235 represented by the real type. */
2236 else if (TREE_CODE (expr_type) == INTEGER_TYPE
2237 && TREE_CODE (type) == REAL_TYPE)
2238 {
2239 tree type_low_bound = TYPE_MIN_VALUE (expr_type);
2240 tree type_high_bound = TYPE_MAX_VALUE (expr_type);
2241 REAL_VALUE_TYPE real_low_bound
2242 = real_value_from_int_cst (0, type_low_bound);
2243 REAL_VALUE_TYPE real_high_bound
2244 = real_value_from_int_cst (0, type_high_bound);
2245
2246 if (!exact_real_truncate (TYPE_MODE (type), &real_low_bound)
2247 || !exact_real_truncate (TYPE_MODE (type), &real_high_bound))
2248 give_warning = true;
2249 }
2250
2251 /* Warn for real types converted to smaller real types. */
2252 else if (TREE_CODE (expr_type) == REAL_TYPE
2253 && TREE_CODE (type) == REAL_TYPE
2254 && TYPE_PRECISION (type) < TYPE_PRECISION (expr_type))
2255 give_warning = true;
2256
2257
2258 if (give_warning)
2259 warning (OPT_Wconversion,
2260 "conversion to %qT from %qT may alter its value",
2261 type, expr_type);
2262 }
2263}
2264
2265/* Produce warnings after a conversion. RESULT is the result of
2266 converting EXPR to TYPE. This is a helper function for
2267 convert_and_check and cp_convert_and_check. */
2268
2269void
2270warnings_for_convert_and_check (tree type, tree expr, tree result)
2271{
2272 if (TREE_CODE (expr) == INTEGER_CST
2273 && (TREE_CODE (type) == INTEGER_TYPE
2274 || TREE_CODE (type) == ENUMERAL_TYPE)
2275 && !int_fits_type_p (expr, type))
2276 {
2277 /* Do not diagnose overflow in a constant expression merely
2278 because a conversion overflowed. */
2279 if (TREE_OVERFLOW (result))
2280 TREE_OVERFLOW (result) = TREE_OVERFLOW (expr);
2281
2282 if (TYPE_UNSIGNED (type))
2283 {
2284 /* This detects cases like converting -129 or 256 to
2285 unsigned char. */
2286 if (!int_fits_type_p (expr, c_common_signed_type (type)))
2287 warning (OPT_Woverflow,
2288 "large integer implicitly truncated to unsigned type");
2289 else
2290 conversion_warning (type, expr);
2291 }
2292 else if (!int_fits_type_p (expr, c_common_unsigned_type (type)))
2293 warning (OPT_Woverflow,
2294 "overflow in implicit constant conversion");
2295 /* No warning for converting 0x80000000 to int. */
2296 else if (pedantic
2297 && (TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE
2298 || TYPE_PRECISION (TREE_TYPE (expr))
2299 != TYPE_PRECISION (type)))
2300 warning (OPT_Woverflow,
2301 "overflow in implicit constant conversion");
2302
2303 else
2304 conversion_warning (type, expr);
2305 }
2306 else if ((TREE_CODE (result) == INTEGER_CST
2307 || TREE_CODE (result) == FIXED_CST) && TREE_OVERFLOW (result))
2308 warning (OPT_Woverflow,
2309 "overflow in implicit constant conversion");
2310 else
2311 conversion_warning (type, expr);
2312}
2313
2314
2315/* Convert EXPR to TYPE, warning about conversion problems with constants.
2316 Invoke this function on every expression that is converted implicitly,
2317 i.e. because of language rules and not because of an explicit cast. */
2318
2319tree
2320convert_and_check (tree type, tree expr)
2321{
2322 tree result;
2323 tree expr_for_warning;
2324
2325 /* Convert from a value with possible excess precision rather than
2326 via the semantic type, but do not warn about values not fitting
2327 exactly in the semantic type. */
2328 if (TREE_CODE (expr) == EXCESS_PRECISION_EXPR)
2329 {
2330 tree orig_type = TREE_TYPE (expr);
2331 expr = TREE_OPERAND (expr, 0);
2332 expr_for_warning = convert (orig_type, expr);
2333 if (orig_type == type)
2334 return expr_for_warning;
2335 }
2336 else
2337 expr_for_warning = expr;
2338
2339 if (TREE_TYPE (expr) == type)
2340 return expr;
2341
2342 result = convert (type, expr);
2343
2344 if (!skip_evaluation && !TREE_OVERFLOW_P (expr) && result != error_mark_node)
2345 warnings_for_convert_and_check (type, expr_for_warning, result);
2346
2347 return result;
2348}
2349\f
2350/* A node in a list that describes references to variables (EXPR), which are
2351 either read accesses if WRITER is zero, or write accesses, in which case
2352 WRITER is the parent of EXPR. */
2353struct tlist
2354{
2355 struct tlist *next;
2356 tree expr, writer;
2357};
2358
2359/* Used to implement a cache the results of a call to verify_tree. We only
2360 use this for SAVE_EXPRs. */
2361struct tlist_cache
2362{
2363 struct tlist_cache *next;
2364 struct tlist *cache_before_sp;
2365 struct tlist *cache_after_sp;
2366 tree expr;
2367};
2368
2369/* Obstack to use when allocating tlist structures, and corresponding
2370 firstobj. */
2371static struct obstack tlist_obstack;
2372static char *tlist_firstobj = 0;
2373
2374/* Keep track of the identifiers we've warned about, so we can avoid duplicate
2375 warnings. */
2376static struct tlist *warned_ids;
2377/* SAVE_EXPRs need special treatment. We process them only once and then
2378 cache the results. */
2379static struct tlist_cache *save_expr_cache;
2380
2381static void add_tlist (struct tlist **, struct tlist *, tree, int);
2382static void merge_tlist (struct tlist **, struct tlist *, int);
2383static void verify_tree (tree, struct tlist **, struct tlist **, tree);
2384static int warning_candidate_p (tree);
2385static bool candidate_equal_p (const_tree, const_tree);
2386static void warn_for_collisions (struct tlist *);
2387static void warn_for_collisions_1 (tree, tree, struct tlist *, int);
2388static struct tlist *new_tlist (struct tlist *, tree, tree);
2389
2390/* Create a new struct tlist and fill in its fields. */
2391static struct tlist *
2392new_tlist (struct tlist *next, tree t, tree writer)
2393{
2394 struct tlist *l;
2395 l = XOBNEW (&tlist_obstack, struct tlist);
2396 l->next = next;
2397 l->expr = t;
2398 l->writer = writer;
2399 return l;
2400}
2401
2402/* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
2403 is nonnull, we ignore any node we find which has a writer equal to it. */
2404
2405static void
2406add_tlist (struct tlist **to, struct tlist *add, tree exclude_writer, int copy)
2407{
2408 while (add)
2409 {
2410 struct tlist *next = add->next;
2411 if (!copy)
2412 add->next = *to;
2413 if (!exclude_writer || !candidate_equal_p (add->writer, exclude_writer))
2414 *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
2415 add = next;
2416 }
2417}
2418
2419/* Merge the nodes of ADD into TO. This merging process is done so that for
2420 each variable that already exists in TO, no new node is added; however if
2421 there is a write access recorded in ADD, and an occurrence on TO is only
2422 a read access, then the occurrence in TO will be modified to record the
2423 write. */
2424
2425static void
2426merge_tlist (struct tlist **to, struct tlist *add, int copy)
2427{
2428 struct tlist **end = to;
2429
2430 while (*end)
2431 end = &(*end)->next;
2432
2433 while (add)
2434 {
2435 int found = 0;
2436 struct tlist *tmp2;
2437 struct tlist *next = add->next;
2438
2439 for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
2440 if (candidate_equal_p (tmp2->expr, add->expr))
2441 {
2442 found = 1;
2443 if (!tmp2->writer)
2444 tmp2->writer = add->writer;
2445 }
2446 if (!found)
2447 {
2448 *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
2449 end = &(*end)->next;
2450 *end = 0;
2451 }
2452 add = next;
2453 }
2454}
2455
2456/* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
2457 references in list LIST conflict with it, excluding reads if ONLY writers
2458 is nonzero. */
2459
2460static void
2461warn_for_collisions_1 (tree written, tree writer, struct tlist *list,
2462 int only_writes)
2463{
2464 struct tlist *tmp;
2465
2466 /* Avoid duplicate warnings. */
2467 for (tmp = warned_ids; tmp; tmp = tmp->next)
2468 if (candidate_equal_p (tmp->expr, written))
2469 return;
2470
2471 while (list)
2472 {
2473 if (candidate_equal_p (list->expr, written)
2474 && !candidate_equal_p (list->writer, writer)
2475 && (!only_writes || list->writer))
2476 {
2477 warned_ids = new_tlist (warned_ids, written, NULL_TREE);
2478 warning_at (EXPR_HAS_LOCATION (writer)
2479 ? EXPR_LOCATION (writer) : input_location,
2480 OPT_Wsequence_point, "operation on %qE may be undefined",
2481 list->expr);
2482 }
2483 list = list->next;
2484 }
2485}
2486
2487/* Given a list LIST of references to variables, find whether any of these
2488 can cause conflicts due to missing sequence points. */
2489
2490static void
2491warn_for_collisions (struct tlist *list)
2492{
2493 struct tlist *tmp;
2494
2495 for (tmp = list; tmp; tmp = tmp->next)
2496 {
2497 if (tmp->writer)
2498 warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
2499 }
2500}
2501
2502/* Return nonzero if X is a tree that can be verified by the sequence point
2503 warnings. */
2504static int
2505warning_candidate_p (tree x)
2506{
2507 /* !VOID_TYPE_P (TREE_TYPE (x)) is workaround for cp/tree.c
2508 (lvalue_p) crash on TRY/CATCH. */
2509 return !(DECL_P (x) && DECL_ARTIFICIAL (x))
2510 && TREE_TYPE (x) && !VOID_TYPE_P (TREE_TYPE (x)) && lvalue_p (x);
2511}
2512
2513/* Return nonzero if X and Y appear to be the same candidate (or NULL) */
2514static bool
2515candidate_equal_p (const_tree x, const_tree y)
2516{
2517 return (x == y) || (x && y && operand_equal_p (x, y, 0));
2518}
2519
2520/* Walk the tree X, and record accesses to variables. If X is written by the
2521 parent tree, WRITER is the parent.
2522 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
2523 expression or its only operand forces a sequence point, then everything up
2524 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
2525 in PNO_SP.
2526 Once we return, we will have emitted warnings if any subexpression before
2527 such a sequence point could be undefined. On a higher level, however, the
2528 sequence point may not be relevant, and we'll merge the two lists.
2529
2530 Example: (b++, a) + b;
2531 The call that processes the COMPOUND_EXPR will store the increment of B
2532 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
2533 processes the PLUS_EXPR will need to merge the two lists so that
2534 eventually, all accesses end up on the same list (and we'll warn about the
2535 unordered subexpressions b++ and b.
2536
2537 A note on merging. If we modify the former example so that our expression
2538 becomes
2539 (b++, b) + a
2540 care must be taken not simply to add all three expressions into the final
2541 PNO_SP list. The function merge_tlist takes care of that by merging the
2542 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
2543 way, so that no more than one access to B is recorded. */
2544
2545static void
2546verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp,
2547 tree writer)
2548{
2549 struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
2550 enum tree_code code;
2551 enum tree_code_class cl;
2552
2553 /* X may be NULL if it is the operand of an empty statement expression
2554 ({ }). */
2555 if (x == NULL)
2556 return;
2557
2558 restart:
2559 code = TREE_CODE (x);
2560 cl = TREE_CODE_CLASS (code);
2561
2562 if (warning_candidate_p (x))
2563 *pno_sp = new_tlist (*pno_sp, x, writer);
2564
2565 switch (code)
2566 {
2567 case CONSTRUCTOR:
2568 return;
2569
2570 case COMPOUND_EXPR:
2571 case TRUTH_ANDIF_EXPR:
2572 case TRUTH_ORIF_EXPR:
2573 tmp_before = tmp_nosp = tmp_list3 = 0;
2574 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
2575 warn_for_collisions (tmp_nosp);
2576 merge_tlist (pbefore_sp, tmp_before, 0);
2577 merge_tlist (pbefore_sp, tmp_nosp, 0);
2578 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
2579 merge_tlist (pbefore_sp, tmp_list3, 0);
2580 return;
2581
2582 case COND_EXPR:
2583 tmp_before = tmp_list2 = 0;
2584 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
2585 warn_for_collisions (tmp_list2);
2586 merge_tlist (pbefore_sp, tmp_before, 0);
2587 merge_tlist (pbefore_sp, tmp_list2, 1);
2588
2589 tmp_list3 = tmp_nosp = 0;
2590 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
2591 warn_for_collisions (tmp_nosp);
2592 merge_tlist (pbefore_sp, tmp_list3, 0);
2593
2594 tmp_list3 = tmp_list2 = 0;
2595 verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
2596 warn_for_collisions (tmp_list2);
2597 merge_tlist (pbefore_sp, tmp_list3, 0);
2598 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
2599 two first, to avoid warning for (a ? b++ : b++). */
2600 merge_tlist (&tmp_nosp, tmp_list2, 0);
2601 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
2602 return;
2603
2604 case PREDECREMENT_EXPR:
2605 case PREINCREMENT_EXPR:
2606 case POSTDECREMENT_EXPR:
2607 case POSTINCREMENT_EXPR:
2608 verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
2609 return;
2610
2611 case MODIFY_EXPR:
2612 tmp_before = tmp_nosp = tmp_list3 = 0;
2613 verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
2614 verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
2615 /* Expressions inside the LHS are not ordered wrt. the sequence points
2616 in the RHS. Example:
2617 *a = (a++, 2)
2618 Despite the fact that the modification of "a" is in the before_sp
2619 list (tmp_before), it conflicts with the use of "a" in the LHS.
2620 We can handle this by adding the contents of tmp_list3
2621 to those of tmp_before, and redoing the collision warnings for that
2622 list. */
2623 add_tlist (&tmp_before, tmp_list3, x, 1);
2624 warn_for_collisions (tmp_before);
2625 /* Exclude the LHS itself here; we first have to merge it into the
2626 tmp_nosp list. This is done to avoid warning for "a = a"; if we
2627 didn't exclude the LHS, we'd get it twice, once as a read and once
2628 as a write. */
2629 add_tlist (pno_sp, tmp_list3, x, 0);
2630 warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
2631
2632 merge_tlist (pbefore_sp, tmp_before, 0);
2633 if (warning_candidate_p (TREE_OPERAND (x, 0)))
2634 merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
2635 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
2636 return;
2637
2638 case CALL_EXPR:
2639 /* We need to warn about conflicts among arguments and conflicts between
2640 args and the function address. Side effects of the function address,
2641 however, are not ordered by the sequence point of the call. */
2642 {
2643 call_expr_arg_iterator iter;
2644 tree arg;
2645 tmp_before = tmp_nosp = 0;
2646 verify_tree (CALL_EXPR_FN (x), &tmp_before, &tmp_nosp, NULL_TREE);
2647 FOR_EACH_CALL_EXPR_ARG (arg, iter, x)
2648 {
2649 tmp_list2 = tmp_list3 = 0;
2650 verify_tree (arg, &tmp_list2, &tmp_list3, NULL_TREE);
2651 merge_tlist (&tmp_list3, tmp_list2, 0);
2652 add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
2653 }
2654 add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
2655 warn_for_collisions (tmp_before);
2656 add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
2657 return;
2658 }
2659
2660 case TREE_LIST:
2661 /* Scan all the list, e.g. indices of multi dimensional array. */
2662 while (x)
2663 {
2664 tmp_before = tmp_nosp = 0;
2665 verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
2666 merge_tlist (&tmp_nosp, tmp_before, 0);
2667 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
2668 x = TREE_CHAIN (x);
2669 }
2670 return;
2671
2672 case SAVE_EXPR:
2673 {
2674 struct tlist_cache *t;
2675 for (t = save_expr_cache; t; t = t->next)
2676 if (candidate_equal_p (t->expr, x))
2677 break;
2678
2679 if (!t)
2680 {
2681 t = XOBNEW (&tlist_obstack, struct tlist_cache);
2682 t->next = save_expr_cache;
2683 t->expr = x;
2684 save_expr_cache = t;
2685
2686 tmp_before = tmp_nosp = 0;
2687 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
2688 warn_for_collisions (tmp_nosp);
2689
2690 tmp_list3 = 0;
2691 while (tmp_nosp)
2692 {
2693 struct tlist *t = tmp_nosp;
2694 tmp_nosp = t->next;
2695 merge_tlist (&tmp_list3, t, 0);
2696 }
2697 t->cache_before_sp = tmp_before;
2698 t->cache_after_sp = tmp_list3;
2699 }
2700 merge_tlist (pbefore_sp, t->cache_before_sp, 1);
2701 add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
2702 return;
2703 }
2704
2705 case ADDR_EXPR:
2706 x = TREE_OPERAND (x, 0);
2707 if (DECL_P (x))
2708 return;
2709 writer = 0;
2710 goto restart;
2711
2712 default:
2713 /* For other expressions, simply recurse on their operands.
2714 Manual tail recursion for unary expressions.
2715 Other non-expressions need not be processed. */
2716 if (cl == tcc_unary)
2717 {
2718 x = TREE_OPERAND (x, 0);
2719 writer = 0;
2720 goto restart;
2721 }
2722 else if (IS_EXPR_CODE_CLASS (cl))
2723 {
2724 int lp;
2725 int max = TREE_OPERAND_LENGTH (x);
2726 for (lp = 0; lp < max; lp++)
2727 {
2728 tmp_before = tmp_nosp = 0;
2729 verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, 0);
2730 merge_tlist (&tmp_nosp, tmp_before, 0);
2731 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
2732 }
2733 }
2734 return;
2735 }
2736}
2737
2738/* Try to warn for undefined behavior in EXPR due to missing sequence
2739 points. */
2740
2741void
2742verify_sequence_points (tree expr)
2743{
2744 struct tlist *before_sp = 0, *after_sp = 0;
2745
2746 warned_ids = 0;
2747 save_expr_cache = 0;
2748 if (tlist_firstobj == 0)
2749 {
2750 gcc_obstack_init (&tlist_obstack);
2751 tlist_firstobj = (char *) obstack_alloc (&tlist_obstack, 0);
2752 }
2753
2754 verify_tree (expr, &before_sp, &after_sp, 0);
2755 warn_for_collisions (after_sp);
2756 obstack_free (&tlist_obstack, tlist_firstobj);
2757}
2758\f
2759/* Validate the expression after `case' and apply default promotions. */
2760
2761static tree
2762check_case_value (tree value)
2763{
2764 if (value == NULL_TREE)
2765 return value;
2766
2767 /* ??? Can we ever get nops here for a valid case value? We
2768 shouldn't for C. */
2769 STRIP_TYPE_NOPS (value);
2770 /* In C++, the following is allowed:
2771
2772 const int i = 3;
2773 switch (...) { case i: ... }
2774
2775 So, we try to reduce the VALUE to a constant that way. */
2776 if (c_dialect_cxx ())
2777 {
2778 value = decl_constant_value (value);
2779 STRIP_TYPE_NOPS (value);
2780 value = fold (value);
2781 }
2782
2783 if (TREE_CODE (value) == INTEGER_CST)
2784 /* Promote char or short to int. */
2785 value = perform_integral_promotions (value);
2786 else if (value != error_mark_node)
2787 {
2788 error ("case label does not reduce to an integer constant");
2789 value = error_mark_node;
2790 }
2791
2792 constant_expression_warning (value);
2793
2794 return value;
2795}
2796\f
2797/* See if the case values LOW and HIGH are in the range of the original
2798 type (i.e. before the default conversion to int) of the switch testing
2799 expression.
2800 TYPE is the promoted type of the testing expression, and ORIG_TYPE is
2801 the type before promoting it. CASE_LOW_P is a pointer to the lower
2802 bound of the case label, and CASE_HIGH_P is the upper bound or NULL
2803 if the case is not a case range.
2804 The caller has to make sure that we are not called with NULL for
2805 CASE_LOW_P (i.e. the default case).
2806 Returns true if the case label is in range of ORIG_TYPE (saturated or
2807 untouched) or false if the label is out of range. */
2808
2809static bool
2810check_case_bounds (tree type, tree orig_type,
2811 tree *case_low_p, tree *case_high_p)
2812{
2813 tree min_value, max_value;
2814 tree case_low = *case_low_p;
2815 tree case_high = case_high_p ? *case_high_p : case_low;
2816
2817 /* If there was a problem with the original type, do nothing. */
2818 if (orig_type == error_mark_node)
2819 return true;
2820
2821 min_value = TYPE_MIN_VALUE (orig_type);
2822 max_value = TYPE_MAX_VALUE (orig_type);
2823
2824 /* Case label is less than minimum for type. */
2825 if (tree_int_cst_compare (case_low, min_value) < 0
2826 && tree_int_cst_compare (case_high, min_value) < 0)
2827 {
2828 warning (0, "case label value is less than minimum value for type");
2829 return false;
2830 }
2831
2832 /* Case value is greater than maximum for type. */
2833 if (tree_int_cst_compare (case_low, max_value) > 0
2834 && tree_int_cst_compare (case_high, max_value) > 0)
2835 {
2836 warning (0, "case label value exceeds maximum value for type");
2837 return false;
2838 }
2839
2840 /* Saturate lower case label value to minimum. */
2841 if (tree_int_cst_compare (case_high, min_value) >= 0
2842 && tree_int_cst_compare (case_low, min_value) < 0)
2843 {
2844 warning (0, "lower value in case label range"
2845 " less than minimum value for type");
2846 case_low = min_value;
2847 }
2848
2849 /* Saturate upper case label value to maximum. */
2850 if (tree_int_cst_compare (case_low, max_value) <= 0
2851 && tree_int_cst_compare (case_high, max_value) > 0)
2852 {
2853 warning (0, "upper value in case label range"
2854 " exceeds maximum value for type");
2855 case_high = max_value;
2856 }
2857
2858 if (*case_low_p != case_low)
2859 *case_low_p = convert (type, case_low);
2860 if (case_high_p && *case_high_p != case_high)
2861 *case_high_p = convert (type, case_high);
2862
2863 return true;
2864}
2865\f
2866/* Return an integer type with BITS bits of precision,
2867 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
2868
2869tree
2870c_common_type_for_size (unsigned int bits, int unsignedp)
2871{
2872 if (bits == TYPE_PRECISION (integer_type_node))
2873 return unsignedp ? unsigned_type_node : integer_type_node;
2874
2875 if (bits == TYPE_PRECISION (signed_char_type_node))
2876 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2877
2878 if (bits == TYPE_PRECISION (short_integer_type_node))
2879 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2880
2881 if (bits == TYPE_PRECISION (long_integer_type_node))
2882 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2883
2884 if (bits == TYPE_PRECISION (long_long_integer_type_node))
2885 return (unsignedp ? long_long_unsigned_type_node
2886 : long_long_integer_type_node);
2887
2888 if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
2889 return (unsignedp ? widest_unsigned_literal_type_node
2890 : widest_integer_literal_type_node);
2891
2892 if (bits <= TYPE_PRECISION (intQI_type_node))
2893 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2894
2895 if (bits <= TYPE_PRECISION (intHI_type_node))
2896 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2897
2898 if (bits <= TYPE_PRECISION (intSI_type_node))
2899 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2900
2901 if (bits <= TYPE_PRECISION (intDI_type_node))
2902 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2903
2904 return 0;
2905}
2906
2907/* Return a fixed-point type that has at least IBIT ibits and FBIT fbits
2908 that is unsigned if UNSIGNEDP is nonzero, otherwise signed;
2909 and saturating if SATP is nonzero, otherwise not saturating. */
2910
2911tree
2912c_common_fixed_point_type_for_size (unsigned int ibit, unsigned int fbit,
2913 int unsignedp, int satp)
2914{
2915 enum machine_mode mode;
2916 if (ibit == 0)
2917 mode = unsignedp ? UQQmode : QQmode;
2918 else
2919 mode = unsignedp ? UHAmode : HAmode;
2920
2921 for (; mode != VOIDmode; mode = GET_MODE_WIDER_MODE (mode))
2922 if (GET_MODE_IBIT (mode) >= ibit && GET_MODE_FBIT (mode) >= fbit)
2923 break;
2924
2925 if (mode == VOIDmode || !targetm.scalar_mode_supported_p (mode))
2926 {
2927 sorry ("GCC cannot support operators with integer types and "
2928 "fixed-point types that have too many integral and "
2929 "fractional bits together");
2930 return 0;
2931 }
2932
2933 return c_common_type_for_mode (mode, satp);
2934}
2935
2936/* Used for communication between c_common_type_for_mode and
2937 c_register_builtin_type. */
2938static GTY(()) tree registered_builtin_types;
2939
2940/* Return a data type that has machine mode MODE.
2941 If the mode is an integer,
2942 then UNSIGNEDP selects between signed and unsigned types.
2943 If the mode is a fixed-point mode,
2944 then UNSIGNEDP selects between saturating and nonsaturating types. */
2945
2946tree
2947c_common_type_for_mode (enum machine_mode mode, int unsignedp)
2948{
2949 tree t;
2950
2951 if (mode == TYPE_MODE (integer_type_node))
2952 return unsignedp ? unsigned_type_node : integer_type_node;
2953
2954 if (mode == TYPE_MODE (signed_char_type_node))
2955 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2956
2957 if (mode == TYPE_MODE (short_integer_type_node))
2958 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2959
2960 if (mode == TYPE_MODE (long_integer_type_node))
2961 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2962
2963 if (mode == TYPE_MODE (long_long_integer_type_node))
2964 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
2965
2966 if (mode == TYPE_MODE (widest_integer_literal_type_node))
2967 return unsignedp ? widest_unsigned_literal_type_node
2968 : widest_integer_literal_type_node;
2969
2970 if (mode == QImode)
2971 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2972
2973 if (mode == HImode)
2974 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2975
2976 if (mode == SImode)
2977 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2978
2979 if (mode == DImode)
2980 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2981
2982#if HOST_BITS_PER_WIDE_INT >= 64
2983 if (mode == TYPE_MODE (intTI_type_node))
2984 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2985#endif
2986
2987 if (mode == TYPE_MODE (float_type_node))
2988 return float_type_node;
2989
2990 if (mode == TYPE_MODE (double_type_node))
2991 return double_type_node;
2992
2993 if (mode == TYPE_MODE (long_double_type_node))
2994 return long_double_type_node;
2995
2996 if (mode == TYPE_MODE (void_type_node))
2997 return void_type_node;
2998
2999 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
3000 return (unsignedp
3001 ? make_unsigned_type (GET_MODE_PRECISION (mode))
3002 : make_signed_type (GET_MODE_PRECISION (mode)));
3003
3004 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
3005 return (unsignedp
3006 ? make_unsigned_type (GET_MODE_PRECISION (mode))
3007 : make_signed_type (GET_MODE_PRECISION (mode)));
3008
3009 if (COMPLEX_MODE_P (mode))
3010 {
3011 enum machine_mode inner_mode;
3012 tree inner_type;
3013
3014 if (mode == TYPE_MODE (complex_float_type_node))
3015 return complex_float_type_node;
3016 if (mode == TYPE_MODE (complex_double_type_node))
3017 return complex_double_type_node;
3018 if (mode == TYPE_MODE (complex_long_double_type_node))
3019 return complex_long_double_type_node;
3020
3021 if (mode == TYPE_MODE (complex_integer_type_node) && !unsignedp)
3022 return complex_integer_type_node;
3023
3024 inner_mode = GET_MODE_INNER (mode);
3025 inner_type = c_common_type_for_mode (inner_mode, unsignedp);
3026 if (inner_type != NULL_TREE)
3027 return build_complex_type (inner_type);
3028 }
3029 else if (VECTOR_MODE_P (mode))
3030 {
3031 enum machine_mode inner_mode = GET_MODE_INNER (mode);
3032 tree inner_type = c_common_type_for_mode (inner_mode, unsignedp);
3033 if (inner_type != NULL_TREE)
3034 return build_vector_type_for_mode (inner_type, mode);
3035 }
3036
3037 if (mode == TYPE_MODE (dfloat32_type_node))
3038 return dfloat32_type_node;
3039 if (mode == TYPE_MODE (dfloat64_type_node))
3040 return dfloat64_type_node;
3041 if (mode == TYPE_MODE (dfloat128_type_node))
3042 return dfloat128_type_node;
3043
3044 if (ALL_SCALAR_FIXED_POINT_MODE_P (mode))
3045 {
3046 if (mode == TYPE_MODE (short_fract_type_node))
3047 return unsignedp ? sat_short_fract_type_node : short_fract_type_node;
3048 if (mode == TYPE_MODE (fract_type_node))
3049 return unsignedp ? sat_fract_type_node : fract_type_node;
3050 if (mode == TYPE_MODE (long_fract_type_node))
3051 return unsignedp ? sat_long_fract_type_node : long_fract_type_node;
3052 if (mode == TYPE_MODE (long_long_fract_type_node))
3053 return unsignedp ? sat_long_long_fract_type_node
3054 : long_long_fract_type_node;
3055
3056 if (mode == TYPE_MODE (unsigned_short_fract_type_node))
3057 return unsignedp ? sat_unsigned_short_fract_type_node
3058 : unsigned_short_fract_type_node;
3059 if (mode == TYPE_MODE (unsigned_fract_type_node))
3060 return unsignedp ? sat_unsigned_fract_type_node
3061 : unsigned_fract_type_node;
3062 if (mode == TYPE_MODE (unsigned_long_fract_type_node))
3063 return unsignedp ? sat_unsigned_long_fract_type_node
3064 : unsigned_long_fract_type_node;
3065 if (mode == TYPE_MODE (unsigned_long_long_fract_type_node))
3066 return unsignedp ? sat_unsigned_long_long_fract_type_node
3067 : unsigned_long_long_fract_type_node;
3068
3069 if (mode == TYPE_MODE (short_accum_type_node))
3070 return unsignedp ? sat_short_accum_type_node : short_accum_type_node;
3071 if (mode == TYPE_MODE (accum_type_node))
3072 return unsignedp ? sat_accum_type_node : accum_type_node;
3073 if (mode == TYPE_MODE (long_accum_type_node))
3074 return unsignedp ? sat_long_accum_type_node : long_accum_type_node;
3075 if (mode == TYPE_MODE (long_long_accum_type_node))
3076 return unsignedp ? sat_long_long_accum_type_node
3077 : long_long_accum_type_node;
3078
3079 if (mode == TYPE_MODE (unsigned_short_accum_type_node))
3080 return unsignedp ? sat_unsigned_short_accum_type_node
3081 : unsigned_short_accum_type_node;
3082 if (mode == TYPE_MODE (unsigned_accum_type_node))
3083 return unsignedp ? sat_unsigned_accum_type_node
3084 : unsigned_accum_type_node;
3085 if (mode == TYPE_MODE (unsigned_long_accum_type_node))
3086 return unsignedp ? sat_unsigned_long_accum_type_node
3087 : unsigned_long_accum_type_node;
3088 if (mode == TYPE_MODE (unsigned_long_long_accum_type_node))
3089 return unsignedp ? sat_unsigned_long_long_accum_type_node
3090 : unsigned_long_long_accum_type_node;
3091
3092 if (mode == QQmode)
3093 return unsignedp ? sat_qq_type_node : qq_type_node;
3094 if (mode == HQmode)
3095 return unsignedp ? sat_hq_type_node : hq_type_node;
3096 if (mode == SQmode)
3097 return unsignedp ? sat_sq_type_node : sq_type_node;
3098 if (mode == DQmode)
3099 return unsignedp ? sat_dq_type_node : dq_type_node;
3100 if (mode == TQmode)
3101 return unsignedp ? sat_tq_type_node : tq_type_node;
3102
3103 if (mode == UQQmode)
3104 return unsignedp ? sat_uqq_type_node : uqq_type_node;
3105 if (mode == UHQmode)
3106 return unsignedp ? sat_uhq_type_node : uhq_type_node;
3107 if (mode == USQmode)
3108 return unsignedp ? sat_usq_type_node : usq_type_node;
3109 if (mode == UDQmode)
3110 return unsignedp ? sat_udq_type_node : udq_type_node;
3111 if (mode == UTQmode)
3112 return unsignedp ? sat_utq_type_node : utq_type_node;
3113
3114 if (mode == HAmode)
3115 return unsignedp ? sat_ha_type_node : ha_type_node;
3116 if (mode == SAmode)
3117 return unsignedp ? sat_sa_type_node : sa_type_node;
3118 if (mode == DAmode)
3119 return unsignedp ? sat_da_type_node : da_type_node;
3120 if (mode == TAmode)
3121 return unsignedp ? sat_ta_type_node : ta_type_node;
3122
3123 if (mode == UHAmode)
3124 return unsignedp ? sat_uha_type_node : uha_type_node;
3125 if (mode == USAmode)
3126 return unsignedp ? sat_usa_type_node : usa_type_node;
3127 if (mode == UDAmode)
3128 return unsignedp ? sat_uda_type_node : uda_type_node;
3129 if (mode == UTAmode)
3130 return unsignedp ? sat_uta_type_node : uta_type_node;
3131 }
3132
3133 for (t = registered_builtin_types; t; t = TREE_CHAIN (t))
3134 if (TYPE_MODE (TREE_VALUE (t)) == mode)
3135 return TREE_VALUE (t);
3136
3137 return 0;
3138}
3139
3140tree
3141c_common_unsigned_type (tree type)
3142{
3143 return c_common_signed_or_unsigned_type (1, type);
3144}
3145
3146/* Return a signed type the same as TYPE in other respects. */
3147
3148tree
3149c_common_signed_type (tree type)
3150{
3151 return c_common_signed_or_unsigned_type (0, type);
3152}
3153
3154/* Return a type the same as TYPE except unsigned or
3155 signed according to UNSIGNEDP. */
3156
3157tree
3158c_common_signed_or_unsigned_type (int unsignedp, tree type)
3159{
3160 tree type1;
3161
3162 /* This block of code emulates the behavior of the old
3163 c_common_unsigned_type. In particular, it returns
3164 long_unsigned_type_node if passed a long, even when a int would
3165 have the same size. This is necessary for warnings to work
3166 correctly in archs where sizeof(int) == sizeof(long) */
3167
3168 type1 = TYPE_MAIN_VARIANT (type);
3169 if (type1 == signed_char_type_node || type1 == char_type_node || type1 == unsigned_char_type_node)
3170 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
3171 if (type1 == integer_type_node || type1 == unsigned_type_node)
3172 return unsignedp ? unsigned_type_node : integer_type_node;
3173 if (type1 == short_integer_type_node || type1 == short_unsigned_type_node)
3174 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
3175 if (type1 == long_integer_type_node || type1 == long_unsigned_type_node)
3176 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
3177 if (type1 == long_long_integer_type_node || type1 == long_long_unsigned_type_node)
3178 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
3179 if (type1 == widest_integer_literal_type_node || type1 == widest_unsigned_literal_type_node)
3180 return unsignedp ? widest_unsigned_literal_type_node : widest_integer_literal_type_node;
3181#if HOST_BITS_PER_WIDE_INT >= 64
3182 if (type1 == intTI_type_node || type1 == unsigned_intTI_type_node)
3183 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
3184#endif
3185 if (type1 == intDI_type_node || type1 == unsigned_intDI_type_node)
3186 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
3187 if (type1 == intSI_type_node || type1 == unsigned_intSI_type_node)
3188 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
3189 if (type1 == intHI_type_node || type1 == unsigned_intHI_type_node)
3190 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
3191 if (type1 == intQI_type_node || type1 == unsigned_intQI_type_node)
3192 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
3193
3194#define C_COMMON_FIXED_TYPES(NAME) \
3195 if (type1 == short_ ## NAME ## _type_node \
3196 || type1 == unsigned_short_ ## NAME ## _type_node) \
3197 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
3198 : short_ ## NAME ## _type_node; \
3199 if (type1 == NAME ## _type_node \
3200 || type1 == unsigned_ ## NAME ## _type_node) \
3201 return unsignedp ? unsigned_ ## NAME ## _type_node \
3202 : NAME ## _type_node; \
3203 if (type1 == long_ ## NAME ## _type_node \
3204 || type1 == unsigned_long_ ## NAME ## _type_node) \
3205 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
3206 : long_ ## NAME ## _type_node; \
3207 if (type1 == long_long_ ## NAME ## _type_node \
3208 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
3209 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
3210 : long_long_ ## NAME ## _type_node;
3211
3212#define C_COMMON_FIXED_MODE_TYPES(NAME) \
3213 if (type1 == NAME ## _type_node \
3214 || type1 == u ## NAME ## _type_node) \
3215 return unsignedp ? u ## NAME ## _type_node \
3216 : NAME ## _type_node;
3217
3218#define C_COMMON_FIXED_TYPES_SAT(NAME) \
3219 if (type1 == sat_ ## short_ ## NAME ## _type_node \
3220 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
3221 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
3222 : sat_ ## short_ ## NAME ## _type_node; \
3223 if (type1 == sat_ ## NAME ## _type_node \
3224 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
3225 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
3226 : sat_ ## NAME ## _type_node; \
3227 if (type1 == sat_ ## long_ ## NAME ## _type_node \
3228 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
3229 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
3230 : sat_ ## long_ ## NAME ## _type_node; \
3231 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
3232 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
3233 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
3234 : sat_ ## long_long_ ## NAME ## _type_node;
3235
3236#define C_COMMON_FIXED_MODE_TYPES_SAT(NAME) \
3237 if (type1 == sat_ ## NAME ## _type_node \
3238 || type1 == sat_ ## u ## NAME ## _type_node) \
3239 return unsignedp ? sat_ ## u ## NAME ## _type_node \
3240 : sat_ ## NAME ## _type_node;
3241
3242 C_COMMON_FIXED_TYPES (fract);
3243 C_COMMON_FIXED_TYPES_SAT (fract);
3244 C_COMMON_FIXED_TYPES (accum);
3245 C_COMMON_FIXED_TYPES_SAT (accum);
3246
3247 C_COMMON_FIXED_MODE_TYPES (qq);
3248 C_COMMON_FIXED_MODE_TYPES (hq);
3249 C_COMMON_FIXED_MODE_TYPES (sq);
3250 C_COMMON_FIXED_MODE_TYPES (dq);
3251 C_COMMON_FIXED_MODE_TYPES (tq);
3252 C_COMMON_FIXED_MODE_TYPES_SAT (qq);
3253 C_COMMON_FIXED_MODE_TYPES_SAT (hq);
3254 C_COMMON_FIXED_MODE_TYPES_SAT (sq);
3255 C_COMMON_FIXED_MODE_TYPES_SAT (dq);
3256 C_COMMON_FIXED_MODE_TYPES_SAT (tq);
3257 C_COMMON_FIXED_MODE_TYPES (ha);
3258 C_COMMON_FIXED_MODE_TYPES (sa);
3259 C_COMMON_FIXED_MODE_TYPES (da);
3260 C_COMMON_FIXED_MODE_TYPES (ta);
3261 C_COMMON_FIXED_MODE_TYPES_SAT (ha);
3262 C_COMMON_FIXED_MODE_TYPES_SAT (sa);
3263 C_COMMON_FIXED_MODE_TYPES_SAT (da);
3264 C_COMMON_FIXED_MODE_TYPES_SAT (ta);
3265
3266 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
3267 the precision; they have precision set to match their range, but
3268 may use a wider mode to match an ABI. If we change modes, we may
3269 wind up with bad conversions. For INTEGER_TYPEs in C, must check
3270 the precision as well, so as to yield correct results for
3271 bit-field types. C++ does not have these separate bit-field
3272 types, and producing a signed or unsigned variant of an
3273 ENUMERAL_TYPE may cause other problems as well. */
3274
3275 if (!INTEGRAL_TYPE_P (type)
3276 || TYPE_UNSIGNED (type) == unsignedp)
3277 return type;
3278
3279#define TYPE_OK(node) \
3280 (TYPE_MODE (type) == TYPE_MODE (node) \
3281 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
3282 if (TYPE_OK (signed_char_type_node))
3283 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
3284 if (TYPE_OK (integer_type_node))
3285 return unsignedp ? unsigned_type_node : integer_type_node;
3286 if (TYPE_OK (short_integer_type_node))
3287 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
3288 if (TYPE_OK (long_integer_type_node))
3289 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
3290 if (TYPE_OK (long_long_integer_type_node))
3291 return (unsignedp ? long_long_unsigned_type_node
3292 : long_long_integer_type_node);
3293 if (TYPE_OK (widest_integer_literal_type_node))
3294 return (unsignedp ? widest_unsigned_literal_type_node
3295 : widest_integer_literal_type_node);
3296
3297#if HOST_BITS_PER_WIDE_INT >= 64
3298 if (TYPE_OK (intTI_type_node))
3299 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
3300#endif
3301 if (TYPE_OK (intDI_type_node))
3302 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
3303 if (TYPE_OK (intSI_type_node))
3304 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
3305 if (TYPE_OK (intHI_type_node))
3306 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
3307 if (TYPE_OK (intQI_type_node))
3308 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
3309#undef TYPE_OK
3310
3311 return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
3312}
3313
3314/* Build a bit-field integer type for the given WIDTH and UNSIGNEDP. */
3315
3316tree
3317c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width, int unsignedp)
3318{
3319 /* Extended integer types of the same width as a standard type have
3320 lesser rank, so those of the same width as int promote to int or
3321 unsigned int and are valid for printf formats expecting int or
3322 unsigned int. To avoid such special cases, avoid creating
3323 extended integer types for bit-fields if a standard integer type
3324 is available. */
3325 if (width == TYPE_PRECISION (integer_type_node))
3326 return unsignedp ? unsigned_type_node : integer_type_node;
3327 if (width == TYPE_PRECISION (signed_char_type_node))
3328 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
3329 if (width == TYPE_PRECISION (short_integer_type_node))
3330 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
3331 if (width == TYPE_PRECISION (long_integer_type_node))
3332 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
3333 if (width == TYPE_PRECISION (long_long_integer_type_node))
3334 return (unsignedp ? long_long_unsigned_type_node
3335 : long_long_integer_type_node);
3336 return build_nonstandard_integer_type (width, unsignedp);
3337}
3338
3339/* The C version of the register_builtin_type langhook. */
3340
3341void
3342c_register_builtin_type (tree type, const char* name)
3343{
3344 tree decl;
3345
3346 decl = build_decl (TYPE_DECL, get_identifier (name), type);
3347 DECL_ARTIFICIAL (decl) = 1;
3348 if (!TYPE_NAME (type))
3349 TYPE_NAME (type) = decl;
3350 pushdecl (decl);
3351
3352 registered_builtin_types = tree_cons (0, type, registered_builtin_types);
3353}
3354\f
3355/* Print an error message for invalid operands to arith operation
3356 CODE with TYPE0 for operand 0, and TYPE1 for operand 1.
3357 LOCATION is the location of the message. */
3358
3359void
3360binary_op_error (location_t location, enum tree_code code,
3361 tree type0, tree type1)
3362{
3363 const char *opname;
3364
3365 switch (code)
3366 {
3367 case PLUS_EXPR:
3368 opname = "+"; break;
3369 case MINUS_EXPR:
3370 opname = "-"; break;
3371 case MULT_EXPR:
3372 opname = "*"; break;
3373 case MAX_EXPR:
3374 opname = "max"; break;
3375 case MIN_EXPR:
3376 opname = "min"; break;
3377 case EQ_EXPR:
3378 opname = "=="; break;
3379 case NE_EXPR:
3380 opname = "!="; break;
3381 case LE_EXPR:
3382 opname = "<="; break;
3383 case GE_EXPR:
3384 opname = ">="; break;
3385 case LT_EXPR:
3386 opname = "<"; break;
3387 case GT_EXPR:
3388 opname = ">"; break;
3389 case LSHIFT_EXPR:
3390 opname = "<<"; break;
3391 case RSHIFT_EXPR:
3392 opname = ">>"; break;
3393 case TRUNC_MOD_EXPR:
3394 case FLOOR_MOD_EXPR:
3395 opname = "%"; break;
3396 case TRUNC_DIV_EXPR:
3397 case FLOOR_DIV_EXPR:
3398 opname = "/"; break;
3399 case BIT_AND_EXPR:
3400 opname = "&"; break;
3401 case BIT_IOR_EXPR:
3402 opname = "|"; break;
3403 case TRUTH_ANDIF_EXPR:
3404 opname = "&&"; break;
3405 case TRUTH_ORIF_EXPR:
3406 opname = "||"; break;
3407 case BIT_XOR_EXPR:
3408 opname = "^"; break;
3409 default:
3410 gcc_unreachable ();
3411 }
3412 error_at (location,
3413 "invalid operands to binary %s (have %qT and %qT)", opname,
3414 type0, type1);
3415}
3416\f
3417/* Subroutine of build_binary_op, used for comparison operations.
3418 See if the operands have both been converted from subword integer types
3419 and, if so, perhaps change them both back to their original type.
3420 This function is also responsible for converting the two operands
3421 to the proper common type for comparison.
3422
3423 The arguments of this function are all pointers to local variables
3424 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
3425 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
3426
3427 If this function returns nonzero, it means that the comparison has
3428 a constant value. What this function returns is an expression for
3429 that value. */
3430
3431tree
3432shorten_compare (tree *op0_ptr, tree *op1_ptr, tree *restype_ptr,
3433 enum tree_code *rescode_ptr)
3434{
3435 tree type;
3436 tree op0 = *op0_ptr;
3437 tree op1 = *op1_ptr;
3438 int unsignedp0, unsignedp1;
3439 int real1, real2;
3440 tree primop0, primop1;
3441 enum tree_code code = *rescode_ptr;
3442
3443 /* Throw away any conversions to wider types
3444 already present in the operands. */
3445
3446 primop0 = get_narrower (op0, &unsignedp0);
3447 primop1 = get_narrower (op1, &unsignedp1);
3448
3449 /* Handle the case that OP0 does not *contain* a conversion
3450 but it *requires* conversion to FINAL_TYPE. */
3451
3452 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
3453 unsignedp0 = TYPE_UNSIGNED (TREE_TYPE (op0));
3454 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
3455 unsignedp1 = TYPE_UNSIGNED (TREE_TYPE (op1));
3456
3457 /* If one of the operands must be floated, we cannot optimize. */
3458 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
3459 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
3460
3461 /* If first arg is constant, swap the args (changing operation
3462 so value is preserved), for canonicalization. Don't do this if
3463 the second arg is 0. */
3464
3465 if (TREE_CONSTANT (primop0)
3466 && !integer_zerop (primop1) && !real_zerop (primop1)
3467 && !fixed_zerop (primop1))
3468 {
3469 tree tem = primop0;
3470 int temi = unsignedp0;
3471 primop0 = primop1;
3472 primop1 = tem;
3473 tem = op0;
3474 op0 = op1;
3475 op1 = tem;
3476 *op0_ptr = op0;
3477 *op1_ptr = op1;
3478 unsignedp0 = unsignedp1;
3479 unsignedp1 = temi;
3480 temi = real1;
3481 real1 = real2;
3482 real2 = temi;
3483
3484 switch (code)
3485 {
3486 case LT_EXPR:
3487 code = GT_EXPR;
3488 break;
3489 case GT_EXPR:
3490 code = LT_EXPR;
3491 break;
3492 case LE_EXPR:
3493 code = GE_EXPR;
3494 break;
3495 case GE_EXPR:
3496 code = LE_EXPR;
3497 break;
3498 default:
3499 break;
3500 }
3501 *rescode_ptr = code;
3502 }
3503
3504 /* If comparing an integer against a constant more bits wide,
3505 maybe we can deduce a value of 1 or 0 independent of the data.
3506 Or else truncate the constant now
3507 rather than extend the variable at run time.
3508
3509 This is only interesting if the constant is the wider arg.
3510 Also, it is not safe if the constant is unsigned and the
3511 variable arg is signed, since in this case the variable
3512 would be sign-extended and then regarded as unsigned.
3513 Our technique fails in this case because the lowest/highest
3514 possible unsigned results don't follow naturally from the
3515 lowest/highest possible values of the variable operand.
3516 For just EQ_EXPR and NE_EXPR there is another technique that
3517 could be used: see if the constant can be faithfully represented
3518 in the other operand's type, by truncating it and reextending it
3519 and see if that preserves the constant's value. */
3520
3521 if (!real1 && !real2
3522 && TREE_CODE (TREE_TYPE (primop0)) != FIXED_POINT_TYPE
3523 && TREE_CODE (primop1) == INTEGER_CST
3524 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
3525 {
3526 int min_gt, max_gt, min_lt, max_lt;
3527 tree maxval, minval;
3528 /* 1 if comparison is nominally unsigned. */
3529 int unsignedp = TYPE_UNSIGNED (*restype_ptr);
3530 tree val;
3531
3532 type = c_common_signed_or_unsigned_type (unsignedp0,
3533 TREE_TYPE (primop0));
3534
3535 maxval = TYPE_MAX_VALUE (type);
3536 minval = TYPE_MIN_VALUE (type);
3537
3538 if (unsignedp && !unsignedp0)
3539 *restype_ptr = c_common_signed_type (*restype_ptr);
3540
3541 if (TREE_TYPE (primop1) != *restype_ptr)
3542 {
3543 /* Convert primop1 to target type, but do not introduce
3544 additional overflow. We know primop1 is an int_cst. */
3545 primop1 = force_fit_type_double (*restype_ptr,
3546 TREE_INT_CST_LOW (primop1),
3547 TREE_INT_CST_HIGH (primop1), 0,
3548 TREE_OVERFLOW (primop1));
3549 }
3550 if (type != *restype_ptr)
3551 {
3552 minval = convert (*restype_ptr, minval);
3553 maxval = convert (*restype_ptr, maxval);
3554 }
3555
3556 if (unsignedp && unsignedp0)
3557 {
3558 min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
3559 max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
3560 min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
3561 max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
3562 }
3563 else
3564 {
3565 min_gt = INT_CST_LT (primop1, minval);
3566 max_gt = INT_CST_LT (primop1, maxval);
3567 min_lt = INT_CST_LT (minval, primop1);
3568 max_lt = INT_CST_LT (maxval, primop1);
3569 }
3570
3571 val = 0;
3572 /* This used to be a switch, but Genix compiler can't handle that. */
3573 if (code == NE_EXPR)
3574 {
3575 if (max_lt || min_gt)
3576 val = truthvalue_true_node;
3577 }
3578 else if (code == EQ_EXPR)
3579 {
3580 if (max_lt || min_gt)
3581 val = truthvalue_false_node;
3582 }
3583 else if (code == LT_EXPR)
3584 {
3585 if (max_lt)
3586 val = truthvalue_true_node;
3587 if (!min_lt)
3588 val = truthvalue_false_node;
3589 }
3590 else if (code == GT_EXPR)
3591 {
3592 if (min_gt)
3593 val = truthvalue_true_node;
3594 if (!max_gt)
3595 val = truthvalue_false_node;
3596 }
3597 else if (code == LE_EXPR)
3598 {
3599 if (!max_gt)
3600 val = truthvalue_true_node;
3601 if (min_gt)
3602 val = truthvalue_false_node;
3603 }
3604 else if (code == GE_EXPR)
3605 {
3606 if (!min_lt)
3607 val = truthvalue_true_node;
3608 if (max_lt)
3609 val = truthvalue_false_node;
3610 }
3611
3612 /* If primop0 was sign-extended and unsigned comparison specd,
3613 we did a signed comparison above using the signed type bounds.
3614 But the comparison we output must be unsigned.
3615
3616 Also, for inequalities, VAL is no good; but if the signed
3617 comparison had *any* fixed result, it follows that the
3618 unsigned comparison just tests the sign in reverse
3619 (positive values are LE, negative ones GE).
3620 So we can generate an unsigned comparison
3621 against an extreme value of the signed type. */
3622
3623 if (unsignedp && !unsignedp0)
3624 {
3625 if (val != 0)
3626 switch (code)
3627 {
3628 case LT_EXPR:
3629 case GE_EXPR:
3630 primop1 = TYPE_MIN_VALUE (type);
3631 val = 0;
3632 break;
3633
3634 case LE_EXPR:
3635 case GT_EXPR:
3636 primop1 = TYPE_MAX_VALUE (type);
3637 val = 0;
3638 break;
3639
3640 default:
3641 break;
3642 }
3643 type = c_common_unsigned_type (type);
3644 }
3645
3646 if (TREE_CODE (primop0) != INTEGER_CST)
3647 {
3648 if (val == truthvalue_false_node)
3649 warning (OPT_Wtype_limits, "comparison is always false due to limited range of data type");
3650 if (val == truthvalue_true_node)
3651 warning (OPT_Wtype_limits, "comparison is always true due to limited range of data type");
3652 }
3653
3654 if (val != 0)
3655 {
3656 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
3657 if (TREE_SIDE_EFFECTS (primop0))
3658 return build2 (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
3659 return val;
3660 }
3661
3662 /* Value is not predetermined, but do the comparison
3663 in the type of the operand that is not constant.
3664 TYPE is already properly set. */
3665 }
3666
3667 /* If either arg is decimal float and the other is float, find the
3668 proper common type to use for comparison. */
3669 else if (real1 && real2
3670 && (DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0)))
3671 || DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1)))))
3672 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
3673
3674 else if (real1 && real2
3675 && (TYPE_PRECISION (TREE_TYPE (primop0))
3676 == TYPE_PRECISION (TREE_TYPE (primop1))))
3677 type = TREE_TYPE (primop0);
3678
3679 /* If args' natural types are both narrower than nominal type
3680 and both extend in the same manner, compare them
3681 in the type of the wider arg.
3682 Otherwise must actually extend both to the nominal
3683 common type lest different ways of extending
3684 alter the result.
3685 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
3686
3687 else if (unsignedp0 == unsignedp1 && real1 == real2
3688 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
3689 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
3690 {
3691 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
3692 type = c_common_signed_or_unsigned_type (unsignedp0
3693 || TYPE_UNSIGNED (*restype_ptr),
3694 type);
3695 /* Make sure shorter operand is extended the right way
3696 to match the longer operand. */
3697 primop0
3698 = convert (c_common_signed_or_unsigned_type (unsignedp0,
3699 TREE_TYPE (primop0)),
3700 primop0);
3701 primop1
3702 = convert (c_common_signed_or_unsigned_type (unsignedp1,
3703 TREE_TYPE (primop1)),
3704 primop1);
3705 }
3706 else
3707 {
3708 /* Here we must do the comparison on the nominal type
3709 using the args exactly as we received them. */
3710 type = *restype_ptr;
3711 primop0 = op0;
3712 primop1 = op1;
3713
3714 if (!real1 && !real2 && integer_zerop (primop1)
3715 && TYPE_UNSIGNED (*restype_ptr))
3716 {
3717 tree value = 0;
3718 switch (code)
3719 {
3720 case GE_EXPR:
3721 /* All unsigned values are >= 0, so we warn. However,
3722 if OP0 is a constant that is >= 0, the signedness of
3723 the comparison isn't an issue, so suppress the
3724 warning. */
3725 if (warn_type_limits && !in_system_header
3726 && !(TREE_CODE (primop0) == INTEGER_CST
3727 && !TREE_OVERFLOW (convert (c_common_signed_type (type),
3728 primop0))))
3729 warning (OPT_Wtype_limits,
3730 "comparison of unsigned expression >= 0 is always true");
3731 value = truthvalue_true_node;
3732 break;
3733
3734 case LT_EXPR:
3735 if (warn_type_limits && !in_system_header
3736 && !(TREE_CODE (primop0) == INTEGER_CST
3737 && !TREE_OVERFLOW (convert (c_common_signed_type (type),
3738 primop0))))
3739 warning (OPT_Wtype_limits,
3740 "comparison of unsigned expression < 0 is always false");
3741 value = truthvalue_false_node;
3742 break;
3743
3744 default:
3745 break;
3746 }
3747
3748 if (value != 0)
3749 {
3750 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
3751 if (TREE_SIDE_EFFECTS (primop0))
3752 return build2 (COMPOUND_EXPR, TREE_TYPE (value),
3753 primop0, value);
3754 return value;
3755 }
3756 }
3757 }
3758
3759 *op0_ptr = convert (type, primop0);
3760 *op1_ptr = convert (type, primop1);
3761
3762 *restype_ptr = truthvalue_type_node;
3763
3764 return 0;
3765}
3766\f
3767/* Return a tree for the sum or difference (RESULTCODE says which)
3768 of pointer PTROP and integer INTOP. */
3769
3770tree
3771pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
3772{
3773 tree size_exp, ret;
3774
3775 /* The result is a pointer of the same type that is being added. */
3776 tree result_type = TREE_TYPE (ptrop);
3777
3778 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
3779 {
3780 pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3781 "pointer of type %<void *%> used in arithmetic");
3782 size_exp = integer_one_node;
3783 }
3784 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
3785 {
3786 pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3787 "pointer to a function used in arithmetic");
3788 size_exp = integer_one_node;
3789 }
3790 else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
3791 {
3792 pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3793 "pointer to member function used in arithmetic");
3794 size_exp = integer_one_node;
3795 }
3796 else
3797 size_exp = size_in_bytes (TREE_TYPE (result_type));
3798
3799 /* We are manipulating pointer values, so we don't need to warn
3800 about relying on undefined signed overflow. We disable the
3801 warning here because we use integer types so fold won't know that
3802 they are really pointers. */
3803 fold_defer_overflow_warnings ();
3804
3805 /* If what we are about to multiply by the size of the elements
3806 contains a constant term, apply distributive law
3807 and multiply that constant term separately.
3808 This helps produce common subexpressions. */
3809 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
3810 && !TREE_CONSTANT (intop)
3811 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
3812 && TREE_CONSTANT (size_exp)
3813 /* If the constant comes from pointer subtraction,
3814 skip this optimization--it would cause an error. */
3815 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
3816 /* If the constant is unsigned, and smaller than the pointer size,
3817 then we must skip this optimization. This is because it could cause
3818 an overflow error if the constant is negative but INTOP is not. */
3819 && (!TYPE_UNSIGNED (TREE_TYPE (intop))
3820 || (TYPE_PRECISION (TREE_TYPE (intop))
3821 == TYPE_PRECISION (TREE_TYPE (ptrop)))))
3822 {
3823 enum tree_code subcode = resultcode;
3824 tree int_type = TREE_TYPE (intop);
3825 if (TREE_CODE (intop) == MINUS_EXPR)
3826 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
3827 /* Convert both subexpression types to the type of intop,
3828 because weird cases involving pointer arithmetic
3829 can result in a sum or difference with different type args. */
3830 ptrop = build_binary_op (EXPR_LOCATION (TREE_OPERAND (intop, 1)),
3831 subcode, ptrop,
3832 convert (int_type, TREE_OPERAND (intop, 1)), 1);
3833 intop = convert (int_type, TREE_OPERAND (intop, 0));
3834 }
3835
3836 /* Convert the integer argument to a type the same size as sizetype
3837 so the multiply won't overflow spuriously. */
3838 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
3839 || TYPE_UNSIGNED (TREE_TYPE (intop)) != TYPE_UNSIGNED (sizetype))
3840 intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
3841 TYPE_UNSIGNED (sizetype)), intop);
3842
3843 /* Replace the integer argument with a suitable product by the object size.
3844 Do this multiplication as signed, then convert to the appropriate
3845 type for the pointer operation. */
3846 intop = convert (sizetype,
3847 build_binary_op (EXPR_LOCATION (intop),
3848 MULT_EXPR, intop,
3849 convert (TREE_TYPE (intop), size_exp), 1));
3850
3851 /* Create the sum or difference. */
3852 if (resultcode == MINUS_EXPR)
3853 intop = fold_build1 (NEGATE_EXPR, sizetype, intop);
3854
3855 ret = fold_build2 (POINTER_PLUS_EXPR, result_type, ptrop, intop);
3856
3857 fold_undefer_and_ignore_overflow_warnings ();
3858
3859 return ret;
3860}
3861\f
3862/* Wrap a SAVE_EXPR around EXPR, if appropriate. Like save_expr, but
3863 for C folds the inside expression and wraps a C_MAYBE_CONST_EXPR
3864 around the SAVE_EXPR if needed so that c_fully_fold does not need
3865 to look inside SAVE_EXPRs. */
3866
3867tree
3868c_save_expr (tree expr)
3869{
3870 bool maybe_const = true;
3871 if (c_dialect_cxx ())
3872 return save_expr (expr);
3873 expr = c_fully_fold (expr, false, &maybe_const);
3874 expr = save_expr (expr);
3875 if (!maybe_const)
3876 {
3877 expr = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (expr), NULL, expr);
3878 C_MAYBE_CONST_EXPR_NON_CONST (expr) = 1;
3879 }
3880 return expr;
3881}
3882
3883/* Return whether EXPR is a declaration whose address can never be
3884 NULL. */
3885
3886bool
3887decl_with_nonnull_addr_p (const_tree expr)
3888{
3889 return (DECL_P (expr)
3890 && (TREE_CODE (expr) == PARM_DECL
3891 || TREE_CODE (expr) == LABEL_DECL
3892 || !DECL_WEAK (expr)));
3893}
3894
3895/* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
3896 or for an `if' or `while' statement or ?..: exp. It should already
3897 have been validated to be of suitable type; otherwise, a bad
3898 diagnostic may result.
3899
3900 The EXPR is located at LOCATION.
3901
3902 This preparation consists of taking the ordinary
3903 representation of an expression expr and producing a valid tree
3904 boolean expression describing whether expr is nonzero. We could
3905 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
3906 but we optimize comparisons, &&, ||, and !.
3907
3908 The resulting type should always be `truthvalue_type_node'. */
3909
3910tree
3911c_common_truthvalue_conversion (location_t location, tree expr)
3912{
3913 switch (TREE_CODE (expr))
3914 {
3915 case EQ_EXPR: case NE_EXPR: case UNEQ_EXPR: case LTGT_EXPR:
3916 case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
3917 case UNLE_EXPR: case UNGE_EXPR: case UNLT_EXPR: case UNGT_EXPR:
3918 case ORDERED_EXPR: case UNORDERED_EXPR:
3919 if (TREE_TYPE (expr) == truthvalue_type_node)
3920 return expr;
3921 return build2 (TREE_CODE (expr), truthvalue_type_node,
3922 TREE_OPERAND (expr, 0), TREE_OPERAND (expr, 1));
3923
3924 case TRUTH_ANDIF_EXPR:
3925 case TRUTH_ORIF_EXPR:
3926 case TRUTH_AND_EXPR:
3927 case TRUTH_OR_EXPR:
3928 case TRUTH_XOR_EXPR:
3929 if (TREE_TYPE (expr) == truthvalue_type_node)
3930 return expr;
3931 return build2 (TREE_CODE (expr), truthvalue_type_node,
3932 c_common_truthvalue_conversion (location,
3933 TREE_OPERAND (expr, 0)),
3934 c_common_truthvalue_conversion (location,
3935 TREE_OPERAND (expr, 1)));
3936
3937 case TRUTH_NOT_EXPR:
3938 if (TREE_TYPE (expr) == truthvalue_type_node)
3939 return expr;
3940 return build1 (TREE_CODE (expr), truthvalue_type_node,
3941 c_common_truthvalue_conversion (location,
3942 TREE_OPERAND (expr, 0)));
3943
3944 case ERROR_MARK:
3945 return expr;
3946
3947 case INTEGER_CST:
3948 return integer_zerop (expr) ? truthvalue_false_node
3949 : truthvalue_true_node;
3950
3951 case REAL_CST:
3952 return real_compare (NE_EXPR, &TREE_REAL_CST (expr), &dconst0)
3953 ? truthvalue_true_node
3954 : truthvalue_false_node;
3955
3956 case FIXED_CST:
3957 return fixed_compare (NE_EXPR, &TREE_FIXED_CST (expr),
3958 &FCONST0 (TYPE_MODE (TREE_TYPE (expr))))
3959 ? truthvalue_true_node
3960 : truthvalue_false_node;
3961
3962 case FUNCTION_DECL:
3963 expr = build_unary_op (location, ADDR_EXPR, expr, 0);
3964 /* Fall through. */
3965
3966 case ADDR_EXPR:
3967 {
3968 tree inner = TREE_OPERAND (expr, 0);
3969 if (decl_with_nonnull_addr_p (inner))
3970 {
3971 /* Common Ada/Pascal programmer's mistake. */
3972 warning_at (location,
3973 OPT_Waddress,
3974 "the address of %qD will always evaluate as %<true%>",
3975 inner);
3976 return truthvalue_true_node;
3977 }
3978
3979 /* If we still have a decl, it is possible for its address to
3980 be NULL, so we cannot optimize. */
3981 if (DECL_P (inner))
3982 {
3983 gcc_assert (DECL_WEAK (inner));
3984 break;
3985 }
3986
3987 if (TREE_SIDE_EFFECTS (inner))
3988 return build2 (COMPOUND_EXPR, truthvalue_type_node,
3989 inner, truthvalue_true_node);
3990 else
3991 return truthvalue_true_node;
3992 }
3993
3994 case COMPLEX_EXPR:
3995 return build_binary_op (EXPR_LOCATION (expr),
3996 (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
3997 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
3998 c_common_truthvalue_conversion (location,
3999 TREE_OPERAND (expr, 0)),
4000 c_common_truthvalue_conversion (location,
4001 TREE_OPERAND (expr, 1)),
4002 0);
4003
4004 case NEGATE_EXPR:
4005 case ABS_EXPR:
4006 case FLOAT_EXPR:
4007 case EXCESS_PRECISION_EXPR:
4008 /* These don't change whether an object is nonzero or zero. */
4009 return c_common_truthvalue_conversion (location, TREE_OPERAND (expr, 0));
4010
4011 case LROTATE_EXPR:
4012 case RROTATE_EXPR:
4013 /* These don't change whether an object is zero or nonzero, but
4014 we can't ignore them if their second arg has side-effects. */
4015 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
4016 return build2 (COMPOUND_EXPR, truthvalue_type_node,
4017 TREE_OPERAND (expr, 1),
4018 c_common_truthvalue_conversion
4019 (location, TREE_OPERAND (expr, 0)));
4020 else
4021 return c_common_truthvalue_conversion (location,
4022 TREE_OPERAND (expr, 0));
4023
4024 case COND_EXPR:
4025 /* Distribute the conversion into the arms of a COND_EXPR. */
4026 if (c_dialect_cxx ())
4027 return fold_build3 (COND_EXPR, truthvalue_type_node,
4028 TREE_OPERAND (expr, 0),
4029 c_common_truthvalue_conversion (location,
4030 TREE_OPERAND (expr,
4031 1)),
4032 c_common_truthvalue_conversion (location,
4033 TREE_OPERAND (expr,
4034 2)));
4035 else
4036 /* Folding will happen later for C. */
4037 return build3 (COND_EXPR, truthvalue_type_node,
4038 TREE_OPERAND (expr, 0),
4039 c_common_truthvalue_conversion (location,
4040 TREE_OPERAND (expr, 1)),
4041 c_common_truthvalue_conversion (location,
4042 TREE_OPERAND (expr, 2)));
4043
4044 CASE_CONVERT:
4045 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
4046 since that affects how `default_conversion' will behave. */
4047 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
4048 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
4049 break;
4050 /* If this is widening the argument, we can ignore it. */
4051 if (TYPE_PRECISION (TREE_TYPE (expr))
4052 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
4053 return c_common_truthvalue_conversion (location,
4054 TREE_OPERAND (expr, 0));
4055 break;
4056
4057 case MODIFY_EXPR:
4058 if (!TREE_NO_WARNING (expr)
4059 && warn_parentheses)
4060 {
4061 warning (OPT_Wparentheses,
4062 "suggest parentheses around assignment used as truth value");
4063 TREE_NO_WARNING (expr) = 1;
4064 }
4065 break;
4066
4067 default:
4068 break;
4069 }
4070
4071 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
4072 {
4073 tree t = c_save_expr (expr);
4074 return (build_binary_op
4075 (EXPR_LOCATION (expr),
4076 (TREE_SIDE_EFFECTS (expr)
4077 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
4078 c_common_truthvalue_conversion
4079 (location,
4080 build_unary_op (location, REALPART_EXPR, t, 0)),
4081 c_common_truthvalue_conversion
4082 (location,
4083 build_unary_op (location, IMAGPART_EXPR, t, 0)),
4084 0));
4085 }
4086
4087 if (TREE_CODE (TREE_TYPE (expr)) == FIXED_POINT_TYPE)
4088 {
4089 tree fixed_zero_node = build_fixed (TREE_TYPE (expr),
4090 FCONST0 (TYPE_MODE
4091 (TREE_TYPE (expr))));
4092 return build_binary_op (location, NE_EXPR, expr, fixed_zero_node, 1);
4093 }
4094
4095 return build_binary_op (location, NE_EXPR, expr, integer_zero_node, 1);
4096}
4097\f
4098static void def_builtin_1 (enum built_in_function fncode,
4099 const char *name,
4100 enum built_in_class fnclass,
4101 tree fntype, tree libtype,
4102 bool both_p, bool fallback_p, bool nonansi_p,
4103 tree fnattrs, bool implicit_p);
4104
4105
4106/* Apply the TYPE_QUALS to the new DECL. */
4107
4108void
4109c_apply_type_quals_to_decl (int type_quals, tree decl)
4110{
4111 tree type = TREE_TYPE (decl);
4112
4113 if (type == error_mark_node)
4114 return;
4115
4116 if (((type_quals & TYPE_QUAL_CONST)
4117 || (type && TREE_CODE (type) == REFERENCE_TYPE))
4118 /* An object declared 'const' is only readonly after it is
4119 initialized. We don't have any way of expressing this currently,
4120 so we need to be conservative and unset TREE_READONLY for types
4121 with constructors. Otherwise aliasing code will ignore stores in
4122 an inline constructor. */
4123 && !(type && TYPE_NEEDS_CONSTRUCTING (type)))
4124 TREE_READONLY (decl) = 1;
4125 if (type_quals & TYPE_QUAL_VOLATILE)
4126 {
4127 TREE_SIDE_EFFECTS (decl) = 1;
4128 TREE_THIS_VOLATILE (decl) = 1;
4129 }
4130 if (type_quals & TYPE_QUAL_RESTRICT)
4131 {
4132 while (type && TREE_CODE (type) == ARRAY_TYPE)
4133 /* Allow 'restrict' on arrays of pointers.
4134 FIXME currently we just ignore it. */
4135 type = TREE_TYPE (type);
4136 if (!type
4137 || !POINTER_TYPE_P (type)
4138 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type)))
4139 error ("invalid use of %<restrict%>");
4140 else if (flag_strict_aliasing && type == TREE_TYPE (decl))
4141 /* Indicate we need to make a unique alias set for this pointer.
4142 We can't do it here because it might be pointing to an
4143 incomplete type. */
4144 DECL_POINTER_ALIAS_SET (decl) = -2;
4145 }
4146}
4147
4148/* Hash function for the problem of multiple type definitions in
4149 different files. This must hash all types that will compare
4150 equal via comptypes to the same value. In practice it hashes
4151 on some of the simple stuff and leaves the details to comptypes. */
4152
4153static hashval_t
4154c_type_hash (const void *p)
4155{
4156 int i = 0;
4157 int shift, size;
4158 const_tree const t = (const_tree) p;
4159 tree t2;
4160 switch (TREE_CODE (t))
4161 {
4162 /* For pointers, hash on pointee type plus some swizzling. */
4163 case POINTER_TYPE:
4164 return c_type_hash (TREE_TYPE (t)) ^ 0x3003003;
4165 /* Hash on number of elements and total size. */
4166 case ENUMERAL_TYPE:
4167 shift = 3;
4168 t2 = TYPE_VALUES (t);
4169 break;
4170 case RECORD_TYPE:
4171 shift = 0;
4172 t2 = TYPE_FIELDS (t);
4173 break;
4174 case QUAL_UNION_TYPE:
4175 shift = 1;
4176 t2 = TYPE_FIELDS (t);
4177 break;
4178 case UNION_TYPE:
4179 shift = 2;
4180 t2 = TYPE_FIELDS (t);
4181 break;
4182 default:
4183 gcc_unreachable ();
4184 }
4185 for (; t2; t2 = TREE_CHAIN (t2))
4186 i++;
4187 /* We might have a VLA here. */
4188 if (TREE_CODE (TYPE_SIZE (t)) != INTEGER_CST)
4189 size = 0;
4190 else
4191 size = TREE_INT_CST_LOW (TYPE_SIZE (t));
4192 return ((size << 24) | (i << shift));
4193}
4194
4195static GTY((param_is (union tree_node))) htab_t type_hash_table;
4196
4197/* Return the typed-based alias set for T, which may be an expression
4198 or a type. Return -1 if we don't do anything special. */
4199
4200alias_set_type
4201c_common_get_alias_set (tree t)
4202{
4203 tree u;
4204 PTR *slot;
4205
4206 /* Permit type-punning when accessing a union, provided the access
4207 is directly through the union. For example, this code does not
4208 permit taking the address of a union member and then storing
4209 through it. Even the type-punning allowed here is a GCC
4210 extension, albeit a common and useful one; the C standard says
4211 that such accesses have implementation-defined behavior. */
4212 for (u = t;
4213 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
4214 u = TREE_OPERAND (u, 0))
4215 if (TREE_CODE (u) == COMPONENT_REF
4216 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
4217 return 0;
4218
4219 /* That's all the expressions we handle specially. */
4220 if (!TYPE_P (t))
4221 return -1;
4222
4223 /* The C standard guarantees that any object may be accessed via an
4224 lvalue that has character type. */
4225 if (t == char_type_node
4226 || t == signed_char_type_node
4227 || t == unsigned_char_type_node)
4228 return 0;
4229
4230 /* The C standard specifically allows aliasing between signed and
4231 unsigned variants of the same type. We treat the signed
4232 variant as canonical. */
4233 if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
4234 {
4235 tree t1 = c_common_signed_type (t);
4236
4237 /* t1 == t can happen for boolean nodes which are always unsigned. */
4238 if (t1 != t)
4239 return get_alias_set (t1);
4240 }
4241 else if (POINTER_TYPE_P (t))
4242 {
4243 tree t1;
4244
4245 /* Unfortunately, there is no canonical form of a pointer type.
4246 In particular, if we have `typedef int I', then `int *', and
4247 `I *' are different types. So, we have to pick a canonical
4248 representative. We do this below.
4249
4250 Technically, this approach is actually more conservative that
4251 it needs to be. In particular, `const int *' and `int *'
4252 should be in different alias sets, according to the C and C++
4253 standard, since their types are not the same, and so,
4254 technically, an `int **' and `const int **' cannot point at
4255 the same thing.
4256
4257 But, the standard is wrong. In particular, this code is
4258 legal C++:
4259
4260 int *ip;
4261 int **ipp = &ip;
4262 const int* const* cipp = ipp;
4263
4264 And, it doesn't make sense for that to be legal unless you
4265 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
4266 the pointed-to types. This issue has been reported to the
4267 C++ committee. */
4268 t1 = build_type_no_quals (t);
4269 if (t1 != t)
4270 return get_alias_set (t1);
4271 }
4272
4273 /* Handle the case of multiple type nodes referring to "the same" type,
4274 which occurs with IMA. These share an alias set. FIXME: Currently only
4275 C90 is handled. (In C99 type compatibility is not transitive, which
4276 complicates things mightily. The alias set splay trees can theoretically
4277 represent this, but insertion is tricky when you consider all the
4278 different orders things might arrive in.) */
4279
4280 if (c_language != clk_c || flag_isoc99)
4281 return -1;
4282
4283 /* Save time if there's only one input file. */
4284 if (num_in_fnames == 1)
4285 return -1;
4286
4287 /* Pointers need special handling if they point to any type that
4288 needs special handling (below). */
4289 if (TREE_CODE (t) == POINTER_TYPE)
4290 {
4291 tree t2;
4292 /* Find bottom type under any nested POINTERs. */
4293 for (t2 = TREE_TYPE (t);
4294 TREE_CODE (t2) == POINTER_TYPE;
4295 t2 = TREE_TYPE (t2))
4296 ;
4297 if (TREE_CODE (t2) != RECORD_TYPE
4298 && TREE_CODE (t2) != ENUMERAL_TYPE
4299 && TREE_CODE (t2) != QUAL_UNION_TYPE
4300 && TREE_CODE (t2) != UNION_TYPE)
4301 return -1;
4302 if (TYPE_SIZE (t2) == 0)
4303 return -1;
4304 }
4305 /* These are the only cases that need special handling. */
4306 if (TREE_CODE (t) != RECORD_TYPE
4307 && TREE_CODE (t) != ENUMERAL_TYPE
4308 && TREE_CODE (t) != QUAL_UNION_TYPE
4309 && TREE_CODE (t) != UNION_TYPE
4310 && TREE_CODE (t) != POINTER_TYPE)
4311 return -1;
4312 /* Undefined? */
4313 if (TYPE_SIZE (t) == 0)
4314 return -1;
4315
4316 /* Look up t in hash table. Only one of the compatible types within each
4317 alias set is recorded in the table. */
4318 if (!type_hash_table)
4319 type_hash_table = htab_create_ggc (1021, c_type_hash,
4320 (htab_eq) lang_hooks.types_compatible_p,
4321 NULL);
4322 slot = htab_find_slot (type_hash_table, t, INSERT);
4323 if (*slot != NULL)
4324 {
4325 TYPE_ALIAS_SET (t) = TYPE_ALIAS_SET ((tree)*slot);
4326 return TYPE_ALIAS_SET ((tree)*slot);
4327 }
4328 else
4329 /* Our caller will assign and record (in t) a new alias set; all we need
4330 to do is remember t in the hash table. */
4331 *slot = t;
4332
4333 return -1;
4334}
4335\f
4336/* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
4337 second parameter indicates which OPERATOR is being applied. The COMPLAIN
4338 flag controls whether we should diagnose possibly ill-formed
4339 constructs or not. */
4340
4341tree
4342c_sizeof_or_alignof_type (tree type, bool is_sizeof, int complain)
4343{
4344 const char *op_name;
4345 tree value = NULL;
4346 enum tree_code type_code = TREE_CODE (type);
4347
4348 op_name = is_sizeof ? "sizeof" : "__alignof__";
4349
4350 if (type_code == FUNCTION_TYPE)
4351 {
4352 if (is_sizeof)
4353 {
4354 if (complain && (pedantic || warn_pointer_arith))
4355 pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
4356 "invalid application of %<sizeof%> to a function type");
4357 else if (!complain)
4358 return error_mark_node;
4359 value = size_one_node;
4360 }
4361 else
4362 value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
4363 }
4364 else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
4365 {
4366 if (type_code == VOID_TYPE
4367 && complain && (pedantic || warn_pointer_arith))
4368 pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
4369 "invalid application of %qs to a void type", op_name);
4370 else if (!complain)
4371 return error_mark_node;
4372 value = size_one_node;
4373 }
4374 else if (!COMPLETE_TYPE_P (type))
4375 {
4376 if (complain)
4377 error ("invalid application of %qs to incomplete type %qT ",
4378 op_name, type);
4379 value = size_zero_node;
4380 }
4381 else
4382 {
4383 if (is_sizeof)
4384 /* Convert in case a char is more than one unit. */
4385 value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
4386 size_int (TYPE_PRECISION (char_type_node)
4387 / BITS_PER_UNIT));
4388 else
4389 value = size_int (TYPE_ALIGN_UNIT (type));
4390 }
4391
4392 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
4393 TYPE_IS_SIZETYPE means that certain things (like overflow) will
4394 never happen. However, this node should really have type
4395 `size_t', which is just a typedef for an ordinary integer type. */
4396 value = fold_convert (size_type_node, value);
4397 gcc_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)));
4398
4399 return value;
4400}
4401
4402/* Implement the __alignof keyword: Return the minimum required
4403 alignment of EXPR, measured in bytes. For VAR_DECLs,
4404 FUNCTION_DECLs and FIELD_DECLs return DECL_ALIGN (which can be set
4405 from an "aligned" __attribute__ specification). */
4406
4407tree
4408c_alignof_expr (tree expr)
4409{
4410 tree t;
4411
4412 if (VAR_OR_FUNCTION_DECL_P (expr))
4413 t = size_int (DECL_ALIGN_UNIT (expr));
4414
4415 else if (TREE_CODE (expr) == COMPONENT_REF
4416 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
4417 {
4418 error ("%<__alignof%> applied to a bit-field");
4419 t = size_one_node;
4420 }
4421 else if (TREE_CODE (expr) == COMPONENT_REF
4422 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
4423 t = size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr, 1)));
4424
4425 else if (TREE_CODE (expr) == INDIRECT_REF)
4426 {
4427 tree t = TREE_OPERAND (expr, 0);
4428 tree best = t;
4429 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
4430
4431 while (CONVERT_EXPR_P (t)
4432 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
4433 {
4434 int thisalign;
4435
4436 t = TREE_OPERAND (t, 0);
4437 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
4438 if (thisalign > bestalign)
4439 best = t, bestalign = thisalign;
4440 }
4441 return c_alignof (TREE_TYPE (TREE_TYPE (best)));
4442 }
4443 else
4444 return c_alignof (TREE_TYPE (expr));
4445
4446 return fold_convert (size_type_node, t);
4447}
4448\f
4449/* Handle C and C++ default attributes. */
4450
4451enum built_in_attribute
4452{
4453#define DEF_ATTR_NULL_TREE(ENUM) ENUM,
4454#define DEF_ATTR_INT(ENUM, VALUE) ENUM,
4455#define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
4456#define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
4457#include "builtin-attrs.def"
4458#undef DEF_ATTR_NULL_TREE
4459#undef DEF_ATTR_INT
4460#undef DEF_ATTR_IDENT
4461#undef DEF_ATTR_TREE_LIST
4462 ATTR_LAST
4463};
4464
4465static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
4466
4467static void c_init_attributes (void);
4468
4469enum c_builtin_type
4470{
4471#define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
4472#define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
4473#define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
4474#define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
4475#define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
4476#define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
4477#define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
4478#define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME,
4479#define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME,
4480#define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
4481#define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
4482#define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
4483#define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
4484#define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
4485#define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
4486 NAME,
4487#define DEF_POINTER_TYPE(NAME, TYPE) NAME,
4488#include "builtin-types.def"
4489#undef DEF_PRIMITIVE_TYPE
4490#undef DEF_FUNCTION_TYPE_0
4491#undef DEF_FUNCTION_TYPE_1
4492#undef DEF_FUNCTION_TYPE_2
4493#undef DEF_FUNCTION_TYPE_3
4494#undef DEF_FUNCTION_TYPE_4
4495#undef DEF_FUNCTION_TYPE_5
4496#undef DEF_FUNCTION_TYPE_6
4497#undef DEF_FUNCTION_TYPE_7
4498#undef DEF_FUNCTION_TYPE_VAR_0
4499#undef DEF_FUNCTION_TYPE_VAR_1
4500#undef DEF_FUNCTION_TYPE_VAR_2
4501#undef DEF_FUNCTION_TYPE_VAR_3
4502#undef DEF_FUNCTION_TYPE_VAR_4
4503#undef DEF_FUNCTION_TYPE_VAR_5
4504#undef DEF_POINTER_TYPE
4505 BT_LAST
4506};
4507
4508typedef enum c_builtin_type builtin_type;
4509
4510/* A temporary array for c_common_nodes_and_builtins. Used in
4511 communication with def_fn_type. */
4512static tree builtin_types[(int) BT_LAST + 1];
4513
4514/* A helper function for c_common_nodes_and_builtins. Build function type
4515 for DEF with return type RET and N arguments. If VAR is true, then the
4516 function should be variadic after those N arguments.
4517
4518 Takes special care not to ICE if any of the types involved are
4519 error_mark_node, which indicates that said type is not in fact available
4520 (see builtin_type_for_size). In which case the function type as a whole
4521 should be error_mark_node. */
4522
4523static void
4524def_fn_type (builtin_type def, builtin_type ret, bool var, int n, ...)
4525{
4526 tree args = NULL, t;
4527 va_list list;
4528 int i;
4529
4530 va_start (list, n);
4531 for (i = 0; i < n; ++i)
4532 {
4533 builtin_type a = (builtin_type) va_arg (list, int);
4534 t = builtin_types[a];
4535 if (t == error_mark_node)
4536 goto egress;
4537 args = tree_cons (NULL_TREE, t, args);
4538 }
4539 va_end (list);
4540
4541 args = nreverse (args);
4542 if (!var)
4543 args = chainon (args, void_list_node);
4544
4545 t = builtin_types[ret];
4546 if (t == error_mark_node)
4547 goto egress;
4548 t = build_function_type (t, args);
4549
4550 egress:
4551 builtin_types[def] = t;
4552}
4553
4554/* Build builtin functions common to both C and C++ language
4555 frontends. */
4556
4557static void
4558c_define_builtins (tree va_list_ref_type_node, tree va_list_arg_type_node)
4559{
4560#define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
4561 builtin_types[ENUM] = VALUE;
4562#define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
4563 def_fn_type (ENUM, RETURN, 0, 0);
4564#define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
4565 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
4566#define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
4567 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
4568#define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
4569 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
4570#define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
4571 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
4572#define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4573 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
4574#define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4575 ARG6) \
4576 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
4577#define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4578 ARG6, ARG7) \
4579 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
4580#define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
4581 def_fn_type (ENUM, RETURN, 1, 0);
4582#define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
4583 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
4584#define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
4585 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
4586#define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
4587 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
4588#define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
4589 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
4590#define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4591 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
4592#define DEF_POINTER_TYPE(ENUM, TYPE) \
4593 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
4594
4595#include "builtin-types.def"
4596
4597#undef DEF_PRIMITIVE_TYPE
4598#undef DEF_FUNCTION_TYPE_1
4599#undef DEF_FUNCTION_TYPE_2
4600#undef DEF_FUNCTION_TYPE_3
4601#undef DEF_FUNCTION_TYPE_4
4602#undef DEF_FUNCTION_TYPE_5
4603#undef DEF_FUNCTION_TYPE_6
4604#undef DEF_FUNCTION_TYPE_VAR_0
4605#undef DEF_FUNCTION_TYPE_VAR_1
4606#undef DEF_FUNCTION_TYPE_VAR_2
4607#undef DEF_FUNCTION_TYPE_VAR_3
4608#undef DEF_FUNCTION_TYPE_VAR_4
4609#undef DEF_FUNCTION_TYPE_VAR_5
4610#undef DEF_POINTER_TYPE
4611 builtin_types[(int) BT_LAST] = NULL_TREE;
4612
4613 c_init_attributes ();
4614
4615#define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
4616 NONANSI_P, ATTRS, IMPLICIT, COND) \
4617 if (NAME && COND) \
4618 def_builtin_1 (ENUM, NAME, CLASS, \
4619 builtin_types[(int) TYPE], \
4620 builtin_types[(int) LIBTYPE], \
4621 BOTH_P, FALLBACK_P, NONANSI_P, \
4622 built_in_attributes[(int) ATTRS], IMPLICIT);
4623#include "builtins.def"
4624#undef DEF_BUILTIN
4625
4626 targetm.init_builtins ();
4627
4628 build_common_builtin_nodes ();
4629
4630 if (flag_mudflap)
4631 mudflap_init ();
4632}
4633
4634/* Like get_identifier, but avoid warnings about null arguments when
4635 the argument may be NULL for targets where GCC lacks stdint.h type
4636 information. */
4637
4638static inline tree
4639c_get_ident (const char *id)
4640{
4641 return get_identifier (id);
4642}
4643
4644/* Build tree nodes and builtin functions common to both C and C++ language
4645 frontends. */
4646
4647void
4648c_common_nodes_and_builtins (void)
4649{
4650 int char16_type_size;
4651 int char32_type_size;
4652 int wchar_type_size;
4653 tree array_domain_type;
4654 tree va_list_ref_type_node;
4655 tree va_list_arg_type_node;
4656
4657 /* Define `int' and `char' first so that dbx will output them first. */
4658 record_builtin_type (RID_INT, NULL, integer_type_node);
4659 record_builtin_type (RID_CHAR, "char", char_type_node);
4660
4661 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
4662 "unsigned long", "long long unsigned" and "unsigned short" were in C++
4663 but not C. Are the conditionals here needed? */
4664 if (c_dialect_cxx ())
4665 record_builtin_type (RID_SIGNED, NULL, integer_type_node);
4666 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
4667 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
4668 record_builtin_type (RID_MAX, "long unsigned int",
4669 long_unsigned_type_node);
4670 if (c_dialect_cxx ())
4671 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
4672 record_builtin_type (RID_MAX, "long long int",
4673 long_long_integer_type_node);
4674 record_builtin_type (RID_MAX, "long long unsigned int",
4675 long_long_unsigned_type_node);
4676 if (c_dialect_cxx ())
4677 record_builtin_type (RID_MAX, "long long unsigned",
4678 long_long_unsigned_type_node);
4679 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
4680 record_builtin_type (RID_MAX, "short unsigned int",
4681 short_unsigned_type_node);
4682 if (c_dialect_cxx ())
4683 record_builtin_type (RID_MAX, "unsigned short",
4684 short_unsigned_type_node);
4685
4686 /* Define both `signed char' and `unsigned char'. */
4687 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
4688 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
4689
4690 /* These are types that c_common_type_for_size and
4691 c_common_type_for_mode use. */
4692 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4693 intQI_type_node));
4694 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4695 intHI_type_node));
4696 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4697 intSI_type_node));
4698 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4699 intDI_type_node));
4700#if HOST_BITS_PER_WIDE_INT >= 64
4701 if (targetm.scalar_mode_supported_p (TImode))
4702 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4703 get_identifier ("__int128_t"),
4704 intTI_type_node));
4705#endif
4706 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4707 unsigned_intQI_type_node));
4708 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4709 unsigned_intHI_type_node));
4710 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4711 unsigned_intSI_type_node));
4712 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4713 unsigned_intDI_type_node));
4714#if HOST_BITS_PER_WIDE_INT >= 64
4715 if (targetm.scalar_mode_supported_p (TImode))
4716 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4717 get_identifier ("__uint128_t"),
4718 unsigned_intTI_type_node));
4719#endif
4720
4721 /* Create the widest literal types. */
4722 widest_integer_literal_type_node
4723 = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
4724 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4725 widest_integer_literal_type_node));
4726
4727 widest_unsigned_literal_type_node
4728 = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
4729 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4730 widest_unsigned_literal_type_node));
4731
4732 /* `unsigned long' is the standard type for sizeof.
4733 Note that stddef.h uses `unsigned long',
4734 and this must agree, even if long and int are the same size. */
4735 size_type_node =
4736 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
4737 signed_size_type_node = c_common_signed_type (size_type_node);
4738 set_sizetype (size_type_node);
4739
4740 pid_type_node =
4741 TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE)));
4742
4743 build_common_tree_nodes_2 (flag_short_double);
4744
4745 record_builtin_type (RID_FLOAT, NULL, float_type_node);
4746 record_builtin_type (RID_DOUBLE, NULL, double_type_node);
4747 record_builtin_type (RID_MAX, "long double", long_double_type_node);
4748
4749 /* Only supported decimal floating point extension if the target
4750 actually supports underlying modes. */
4751 if (targetm.scalar_mode_supported_p (SDmode)
4752 && targetm.scalar_mode_supported_p (DDmode)
4753 && targetm.scalar_mode_supported_p (TDmode))
4754 {
4755 record_builtin_type (RID_DFLOAT32, NULL, dfloat32_type_node);
4756 record_builtin_type (RID_DFLOAT64, NULL, dfloat64_type_node);
4757 record_builtin_type (RID_DFLOAT128, NULL, dfloat128_type_node);
4758 }
4759
4760 if (targetm.fixed_point_supported_p ())
4761 {
4762 record_builtin_type (RID_MAX, "short _Fract", short_fract_type_node);
4763 record_builtin_type (RID_FRACT, NULL, fract_type_node);
4764 record_builtin_type (RID_MAX, "long _Fract", long_fract_type_node);
4765 record_builtin_type (RID_MAX, "long long _Fract",
4766 long_long_fract_type_node);
4767 record_builtin_type (RID_MAX, "unsigned short _Fract",
4768 unsigned_short_fract_type_node);
4769 record_builtin_type (RID_MAX, "unsigned _Fract",
4770 unsigned_fract_type_node);
4771 record_builtin_type (RID_MAX, "unsigned long _Fract",
4772 unsigned_long_fract_type_node);
4773 record_builtin_type (RID_MAX, "unsigned long long _Fract",
4774 unsigned_long_long_fract_type_node);
4775 record_builtin_type (RID_MAX, "_Sat short _Fract",
4776 sat_short_fract_type_node);
4777 record_builtin_type (RID_MAX, "_Sat _Fract", sat_fract_type_node);
4778 record_builtin_type (RID_MAX, "_Sat long _Fract",
4779 sat_long_fract_type_node);
4780 record_builtin_type (RID_MAX, "_Sat long long _Fract",
4781 sat_long_long_fract_type_node);
4782 record_builtin_type (RID_MAX, "_Sat unsigned short _Fract",
4783 sat_unsigned_short_fract_type_node);
4784 record_builtin_type (RID_MAX, "_Sat unsigned _Fract",
4785 sat_unsigned_fract_type_node);
4786 record_builtin_type (RID_MAX, "_Sat unsigned long _Fract",
4787 sat_unsigned_long_fract_type_node);
4788 record_builtin_type (RID_MAX, "_Sat unsigned long long _Fract",
4789 sat_unsigned_long_long_fract_type_node);
4790 record_builtin_type (RID_MAX, "short _Accum", short_accum_type_node);
4791 record_builtin_type (RID_ACCUM, NULL, accum_type_node);
4792 record_builtin_type (RID_MAX, "long _Accum", long_accum_type_node);
4793 record_builtin_type (RID_MAX, "long long _Accum",
4794 long_long_accum_type_node);
4795 record_builtin_type (RID_MAX, "unsigned short _Accum",
4796 unsigned_short_accum_type_node);
4797 record_builtin_type (RID_MAX, "unsigned _Accum",
4798 unsigned_accum_type_node);
4799 record_builtin_type (RID_MAX, "unsigned long _Accum",
4800 unsigned_long_accum_type_node);
4801 record_builtin_type (RID_MAX, "unsigned long long _Accum",
4802 unsigned_long_long_accum_type_node);
4803 record_builtin_type (RID_MAX, "_Sat short _Accum",
4804 sat_short_accum_type_node);
4805 record_builtin_type (RID_MAX, "_Sat _Accum", sat_accum_type_node);
4806 record_builtin_type (RID_MAX, "_Sat long _Accum",
4807 sat_long_accum_type_node);
4808 record_builtin_type (RID_MAX, "_Sat long long _Accum",
4809 sat_long_long_accum_type_node);
4810 record_builtin_type (RID_MAX, "_Sat unsigned short _Accum",
4811 sat_unsigned_short_accum_type_node);
4812 record_builtin_type (RID_MAX, "_Sat unsigned _Accum",
4813 sat_unsigned_accum_type_node);
4814 record_builtin_type (RID_MAX, "_Sat unsigned long _Accum",
4815 sat_unsigned_long_accum_type_node);
4816 record_builtin_type (RID_MAX, "_Sat unsigned long long _Accum",
4817 sat_unsigned_long_long_accum_type_node);
4818
4819 }
4820
4821 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4822 get_identifier ("complex int"),
4823 complex_integer_type_node));
4824 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4825 get_identifier ("complex float"),
4826 complex_float_type_node));
4827 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4828 get_identifier ("complex double"),
4829 complex_double_type_node));
4830 lang_hooks.decls.pushdecl
4831 (build_decl (TYPE_DECL, get_identifier ("complex long double"),
4832 complex_long_double_type_node));
4833
4834 if (c_dialect_cxx ())
4835 /* For C++, make fileptr_type_node a distinct void * type until
4836 FILE type is defined. */
4837 fileptr_type_node = build_variant_type_copy (ptr_type_node);
4838
4839 record_builtin_type (RID_VOID, NULL, void_type_node);
4840
4841 /* Set the TYPE_NAME for any variants that were built before
4842 record_builtin_type gave names to the built-in types. */
4843 {
4844 tree void_name = TYPE_NAME (void_type_node);
4845 TYPE_NAME (void_type_node) = NULL_TREE;
4846 TYPE_NAME (build_qualified_type (void_type_node, TYPE_QUAL_CONST))
4847 = void_name;
4848 TYPE_NAME (void_type_node) = void_name;
4849 }
4850
4851 /* This node must not be shared. */
4852 void_zero_node = make_node (INTEGER_CST);
4853 TREE_TYPE (void_zero_node) = void_type_node;
4854
4855 void_list_node = build_void_list_node ();
4856
4857 /* Make a type to be the domain of a few array types
4858 whose domains don't really matter.
4859 200 is small enough that it always fits in size_t
4860 and large enough that it can hold most function names for the
4861 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
4862 array_domain_type = build_index_type (size_int (200));
4863
4864 /* Make a type for arrays of characters.
4865 With luck nothing will ever really depend on the length of this
4866 array type. */
4867 char_array_type_node
4868 = build_array_type (char_type_node, array_domain_type);
4869
4870 /* Likewise for arrays of ints. */
4871 int_array_type_node
4872 = build_array_type (integer_type_node, array_domain_type);
4873
4874 string_type_node = build_pointer_type (char_type_node);
4875 const_string_type_node
4876 = build_pointer_type (build_qualified_type
4877 (char_type_node, TYPE_QUAL_CONST));
4878
4879 /* This is special for C++ so functions can be overloaded. */
4880 wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
4881 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
4882 wchar_type_size = TYPE_PRECISION (wchar_type_node);
4883 underlying_wchar_type_node = wchar_type_node;
4884 if (c_dialect_cxx ())
4885 {
4886 if (TYPE_UNSIGNED (wchar_type_node))
4887 wchar_type_node = make_unsigned_type (wchar_type_size);
4888 else
4889 wchar_type_node = make_signed_type (wchar_type_size);
4890 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
4891 }
4892
4893 /* This is for wide string constants. */
4894 wchar_array_type_node
4895 = build_array_type (wchar_type_node, array_domain_type);
4896
4897 /* Define 'char16_t'. */
4898 char16_type_node = get_identifier (CHAR16_TYPE);
4899 char16_type_node = TREE_TYPE (identifier_global_value (char16_type_node));
4900 char16_type_size = TYPE_PRECISION (char16_type_node);
4901 if (c_dialect_cxx ())
4902 {
4903 char16_type_node = make_unsigned_type (char16_type_size);
4904
4905 if (cxx_dialect == cxx0x)
4906 record_builtin_type (RID_CHAR16, "char16_t", char16_type_node);
4907 }
4908
4909 /* This is for UTF-16 string constants. */
4910 char16_array_type_node
4911 = build_array_type (char16_type_node, array_domain_type);
4912
4913 /* Define 'char32_t'. */
4914 char32_type_node = get_identifier (CHAR32_TYPE);
4915 char32_type_node = TREE_TYPE (identifier_global_value (char32_type_node));
4916 char32_type_size = TYPE_PRECISION (char32_type_node);
4917 if (c_dialect_cxx ())
4918 {
4919 char32_type_node = make_unsigned_type (char32_type_size);
4920
4921 if (cxx_dialect == cxx0x)
4922 record_builtin_type (RID_CHAR32, "char32_t", char32_type_node);
4923 }
4924
4925 /* This is for UTF-32 string constants. */
4926 char32_array_type_node
4927 = build_array_type (char32_type_node, array_domain_type);
4928
4929 wint_type_node =
4930 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
4931
4932 intmax_type_node =
4933 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
4934 uintmax_type_node =
4935 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
4936
4937 if (SIG_ATOMIC_TYPE)
4938 sig_atomic_type_node =
4939 TREE_TYPE (identifier_global_value (c_get_ident (SIG_ATOMIC_TYPE)));
4940 if (INT8_TYPE)
4941 int8_type_node =
4942 TREE_TYPE (identifier_global_value (c_get_ident (INT8_TYPE)));
4943 if (INT16_TYPE)
4944 int16_type_node =
4945 TREE_TYPE (identifier_global_value (c_get_ident (INT16_TYPE)));
4946 if (INT32_TYPE)
4947 int32_type_node =
4948 TREE_TYPE (identifier_global_value (c_get_ident (INT32_TYPE)));
4949 if (INT64_TYPE)
4950 int64_type_node =
4951 TREE_TYPE (identifier_global_value (c_get_ident (INT64_TYPE)));
4952 if (UINT8_TYPE)
4953 uint8_type_node =
4954 TREE_TYPE (identifier_global_value (c_get_ident (UINT8_TYPE)));
4955 if (UINT16_TYPE)
4956 uint16_type_node =
4957 TREE_TYPE (identifier_global_value (c_get_ident (UINT16_TYPE)));
4958 if (UINT32_TYPE)
4959 c_uint32_type_node =
4960 TREE_TYPE (identifier_global_value (c_get_ident (UINT32_TYPE)));
4961 if (UINT64_TYPE)
4962 c_uint64_type_node =
4963 TREE_TYPE (identifier_global_value (c_get_ident (UINT64_TYPE)));
4964 if (INT_LEAST8_TYPE)
4965 int_least8_type_node =
4966 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST8_TYPE)));
4967 if (INT_LEAST16_TYPE)
4968 int_least16_type_node =
4969 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST16_TYPE)));
4970 if (INT_LEAST32_TYPE)
4971 int_least32_type_node =
4972 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST32_TYPE)));
4973 if (INT_LEAST64_TYPE)
4974 int_least64_type_node =
4975 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST64_TYPE)));
4976 if (UINT_LEAST8_TYPE)
4977 uint_least8_type_node =
4978 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST8_TYPE)));
4979 if (UINT_LEAST16_TYPE)
4980 uint_least16_type_node =
4981 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST16_TYPE)));
4982 if (UINT_LEAST32_TYPE)
4983 uint_least32_type_node =
4984 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST32_TYPE)));
4985 if (UINT_LEAST64_TYPE)
4986 uint_least64_type_node =
4987 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST64_TYPE)));
4988 if (INT_FAST8_TYPE)
4989 int_fast8_type_node =
4990 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST8_TYPE)));
4991 if (INT_FAST16_TYPE)
4992 int_fast16_type_node =
4993 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST16_TYPE)));
4994 if (INT_FAST32_TYPE)
4995 int_fast32_type_node =
4996 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST32_TYPE)));
4997 if (INT_FAST64_TYPE)
4998 int_fast64_type_node =
4999 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST64_TYPE)));
5000 if (UINT_FAST8_TYPE)
5001 uint_fast8_type_node =
5002 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST8_TYPE)));
5003 if (UINT_FAST16_TYPE)
5004 uint_fast16_type_node =
5005 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST16_TYPE)));
5006 if (UINT_FAST32_TYPE)
5007 uint_fast32_type_node =
5008 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST32_TYPE)));
5009 if (UINT_FAST64_TYPE)
5010 uint_fast64_type_node =
5011 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST64_TYPE)));
5012 if (INTPTR_TYPE)
5013 intptr_type_node =
5014 TREE_TYPE (identifier_global_value (c_get_ident (INTPTR_TYPE)));
5015 if (UINTPTR_TYPE)
5016 uintptr_type_node =
5017 TREE_TYPE (identifier_global_value (c_get_ident (UINTPTR_TYPE)));
5018
5019 default_function_type = build_function_type (integer_type_node, NULL_TREE);
5020 ptrdiff_type_node
5021 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
5022 unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
5023
5024 lang_hooks.decls.pushdecl
5025 (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
5026 va_list_type_node));
5027#ifdef TARGET_ENUM_VA_LIST
5028 {
5029 int l;
5030 const char *pname;
5031 tree ptype;
5032 for (l = 0; TARGET_ENUM_VA_LIST (l, &pname, &ptype); ++l)
5033 {
5034 lang_hooks.decls.pushdecl
5035 (build_decl (TYPE_DECL, get_identifier (pname),
5036 ptype));
5037
5038 }
5039 }
5040#endif
5041
5042 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
5043 {
5044 va_list_arg_type_node = va_list_ref_type_node =
5045 build_pointer_type (TREE_TYPE (va_list_type_node));
5046 }
5047 else
5048 {
5049 va_list_arg_type_node = va_list_type_node;
5050 va_list_ref_type_node = build_reference_type (va_list_type_node);
5051 }
5052
5053 if (!flag_preprocess_only)
5054 c_define_builtins (va_list_ref_type_node, va_list_arg_type_node);
5055
5056 main_identifier_node = get_identifier ("main");
5057
5058 /* Create the built-in __null node. It is important that this is
5059 not shared. */
5060 null_node = make_node (INTEGER_CST);
5061 TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0);
5062
5063 /* Since builtin_types isn't gc'ed, don't export these nodes. */
5064 memset (builtin_types, 0, sizeof (builtin_types));
5065}
5066
5067/* Look up the function in built_in_decls that corresponds to DECL
5068 and set ASMSPEC as its user assembler name. DECL must be a
5069 function decl that declares a builtin. */
5070
5071void
5072set_builtin_user_assembler_name (tree decl, const char *asmspec)
5073{
5074 tree builtin;
5075 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
5076 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
5077 && asmspec != 0);
5078
5079 builtin = built_in_decls [DECL_FUNCTION_CODE (decl)];
5080 set_user_assembler_name (builtin, asmspec);
5081 switch (DECL_FUNCTION_CODE (decl))
5082 {
5083 case BUILT_IN_MEMCPY:
5084 init_block_move_fn (asmspec);
5085 memcpy_libfunc = set_user_assembler_libfunc ("memcpy", asmspec);
5086 break;
5087 case BUILT_IN_MEMSET:
5088 init_block_clear_fn (asmspec);
5089 memset_libfunc = set_user_assembler_libfunc ("memset", asmspec);
5090 break;
5091 case BUILT_IN_MEMMOVE:
5092 memmove_libfunc = set_user_assembler_libfunc ("memmove", asmspec);
5093 break;
5094 case BUILT_IN_MEMCMP:
5095 memcmp_libfunc = set_user_assembler_libfunc ("memcmp", asmspec);
5096 break;
5097 case BUILT_IN_ABORT:
5098 abort_libfunc = set_user_assembler_libfunc ("abort", asmspec);
5099 break;
5100 default:
5101 break;
5102 }
5103}
5104
5105/* The number of named compound-literals generated thus far. */
5106static GTY(()) int compound_literal_number;
5107
5108/* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal. */
5109
5110void
5111set_compound_literal_name (tree decl)
5112{
5113 char *name;
5114 ASM_FORMAT_PRIVATE_NAME (name, "__compound_literal",
5115 compound_literal_number);
5116 compound_literal_number++;
5117 DECL_NAME (decl) = get_identifier (name);
5118}
5119
5120tree
5121build_va_arg (tree expr, tree type)
5122{
5123 return build1 (VA_ARG_EXPR, type, expr);
5124}
5125
5126
5127/* Linked list of disabled built-in functions. */
5128
5129typedef struct disabled_builtin
5130{
5131 const char *name;
5132 struct disabled_builtin *next;
5133} disabled_builtin;
5134static disabled_builtin *disabled_builtins = NULL;
5135
5136static bool builtin_function_disabled_p (const char *);
5137
5138/* Disable a built-in function specified by -fno-builtin-NAME. If NAME
5139 begins with "__builtin_", give an error. */
5140
5141void
5142disable_builtin_function (const char *name)
5143{
5144 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
5145 error ("cannot disable built-in function %qs", name);
5146 else
5147 {
5148 disabled_builtin *new_disabled_builtin = XNEW (disabled_builtin);
5149 new_disabled_builtin->name = name;
5150 new_disabled_builtin->next = disabled_builtins;
5151 disabled_builtins = new_disabled_builtin;
5152 }
5153}
5154
5155
5156/* Return true if the built-in function NAME has been disabled, false
5157 otherwise. */
5158
5159static bool
5160builtin_function_disabled_p (const char *name)
5161{
5162 disabled_builtin *p;
5163 for (p = disabled_builtins; p != NULL; p = p->next)
5164 {
5165 if (strcmp (name, p->name) == 0)
5166 return true;
5167 }
5168 return false;
5169}
5170
5171
5172/* Worker for DEF_BUILTIN.
5173 Possibly define a builtin function with one or two names.
5174 Does not declare a non-__builtin_ function if flag_no_builtin, or if
5175 nonansi_p and flag_no_nonansi_builtin. */
5176
5177static void
5178def_builtin_1 (enum built_in_function fncode,
5179 const char *name,
5180 enum built_in_class fnclass,
5181 tree fntype, tree libtype,
5182 bool both_p, bool fallback_p, bool nonansi_p,
5183 tree fnattrs, bool implicit_p)
5184{
5185 tree decl;
5186 const char *libname;
5187
5188 if (fntype == error_mark_node)
5189 return;
5190
5191 gcc_assert ((!both_p && !fallback_p)
5192 || !strncmp (name, "__builtin_",
5193 strlen ("__builtin_")));
5194
5195 libname = name + strlen ("__builtin_");
5196 decl = add_builtin_function (name, fntype, fncode, fnclass,
5197 (fallback_p ? libname : NULL),
5198 fnattrs);
5199 if (both_p
5200 && !flag_no_builtin && !builtin_function_disabled_p (libname)
5201 && !(nonansi_p && flag_no_nonansi_builtin))
5202 add_builtin_function (libname, libtype, fncode, fnclass,
5203 NULL, fnattrs);
5204
5205 built_in_decls[(int) fncode] = decl;
5206 if (implicit_p)
5207 implicit_built_in_decls[(int) fncode] = decl;
5208}
5209\f
5210/* Nonzero if the type T promotes to int. This is (nearly) the
5211 integral promotions defined in ISO C99 6.3.1.1/2. */
5212
5213bool
5214c_promoting_integer_type_p (const_tree t)
5215{
5216 switch (TREE_CODE (t))
5217 {
5218 case INTEGER_TYPE:
5219 return (TYPE_MAIN_VARIANT (t) == char_type_node
5220 || TYPE_MAIN_VARIANT (t) == signed_char_type_node
5221 || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
5222 || TYPE_MAIN_VARIANT (t) == short_integer_type_node
5223 || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
5224 || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
5225
5226 case ENUMERAL_TYPE:
5227 /* ??? Technically all enumerations not larger than an int
5228 promote to an int. But this is used along code paths
5229 that only want to notice a size change. */
5230 return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
5231
5232 case BOOLEAN_TYPE:
5233 return 1;
5234
5235 default:
5236 return 0;
5237 }
5238}
5239
5240/* Return 1 if PARMS specifies a fixed number of parameters
5241 and none of their types is affected by default promotions. */
5242
5243int
5244self_promoting_args_p (const_tree parms)
5245{
5246 const_tree t;
5247 for (t = parms; t; t = TREE_CHAIN (t))
5248 {
5249 tree type = TREE_VALUE (t);
5250
5251 if (type == error_mark_node)
5252 continue;
5253
5254 if (TREE_CHAIN (t) == 0 && type != void_type_node)
5255 return 0;
5256
5257 if (type == 0)
5258 return 0;
5259
5260 if (TYPE_MAIN_VARIANT (type) == float_type_node)
5261 return 0;
5262
5263 if (c_promoting_integer_type_p (type))
5264 return 0;
5265 }
5266 return 1;
5267}
5268
5269/* Recursively remove any '*' or '&' operator from TYPE. */
5270tree
5271strip_pointer_operator (tree t)
5272{
5273 while (POINTER_TYPE_P (t))
5274 t = TREE_TYPE (t);
5275 return t;
5276}
5277
5278/* Recursively remove pointer or array type from TYPE. */
5279tree
5280strip_pointer_or_array_types (tree t)
5281{
5282 while (TREE_CODE (t) == ARRAY_TYPE || POINTER_TYPE_P (t))
5283 t = TREE_TYPE (t);
5284 return t;
5285}
5286
5287/* Used to compare case labels. K1 and K2 are actually tree nodes
5288 representing case labels, or NULL_TREE for a `default' label.
5289 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
5290 K2, and 0 if K1 and K2 are equal. */
5291
5292int
5293case_compare (splay_tree_key k1, splay_tree_key k2)
5294{
5295 /* Consider a NULL key (such as arises with a `default' label) to be
5296 smaller than anything else. */
5297 if (!k1)
5298 return k2 ? -1 : 0;
5299 else if (!k2)
5300 return k1 ? 1 : 0;
5301
5302 return tree_int_cst_compare ((tree) k1, (tree) k2);
5303}
5304
5305/* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
5306 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
5307 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
5308 case label was declared using the usual C/C++ syntax, rather than
5309 the GNU case range extension. CASES is a tree containing all the
5310 case ranges processed so far; COND is the condition for the
5311 switch-statement itself. Returns the CASE_LABEL_EXPR created, or
5312 ERROR_MARK_NODE if no CASE_LABEL_EXPR is created. */
5313
5314tree
5315c_add_case_label (splay_tree cases, tree cond, tree orig_type,
5316 tree low_value, tree high_value)
5317{
5318 tree type;
5319 tree label;
5320 tree case_label;
5321 splay_tree_node node;
5322
5323 /* Create the LABEL_DECL itself. */
5324 label = create_artificial_label ();
5325
5326 /* If there was an error processing the switch condition, bail now
5327 before we get more confused. */
5328 if (!cond || cond == error_mark_node)
5329 goto error_out;
5330
5331 if ((low_value && TREE_TYPE (low_value)
5332 && POINTER_TYPE_P (TREE_TYPE (low_value)))
5333 || (high_value && TREE_TYPE (high_value)
5334 && POINTER_TYPE_P (TREE_TYPE (high_value))))
5335 {
5336 error ("pointers are not permitted as case values");
5337 goto error_out;
5338 }
5339
5340 /* Case ranges are a GNU extension. */
5341 if (high_value)
5342 pedwarn (input_location, OPT_pedantic,
5343 "range expressions in switch statements are non-standard");
5344
5345 type = TREE_TYPE (cond);
5346 if (low_value)
5347 {
5348 low_value = check_case_value (low_value);
5349 low_value = convert_and_check (type, low_value);
5350 if (low_value == error_mark_node)
5351 goto error_out;
5352 }
5353 if (high_value)
5354 {
5355 high_value = check_case_value (high_value);
5356 high_value = convert_and_check (type, high_value);
5357 if (high_value == error_mark_node)
5358 goto error_out;
5359 }
5360
5361 if (low_value && high_value)
5362 {
5363 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
5364 really a case range, even though it was written that way.
5365 Remove the HIGH_VALUE to simplify later processing. */
5366 if (tree_int_cst_equal (low_value, high_value))
5367 high_value = NULL_TREE;
5368 else if (!tree_int_cst_lt (low_value, high_value))
5369 warning (0, "empty range specified");
5370 }
5371
5372 /* See if the case is in range of the type of the original testing
5373 expression. If both low_value and high_value are out of range,
5374 don't insert the case label and return NULL_TREE. */
5375 if (low_value
5376 && !check_case_bounds (type, orig_type,
5377 &low_value, high_value ? &high_value : NULL))
5378 return NULL_TREE;
5379
5380 /* Look up the LOW_VALUE in the table of case labels we already
5381 have. */
5382 node = splay_tree_lookup (cases, (splay_tree_key) low_value);
5383 /* If there was not an exact match, check for overlapping ranges.
5384 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
5385 that's a `default' label and the only overlap is an exact match. */
5386 if (!node && (low_value || high_value))
5387 {
5388 splay_tree_node low_bound;
5389 splay_tree_node high_bound;
5390
5391 /* Even though there wasn't an exact match, there might be an
5392 overlap between this case range and another case range.
5393 Since we've (inductively) not allowed any overlapping case
5394 ranges, we simply need to find the greatest low case label
5395 that is smaller that LOW_VALUE, and the smallest low case
5396 label that is greater than LOW_VALUE. If there is an overlap
5397 it will occur in one of these two ranges. */
5398 low_bound = splay_tree_predecessor (cases,
5399 (splay_tree_key) low_value);
5400 high_bound = splay_tree_successor (cases,
5401 (splay_tree_key) low_value);
5402
5403 /* Check to see if the LOW_BOUND overlaps. It is smaller than
5404 the LOW_VALUE, so there is no need to check unless the
5405 LOW_BOUND is in fact itself a case range. */
5406 if (low_bound
5407 && CASE_HIGH ((tree) low_bound->value)
5408 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
5409 low_value) >= 0)
5410 node = low_bound;
5411 /* Check to see if the HIGH_BOUND overlaps. The low end of that
5412 range is bigger than the low end of the current range, so we
5413 are only interested if the current range is a real range, and
5414 not an ordinary case label. */
5415 else if (high_bound
5416 && high_value
5417 && (tree_int_cst_compare ((tree) high_bound->key,
5418 high_value)
5419 <= 0))
5420 node = high_bound;
5421 }
5422 /* If there was an overlap, issue an error. */
5423 if (node)
5424 {
5425 tree duplicate = CASE_LABEL ((tree) node->value);
5426
5427 if (high_value)
5428 {
5429 error ("duplicate (or overlapping) case value");
5430 error ("%Jthis is the first entry overlapping that value", duplicate);
5431 }
5432 else if (low_value)
5433 {
5434 error ("duplicate case value") ;
5435 error ("%Jpreviously used here", duplicate);
5436 }
5437 else
5438 {
5439 error ("multiple default labels in one switch");
5440 error ("%Jthis is the first default label", duplicate);
5441 }
5442 goto error_out;
5443 }
5444
5445 /* Add a CASE_LABEL to the statement-tree. */
5446 case_label = add_stmt (build_case_label (low_value, high_value, label));
5447 /* Register this case label in the splay tree. */
5448 splay_tree_insert (cases,
5449 (splay_tree_key) low_value,
5450 (splay_tree_value) case_label);
5451
5452 return case_label;
5453
5454 error_out:
5455 /* Add a label so that the back-end doesn't think that the beginning of
5456 the switch is unreachable. Note that we do not add a case label, as
5457 that just leads to duplicates and thence to failure later on. */
5458 if (!cases->root)
5459 {
5460 tree t = create_artificial_label ();
5461 add_stmt (build_stmt (LABEL_EXPR, t));
5462 }
5463 return error_mark_node;
5464}
5465
5466/* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
5467 Used to verify that case values match up with enumerator values. */
5468
5469static void
5470match_case_to_enum_1 (tree key, tree type, tree label)
5471{
5472 char buf[2 + 2*HOST_BITS_PER_WIDE_INT/4 + 1];
5473
5474 /* ??? Not working too hard to print the double-word value.
5475 Should perhaps be done with %lwd in the diagnostic routines? */
5476 if (TREE_INT_CST_HIGH (key) == 0)
5477 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_UNSIGNED,
5478 TREE_INT_CST_LOW (key));
5479 else if (!TYPE_UNSIGNED (type)
5480 && TREE_INT_CST_HIGH (key) == -1
5481 && TREE_INT_CST_LOW (key) != 0)
5482 snprintf (buf, sizeof (buf), "-" HOST_WIDE_INT_PRINT_UNSIGNED,
5483 -TREE_INT_CST_LOW (key));
5484 else
5485 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_DOUBLE_HEX,
5486 (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (key),
5487 (unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (key));
5488
5489 if (TYPE_NAME (type) == 0)
5490 warning (warn_switch ? OPT_Wswitch : OPT_Wswitch_enum,
5491 "%Jcase value %qs not in enumerated type",
5492 CASE_LABEL (label), buf);
5493 else
5494 warning (warn_switch ? OPT_Wswitch : OPT_Wswitch_enum,
5495 "%Jcase value %qs not in enumerated type %qT",
5496 CASE_LABEL (label), buf, type);
5497}
5498
5499/* Subroutine of c_do_switch_warnings, called via splay_tree_foreach.
5500 Used to verify that case values match up with enumerator values. */
5501
5502static int
5503match_case_to_enum (splay_tree_node node, void *data)
5504{
5505 tree label = (tree) node->value;
5506 tree type = (tree) data;
5507
5508 /* Skip default case. */
5509 if (!CASE_LOW (label))
5510 return 0;
5511
5512 /* If CASE_LOW_SEEN is not set, that means CASE_LOW did not appear
5513 when we did our enum->case scan. Reset our scratch bit after. */
5514 if (!CASE_LOW_SEEN (label))
5515 match_case_to_enum_1 (CASE_LOW (label), type, label);
5516 else
5517 CASE_LOW_SEEN (label) = 0;
5518
5519 /* If CASE_HIGH is non-null, we have a range. If CASE_HIGH_SEEN is
5520 not set, that means that CASE_HIGH did not appear when we did our
5521 enum->case scan. Reset our scratch bit after. */
5522 if (CASE_HIGH (label))
5523 {
5524 if (!CASE_HIGH_SEEN (label))
5525 match_case_to_enum_1 (CASE_HIGH (label), type, label);
5526 else
5527 CASE_HIGH_SEEN (label) = 0;
5528 }
5529
5530 return 0;
5531}
5532
5533/* Handle -Wswitch*. Called from the front end after parsing the
5534 switch construct. */
5535/* ??? Should probably be somewhere generic, since other languages
5536 besides C and C++ would want this. At the moment, however, C/C++
5537 are the only tree-ssa languages that support enumerations at all,
5538 so the point is moot. */
5539
5540void
5541c_do_switch_warnings (splay_tree cases, location_t switch_location,
5542 tree type, tree cond)
5543{
5544 splay_tree_node default_node;
5545 splay_tree_node node;
5546 tree chain;
5547 int saved_warn_switch;
5548
5549 if (!warn_switch && !warn_switch_enum && !warn_switch_default)
5550 return;
5551
5552 default_node = splay_tree_lookup (cases, (splay_tree_key) NULL);
5553 if (!default_node)
5554 warning (OPT_Wswitch_default, "%Hswitch missing default case",
5555 &switch_location);
5556
5557 /* From here on, we only care about about enumerated types. */
5558 if (!type || TREE_CODE (type) != ENUMERAL_TYPE)
5559 return;
5560
5561 /* If the switch expression was an enumerated type, check that
5562 exactly all enumeration literals are covered by the cases.
5563 The check is made when -Wswitch was specified and there is no
5564 default case, or when -Wswitch-enum was specified. */
5565
5566 if (!warn_switch_enum
5567 && !(warn_switch && !default_node))
5568 return;
5569
5570 /* Clearing COND if it is not an integer constant simplifies
5571 the tests inside the loop below. */
5572 if (TREE_CODE (cond) != INTEGER_CST)
5573 cond = NULL_TREE;
5574
5575 /* The time complexity here is O(N*lg(N)) worst case, but for the
5576 common case of monotonically increasing enumerators, it is
5577 O(N), since the nature of the splay tree will keep the next
5578 element adjacent to the root at all times. */
5579
5580 for (chain = TYPE_VALUES (type); chain; chain = TREE_CHAIN (chain))
5581 {
5582 tree value = TREE_VALUE (chain);
5583 if (TREE_CODE (value) == CONST_DECL)
5584 value = DECL_INITIAL (value);
5585 node = splay_tree_lookup (cases, (splay_tree_key) value);
5586 if (node)
5587 {
5588 /* Mark the CASE_LOW part of the case entry as seen. */
5589 tree label = (tree) node->value;
5590 CASE_LOW_SEEN (label) = 1;
5591 continue;
5592 }
5593
5594 /* Even though there wasn't an exact match, there might be a
5595 case range which includes the enumerator's value. */
5596 node = splay_tree_predecessor (cases, (splay_tree_key) value);
5597 if (node && CASE_HIGH ((tree) node->value))
5598 {
5599 tree label = (tree) node->value;
5600 int cmp = tree_int_cst_compare (CASE_HIGH (label), value);
5601 if (cmp >= 0)
5602 {
5603 /* If we match the upper bound exactly, mark the CASE_HIGH
5604 part of the case entry as seen. */
5605 if (cmp == 0)
5606 CASE_HIGH_SEEN (label) = 1;
5607 continue;
5608 }
5609 }
5610
5611 /* We've now determined that this enumerated literal isn't
5612 handled by the case labels of the switch statement. */
5613
5614 /* If the switch expression is a constant, we only really care
5615 about whether that constant is handled by the switch. */
5616 if (cond && tree_int_cst_compare (cond, value))
5617 continue;
5618
5619 /* If there is a default_node, the only relevant option is
5620 Wswitch-enum. Otherwise, if both are enabled then we prefer
5621 to warn using -Wswitch because -Wswitch is enabled by -Wall
5622 while -Wswitch-enum is explicit. */
5623 warning ((default_node || !warn_switch)
5624 ? OPT_Wswitch_enum : OPT_Wswitch,
5625 "%Henumeration value %qE not handled in switch",
5626 &switch_location, TREE_PURPOSE (chain));
5627 }
5628
5629 /* Warn if there are case expressions that don't correspond to
5630 enumerators. This can occur since C and C++ don't enforce
5631 type-checking of assignments to enumeration variables.
5632
5633 The time complexity here is now always O(N) worst case, since
5634 we should have marked both the lower bound and upper bound of
5635 every disjoint case label, with CASE_LOW_SEEN and CASE_HIGH_SEEN
5636 above. This scan also resets those fields. */
5637
5638 /* If there is a default_node, the only relevant option is
5639 Wswitch-enum. Otherwise, if both are enabled then we prefer
5640 to warn using -Wswitch because -Wswitch is enabled by -Wall
5641 while -Wswitch-enum is explicit. */
5642 saved_warn_switch = warn_switch;
5643 if (default_node)
5644 warn_switch = 0;
5645 splay_tree_foreach (cases, match_case_to_enum, type);
5646 warn_switch = saved_warn_switch;
5647
5648}
5649
5650/* Finish an expression taking the address of LABEL (an
5651 IDENTIFIER_NODE). Returns an expression for the address.
5652
5653 LOC is the location for the expression returned. */
5654
5655tree
5656finish_label_address_expr (tree label, location_t loc)
5657{
5658 tree result;
5659
5660 pedwarn (input_location, OPT_pedantic, "taking the address of a label is non-standard");
5661
5662 if (label == error_mark_node)
5663 return error_mark_node;
5664
5665 label = lookup_label (label);
5666 if (label == NULL_TREE)
5667 result = null_pointer_node;
5668 else
5669 {
5670 TREE_USED (label) = 1;
5671 result = build1 (ADDR_EXPR, ptr_type_node, label);
5672 /* The current function in not necessarily uninlinable.
5673 Computed gotos are incompatible with inlining, but the value
5674 here could be used only in a diagnostic, for example. */
5675 protected_set_expr_location (result, loc);
5676 }
5677
5678 return result;
5679}
5680\f
5681
5682/* Given a boolean expression ARG, return a tree representing an increment
5683 or decrement (as indicated by CODE) of ARG. The front end must check for
5684 invalid cases (e.g., decrement in C++). */
5685tree
5686boolean_increment (enum tree_code code, tree arg)
5687{
5688 tree val;
5689 tree true_res = build_int_cst (TREE_TYPE (arg), 1);
5690
5691 arg = stabilize_reference (arg);
5692 switch (code)
5693 {
5694 case PREINCREMENT_EXPR:
5695 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
5696 break;
5697 case POSTINCREMENT_EXPR:
5698 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
5699 arg = save_expr (arg);
5700 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
5701 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
5702 break;
5703 case PREDECREMENT_EXPR:
5704 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
5705 invert_truthvalue (arg));
5706 break;
5707 case POSTDECREMENT_EXPR:
5708 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
5709 invert_truthvalue (arg));
5710 arg = save_expr (arg);
5711 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
5712 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
5713 break;
5714 default:
5715 gcc_unreachable ();
5716 }
5717 TREE_SIDE_EFFECTS (val) = 1;
5718 return val;
5719}
5720\f
5721/* Built-in macros for stddef.h and stdint.h, that require macros
5722 defined in this file. */
5723void
5724c_stddef_cpp_builtins(void)
5725{
5726 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
5727 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
5728 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
5729 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
5730 builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE, 0);
5731 builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE, 0);
5732 builtin_define_with_value ("__CHAR16_TYPE__", CHAR16_TYPE, 0);
5733 builtin_define_with_value ("__CHAR32_TYPE__", CHAR32_TYPE, 0);
5734 if (SIG_ATOMIC_TYPE)
5735 builtin_define_with_value ("__SIG_ATOMIC_TYPE__", SIG_ATOMIC_TYPE, 0);
5736 if (INT8_TYPE)
5737 builtin_define_with_value ("__INT8_TYPE__", INT8_TYPE, 0);
5738 if (INT16_TYPE)
5739 builtin_define_with_value ("__INT16_TYPE__", INT16_TYPE, 0);
5740 if (INT32_TYPE)
5741 builtin_define_with_value ("__INT32_TYPE__", INT32_TYPE, 0);
5742 if (INT64_TYPE)
5743 builtin_define_with_value ("__INT64_TYPE__", INT64_TYPE, 0);
5744 if (UINT8_TYPE)
5745 builtin_define_with_value ("__UINT8_TYPE__", UINT8_TYPE, 0);
5746 if (UINT16_TYPE)
5747 builtin_define_with_value ("__UINT16_TYPE__", UINT16_TYPE, 0);
5748 if (UINT32_TYPE)
5749 builtin_define_with_value ("__UINT32_TYPE__", UINT32_TYPE, 0);
5750 if (UINT64_TYPE)
5751 builtin_define_with_value ("__UINT64_TYPE__", UINT64_TYPE, 0);
5752 if (INT_LEAST8_TYPE)
5753 builtin_define_with_value ("__INT_LEAST8_TYPE__", INT_LEAST8_TYPE, 0);
5754 if (INT_LEAST16_TYPE)
5755 builtin_define_with_value ("__INT_LEAST16_TYPE__", INT_LEAST16_TYPE, 0);
5756 if (INT_LEAST32_TYPE)
5757 builtin_define_with_value ("__INT_LEAST32_TYPE__", INT_LEAST32_TYPE, 0);
5758 if (INT_LEAST64_TYPE)
5759 builtin_define_with_value ("__INT_LEAST64_TYPE__", INT_LEAST64_TYPE, 0);
5760 if (UINT_LEAST8_TYPE)
5761 builtin_define_with_value ("__UINT_LEAST8_TYPE__", UINT_LEAST8_TYPE, 0);
5762 if (UINT_LEAST16_TYPE)
5763 builtin_define_with_value ("__UINT_LEAST16_TYPE__", UINT_LEAST16_TYPE, 0);
5764 if (UINT_LEAST32_TYPE)
5765 builtin_define_with_value ("__UINT_LEAST32_TYPE__", UINT_LEAST32_TYPE, 0);
5766 if (UINT_LEAST64_TYPE)
5767 builtin_define_with_value ("__UINT_LEAST64_TYPE__", UINT_LEAST64_TYPE, 0);
5768 if (INT_FAST8_TYPE)
5769 builtin_define_with_value ("__INT_FAST8_TYPE__", INT_FAST8_TYPE, 0);
5770 if (INT_FAST16_TYPE)
5771 builtin_define_with_value ("__INT_FAST16_TYPE__", INT_FAST16_TYPE, 0);
5772 if (INT_FAST32_TYPE)
5773 builtin_define_with_value ("__INT_FAST32_TYPE__", INT_FAST32_TYPE, 0);
5774 if (INT_FAST64_TYPE)
5775 builtin_define_with_value ("__INT_FAST64_TYPE__", INT_FAST64_TYPE, 0);
5776 if (UINT_FAST8_TYPE)
5777 builtin_define_with_value ("__UINT_FAST8_TYPE__", UINT_FAST8_TYPE, 0);
5778 if (UINT_FAST16_TYPE)
5779 builtin_define_with_value ("__UINT_FAST16_TYPE__", UINT_FAST16_TYPE, 0);
5780 if (UINT_FAST32_TYPE)
5781 builtin_define_with_value ("__UINT_FAST32_TYPE__", UINT_FAST32_TYPE, 0);
5782 if (UINT_FAST64_TYPE)
5783 builtin_define_with_value ("__UINT_FAST64_TYPE__", UINT_FAST64_TYPE, 0);
5784 if (INTPTR_TYPE)
5785 builtin_define_with_value ("__INTPTR_TYPE__", INTPTR_TYPE, 0);
5786 if (UINTPTR_TYPE)
5787 builtin_define_with_value ("__UINTPTR_TYPE__", UINTPTR_TYPE, 0);
5788}
5789
5790static void
5791c_init_attributes (void)
5792{
5793 /* Fill in the built_in_attributes array. */
5794#define DEF_ATTR_NULL_TREE(ENUM) \
5795 built_in_attributes[(int) ENUM] = NULL_TREE;
5796#define DEF_ATTR_INT(ENUM, VALUE) \
5797 built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
5798#define DEF_ATTR_IDENT(ENUM, STRING) \
5799 built_in_attributes[(int) ENUM] = get_identifier (STRING);
5800#define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
5801 built_in_attributes[(int) ENUM] \
5802 = tree_cons (built_in_attributes[(int) PURPOSE], \
5803 built_in_attributes[(int) VALUE], \
5804 built_in_attributes[(int) CHAIN]);
5805#include "builtin-attrs.def"
5806#undef DEF_ATTR_NULL_TREE
5807#undef DEF_ATTR_INT
5808#undef DEF_ATTR_IDENT
5809#undef DEF_ATTR_TREE_LIST
5810}
5811
5812/* Attribute handlers common to C front ends. */
5813
5814/* Handle a "packed" attribute; arguments as in
5815 struct attribute_spec.handler. */
5816
5817static tree
5818handle_packed_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5819 int flags, bool *no_add_attrs)
5820{
5821 if (TYPE_P (*node))
5822 {
5823 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5824 *node = build_variant_type_copy (*node);
5825 TYPE_PACKED (*node) = 1;
5826 }
5827 else if (TREE_CODE (*node) == FIELD_DECL)
5828 {
5829 if (TYPE_ALIGN (TREE_TYPE (*node)) <= BITS_PER_UNIT
5830 /* Still pack bitfields. */
5831 && ! DECL_INITIAL (*node))
5832 warning (OPT_Wattributes,
5833 "%qE attribute ignored for field of type %qT",
5834 name, TREE_TYPE (*node));
5835 else
5836 DECL_PACKED (*node) = 1;
5837 }
5838 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
5839 used for DECL_REGISTER. It wouldn't mean anything anyway.
5840 We can't set DECL_PACKED on the type of a TYPE_DECL, because
5841 that changes what the typedef is typing. */
5842 else
5843 {
5844 warning (OPT_Wattributes, "%qE attribute ignored", name);
5845 *no_add_attrs = true;
5846 }
5847
5848 return NULL_TREE;
5849}
5850
5851/* Handle a "nocommon" attribute; arguments as in
5852 struct attribute_spec.handler. */
5853
5854static tree
5855handle_nocommon_attribute (tree *node, tree name,
5856 tree ARG_UNUSED (args),
5857 int ARG_UNUSED (flags), bool *no_add_attrs)
5858{
5859 if (TREE_CODE (*node) == VAR_DECL)
5860 DECL_COMMON (*node) = 0;
5861 else
5862 {
5863 warning (OPT_Wattributes, "%qE attribute ignored", name);
5864 *no_add_attrs = true;
5865 }
5866
5867 return NULL_TREE;
5868}
5869
5870/* Handle a "common" attribute; arguments as in
5871 struct attribute_spec.handler. */
5872
5873static tree
5874handle_common_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5875 int ARG_UNUSED (flags), bool *no_add_attrs)
5876{
5877 if (TREE_CODE (*node) == VAR_DECL)
5878 DECL_COMMON (*node) = 1;
5879 else
5880 {
5881 warning (OPT_Wattributes, "%qE attribute ignored", name);
5882 *no_add_attrs = true;
5883 }
5884
5885 return NULL_TREE;
5886}
5887
5888/* Handle a "noreturn" attribute; arguments as in
5889 struct attribute_spec.handler. */
5890
5891static tree
5892handle_noreturn_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5893 int ARG_UNUSED (flags), bool *no_add_attrs)
5894{
5895 tree type = TREE_TYPE (*node);
5896
5897 /* See FIXME comment in c_common_attribute_table. */
5898 if (TREE_CODE (*node) == FUNCTION_DECL)
5899 TREE_THIS_VOLATILE (*node) = 1;
5900 else if (TREE_CODE (type) == POINTER_TYPE
5901 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
5902 TREE_TYPE (*node)
5903 = build_pointer_type
5904 (build_type_variant (TREE_TYPE (type),
5905 TYPE_READONLY (TREE_TYPE (type)), 1));
5906 else
5907 {
5908 warning (OPT_Wattributes, "%qE attribute ignored", name);
5909 *no_add_attrs = true;
5910 }
5911
5912 return NULL_TREE;
5913}
5914
5915/* Handle a "hot" and attribute; arguments as in
5916 struct attribute_spec.handler. */
5917
5918static tree
5919handle_hot_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5920 int ARG_UNUSED (flags), bool *no_add_attrs)
5921{
5922 if (TREE_CODE (*node) == FUNCTION_DECL)
5923 {
5924 if (lookup_attribute ("cold", DECL_ATTRIBUTES (*node)) != NULL)
5925 {
5926 warning (OPT_Wattributes, "%qE attribute conflicts with attribute %s",
5927 name, "cold");
5928 *no_add_attrs = true;
5929 }
5930 /* Most of the rest of the hot processing is done later with
5931 lookup_attribute. */
5932 }
5933 else
5934 {
5935 warning (OPT_Wattributes, "%qE attribute ignored", name);
5936 *no_add_attrs = true;
5937 }
5938
5939 return NULL_TREE;
5940}
5941/* Handle a "cold" and attribute; arguments as in
5942 struct attribute_spec.handler. */
5943
5944static tree
5945handle_cold_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5946 int ARG_UNUSED (flags), bool *no_add_attrs)
5947{
5948 if (TREE_CODE (*node) == FUNCTION_DECL)
5949 {
5950 if (lookup_attribute ("hot", DECL_ATTRIBUTES (*node)) != NULL)
5951 {
5952 warning (OPT_Wattributes, "%qE attribute conflicts with attribute %s",
5953 name, "hot");
5954 *no_add_attrs = true;
5955 }
5956 /* Most of the rest of the cold processing is done later with
5957 lookup_attribute. */
5958 }
5959 else
5960 {
5961 warning (OPT_Wattributes, "%qE attribute ignored", name);
5962 *no_add_attrs = true;
5963 }
5964
5965 return NULL_TREE;
5966}
5967
5968/* Handle a "noinline" attribute; arguments as in
5969 struct attribute_spec.handler. */
5970
5971static tree
5972handle_noinline_attribute (tree *node, tree name,
5973 tree ARG_UNUSED (args),
5974 int ARG_UNUSED (flags), bool *no_add_attrs)
5975{
5976 if (TREE_CODE (*node) == FUNCTION_DECL)
5977 DECL_UNINLINABLE (*node) = 1;
5978 else
5979 {
5980 warning (OPT_Wattributes, "%qE attribute ignored", name);
5981 *no_add_attrs = true;
5982 }
5983
5984 return NULL_TREE;
5985}
5986
5987/* Handle a "always_inline" attribute; arguments as in
5988 struct attribute_spec.handler. */
5989
5990static tree
5991handle_always_inline_attribute (tree *node, tree name,
5992 tree ARG_UNUSED (args),
5993 int ARG_UNUSED (flags),
5994 bool *no_add_attrs)
5995{
5996 if (TREE_CODE (*node) == FUNCTION_DECL)
5997 {
5998 /* Set the attribute and mark it for disregarding inline
5999 limits. */
6000 DECL_DISREGARD_INLINE_LIMITS (*node) = 1;
6001 }
6002 else
6003 {
6004 warning (OPT_Wattributes, "%qE attribute ignored", name);
6005 *no_add_attrs = true;
6006 }
6007
6008 return NULL_TREE;
6009}
6010
6011/* Handle a "gnu_inline" attribute; arguments as in
6012 struct attribute_spec.handler. */
6013
6014static tree
6015handle_gnu_inline_attribute (tree *node, tree name,
6016 tree ARG_UNUSED (args),
6017 int ARG_UNUSED (flags),
6018 bool *no_add_attrs)
6019{
6020 if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
6021 {
6022 /* Do nothing else, just set the attribute. We'll get at
6023 it later with lookup_attribute. */
6024 }
6025 else
6026 {
6027 warning (OPT_Wattributes, "%qE attribute ignored", name);
6028 *no_add_attrs = true;
6029 }
6030
6031 return NULL_TREE;
6032}
6033
6034/* Handle an "artificial" attribute; arguments as in
6035 struct attribute_spec.handler. */
6036
6037static tree
6038handle_artificial_attribute (tree *node, tree name,
6039 tree ARG_UNUSED (args),
6040 int ARG_UNUSED (flags),
6041 bool *no_add_attrs)
6042{
6043 if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
6044 {
6045 /* Do nothing else, just set the attribute. We'll get at
6046 it later with lookup_attribute. */
6047 }
6048 else
6049 {
6050 warning (OPT_Wattributes, "%qE attribute ignored", name);
6051 *no_add_attrs = true;
6052 }
6053
6054 return NULL_TREE;
6055}
6056
6057/* Handle a "flatten" attribute; arguments as in
6058 struct attribute_spec.handler. */
6059
6060static tree
6061handle_flatten_attribute (tree *node, tree name,
6062 tree args ATTRIBUTE_UNUSED,
6063 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
6064{
6065 if (TREE_CODE (*node) == FUNCTION_DECL)
6066 /* Do nothing else, just set the attribute. We'll get at
6067 it later with lookup_attribute. */
6068 ;
6069 else
6070 {
6071 warning (OPT_Wattributes, "%qE attribute ignored", name);
6072 *no_add_attrs = true;
6073 }
6074
6075 return NULL_TREE;
6076}
6077
6078/* Handle a "warning" or "error" attribute; arguments as in
6079 struct attribute_spec.handler. */
6080
6081static tree
6082handle_error_attribute (tree *node, tree name, tree args,
6083 int ARG_UNUSED (flags), bool *no_add_attrs)
6084{
6085 if (TREE_CODE (*node) == FUNCTION_DECL
6086 || TREE_CODE (TREE_VALUE (args)) == STRING_CST)
6087 /* Do nothing else, just set the attribute. We'll get at
6088 it later with lookup_attribute. */
6089 ;
6090 else
6091 {
6092 warning (OPT_Wattributes, "%qE attribute ignored", name);
6093 *no_add_attrs = true;
6094 }
6095
6096 return NULL_TREE;
6097}
6098
6099/* Handle a "used" attribute; arguments as in
6100 struct attribute_spec.handler. */
6101
6102static tree
6103handle_used_attribute (tree *pnode, tree name, tree ARG_UNUSED (args),
6104 int ARG_UNUSED (flags), bool *no_add_attrs)
6105{
6106 tree node = *pnode;
6107
6108 if (TREE_CODE (node) == FUNCTION_DECL
6109 || (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node)))
6110 {
6111 TREE_USED (node) = 1;
6112 DECL_PRESERVE_P (node) = 1;
6113 }
6114 else
6115 {
6116 warning (OPT_Wattributes, "%qE attribute ignored", name);
6117 *no_add_attrs = true;
6118 }
6119
6120 return NULL_TREE;
6121}
6122
6123/* Handle a "unused" attribute; arguments as in
6124 struct attribute_spec.handler. */
6125
6126static tree
6127handle_unused_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6128 int flags, bool *no_add_attrs)
6129{
6130 if (DECL_P (*node))
6131 {
6132 tree decl = *node;
6133
6134 if (TREE_CODE (decl) == PARM_DECL
6135 || TREE_CODE (decl) == VAR_DECL
6136 || TREE_CODE (decl) == FUNCTION_DECL
6137 || TREE_CODE (decl) == LABEL_DECL
6138 || TREE_CODE (decl) == TYPE_DECL)
6139 TREE_USED (decl) = 1;
6140 else
6141 {
6142 warning (OPT_Wattributes, "%qE attribute ignored", name);
6143 *no_add_attrs = true;
6144 }
6145 }
6146 else
6147 {
6148 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
6149 *node = build_variant_type_copy (*node);
6150 TREE_USED (*node) = 1;
6151 }
6152
6153 return NULL_TREE;
6154}
6155
6156/* Handle a "externally_visible" attribute; arguments as in
6157 struct attribute_spec.handler. */
6158
6159static tree
6160handle_externally_visible_attribute (tree *pnode, tree name,
6161 tree ARG_UNUSED (args),
6162 int ARG_UNUSED (flags),
6163 bool *no_add_attrs)
6164{
6165 tree node = *pnode;
6166
6167 if (TREE_CODE (node) == FUNCTION_DECL || TREE_CODE (node) == VAR_DECL)
6168 {
6169 if ((!TREE_STATIC (node) && TREE_CODE (node) != FUNCTION_DECL
6170 && !DECL_EXTERNAL (node)) || !TREE_PUBLIC (node))
6171 {
6172 warning (OPT_Wattributes,
6173 "%qE attribute have effect only on public objects", name);
6174 *no_add_attrs = true;
6175 }
6176 }
6177 else
6178 {
6179 warning (OPT_Wattributes, "%qE attribute ignored", name);
6180 *no_add_attrs = true;
6181 }
6182
6183 return NULL_TREE;
6184}
6185
6186/* Handle a "const" attribute; arguments as in
6187 struct attribute_spec.handler. */
6188
6189static tree
6190handle_const_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6191 int ARG_UNUSED (flags), bool *no_add_attrs)
6192{
6193 tree type = TREE_TYPE (*node);
6194
6195 /* See FIXME comment on noreturn in c_common_attribute_table. */
6196 if (TREE_CODE (*node) == FUNCTION_DECL)
6197 TREE_READONLY (*node) = 1;
6198 else if (TREE_CODE (type) == POINTER_TYPE
6199 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
6200 TREE_TYPE (*node)
6201 = build_pointer_type
6202 (build_type_variant (TREE_TYPE (type), 1,
6203 TREE_THIS_VOLATILE (TREE_TYPE (type))));
6204 else
6205 {
6206 warning (OPT_Wattributes, "%qE attribute ignored", name);
6207 *no_add_attrs = true;
6208 }
6209
6210 return NULL_TREE;
6211}
6212
6213/* Handle a "transparent_union" attribute; arguments as in
6214 struct attribute_spec.handler. */
6215
6216static tree
6217handle_transparent_union_attribute (tree *node, tree name,
6218 tree ARG_UNUSED (args), int flags,
6219 bool *no_add_attrs)
6220{
6221 tree type;
6222
6223 *no_add_attrs = true;
6224
6225 if (TREE_CODE (*node) == TYPE_DECL)
6226 node = &TREE_TYPE (*node);
6227 type = *node;
6228
6229 if (TREE_CODE (type) == UNION_TYPE)
6230 {
6231 /* When IN_PLACE is set, leave the check for FIELDS and MODE to
6232 the code in finish_struct. */
6233 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
6234 {
6235 if (TYPE_FIELDS (type) == NULL_TREE
6236 || TYPE_MODE (type) != DECL_MODE (TYPE_FIELDS (type)))
6237 goto ignored;
6238
6239 /* A type variant isn't good enough, since we don't a cast
6240 to such a type removed as a no-op. */
6241 *node = type = build_duplicate_type (type);
6242 }
6243
6244 TYPE_TRANSPARENT_UNION (type) = 1;
6245 return NULL_TREE;
6246 }
6247
6248 ignored:
6249 warning (OPT_Wattributes, "%qE attribute ignored", name);
6250 return NULL_TREE;
6251}
6252
6253/* Subroutine of handle_{con,de}structor_attribute. Evaluate ARGS to
6254 get the requested priority for a constructor or destructor,
6255 possibly issuing diagnostics for invalid or reserved
6256 priorities. */
6257
6258static priority_type
6259get_priority (tree args, bool is_destructor)
6260{
6261 HOST_WIDE_INT pri;
6262 tree arg;
6263
6264 if (!args)
6265 return DEFAULT_INIT_PRIORITY;
6266
6267 if (!SUPPORTS_INIT_PRIORITY)
6268 {
6269 if (is_destructor)
6270 error ("destructor priorities are not supported");
6271 else
6272 error ("constructor priorities are not supported");
6273 return DEFAULT_INIT_PRIORITY;
6274 }
6275
6276 arg = TREE_VALUE (args);
6277 if (!host_integerp (arg, /*pos=*/0)
6278 || !INTEGRAL_TYPE_P (TREE_TYPE (arg)))
6279 goto invalid;
6280
6281 pri = tree_low_cst (TREE_VALUE (args), /*pos=*/0);
6282 if (pri < 0 || pri > MAX_INIT_PRIORITY)
6283 goto invalid;
6284
6285 if (pri <= MAX_RESERVED_INIT_PRIORITY)
6286 {
6287 if (is_destructor)
6288 warning (0,
6289 "destructor priorities from 0 to %d are reserved "
6290 "for the implementation",
6291 MAX_RESERVED_INIT_PRIORITY);
6292 else
6293 warning (0,
6294 "constructor priorities from 0 to %d are reserved "
6295 "for the implementation",
6296 MAX_RESERVED_INIT_PRIORITY);
6297 }
6298 return pri;
6299
6300 invalid:
6301 if (is_destructor)
6302 error ("destructor priorities must be integers from 0 to %d inclusive",
6303 MAX_INIT_PRIORITY);
6304 else
6305 error ("constructor priorities must be integers from 0 to %d inclusive",
6306 MAX_INIT_PRIORITY);
6307 return DEFAULT_INIT_PRIORITY;
6308}
6309
6310/* Handle a "constructor" attribute; arguments as in
6311 struct attribute_spec.handler. */
6312
6313static tree
6314handle_constructor_attribute (tree *node, tree name, tree args,
6315 int ARG_UNUSED (flags),
6316 bool *no_add_attrs)
6317{
6318 tree decl = *node;
6319 tree type = TREE_TYPE (decl);
6320
6321 if (TREE_CODE (decl) == FUNCTION_DECL
6322 && TREE_CODE (type) == FUNCTION_TYPE
6323 && decl_function_context (decl) == 0)
6324 {
6325 priority_type priority;
6326 DECL_STATIC_CONSTRUCTOR (decl) = 1;
6327 priority = get_priority (args, /*is_destructor=*/false);
6328 SET_DECL_INIT_PRIORITY (decl, priority);
6329 TREE_USED (decl) = 1;
6330 }
6331 else
6332 {
6333 warning (OPT_Wattributes, "%qE attribute ignored", name);
6334 *no_add_attrs = true;
6335 }
6336
6337 return NULL_TREE;
6338}
6339
6340/* Handle a "destructor" attribute; arguments as in
6341 struct attribute_spec.handler. */
6342
6343static tree
6344handle_destructor_attribute (tree *node, tree name, tree args,
6345 int ARG_UNUSED (flags),
6346 bool *no_add_attrs)
6347{
6348 tree decl = *node;
6349 tree type = TREE_TYPE (decl);
6350
6351 if (TREE_CODE (decl) == FUNCTION_DECL
6352 && TREE_CODE (type) == FUNCTION_TYPE
6353 && decl_function_context (decl) == 0)
6354 {
6355 priority_type priority;
6356 DECL_STATIC_DESTRUCTOR (decl) = 1;
6357 priority = get_priority (args, /*is_destructor=*/true);
6358 SET_DECL_FINI_PRIORITY (decl, priority);
6359 TREE_USED (decl) = 1;
6360 }
6361 else
6362 {
6363 warning (OPT_Wattributes, "%qE attribute ignored", name);
6364 *no_add_attrs = true;
6365 }
6366
6367 return NULL_TREE;
6368}
6369
6370/* Handle a "mode" attribute; arguments as in
6371 struct attribute_spec.handler. */
6372
6373static tree
6374handle_mode_attribute (tree *node, tree name, tree args,
6375 int ARG_UNUSED (flags), bool *no_add_attrs)
6376{
6377 tree type = *node;
6378
6379 *no_add_attrs = true;
6380
6381 if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
6382 warning (OPT_Wattributes, "%qE attribute ignored", name);
6383 else
6384 {
6385 int j;
6386 const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
6387 int len = strlen (p);
6388 enum machine_mode mode = VOIDmode;
6389 tree typefm;
6390 bool valid_mode;
6391
6392 if (len > 4 && p[0] == '_' && p[1] == '_'
6393 && p[len - 1] == '_' && p[len - 2] == '_')
6394 {
6395 char *newp = (char *) alloca (len - 1);
6396
6397 strcpy (newp, &p[2]);
6398 newp[len - 4] = '\0';
6399 p = newp;
6400 }
6401
6402 /* Change this type to have a type with the specified mode.
6403 First check for the special modes. */
6404 if (!strcmp (p, "byte"))
6405 mode = byte_mode;
6406 else if (!strcmp (p, "word"))
6407 mode = word_mode;
6408 else if (!strcmp (p, "pointer"))
6409 mode = ptr_mode;
6410 else if (!strcmp (p, "libgcc_cmp_return"))
6411 mode = targetm.libgcc_cmp_return_mode ();
6412 else if (!strcmp (p, "libgcc_shift_count"))
6413 mode = targetm.libgcc_shift_count_mode ();
6414 else if (!strcmp (p, "unwind_word"))
6415 mode = targetm.unwind_word_mode ();
6416 else
6417 for (j = 0; j < NUM_MACHINE_MODES; j++)
6418 if (!strcmp (p, GET_MODE_NAME (j)))
6419 {
6420 mode = (enum machine_mode) j;
6421 break;
6422 }
6423
6424 if (mode == VOIDmode)
6425 {
6426 error ("unknown machine mode %qs", p);
6427 return NULL_TREE;
6428 }
6429
6430 valid_mode = false;
6431 switch (GET_MODE_CLASS (mode))
6432 {
6433 case MODE_INT:
6434 case MODE_PARTIAL_INT:
6435 case MODE_FLOAT:
6436 case MODE_DECIMAL_FLOAT:
6437 case MODE_FRACT:
6438 case MODE_UFRACT:
6439 case MODE_ACCUM:
6440 case MODE_UACCUM:
6441 valid_mode = targetm.scalar_mode_supported_p (mode);
6442 break;
6443
6444 case MODE_COMPLEX_INT:
6445 case MODE_COMPLEX_FLOAT:
6446 valid_mode = targetm.scalar_mode_supported_p (GET_MODE_INNER (mode));
6447 break;
6448
6449 case MODE_VECTOR_INT:
6450 case MODE_VECTOR_FLOAT:
6451 case MODE_VECTOR_FRACT:
6452 case MODE_VECTOR_UFRACT:
6453 case MODE_VECTOR_ACCUM:
6454 case MODE_VECTOR_UACCUM:
6455 warning (OPT_Wattributes, "specifying vector types with "
6456 "__attribute__ ((mode)) is deprecated");
6457 warning (OPT_Wattributes,
6458 "use __attribute__ ((vector_size)) instead");
6459 valid_mode = vector_mode_valid_p (mode);
6460 break;
6461
6462 default:
6463 break;
6464 }
6465 if (!valid_mode)
6466 {
6467 error ("unable to emulate %qs", p);
6468 return NULL_TREE;
6469 }
6470
6471 if (POINTER_TYPE_P (type))
6472 {
6473 tree (*fn)(tree, enum machine_mode, bool);
6474
6475 if (!targetm.valid_pointer_mode (mode))
6476 {
6477 error ("invalid pointer mode %qs", p);
6478 return NULL_TREE;
6479 }
6480
6481 if (TREE_CODE (type) == POINTER_TYPE)
6482 fn = build_pointer_type_for_mode;
6483 else
6484 fn = build_reference_type_for_mode;
6485 typefm = fn (TREE_TYPE (type), mode, false);
6486 }
6487 else
6488 {
6489 /* For fixed-point modes, we need to test if the signness of type
6490 and the machine mode are consistent. */
6491 if (ALL_FIXED_POINT_MODE_P (mode)
6492 && TYPE_UNSIGNED (type) != UNSIGNED_FIXED_POINT_MODE_P (mode))
6493 {
6494 error ("signness of type and machine mode %qs don't match", p);
6495 return NULL_TREE;
6496 }
6497 /* For fixed-point modes, we need to pass saturating info. */
6498 typefm = lang_hooks.types.type_for_mode (mode,
6499 ALL_FIXED_POINT_MODE_P (mode) ? TYPE_SATURATING (type)
6500 : TYPE_UNSIGNED (type));
6501 }
6502
6503 if (typefm == NULL_TREE)
6504 {
6505 error ("no data type for mode %qs", p);
6506 return NULL_TREE;
6507 }
6508 else if (TREE_CODE (type) == ENUMERAL_TYPE)
6509 {
6510 /* For enumeral types, copy the precision from the integer
6511 type returned above. If not an INTEGER_TYPE, we can't use
6512 this mode for this type. */
6513 if (TREE_CODE (typefm) != INTEGER_TYPE)
6514 {
6515 error ("cannot use mode %qs for enumeral types", p);
6516 return NULL_TREE;
6517 }
6518
6519 if (flags & ATTR_FLAG_TYPE_IN_PLACE)
6520 {
6521 TYPE_PRECISION (type) = TYPE_PRECISION (typefm);
6522 typefm = type;
6523 }
6524 else
6525 {
6526 /* We cannot build a type variant, as there's code that assumes
6527 that TYPE_MAIN_VARIANT has the same mode. This includes the
6528 debug generators. Instead, create a subrange type. This
6529 results in all of the enumeral values being emitted only once
6530 in the original, and the subtype gets them by reference. */
6531 if (TYPE_UNSIGNED (type))
6532 typefm = make_unsigned_type (TYPE_PRECISION (typefm));
6533 else
6534 typefm = make_signed_type (TYPE_PRECISION (typefm));
6535 TREE_TYPE (typefm) = type;
6536 }
6537 }
6538 else if (VECTOR_MODE_P (mode)
6539 ? TREE_CODE (type) != TREE_CODE (TREE_TYPE (typefm))
6540 : TREE_CODE (type) != TREE_CODE (typefm))
6541 {
6542 error ("mode %qs applied to inappropriate type", p);
6543 return NULL_TREE;
6544 }
6545
6546 *node = typefm;
6547 }
6548
6549 return NULL_TREE;
6550}
6551
6552/* Handle a "section" attribute; arguments as in
6553 struct attribute_spec.handler. */
6554
6555static tree
6556handle_section_attribute (tree *node, tree ARG_UNUSED (name), tree args,
6557 int ARG_UNUSED (flags), bool *no_add_attrs)
6558{
6559 tree decl = *node;
6560
6561 if (targetm.have_named_sections)
6562 {
6563 user_defined_section_attribute = true;
6564
6565 if ((TREE_CODE (decl) == FUNCTION_DECL
6566 || TREE_CODE (decl) == VAR_DECL)
6567 && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
6568 {
6569 if (TREE_CODE (decl) == VAR_DECL
6570 && current_function_decl != NULL_TREE
6571 && !TREE_STATIC (decl))
6572 {
6573 error ("%Jsection attribute cannot be specified for "
6574 "local variables", decl);
6575 *no_add_attrs = true;
6576 }
6577
6578 /* The decl may have already been given a section attribute
6579 from a previous declaration. Ensure they match. */
6580 else if (DECL_SECTION_NAME (decl) != NULL_TREE
6581 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
6582 TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
6583 {
6584 error ("section of %q+D conflicts with previous declaration",
6585 *node);
6586 *no_add_attrs = true;
6587 }
6588 else if (TREE_CODE (decl) == VAR_DECL
6589 && !targetm.have_tls && targetm.emutls.tmpl_section
6590 && DECL_THREAD_LOCAL_P (decl))
6591 {
6592 error ("section of %q+D cannot be overridden", *node);
6593 *no_add_attrs = true;
6594 }
6595 else
6596 DECL_SECTION_NAME (decl) = TREE_VALUE (args);
6597 }
6598 else
6599 {
6600 error ("section attribute not allowed for %q+D", *node);
6601 *no_add_attrs = true;
6602 }
6603 }
6604 else
6605 {
6606 error ("%Jsection attributes are not supported for this target", *node);
6607 *no_add_attrs = true;
6608 }
6609
6610 return NULL_TREE;
6611}
6612
6613/* Handle a "aligned" attribute; arguments as in
6614 struct attribute_spec.handler. */
6615
6616static tree
6617handle_aligned_attribute (tree *node, tree ARG_UNUSED (name), tree args,
6618 int flags, bool *no_add_attrs)
6619{
6620 tree decl = NULL_TREE;
6621 tree *type = NULL;
6622 int is_type = 0;
6623 tree align_expr = (args ? TREE_VALUE (args)
6624 : size_int (ATTRIBUTE_ALIGNED_VALUE / BITS_PER_UNIT));
6625 int i;
6626
6627 if (DECL_P (*node))
6628 {
6629 decl = *node;
6630 type = &TREE_TYPE (decl);
6631 is_type = TREE_CODE (*node) == TYPE_DECL;
6632 }
6633 else if (TYPE_P (*node))
6634 type = node, is_type = 1;
6635
6636 if (TREE_CODE (align_expr) != INTEGER_CST)
6637 {
6638 error ("requested alignment is not a constant");
6639 *no_add_attrs = true;
6640 }
6641 else if ((i = tree_log2 (align_expr)) == -1)
6642 {
6643 error ("requested alignment is not a power of 2");
6644 *no_add_attrs = true;
6645 }
6646 else if (i >= HOST_BITS_PER_INT - BITS_PER_UNIT_LOG)
6647 {
6648 error ("requested alignment is too large");
6649 *no_add_attrs = true;
6650 }
6651 else if (is_type)
6652 {
6653 /* If we have a TYPE_DECL, then copy the type, so that we
6654 don't accidentally modify a builtin type. See pushdecl. */
6655 if (decl && TREE_TYPE (decl) != error_mark_node
6656 && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
6657 {
6658 tree tt = TREE_TYPE (decl);
6659 *type = build_variant_type_copy (*type);
6660 DECL_ORIGINAL_TYPE (decl) = tt;
6661 TYPE_NAME (*type) = decl;
6662 TREE_USED (*type) = TREE_USED (decl);
6663 TREE_TYPE (decl) = *type;
6664 }
6665 else if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
6666 *type = build_variant_type_copy (*type);
6667
6668 TYPE_ALIGN (*type) = (1U << i) * BITS_PER_UNIT;
6669 TYPE_USER_ALIGN (*type) = 1;
6670 }
6671 else if (! VAR_OR_FUNCTION_DECL_P (decl)
6672 && TREE_CODE (decl) != FIELD_DECL)
6673 {
6674 error ("alignment may not be specified for %q+D", decl);
6675 *no_add_attrs = true;
6676 }
6677 else if (TREE_CODE (decl) == FUNCTION_DECL
6678 && DECL_ALIGN (decl) > (1U << i) * BITS_PER_UNIT)
6679 {
6680 if (DECL_USER_ALIGN (decl))
6681 error ("alignment for %q+D was previously specified as %d "
6682 "and may not be decreased", decl,
6683 DECL_ALIGN (decl) / BITS_PER_UNIT);
6684 else
6685 error ("alignment for %q+D must be at least %d", decl,
6686 DECL_ALIGN (decl) / BITS_PER_UNIT);
6687 *no_add_attrs = true;
6688 }
6689 else
6690 {
6691 DECL_ALIGN (decl) = (1U << i) * BITS_PER_UNIT;
6692 DECL_USER_ALIGN (decl) = 1;
6693 }
6694
6695 return NULL_TREE;
6696}
6697
6698/* Handle a "weak" attribute; arguments as in
6699 struct attribute_spec.handler. */
6700
6701static tree
6702handle_weak_attribute (tree *node, tree name,
6703 tree ARG_UNUSED (args),
6704 int ARG_UNUSED (flags),
6705 bool * ARG_UNUSED (no_add_attrs))
6706{
6707 if (TREE_CODE (*node) == FUNCTION_DECL
6708 && DECL_DECLARED_INLINE_P (*node))
6709 {
6710 error ("inline function %q+D cannot be declared weak", *node);
6711 *no_add_attrs = true;
6712 }
6713 else if (TREE_CODE (*node) == FUNCTION_DECL
6714 || TREE_CODE (*node) == VAR_DECL)
6715 declare_weak (*node);
6716 else
6717 warning (OPT_Wattributes, "%qE attribute ignored", name);
6718
6719 return NULL_TREE;
6720}
6721
6722/* Handle an "alias" attribute; arguments as in
6723 struct attribute_spec.handler. */
6724
6725static tree
6726handle_alias_attribute (tree *node, tree name, tree args,
6727 int ARG_UNUSED (flags), bool *no_add_attrs)
6728{
6729 tree decl = *node;
6730
6731 if (TREE_CODE (decl) != FUNCTION_DECL && TREE_CODE (decl) != VAR_DECL)
6732 {
6733 warning (OPT_Wattributes, "%qE attribute ignored", name);
6734 *no_add_attrs = true;
6735 }
6736 else if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
6737 || (TREE_CODE (decl) != FUNCTION_DECL
6738 && TREE_PUBLIC (decl) && !DECL_EXTERNAL (decl))
6739 /* A static variable declaration is always a tentative definition,
6740 but the alias is a non-tentative definition which overrides. */
6741 || (TREE_CODE (decl) != FUNCTION_DECL
6742 && ! TREE_PUBLIC (decl) && DECL_INITIAL (decl)))
6743 {
6744 error ("%q+D defined both normally and as an alias", decl);
6745 *no_add_attrs = true;
6746 }
6747
6748 /* Note that the very first time we process a nested declaration,
6749 decl_function_context will not be set. Indeed, *would* never
6750 be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
6751 we do below. After such frobbery, pushdecl would set the context.
6752 In any case, this is never what we want. */
6753 else if (decl_function_context (decl) == 0 && current_function_decl == NULL)
6754 {
6755 tree id;
6756
6757 id = TREE_VALUE (args);
6758 if (TREE_CODE (id) != STRING_CST)
6759 {
6760 error ("alias argument not a string");
6761 *no_add_attrs = true;
6762 return NULL_TREE;
6763 }
6764 id = get_identifier (TREE_STRING_POINTER (id));
6765 /* This counts as a use of the object pointed to. */
6766 TREE_USED (id) = 1;
6767
6768 if (TREE_CODE (decl) == FUNCTION_DECL)
6769 DECL_INITIAL (decl) = error_mark_node;
6770 else
6771 {
6772 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
6773 DECL_EXTERNAL (decl) = 1;
6774 else
6775 DECL_EXTERNAL (decl) = 0;
6776 TREE_STATIC (decl) = 1;
6777 }
6778 }
6779 else
6780 {
6781 warning (OPT_Wattributes, "%qE attribute ignored", name);
6782 *no_add_attrs = true;
6783 }
6784
6785 return NULL_TREE;
6786}
6787
6788/* Handle a "weakref" attribute; arguments as in struct
6789 attribute_spec.handler. */
6790
6791static tree
6792handle_weakref_attribute (tree *node, tree ARG_UNUSED (name), tree args,
6793 int flags, bool *no_add_attrs)
6794{
6795 tree attr = NULL_TREE;
6796
6797 /* We must ignore the attribute when it is associated with
6798 local-scoped decls, since attribute alias is ignored and many
6799 such symbols do not even have a DECL_WEAK field. */
6800 if (decl_function_context (*node)
6801 || current_function_decl
6802 || (TREE_CODE (*node) != VAR_DECL && TREE_CODE (*node) != FUNCTION_DECL))
6803 {
6804 warning (OPT_Wattributes, "%qE attribute ignored", name);
6805 *no_add_attrs = true;
6806 return NULL_TREE;
6807 }
6808
6809 /* The idea here is that `weakref("name")' mutates into `weakref,
6810 alias("name")', and weakref without arguments, in turn,
6811 implicitly adds weak. */
6812
6813 if (args)
6814 {
6815 attr = tree_cons (get_identifier ("alias"), args, attr);
6816 attr = tree_cons (get_identifier ("weakref"), NULL_TREE, attr);
6817
6818 *no_add_attrs = true;
6819
6820 decl_attributes (node, attr, flags);
6821 }
6822 else
6823 {
6824 if (lookup_attribute ("alias", DECL_ATTRIBUTES (*node)))
6825 error ("%Jweakref attribute must appear before alias attribute",
6826 *node);
6827
6828 /* Can't call declare_weak because it wants this to be TREE_PUBLIC,
6829 and that isn't supported; and because it wants to add it to
6830 the list of weak decls, which isn't helpful. */
6831 DECL_WEAK (*node) = 1;
6832 }
6833
6834 return NULL_TREE;
6835}
6836
6837/* Handle an "visibility" attribute; arguments as in
6838 struct attribute_spec.handler. */
6839
6840static tree
6841handle_visibility_attribute (tree *node, tree name, tree args,
6842 int ARG_UNUSED (flags),
6843 bool *ARG_UNUSED (no_add_attrs))
6844{
6845 tree decl = *node;
6846 tree id = TREE_VALUE (args);
6847 enum symbol_visibility vis;
6848
6849 if (TYPE_P (*node))
6850 {
6851 if (TREE_CODE (*node) == ENUMERAL_TYPE)
6852 /* OK */;
6853 else if (TREE_CODE (*node) != RECORD_TYPE && TREE_CODE (*node) != UNION_TYPE)
6854 {
6855 warning (OPT_Wattributes, "%qE attribute ignored on non-class types",
6856 name);
6857 return NULL_TREE;
6858 }
6859 else if (TYPE_FIELDS (*node))
6860 {
6861 error ("%qE attribute ignored because %qT is already defined",
6862 name, *node);
6863 return NULL_TREE;
6864 }
6865 }
6866 else if (decl_function_context (decl) != 0 || !TREE_PUBLIC (decl))
6867 {
6868 warning (OPT_Wattributes, "%qE attribute ignored", name);
6869 return NULL_TREE;
6870 }
6871
6872 if (TREE_CODE (id) != STRING_CST)
6873 {
6874 error ("visibility argument not a string");
6875 return NULL_TREE;
6876 }
6877
6878 /* If this is a type, set the visibility on the type decl. */
6879 if (TYPE_P (decl))
6880 {
6881 decl = TYPE_NAME (decl);
6882 if (!decl)
6883 return NULL_TREE;
6884 if (TREE_CODE (decl) == IDENTIFIER_NODE)
6885 {
6886 warning (OPT_Wattributes, "%qE attribute ignored on types",
6887 name);
6888 return NULL_TREE;
6889 }
6890 }
6891
6892 if (strcmp (TREE_STRING_POINTER (id), "default") == 0)
6893 vis = VISIBILITY_DEFAULT;
6894 else if (strcmp (TREE_STRING_POINTER (id), "internal") == 0)
6895 vis = VISIBILITY_INTERNAL;
6896 else if (strcmp (TREE_STRING_POINTER (id), "hidden") == 0)
6897 vis = VISIBILITY_HIDDEN;
6898 else if (strcmp (TREE_STRING_POINTER (id), "protected") == 0)
6899 vis = VISIBILITY_PROTECTED;
6900 else
6901 {
6902 error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
6903 vis = VISIBILITY_DEFAULT;
6904 }
6905
6906 if (DECL_VISIBILITY_SPECIFIED (decl)
6907 && vis != DECL_VISIBILITY (decl))
6908 {
6909 tree attributes = (TYPE_P (*node)
6910 ? TYPE_ATTRIBUTES (*node)
6911 : DECL_ATTRIBUTES (decl));
6912 if (lookup_attribute ("visibility", attributes))
6913 error ("%qD redeclared with different visibility", decl);
6914 else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6915 && lookup_attribute ("dllimport", attributes))
6916 error ("%qD was declared %qs which implies default visibility",
6917 decl, "dllimport");
6918 else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6919 && lookup_attribute ("dllexport", attributes))
6920 error ("%qD was declared %qs which implies default visibility",
6921 decl, "dllexport");
6922 }
6923
6924 DECL_VISIBILITY (decl) = vis;
6925 DECL_VISIBILITY_SPECIFIED (decl) = 1;
6926
6927 /* Go ahead and attach the attribute to the node as well. This is needed
6928 so we can determine whether we have VISIBILITY_DEFAULT because the
6929 visibility was not specified, or because it was explicitly overridden
6930 from the containing scope. */
6931
6932 return NULL_TREE;
6933}
6934
6935/* Determine the ELF symbol visibility for DECL, which is either a
6936 variable or a function. It is an error to use this function if a
6937 definition of DECL is not available in this translation unit.
6938 Returns true if the final visibility has been determined by this
6939 function; false if the caller is free to make additional
6940 modifications. */
6941
6942bool
6943c_determine_visibility (tree decl)
6944{
6945 gcc_assert (TREE_CODE (decl) == VAR_DECL
6946 || TREE_CODE (decl) == FUNCTION_DECL);
6947
6948 /* If the user explicitly specified the visibility with an
6949 attribute, honor that. DECL_VISIBILITY will have been set during
6950 the processing of the attribute. We check for an explicit
6951 attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
6952 to distinguish the use of an attribute from the use of a "#pragma
6953 GCC visibility push(...)"; in the latter case we still want other
6954 considerations to be able to overrule the #pragma. */
6955 if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl))
6956 || (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6957 && (lookup_attribute ("dllimport", DECL_ATTRIBUTES (decl))
6958 || lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))))
6959 return true;
6960
6961 /* Set default visibility to whatever the user supplied with
6962 visibility_specified depending on #pragma GCC visibility. */
6963 if (!DECL_VISIBILITY_SPECIFIED (decl))
6964 {
6965 if (visibility_options.inpragma
6966 || DECL_VISIBILITY (decl) != default_visibility)
6967 {
6968 DECL_VISIBILITY (decl) = default_visibility;
6969 DECL_VISIBILITY_SPECIFIED (decl) = visibility_options.inpragma;
6970 /* If visibility changed and DECL already has DECL_RTL, ensure
6971 symbol flags are updated. */
6972 if (((TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
6973 || TREE_CODE (decl) == FUNCTION_DECL)
6974 && DECL_RTL_SET_P (decl))
6975 make_decl_rtl (decl);
6976 }
6977 }
6978 return false;
6979}
6980
6981/* Handle an "tls_model" attribute; arguments as in
6982 struct attribute_spec.handler. */
6983
6984static tree
6985handle_tls_model_attribute (tree *node, tree name, tree args,
6986 int ARG_UNUSED (flags), bool *no_add_attrs)
6987{
6988 tree id;
6989 tree decl = *node;
6990 enum tls_model kind;
6991
6992 *no_add_attrs = true;
6993
6994 if (TREE_CODE (decl) != VAR_DECL || !DECL_THREAD_LOCAL_P (decl))
6995 {
6996 warning (OPT_Wattributes, "%qE attribute ignored", name);
6997 return NULL_TREE;
6998 }
6999
7000 kind = DECL_TLS_MODEL (decl);
7001 id = TREE_VALUE (args);
7002 if (TREE_CODE (id) != STRING_CST)
7003 {
7004 error ("tls_model argument not a string");
7005 return NULL_TREE;
7006 }
7007
7008 if (!strcmp (TREE_STRING_POINTER (id), "local-exec"))
7009 kind = TLS_MODEL_LOCAL_EXEC;
7010 else if (!strcmp (TREE_STRING_POINTER (id), "initial-exec"))
7011 kind = TLS_MODEL_INITIAL_EXEC;
7012 else if (!strcmp (TREE_STRING_POINTER (id), "local-dynamic"))
7013 kind = optimize ? TLS_MODEL_LOCAL_DYNAMIC : TLS_MODEL_GLOBAL_DYNAMIC;
7014 else if (!strcmp (TREE_STRING_POINTER (id), "global-dynamic"))
7015 kind = TLS_MODEL_GLOBAL_DYNAMIC;
7016 else
7017 error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
7018
7019 DECL_TLS_MODEL (decl) = kind;
7020 return NULL_TREE;
7021}
7022
7023/* Handle a "no_instrument_function" attribute; arguments as in
7024 struct attribute_spec.handler. */
7025
7026static tree
7027handle_no_instrument_function_attribute (tree *node, tree name,
7028 tree ARG_UNUSED (args),
7029 int ARG_UNUSED (flags),
7030 bool *no_add_attrs)
7031{
7032 tree decl = *node;
7033
7034 if (TREE_CODE (decl) != FUNCTION_DECL)
7035 {
7036 error ("%J%qE attribute applies only to functions", decl, name);
7037 *no_add_attrs = true;
7038 }
7039 else if (DECL_INITIAL (decl))
7040 {
7041 error ("%Jcan%'t set %qE attribute after definition", decl, name);
7042 *no_add_attrs = true;
7043 }
7044 else
7045 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
7046
7047 return NULL_TREE;
7048}
7049
7050/* Handle a "malloc" attribute; arguments as in
7051 struct attribute_spec.handler. */
7052
7053static tree
7054handle_malloc_attribute (tree *node, tree name, tree ARG_UNUSED (args),
7055 int ARG_UNUSED (flags), bool *no_add_attrs)
7056{
7057 if (TREE_CODE (*node) == FUNCTION_DECL
7058 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node))))
7059 DECL_IS_MALLOC (*node) = 1;
7060 else
7061 {
7062 warning (OPT_Wattributes, "%qE attribute ignored", name);
7063 *no_add_attrs = true;
7064 }
7065
7066 return NULL_TREE;
7067}
7068
7069/* Handle a "alloc_size" attribute; arguments as in
7070 struct attribute_spec.handler. */
7071
7072static tree
7073handle_alloc_size_attribute (tree *node, tree ARG_UNUSED (name), tree args,
7074 int ARG_UNUSED (flags), bool *no_add_attrs)
7075{
7076 unsigned arg_count = type_num_arguments (*node);
7077 for (; args; args = TREE_CHAIN (args))
7078 {
7079 tree position = TREE_VALUE (args);
7080
7081 if (TREE_CODE (position) != INTEGER_CST
7082 || TREE_INT_CST_HIGH (position)
7083 || TREE_INT_CST_LOW (position) < 1
7084 || TREE_INT_CST_LOW (position) > arg_count )
7085 {
7086 warning (OPT_Wattributes,
7087 "alloc_size parameter outside range");
7088 *no_add_attrs = true;
7089 return NULL_TREE;
7090 }
7091 }
7092 return NULL_TREE;
7093}
7094
7095/* Handle a "returns_twice" attribute; arguments as in
7096 struct attribute_spec.handler. */
7097
7098static tree
7099handle_returns_twice_attribute (tree *node, tree name, tree ARG_UNUSED (args),
7100 int ARG_UNUSED (flags), bool *no_add_attrs)
7101{
7102 if (TREE_CODE (*node) == FUNCTION_DECL)
7103 DECL_IS_RETURNS_TWICE (*node) = 1;
7104 else
7105 {
7106 warning (OPT_Wattributes, "%qE attribute ignored", name);
7107 *no_add_attrs = true;
7108 }
7109
7110 return NULL_TREE;
7111}
7112
7113/* Handle a "no_limit_stack" attribute; arguments as in
7114 struct attribute_spec.handler. */
7115
7116static tree
7117handle_no_limit_stack_attribute (tree *node, tree name,
7118 tree ARG_UNUSED (args),
7119 int ARG_UNUSED (flags),
7120 bool *no_add_attrs)
7121{
7122 tree decl = *node;
7123
7124 if (TREE_CODE (decl) != FUNCTION_DECL)
7125 {
7126 error ("%J%qE attribute applies only to functions", decl, name);
7127 *no_add_attrs = true;
7128 }
7129 else if (DECL_INITIAL (decl))
7130 {
7131 error ("%Jcan%'t set %qE attribute after definition", decl, name);
7132 *no_add_attrs = true;
7133 }
7134 else
7135 DECL_NO_LIMIT_STACK (decl) = 1;
7136
7137 return NULL_TREE;
7138}
7139
7140/* Handle a "pure" attribute; arguments as in
7141 struct attribute_spec.handler. */
7142
7143static tree
7144handle_pure_attribute (tree *node, tree name, tree ARG_UNUSED (args),
7145 int ARG_UNUSED (flags), bool *no_add_attrs)
7146{
7147 if (TREE_CODE (*node) == FUNCTION_DECL)
7148 DECL_PURE_P (*node) = 1;
7149 /* ??? TODO: Support types. */
7150 else
7151 {
7152 warning (OPT_Wattributes, "%qE attribute ignored", name);
7153 *no_add_attrs = true;
7154 }
7155
7156 return NULL_TREE;
7157}
7158
7159/* Handle a "no vops" attribute; arguments as in
7160 struct attribute_spec.handler. */
7161
7162static tree
7163handle_novops_attribute (tree *node, tree ARG_UNUSED (name),
7164 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
7165 bool *ARG_UNUSED (no_add_attrs))
7166{
7167 gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
7168 DECL_IS_NOVOPS (*node) = 1;
7169 return NULL_TREE;
7170}
7171
7172/* Handle a "deprecated" attribute; arguments as in
7173 struct attribute_spec.handler. */
7174
7175static tree
7176handle_deprecated_attribute (tree *node, tree name,
7177 tree ARG_UNUSED (args), int flags,
7178 bool *no_add_attrs)
7179{
7180 tree type = NULL_TREE;
7181 int warn = 0;
7182 tree what = NULL_TREE;
7183
7184 if (DECL_P (*node))
7185 {
7186 tree decl = *node;
7187 type = TREE_TYPE (decl);
7188
7189 if (TREE_CODE (decl) == TYPE_DECL
7190 || TREE_CODE (decl) == PARM_DECL
7191 || TREE_CODE (decl) == VAR_DECL
7192 || TREE_CODE (decl) == FUNCTION_DECL
7193 || TREE_CODE (decl) == FIELD_DECL)
7194 TREE_DEPRECATED (decl) = 1;
7195 else
7196 warn = 1;
7197 }
7198 else if (TYPE_P (*node))
7199 {
7200 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
7201 *node = build_variant_type_copy (*node);
7202 TREE_DEPRECATED (*node) = 1;
7203 type = *node;
7204 }
7205 else
7206 warn = 1;
7207
7208 if (warn)
7209 {
7210 *no_add_attrs = true;
7211 if (type && TYPE_NAME (type))
7212 {
7213 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
7214 what = TYPE_NAME (*node);
7215 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
7216 && DECL_NAME (TYPE_NAME (type)))
7217 what = DECL_NAME (TYPE_NAME (type));
7218 }
7219 if (what)
7220 warning (OPT_Wattributes, "%qE attribute ignored for %qE", name, what);
7221 else
7222 warning (OPT_Wattributes, "%qE attribute ignored", name);
7223 }
7224
7225 return NULL_TREE;
7226}
7227
7228/* Handle a "vector_size" attribute; arguments as in
7229 struct attribute_spec.handler. */
7230
7231static tree
7232handle_vector_size_attribute (tree *node, tree name, tree args,
7233 int ARG_UNUSED (flags),
7234 bool *no_add_attrs)
7235{
7236 unsigned HOST_WIDE_INT vecsize, nunits;
7237 enum machine_mode orig_mode;
7238 tree type = *node, new_type, size;
7239
7240 *no_add_attrs = true;
7241
7242 size = TREE_VALUE (args);
7243
7244 if (!host_integerp (size, 1))
7245 {
7246 warning (OPT_Wattributes, "%qE attribute ignored", name);
7247 return NULL_TREE;
7248 }
7249
7250 /* Get the vector size (in bytes). */
7251 vecsize = tree_low_cst (size, 1);
7252
7253 /* We need to provide for vector pointers, vector arrays, and
7254 functions returning vectors. For example:
7255
7256 __attribute__((vector_size(16))) short *foo;
7257
7258 In this case, the mode is SI, but the type being modified is
7259 HI, so we need to look further. */
7260
7261 while (POINTER_TYPE_P (type)
7262 || TREE_CODE (type) == FUNCTION_TYPE
7263 || TREE_CODE (type) == METHOD_TYPE
7264 || TREE_CODE (type) == ARRAY_TYPE
7265 || TREE_CODE (type) == OFFSET_TYPE)
7266 type = TREE_TYPE (type);
7267
7268 /* Get the mode of the type being modified. */
7269 orig_mode = TYPE_MODE (type);
7270
7271 if ((!INTEGRAL_TYPE_P (type)
7272 && !SCALAR_FLOAT_TYPE_P (type)
7273 && !FIXED_POINT_TYPE_P (type))
7274 || (!SCALAR_FLOAT_MODE_P (orig_mode)
7275 && GET_MODE_CLASS (orig_mode) != MODE_INT
7276 && !ALL_SCALAR_FIXED_POINT_MODE_P (orig_mode))
7277 || !host_integerp (TYPE_SIZE_UNIT (type), 1)
7278 || TREE_CODE (type) == BOOLEAN_TYPE)
7279 {
7280 error ("invalid vector type for attribute %qE", name);
7281 return NULL_TREE;
7282 }
7283
7284 if (vecsize % tree_low_cst (TYPE_SIZE_UNIT (type), 1))
7285 {
7286 error ("vector size not an integral multiple of component size");
7287 return NULL;
7288 }
7289
7290 if (vecsize == 0)
7291 {
7292 error ("zero vector size");
7293 return NULL;
7294 }
7295
7296 /* Calculate how many units fit in the vector. */
7297 nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
7298 if (nunits & (nunits - 1))
7299 {
7300 error ("number of components of the vector not a power of two");
7301 return NULL_TREE;
7302 }
7303
7304 new_type = build_vector_type (type, nunits);
7305
7306 /* Build back pointers if needed. */
7307 *node = lang_hooks.types.reconstruct_complex_type (*node, new_type);
7308
7309 return NULL_TREE;
7310}
7311
7312/* Handle the "nonnull" attribute. */
7313static tree
7314handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
7315 tree args, int ARG_UNUSED (flags),
7316 bool *no_add_attrs)
7317{
7318 tree type = *node;
7319 unsigned HOST_WIDE_INT attr_arg_num;
7320
7321 /* If no arguments are specified, all pointer arguments should be
7322 non-null. Verify a full prototype is given so that the arguments
7323 will have the correct types when we actually check them later. */
7324 if (!args)
7325 {
7326 if (!TYPE_ARG_TYPES (type))
7327 {
7328 error ("nonnull attribute without arguments on a non-prototype");
7329 *no_add_attrs = true;
7330 }
7331 return NULL_TREE;
7332 }
7333
7334 /* Argument list specified. Verify that each argument number references
7335 a pointer argument. */
7336 for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
7337 {
7338 tree argument;
7339 unsigned HOST_WIDE_INT arg_num = 0, ck_num;
7340
7341 if (!get_nonnull_operand (TREE_VALUE (args), &arg_num))
7342 {
7343 error ("nonnull argument has invalid operand number (argument %lu)",
7344 (unsigned long) attr_arg_num);
7345 *no_add_attrs = true;
7346 return NULL_TREE;
7347 }
7348
7349 argument = TYPE_ARG_TYPES (type);
7350 if (argument)
7351 {
7352 for (ck_num = 1; ; ck_num++)
7353 {
7354 if (!argument || ck_num == arg_num)
7355 break;
7356 argument = TREE_CHAIN (argument);
7357 }
7358
7359 if (!argument
7360 || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
7361 {
7362 error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
7363 (unsigned long) attr_arg_num, (unsigned long) arg_num);
7364 *no_add_attrs = true;
7365 return NULL_TREE;
7366 }
7367
7368 if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
7369 {
7370 error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
7371 (unsigned long) attr_arg_num, (unsigned long) arg_num);
7372 *no_add_attrs = true;
7373 return NULL_TREE;
7374 }
7375 }
7376 }
7377
7378 return NULL_TREE;
7379}
7380
7381/* Check the argument list of a function call for null in argument slots
7382 that are marked as requiring a non-null pointer argument. The NARGS
7383 arguments are passed in the array ARGARRAY.
7384*/
7385
7386static void
7387check_function_nonnull (tree attrs, int nargs, tree *argarray)
7388{
7389 tree a, args;
7390 int i;
7391
7392 for (a = attrs; a; a = TREE_CHAIN (a))
7393 {
7394 if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
7395 {
7396 args = TREE_VALUE (a);
7397
7398 /* Walk the argument list. If we encounter an argument number we
7399 should check for non-null, do it. If the attribute has no args,
7400 then every pointer argument is checked (in which case the check
7401 for pointer type is done in check_nonnull_arg). */
7402 for (i = 0; i < nargs; i++)
7403 {
7404 if (!args || nonnull_check_p (args, i + 1))
7405 check_function_arguments_recurse (check_nonnull_arg, NULL,
7406 argarray[i],
7407 i + 1);
7408 }
7409 }
7410 }
7411}
7412
7413/* Check that the Nth argument of a function call (counting backwards
7414 from the end) is a (pointer)0. The NARGS arguments are passed in the
7415 array ARGARRAY. */
7416
7417static void
7418check_function_sentinel (tree attrs, int nargs, tree *argarray, tree typelist)
7419{
7420 tree attr = lookup_attribute ("sentinel", attrs);
7421
7422 if (attr)
7423 {
7424 int len = 0;
7425 int pos = 0;
7426 tree sentinel;
7427
7428 /* Skip over the named arguments. */
7429 while (typelist && len < nargs)
7430 {
7431 typelist = TREE_CHAIN (typelist);
7432 len++;
7433 }
7434
7435 if (TREE_VALUE (attr))
7436 {
7437 tree p = TREE_VALUE (TREE_VALUE (attr));
7438 pos = TREE_INT_CST_LOW (p);
7439 }
7440
7441 /* The sentinel must be one of the varargs, i.e.
7442 in position >= the number of fixed arguments. */
7443 if ((nargs - 1 - pos) < len)
7444 {
7445 warning (OPT_Wformat,
7446 "not enough variable arguments to fit a sentinel");
7447 return;
7448 }
7449
7450 /* Validate the sentinel. */
7451 sentinel = argarray[nargs - 1 - pos];
7452 if ((!POINTER_TYPE_P (TREE_TYPE (sentinel))
7453 || !integer_zerop (sentinel))
7454 /* Although __null (in C++) is only an integer we allow it
7455 nevertheless, as we are guaranteed that it's exactly
7456 as wide as a pointer, and we don't want to force
7457 users to cast the NULL they have written there.
7458 We warn with -Wstrict-null-sentinel, though. */
7459 && (warn_strict_null_sentinel || null_node != sentinel))
7460 warning (OPT_Wformat, "missing sentinel in function call");
7461 }
7462}
7463
7464/* Helper for check_function_nonnull; given a list of operands which
7465 must be non-null in ARGS, determine if operand PARAM_NUM should be
7466 checked. */
7467
7468static bool
7469nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num)
7470{
7471 unsigned HOST_WIDE_INT arg_num = 0;
7472
7473 for (; args; args = TREE_CHAIN (args))
7474 {
7475 bool found = get_nonnull_operand (TREE_VALUE (args), &arg_num);
7476
7477 gcc_assert (found);
7478
7479 if (arg_num == param_num)
7480 return true;
7481 }
7482 return false;
7483}
7484
7485/* Check that the function argument PARAM (which is operand number
7486 PARAM_NUM) is non-null. This is called by check_function_nonnull
7487 via check_function_arguments_recurse. */
7488
7489static void
7490check_nonnull_arg (void * ARG_UNUSED (ctx), tree param,
7491 unsigned HOST_WIDE_INT param_num)
7492{
7493 /* Just skip checking the argument if it's not a pointer. This can
7494 happen if the "nonnull" attribute was given without an operand
7495 list (which means to check every pointer argument). */
7496
7497 if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
7498 return;
7499
7500 if (integer_zerop (param))
7501 warning (OPT_Wnonnull, "null argument where non-null required "
7502 "(argument %lu)", (unsigned long) param_num);
7503}
7504
7505/* Helper for nonnull attribute handling; fetch the operand number
7506 from the attribute argument list. */
7507
7508static bool
7509get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
7510{
7511 /* Verify the arg number is a constant. */
7512 if (TREE_CODE (arg_num_expr) != INTEGER_CST
7513 || TREE_INT_CST_HIGH (arg_num_expr) != 0)
7514 return false;
7515
7516 *valp = TREE_INT_CST_LOW (arg_num_expr);
7517 return true;
7518}
7519
7520/* Handle a "nothrow" attribute; arguments as in
7521 struct attribute_spec.handler. */
7522
7523static tree
7524handle_nothrow_attribute (tree *node, tree name, tree ARG_UNUSED (args),
7525 int ARG_UNUSED (flags), bool *no_add_attrs)
7526{
7527 if (TREE_CODE (*node) == FUNCTION_DECL)
7528 TREE_NOTHROW (*node) = 1;
7529 /* ??? TODO: Support types. */
7530 else
7531 {
7532 warning (OPT_Wattributes, "%qE attribute ignored", name);
7533 *no_add_attrs = true;
7534 }
7535
7536 return NULL_TREE;
7537}
7538
7539/* Handle a "cleanup" attribute; arguments as in
7540 struct attribute_spec.handler. */
7541
7542static tree
7543handle_cleanup_attribute (tree *node, tree name, tree args,
7544 int ARG_UNUSED (flags), bool *no_add_attrs)
7545{
7546 tree decl = *node;
7547 tree cleanup_id, cleanup_decl;
7548
7549 /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
7550 for global destructors in C++. This requires infrastructure that
7551 we don't have generically at the moment. It's also not a feature
7552 we'd be missing too much, since we do have attribute constructor. */
7553 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
7554 {
7555 warning (OPT_Wattributes, "%qE attribute ignored", name);
7556 *no_add_attrs = true;
7557 return NULL_TREE;
7558 }
7559
7560 /* Verify that the argument is a function in scope. */
7561 /* ??? We could support pointers to functions here as well, if
7562 that was considered desirable. */
7563 cleanup_id = TREE_VALUE (args);
7564 if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE)
7565 {
7566 error ("cleanup argument not an identifier");
7567 *no_add_attrs = true;
7568 return NULL_TREE;
7569 }
7570 cleanup_decl = lookup_name (cleanup_id);
7571 if (!cleanup_decl || TREE_CODE (cleanup_decl) != FUNCTION_DECL)
7572 {
7573 error ("cleanup argument not a function");
7574 *no_add_attrs = true;
7575 return NULL_TREE;
7576 }
7577
7578 /* That the function has proper type is checked with the
7579 eventual call to build_function_call. */
7580
7581 return NULL_TREE;
7582}
7583
7584/* Handle a "warn_unused_result" attribute. No special handling. */
7585
7586static tree
7587handle_warn_unused_result_attribute (tree *node, tree name,
7588 tree ARG_UNUSED (args),
7589 int ARG_UNUSED (flags), bool *no_add_attrs)
7590{
7591 /* Ignore the attribute for functions not returning any value. */
7592 if (VOID_TYPE_P (TREE_TYPE (*node)))
7593 {
7594 warning (OPT_Wattributes, "%qE attribute ignored", name);
7595 *no_add_attrs = true;
7596 }
7597
7598 return NULL_TREE;
7599}
7600
7601/* Handle a "sentinel" attribute. */
7602
7603static tree
7604handle_sentinel_attribute (tree *node, tree name, tree args,
7605 int ARG_UNUSED (flags), bool *no_add_attrs)
7606{
7607 tree params = TYPE_ARG_TYPES (*node);
7608
7609 if (!params)
7610 {
7611 warning (OPT_Wattributes,
7612 "%qE attribute requires prototypes with named arguments", name);
7613 *no_add_attrs = true;
7614 }
7615 else
7616 {
7617 while (TREE_CHAIN (params))
7618 params = TREE_CHAIN (params);
7619
7620 if (VOID_TYPE_P (TREE_VALUE (params)))
7621 {
7622 warning (OPT_Wattributes,
7623 "%qE attribute only applies to variadic functions", name);
7624 *no_add_attrs = true;
7625 }
7626 }
7627
7628 if (args)
7629 {
7630 tree position = TREE_VALUE (args);
7631
7632 if (TREE_CODE (position) != INTEGER_CST)
7633 {
7634 warning (OPT_Wattributes,
7635 "requested position is not an integer constant");
7636 *no_add_attrs = true;
7637 }
7638 else
7639 {
7640 if (tree_int_cst_lt (position, integer_zero_node))
7641 {
7642 warning (OPT_Wattributes,
7643 "requested position is less than zero");
7644 *no_add_attrs = true;
7645 }
7646 }
7647 }
7648
7649 return NULL_TREE;
7650}
7651
7652/* Handle a "type_generic" attribute. */
7653
7654static tree
7655handle_type_generic_attribute (tree *node, tree ARG_UNUSED (name),
7656 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
7657 bool * ARG_UNUSED (no_add_attrs))
7658{
7659 tree params;
7660
7661 /* Ensure we have a function type. */
7662 gcc_assert (TREE_CODE (*node) == FUNCTION_TYPE);
7663
7664 params = TYPE_ARG_TYPES (*node);
7665 while (params && ! VOID_TYPE_P (TREE_VALUE (params)))
7666 params = TREE_CHAIN (params);
7667
7668 /* Ensure we have a variadic function. */
7669 gcc_assert (!params);
7670
7671 return NULL_TREE;
7672}
7673
7674/* Handle a "target" attribute. */
7675
7676static tree
7677handle_target_attribute (tree *node, tree name, tree args, int flags,
7678 bool *no_add_attrs)
7679{
7680 /* Ensure we have a function type. */
7681 if (TREE_CODE (*node) != FUNCTION_DECL)
7682 {
7683 warning (OPT_Wattributes, "%qE attribute ignored", name);
7684 *no_add_attrs = true;
7685 }
7686 else if (! targetm.target_option.valid_attribute_p (*node, name, args,
7687 flags))
7688 *no_add_attrs = true;
7689
7690 return NULL_TREE;
7691}
7692
7693/* Arguments being collected for optimization. */
7694typedef const char *const_char_p; /* For DEF_VEC_P. */
7695DEF_VEC_P(const_char_p);
7696DEF_VEC_ALLOC_P(const_char_p, gc);
7697static GTY(()) VEC(const_char_p, gc) *optimize_args;
7698
7699
7700/* Inner function to convert a TREE_LIST to argv string to parse the optimize
7701 options in ARGS. ATTR_P is true if this is for attribute(optimize), and
7702 false for #pragma GCC optimize. */
7703
7704bool
7705parse_optimize_options (tree args, bool attr_p)
7706{
7707 bool ret = true;
7708 unsigned opt_argc;
7709 unsigned i;
7710 int saved_flag_strict_aliasing;
7711 const char **opt_argv;
7712 tree ap;
7713
7714 /* Build up argv vector. Just in case the string is stored away, use garbage
7715 collected strings. */
7716 VEC_truncate (const_char_p, optimize_args, 0);
7717 VEC_safe_push (const_char_p, gc, optimize_args, NULL);
7718
7719 for (ap = args; ap != NULL_TREE; ap = TREE_CHAIN (ap))
7720 {
7721 tree value = TREE_VALUE (ap);
7722
7723 if (TREE_CODE (value) == INTEGER_CST)
7724 {
7725 char buffer[20];
7726 sprintf (buffer, "-O%ld", (long) TREE_INT_CST_LOW (value));
7727 VEC_safe_push (const_char_p, gc, optimize_args, ggc_strdup (buffer));
7728 }
7729
7730 else if (TREE_CODE (value) == STRING_CST)
7731 {
7732 /* Split string into multiple substrings. */
7733 size_t len = TREE_STRING_LENGTH (value);
7734 char *p = ASTRDUP (TREE_STRING_POINTER (value));
7735 char *end = p + len;
7736 char *comma;
7737 char *next_p = p;
7738
7739 while (next_p != NULL)
7740 {
7741 size_t len2;
7742 char *q, *r;
7743
7744 p = next_p;
7745 comma = strchr (p, ',');
7746 if (comma)
7747 {
7748 len2 = comma - p;
7749 *comma = '\0';
7750 next_p = comma+1;
7751 }
7752 else
7753 {
7754 len2 = end - p;
7755 next_p = NULL;
7756 }
7757
7758 r = q = (char *) ggc_alloc (len2 + 3);
7759
7760 /* If the user supplied -Oxxx or -fxxx, only allow -Oxxx or -fxxx
7761 options. */
7762 if (*p == '-' && p[1] != 'O' && p[1] != 'f')
7763 {
7764 ret = false;
7765 if (attr_p)
7766 warning (OPT_Wattributes,
7767 "Bad option %s to optimize attribute.", p);
7768 else
7769 warning (OPT_Wpragmas,
7770 "Bad option %s to pragma attribute", p);
7771 continue;
7772 }
7773
7774 if (*p != '-')
7775 {
7776 *r++ = '-';
7777
7778 /* Assume that Ox is -Ox, a numeric value is -Ox, a s by
7779 itself is -Os, and any other switch begins with a -f. */
7780 if ((*p >= '0' && *p <= '9')
7781 || (p[0] == 's' && p[1] == '\0'))
7782 *r++ = 'O';
7783 else if (*p != 'O')
7784 *r++ = 'f';
7785 }
7786
7787 memcpy (r, p, len2);
7788 r[len2] = '\0';
7789 VEC_safe_push (const_char_p, gc, optimize_args, q);
7790 }
7791
7792 }
7793 }
7794
7795 opt_argc = VEC_length (const_char_p, optimize_args);
7796 opt_argv = (const char **) alloca (sizeof (char *) * (opt_argc + 1));
7797
7798 for (i = 1; i < opt_argc; i++)
7799 opt_argv[i] = VEC_index (const_char_p, optimize_args, i);
7800
7801 saved_flag_strict_aliasing = flag_strict_aliasing;
7802
7803 /* Now parse the options. */
7804 decode_options (opt_argc, opt_argv);
7805
7806 /* Don't allow changing -fstrict-aliasing. */
7807 flag_strict_aliasing = saved_flag_strict_aliasing;
7808
7809 VEC_truncate (const_char_p, optimize_args, 0);
7810 return ret;
7811}
7812
7813/* For handling "optimize" attribute. arguments as in
7814 struct attribute_spec.handler. */
7815
7816static tree
7817handle_optimize_attribute (tree *node, tree name, tree args,
7818 int ARG_UNUSED (flags), bool *no_add_attrs)
7819{
7820 /* Ensure we have a function type. */
7821 if (TREE_CODE (*node) != FUNCTION_DECL)
7822 {
7823 warning (OPT_Wattributes, "%qE attribute ignored", name);
7824 *no_add_attrs = true;
7825 }
7826 else
7827 {
7828 struct cl_optimization cur_opts;
7829 tree old_opts = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node);
7830
7831 /* Save current options. */
7832 cl_optimization_save (&cur_opts);
7833
7834 /* If we previously had some optimization options, use them as the
7835 default. */
7836 if (old_opts)
7837 cl_optimization_restore (TREE_OPTIMIZATION (old_opts));
7838
7839 /* Parse options, and update the vector. */
7840 parse_optimize_options (args, true);
7841 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node)
7842 = build_optimization_node ();
7843
7844 /* Restore current options. */
7845 cl_optimization_restore (&cur_opts);
7846 }
7847
7848 return NULL_TREE;
7849}
7850\f
7851/* Check for valid arguments being passed to a function.
7852 ATTRS is a list of attributes. There are NARGS arguments in the array
7853 ARGARRAY. TYPELIST is the list of argument types for the function.
7854 */
7855void
7856check_function_arguments (tree attrs, int nargs, tree *argarray, tree typelist)
7857{
7858 /* Check for null being passed in a pointer argument that must be
7859 non-null. We also need to do this if format checking is enabled. */
7860
7861 if (warn_nonnull)
7862 check_function_nonnull (attrs, nargs, argarray);
7863
7864 /* Check for errors in format strings. */
7865
7866 if (warn_format || warn_missing_format_attribute)
7867 check_function_format (attrs, nargs, argarray);
7868
7869 if (warn_format)
7870 check_function_sentinel (attrs, nargs, argarray, typelist);
7871}
7872
7873/* Generic argument checking recursion routine. PARAM is the argument to
7874 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
7875 once the argument is resolved. CTX is context for the callback. */
7876void
7877check_function_arguments_recurse (void (*callback)
7878 (void *, tree, unsigned HOST_WIDE_INT),
7879 void *ctx, tree param,
7880 unsigned HOST_WIDE_INT param_num)
7881{
7882 if (CONVERT_EXPR_P (param)
7883 && (TYPE_PRECISION (TREE_TYPE (param))
7884 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (param, 0)))))
7885 {
7886 /* Strip coercion. */
7887 check_function_arguments_recurse (callback, ctx,
7888 TREE_OPERAND (param, 0), param_num);
7889 return;
7890 }
7891
7892 if (TREE_CODE (param) == CALL_EXPR)
7893 {
7894 tree type = TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (param)));
7895 tree attrs;
7896 bool found_format_arg = false;
7897
7898 /* See if this is a call to a known internationalization function
7899 that modifies a format arg. Such a function may have multiple
7900 format_arg attributes (for example, ngettext). */
7901
7902 for (attrs = TYPE_ATTRIBUTES (type);
7903 attrs;
7904 attrs = TREE_CHAIN (attrs))
7905 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
7906 {
7907 tree inner_arg;
7908 tree format_num_expr;
7909 int format_num;
7910 int i;
7911 call_expr_arg_iterator iter;
7912
7913 /* Extract the argument number, which was previously checked
7914 to be valid. */
7915 format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
7916
7917 gcc_assert (TREE_CODE (format_num_expr) == INTEGER_CST
7918 && !TREE_INT_CST_HIGH (format_num_expr));
7919
7920 format_num = TREE_INT_CST_LOW (format_num_expr);
7921
7922 for (inner_arg = first_call_expr_arg (param, &iter), i = 1;
7923 inner_arg != 0;
7924 inner_arg = next_call_expr_arg (&iter), i++)
7925 if (i == format_num)
7926 {
7927 check_function_arguments_recurse (callback, ctx,
7928 inner_arg, param_num);
7929 found_format_arg = true;
7930 break;
7931 }
7932 }
7933
7934 /* If we found a format_arg attribute and did a recursive check,
7935 we are done with checking this argument. Otherwise, we continue
7936 and this will be considered a non-literal. */
7937 if (found_format_arg)
7938 return;
7939 }
7940
7941 if (TREE_CODE (param) == COND_EXPR)
7942 {
7943 /* Check both halves of the conditional expression. */
7944 check_function_arguments_recurse (callback, ctx,
7945 TREE_OPERAND (param, 1), param_num);
7946 check_function_arguments_recurse (callback, ctx,
7947 TREE_OPERAND (param, 2), param_num);
7948 return;
7949 }
7950
7951 (*callback) (ctx, param, param_num);
7952}
7953
7954/* Checks the number of arguments NARGS against the required number
7955 REQUIRED and issues an error if there is a mismatch. Returns true
7956 if the number of arguments is correct, otherwise false. */
7957
7958static bool
7959validate_nargs (tree fndecl, int nargs, int required)
7960{
7961 if (nargs < required)
7962 {
7963 error ("not enough arguments to function %qE", fndecl);
7964 return false;
7965 }
7966 else if (nargs > required)
7967 {
7968 error ("too many arguments to function %qE", fndecl);
7969 return false;
7970 }
7971 return true;
7972}
7973
7974/* Verifies the NARGS arguments ARGS to the builtin function FNDECL.
7975 Returns false if there was an error, otherwise true. */
7976
7977bool
7978check_builtin_function_arguments (tree fndecl, int nargs, tree *args)
7979{
7980 if (!DECL_BUILT_IN (fndecl)
7981 || DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_NORMAL)
7982 return true;
7983
7984 switch (DECL_FUNCTION_CODE (fndecl))
7985 {
7986 case BUILT_IN_CONSTANT_P:
7987 return validate_nargs (fndecl, nargs, 1);
7988
7989 case BUILT_IN_ISFINITE:
7990 case BUILT_IN_ISINF:
7991 case BUILT_IN_ISINF_SIGN:
7992 case BUILT_IN_ISNAN:
7993 case BUILT_IN_ISNORMAL:
7994 if (validate_nargs (fndecl, nargs, 1))
7995 {
7996 if (TREE_CODE (TREE_TYPE (args[0])) != REAL_TYPE)
7997 {
7998 error ("non-floating-point argument in call to "
7999 "function %qE", fndecl);
8000 return false;
8001 }
8002 return true;
8003 }
8004 return false;
8005
8006 case BUILT_IN_ISGREATER:
8007 case BUILT_IN_ISGREATEREQUAL:
8008 case BUILT_IN_ISLESS:
8009 case BUILT_IN_ISLESSEQUAL:
8010 case BUILT_IN_ISLESSGREATER:
8011 case BUILT_IN_ISUNORDERED:
8012 if (validate_nargs (fndecl, nargs, 2))
8013 {
8014 enum tree_code code0, code1;
8015 code0 = TREE_CODE (TREE_TYPE (args[0]));
8016 code1 = TREE_CODE (TREE_TYPE (args[1]));
8017 if (!((code0 == REAL_TYPE && code1 == REAL_TYPE)
8018 || (code0 == REAL_TYPE && code1 == INTEGER_TYPE)
8019 || (code0 == INTEGER_TYPE && code1 == REAL_TYPE)))
8020 {
8021 error ("non-floating-point arguments in call to "
8022 "function %qE", fndecl);
8023 return false;
8024 }
8025 return true;
8026 }
8027 return false;
8028
8029 case BUILT_IN_FPCLASSIFY:
8030 if (validate_nargs (fndecl, nargs, 6))
8031 {
8032 unsigned i;
8033
8034 for (i=0; i<5; i++)
8035 if (TREE_CODE (args[i]) != INTEGER_CST)
8036 {
8037 error ("non-const integer argument %u in call to function %qE",
8038 i+1, fndecl);
8039 return false;
8040 }
8041
8042 if (TREE_CODE (TREE_TYPE (args[5])) != REAL_TYPE)
8043 {
8044 error ("non-floating-point argument in call to function %qE",
8045 fndecl);
8046 return false;
8047 }
8048 return true;
8049 }
8050 return false;
8051
8052 default:
8053 return true;
8054 }
8055}
8056
8057/* Function to help qsort sort FIELD_DECLs by name order. */
8058
8059int
8060field_decl_cmp (const void *x_p, const void *y_p)
8061{
8062 const tree *const x = (const tree *const) x_p;
8063 const tree *const y = (const tree *const) y_p;
8064
8065 if (DECL_NAME (*x) == DECL_NAME (*y))
8066 /* A nontype is "greater" than a type. */
8067 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
8068 if (DECL_NAME (*x) == NULL_TREE)
8069 return -1;
8070 if (DECL_NAME (*y) == NULL_TREE)
8071 return 1;
8072 if (DECL_NAME (*x) < DECL_NAME (*y))
8073 return -1;
8074 return 1;
8075}
8076
8077static struct {
8078 gt_pointer_operator new_value;
8079 void *cookie;
8080} resort_data;
8081
8082/* This routine compares two fields like field_decl_cmp but using the
8083pointer operator in resort_data. */
8084
8085static int
8086resort_field_decl_cmp (const void *x_p, const void *y_p)
8087{
8088 const tree *const x = (const tree *const) x_p;
8089 const tree *const y = (const tree *const) y_p;
8090
8091 if (DECL_NAME (*x) == DECL_NAME (*y))
8092 /* A nontype is "greater" than a type. */
8093 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
8094 if (DECL_NAME (*x) == NULL_TREE)
8095 return -1;
8096 if (DECL_NAME (*y) == NULL_TREE)
8097 return 1;
8098 {
8099 tree d1 = DECL_NAME (*x);
8100 tree d2 = DECL_NAME (*y);
8101 resort_data.new_value (&d1, resort_data.cookie);
8102 resort_data.new_value (&d2, resort_data.cookie);
8103 if (d1 < d2)
8104 return -1;
8105 }
8106 return 1;
8107}
8108
8109/* Resort DECL_SORTED_FIELDS because pointers have been reordered. */
8110
8111void
8112resort_sorted_fields (void *obj,
8113 void * ARG_UNUSED (orig_obj),
8114 gt_pointer_operator new_value,
8115 void *cookie)
8116{
8117 struct sorted_fields_type *sf = (struct sorted_fields_type *) obj;
8118 resort_data.new_value = new_value;
8119 resort_data.cookie = cookie;
8120 qsort (&sf->elts[0], sf->len, sizeof (tree),
8121 resort_field_decl_cmp);
8122}
8123
8124/* Subroutine of c_parse_error.
8125 Return the result of concatenating LHS and RHS. RHS is really
8126 a string literal, its first character is indicated by RHS_START and
8127 RHS_SIZE is its length (including the terminating NUL character).
8128
8129 The caller is responsible for deleting the returned pointer. */
8130
8131static char *
8132catenate_strings (const char *lhs, const char *rhs_start, int rhs_size)
8133{
8134 const int lhs_size = strlen (lhs);
8135 char *result = XNEWVEC (char, lhs_size + rhs_size);
8136 strncpy (result, lhs, lhs_size);
8137 strncpy (result + lhs_size, rhs_start, rhs_size);
8138 return result;
8139}
8140
8141/* Issue the error given by GMSGID, indicating that it occurred before
8142 TOKEN, which had the associated VALUE. */
8143
8144void
8145c_parse_error (const char *gmsgid, enum cpp_ttype token_type,
8146 tree value, unsigned char token_flags)
8147{
8148#define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
8149
8150 char *message = NULL;
8151
8152 if (token_type == CPP_EOF)
8153 message = catenate_messages (gmsgid, " at end of input");
8154 else if (token_type == CPP_CHAR
8155 || token_type == CPP_WCHAR
8156 || token_type == CPP_CHAR16
8157 || token_type == CPP_CHAR32)
8158 {
8159 unsigned int val = TREE_INT_CST_LOW (value);
8160 const char *prefix;
8161
8162 switch (token_type)
8163 {
8164 default:
8165 prefix = "";
8166 break;
8167 case CPP_WCHAR:
8168 prefix = "L";
8169 break;
8170 case CPP_CHAR16:
8171 prefix = "u";
8172 break;
8173 case CPP_CHAR32:
8174 prefix = "U";
8175 break;
8176 }
8177
8178 if (val <= UCHAR_MAX && ISGRAPH (val))
8179 message = catenate_messages (gmsgid, " before %s'%c'");
8180 else
8181 message = catenate_messages (gmsgid, " before %s'\\x%x'");
8182
8183 error (message, prefix, val);
8184 free (message);
8185 message = NULL;
8186 }
8187 else if (token_type == CPP_STRING
8188 || token_type == CPP_WSTRING
8189 || token_type == CPP_STRING16
8190 || token_type == CPP_STRING32)
8191 message = catenate_messages (gmsgid, " before string constant");
8192 else if (token_type == CPP_NUMBER)
8193 message = catenate_messages (gmsgid, " before numeric constant");
8194 else if (token_type == CPP_NAME)
8195 {
8196 message = catenate_messages (gmsgid, " before %qE");
8197 error (message, value);
8198 free (message);
8199 message = NULL;
8200 }
8201 else if (token_type == CPP_PRAGMA)
8202 message = catenate_messages (gmsgid, " before %<#pragma%>");
8203 else if (token_type == CPP_PRAGMA_EOL)
8204 message = catenate_messages (gmsgid, " before end of line");
8205 else if (token_type < N_TTYPES)
8206 {
8207 message = catenate_messages (gmsgid, " before %qs token");
8208 error (message, cpp_type2name (token_type, token_flags));
8209 free (message);
8210 message = NULL;
8211 }
8212 else
8213 error (gmsgid);
8214
8215 if (message)
8216 {
8217 error (message);
8218 free (message);
8219 }
8220#undef catenate_messages
8221}
8222
8223/* Callback from cpp_error for PFILE to print diagnostics from the
8224 preprocessor. The diagnostic is of type LEVEL, at location
8225 LOCATION unless this is after lexing and the compiler's location
8226 should be used instead, with column number possibly overridden by
8227 COLUMN_OVERRIDE if not zero; MSG is the translated message and AP
8228 the arguments. Returns true if a diagnostic was emitted, false
8229 otherwise. */
8230
8231bool
8232c_cpp_error (cpp_reader *pfile ATTRIBUTE_UNUSED, int level,
8233 location_t location, unsigned int column_override,
8234 const char *msg, va_list *ap)
8235{
8236 diagnostic_info diagnostic;
8237 diagnostic_t dlevel;
8238 int save_warn_system_headers = warn_system_headers;
8239 bool ret;
8240
8241 switch (level)
8242 {
8243 case CPP_DL_WARNING_SYSHDR:
8244 if (flag_no_output)
8245 return false;
8246 warn_system_headers = 1;
8247 /* Fall through. */
8248 case CPP_DL_WARNING:
8249 if (flag_no_output)
8250 return false;
8251 dlevel = DK_WARNING;
8252 break;
8253 case CPP_DL_PEDWARN:
8254 if (flag_no_output && !flag_pedantic_errors)
8255 return false;
8256 dlevel = DK_PEDWARN;
8257 break;
8258 case CPP_DL_ERROR:
8259 dlevel = DK_ERROR;
8260 break;
8261 case CPP_DL_ICE:
8262 dlevel = DK_ICE;
8263 break;
8264 case CPP_DL_NOTE:
8265 dlevel = DK_NOTE;
8266 break;
8267 case CPP_DL_FATAL:
8268 dlevel = DK_FATAL;
8269 break;
8270 default:
8271 gcc_unreachable ();
8272 }
8273 if (done_lexing)
8274 location = input_location;
8275 diagnostic_set_info_translated (&diagnostic, msg, ap,
8276 location, dlevel);
8277 if (column_override)
8278 diagnostic_override_column (&diagnostic, column_override);
8279 ret = report_diagnostic (&diagnostic);
8280 if (level == CPP_DL_WARNING_SYSHDR)
8281 warn_system_headers = save_warn_system_headers;
8282 return ret;
8283}
8284
8285/* Walk a gimplified function and warn for functions whose return value is
8286 ignored and attribute((warn_unused_result)) is set. This is done before
8287 inlining, so we don't have to worry about that. */
8288
8289void
8290c_warn_unused_result (gimple_seq seq)
8291{
8292 tree fdecl, ftype;
8293 gimple_stmt_iterator i;
8294
8295 for (i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i))
8296 {
8297 gimple g = gsi_stmt (i);
8298
8299 switch (gimple_code (g))
8300 {
8301 case GIMPLE_BIND:
8302 c_warn_unused_result (gimple_bind_body (g));
8303 break;
8304 case GIMPLE_TRY:
8305 c_warn_unused_result (gimple_try_eval (g));
8306 c_warn_unused_result (gimple_try_cleanup (g));
8307 break;
8308 case GIMPLE_CATCH:
8309 c_warn_unused_result (gimple_catch_handler (g));
8310 break;
8311 case GIMPLE_EH_FILTER:
8312 c_warn_unused_result (gimple_eh_filter_failure (g));
8313 break;
8314
8315 case GIMPLE_CALL:
8316 if (gimple_call_lhs (g))
8317 break;
8318
8319 /* This is a naked call, as opposed to a GIMPLE_CALL with an
8320 LHS. All calls whose value is ignored should be
8321 represented like this. Look for the attribute. */
8322 fdecl = gimple_call_fndecl (g);
8323 ftype = TREE_TYPE (TREE_TYPE (gimple_call_fn (g)));
8324
8325 if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype)))
8326 {
8327 location_t loc = gimple_location (g);
8328
8329 if (fdecl)
8330 warning (0, "%Hignoring return value of %qD, "
8331 "declared with attribute warn_unused_result",
8332 &loc, fdecl);
8333 else
8334 warning (0, "%Hignoring return value of function "
8335 "declared with attribute warn_unused_result",
8336 &loc);
8337 }
8338 break;
8339
8340 default:
8341 /* Not a container, not a call, or a call whose value is used. */
8342 break;
8343 }
8344 }
8345}
8346
8347/* Convert a character from the host to the target execution character
8348 set. cpplib handles this, mostly. */
8349
8350HOST_WIDE_INT
8351c_common_to_target_charset (HOST_WIDE_INT c)
8352{
8353 /* Character constants in GCC proper are sign-extended under -fsigned-char,
8354 zero-extended under -fno-signed-char. cpplib insists that characters
8355 and character constants are always unsigned. Hence we must convert
8356 back and forth. */
8357 cppchar_t uc = ((cppchar_t)c) & ((((cppchar_t)1) << CHAR_BIT)-1);
8358
8359 uc = cpp_host_to_exec_charset (parse_in, uc);
8360
8361 if (flag_signed_char)
8362 return ((HOST_WIDE_INT)uc) << (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE)
8363 >> (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE);
8364 else
8365 return uc;
8366}
8367
8368/* Build the result of __builtin_offsetof. EXPR is a nested sequence of
8369 component references, with STOP_REF, or alternatively an INDIRECT_REF of
8370 NULL, at the bottom; much like the traditional rendering of offsetof as a
8371 macro. Returns the folded and properly cast result. */
8372
8373static tree
8374fold_offsetof_1 (tree expr, tree stop_ref)
8375{
8376 enum tree_code code = PLUS_EXPR;
8377 tree base, off, t;
8378
8379 if (expr == stop_ref && TREE_CODE (expr) != ERROR_MARK)
8380 return size_zero_node;
8381
8382 switch (TREE_CODE (expr))
8383 {
8384 case ERROR_MARK:
8385 return expr;
8386
8387 case VAR_DECL:
8388 error ("cannot apply %<offsetof%> to static data member %qD", expr);
8389 return error_mark_node;
8390
8391 case CALL_EXPR:
8392 case TARGET_EXPR:
8393 error ("cannot apply %<offsetof%> when %<operator[]%> is overloaded");
8394 return error_mark_node;
8395
8396 case INTEGER_CST:
8397 gcc_assert (integer_zerop (expr));
8398 return size_zero_node;
8399
8400 case NOP_EXPR:
8401 case INDIRECT_REF:
8402 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
8403 gcc_assert (base == error_mark_node || base == size_zero_node);
8404 return base;
8405
8406 case COMPONENT_REF:
8407 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
8408 if (base == error_mark_node)
8409 return base;
8410
8411 t = TREE_OPERAND (expr, 1);
8412 if (DECL_C_BIT_FIELD (t))
8413 {
8414 error ("attempt to take address of bit-field structure "
8415 "member %qD", t);
8416 return error_mark_node;
8417 }
8418 off = size_binop (PLUS_EXPR, DECL_FIELD_OFFSET (t),
8419 size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t), 1)
8420 / BITS_PER_UNIT));
8421 break;
8422
8423 case ARRAY_REF:
8424 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
8425 if (base == error_mark_node)
8426 return base;
8427
8428 t = TREE_OPERAND (expr, 1);
8429 if (TREE_CODE (t) == INTEGER_CST && tree_int_cst_sgn (t) < 0)
8430 {
8431 code = MINUS_EXPR;
8432 t = fold_build1 (NEGATE_EXPR, TREE_TYPE (t), t);
8433 }
8434 t = convert (sizetype, t);
8435 off = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (TREE_TYPE (expr)), t);
8436 break;
8437
8438 case COMPOUND_EXPR:
8439 /* Handle static members of volatile structs. */
8440 t = TREE_OPERAND (expr, 1);
8441 gcc_assert (TREE_CODE (t) == VAR_DECL);
8442 return fold_offsetof_1 (t, stop_ref);
8443
8444 default:
8445 gcc_unreachable ();
8446 }
8447
8448 return size_binop (code, base, off);
8449}
8450
8451tree
8452fold_offsetof (tree expr, tree stop_ref)
8453{
8454 /* Convert back from the internal sizetype to size_t. */
8455 return convert (size_type_node, fold_offsetof_1 (expr, stop_ref));
8456}
8457
8458/* Print an error message for an invalid lvalue. USE says
8459 how the lvalue is being used and so selects the error message. */
8460
8461void
8462lvalue_error (enum lvalue_use use)
8463{
8464 switch (use)
8465 {
8466 case lv_assign:
8467 error ("lvalue required as left operand of assignment");
8468 break;
8469 case lv_increment:
8470 error ("lvalue required as increment operand");
8471 break;
8472 case lv_decrement:
8473 error ("lvalue required as decrement operand");
8474 break;
8475 case lv_addressof:
8476 error ("lvalue required as unary %<&%> operand");
8477 break;
8478 case lv_asm:
8479 error ("lvalue required in asm statement");
8480 break;
8481 default:
8482 gcc_unreachable ();
8483 }
8484}
8485\f
8486/* *PTYPE is an incomplete array. Complete it with a domain based on
8487 INITIAL_VALUE. If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
8488 is true. Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8489 2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty. */
8490
8491int
8492complete_array_type (tree *ptype, tree initial_value, bool do_default)
8493{
8494 tree maxindex, type, main_type, elt, unqual_elt;
8495 int failure = 0, quals;
8496 hashval_t hashcode = 0;
8497
8498 maxindex = size_zero_node;
8499 if (initial_value)
8500 {
8501 if (TREE_CODE (initial_value) == STRING_CST)
8502 {
8503 int eltsize
8504 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8505 maxindex = size_int (TREE_STRING_LENGTH (initial_value)/eltsize - 1);
8506 }
8507 else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8508 {
8509 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
8510
8511 if (VEC_empty (constructor_elt, v))
8512 {
8513 if (pedantic)
8514 failure = 3;
8515 maxindex = integer_minus_one_node;
8516 }
8517 else
8518 {
8519 tree curindex;
8520 unsigned HOST_WIDE_INT cnt;
8521 constructor_elt *ce;
8522 bool fold_p = false;
8523
8524 if (VEC_index (constructor_elt, v, 0)->index)
8525 maxindex = fold_convert (sizetype,
8526 VEC_index (constructor_elt,
8527 v, 0)->index);
8528 curindex = maxindex;
8529
8530 for (cnt = 1;
8531 VEC_iterate (constructor_elt, v, cnt, ce);
8532 cnt++)
8533 {
8534 bool curfold_p = false;
8535 if (ce->index)
8536 curindex = ce->index, curfold_p = true;
8537 else
8538 {
8539 if (fold_p)
8540 curindex = fold_convert (sizetype, curindex);
8541 curindex = size_binop (PLUS_EXPR, curindex, size_one_node);
8542 }
8543 if (tree_int_cst_lt (maxindex, curindex))
8544 maxindex = curindex, fold_p = curfold_p;
8545 }
8546 if (fold_p)
8547 maxindex = fold_convert (sizetype, maxindex);
8548 }
8549 }
8550 else
8551 {
8552 /* Make an error message unless that happened already. */
8553 if (initial_value != error_mark_node)
8554 failure = 1;
8555 }
8556 }
8557 else
8558 {
8559 failure = 2;
8560 if (!do_default)
8561 return failure;
8562 }
8563
8564 type = *ptype;
8565 elt = TREE_TYPE (type);
8566 quals = TYPE_QUALS (strip_array_types (elt));
8567 if (quals == 0)
8568 unqual_elt = elt;
8569 else
8570 unqual_elt = c_build_qualified_type (elt, TYPE_UNQUALIFIED);
8571
8572 /* Using build_distinct_type_copy and modifying things afterward instead
8573 of using build_array_type to create a new type preserves all of the
8574 TYPE_LANG_FLAG_? bits that the front end may have set. */
8575 main_type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
8576 TREE_TYPE (main_type) = unqual_elt;
8577 TYPE_DOMAIN (main_type) = build_index_type (maxindex);
8578 layout_type (main_type);
8579
8580 /* Make sure we have the canonical MAIN_TYPE. */
8581 hashcode = iterative_hash_object (TYPE_HASH (unqual_elt), hashcode);
8582 hashcode = iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (main_type)),
8583 hashcode);
8584 main_type = type_hash_canon (hashcode, main_type);
8585
8586 /* Fix the canonical type. */
8587 if (TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (main_type))
8588 || TYPE_STRUCTURAL_EQUALITY_P (TYPE_DOMAIN (main_type)))
8589 SET_TYPE_STRUCTURAL_EQUALITY (main_type);
8590 else if (TYPE_CANONICAL (TREE_TYPE (main_type)) != TREE_TYPE (main_type)
8591 || (TYPE_CANONICAL (TYPE_DOMAIN (main_type))
8592 != TYPE_DOMAIN (main_type)))
8593 TYPE_CANONICAL (main_type)
8594 = build_array_type (TYPE_CANONICAL (TREE_TYPE (main_type)),
8595 TYPE_CANONICAL (TYPE_DOMAIN (main_type)));
8596 else
8597 TYPE_CANONICAL (main_type) = main_type;
8598
8599 if (quals == 0)
8600 type = main_type;
8601 else
8602 type = c_build_qualified_type (main_type, quals);
8603
8604 if (COMPLETE_TYPE_P (type)
8605 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
8606 && TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
8607 {
8608 error ("size of array is too large");
8609 /* If we proceed with the array type as it is, we'll eventually
8610 crash in tree_low_cst(). */
8611 type = error_mark_node;
8612 }
8613
8614 *ptype = type;
8615 return failure;
8616}
8617
8618\f
8619/* Used to help initialize the builtin-types.def table. When a type of
8620 the correct size doesn't exist, use error_mark_node instead of NULL.
8621 The later results in segfaults even when a decl using the type doesn't
8622 get invoked. */
8623
8624tree
8625builtin_type_for_size (int size, bool unsignedp)
8626{
8627 tree type = lang_hooks.types.type_for_size (size, unsignedp);
8628 return type ? type : error_mark_node;
8629}
8630
8631/* A helper function for resolve_overloaded_builtin in resolving the
8632 overloaded __sync_ builtins. Returns a positive power of 2 if the
8633 first operand of PARAMS is a pointer to a supported data type.
8634 Returns 0 if an error is encountered. */
8635
8636static int
8637sync_resolve_size (tree function, VEC(tree,gc) *params)
8638{
8639 tree type;
8640 int size;
8641
8642 if (VEC_empty (tree, params))
8643 {
8644 error ("too few arguments to function %qE", function);
8645 return 0;
8646 }
8647
8648 type = TREE_TYPE (VEC_index (tree, params, 0));
8649 if (TREE_CODE (type) != POINTER_TYPE)
8650 goto incompatible;
8651
8652 type = TREE_TYPE (type);
8653 if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
8654 goto incompatible;
8655
8656 size = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
8657 if (size == 1 || size == 2 || size == 4 || size == 8 || size == 16)
8658 return size;
8659
8660 incompatible:
8661 error ("incompatible type for argument %d of %qE", 1, function);
8662 return 0;
8663}
8664
8665/* A helper function for resolve_overloaded_builtin. Adds casts to
8666 PARAMS to make arguments match up with those of FUNCTION. Drops
8667 the variadic arguments at the end. Returns false if some error
8668 was encountered; true on success. */
8669
8670static bool
8671sync_resolve_params (tree orig_function, tree function, VEC(tree, gc) *params)
8672{
8673 tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (function));
8674 tree ptype;
8675 int number;
8676 unsigned int parmnum;
8677
8678 /* We've declared the implementation functions to use "volatile void *"
8679 as the pointer parameter, so we shouldn't get any complaints from the
8680 call to check_function_arguments what ever type the user used. */
8681 arg_types = TREE_CHAIN (arg_types);
8682 ptype = TREE_TYPE (TREE_TYPE (VEC_index (tree, params, 0)));
8683 number = 2;
8684
8685 /* For the rest of the values, we need to cast these to FTYPE, so that we
8686 don't get warnings for passing pointer types, etc. */
8687 parmnum = 0;
8688 while (arg_types != void_list_node)
8689 {
8690 tree val;
8691
8692 ++parmnum;
8693 if (VEC_length (tree, params) <= parmnum)
8694 {
8695 error ("too few arguments to function %qE", orig_function);
8696 return false;
8697 }
8698
8699 /* ??? Ideally for the first conversion we'd use convert_for_assignment
8700 so that we get warnings for anything that doesn't match the pointer
8701 type. This isn't portable across the C and C++ front ends atm. */
8702 val = VEC_index (tree, params, parmnum);
8703 val = convert (ptype, val);
8704 val = convert (TREE_VALUE (arg_types), val);
8705 VEC_replace (tree, params, parmnum, val);
8706
8707 arg_types = TREE_CHAIN (arg_types);
8708 number++;
8709 }
8710
8711 /* The definition of these primitives is variadic, with the remaining
8712 being "an optional list of variables protected by the memory barrier".
8713 No clue what that's supposed to mean, precisely, but we consider all
8714 call-clobbered variables to be protected so we're safe. */
8715 VEC_truncate (tree, params, parmnum + 1);
8716
8717 return true;
8718}
8719
8720/* A helper function for resolve_overloaded_builtin. Adds a cast to
8721 RESULT to make it match the type of the first pointer argument in
8722 PARAMS. */
8723
8724static tree
8725sync_resolve_return (tree first_param, tree result)
8726{
8727 tree ptype = TREE_TYPE (TREE_TYPE (first_param));
8728 ptype = TYPE_MAIN_VARIANT (ptype);
8729 return convert (ptype, result);
8730}
8731
8732/* Some builtin functions are placeholders for other expressions. This
8733 function should be called immediately after parsing the call expression
8734 before surrounding code has committed to the type of the expression.
8735
8736 FUNCTION is the DECL that has been invoked; it is known to be a builtin.
8737 PARAMS is the argument list for the call. The return value is non-null
8738 when expansion is complete, and null if normal processing should
8739 continue. */
8740
8741tree
8742resolve_overloaded_builtin (tree function, VEC(tree,gc) *params)
8743{
8744 enum built_in_function orig_code = DECL_FUNCTION_CODE (function);
8745 switch (DECL_BUILT_IN_CLASS (function))
8746 {
8747 case BUILT_IN_NORMAL:
8748 break;
8749 case BUILT_IN_MD:
8750 if (targetm.resolve_overloaded_builtin)
8751 return targetm.resolve_overloaded_builtin (function, params);
8752 else
8753 return NULL_TREE;
8754 default:
8755 return NULL_TREE;
8756 }
8757
8758 /* Handle BUILT_IN_NORMAL here. */
8759 switch (orig_code)
8760 {
8761 case BUILT_IN_FETCH_AND_ADD_N:
8762 case BUILT_IN_FETCH_AND_SUB_N:
8763 case BUILT_IN_FETCH_AND_OR_N:
8764 case BUILT_IN_FETCH_AND_AND_N:
8765 case BUILT_IN_FETCH_AND_XOR_N:
8766 case BUILT_IN_FETCH_AND_NAND_N:
8767 case BUILT_IN_ADD_AND_FETCH_N:
8768 case BUILT_IN_SUB_AND_FETCH_N:
8769 case BUILT_IN_OR_AND_FETCH_N:
8770 case BUILT_IN_AND_AND_FETCH_N:
8771 case BUILT_IN_XOR_AND_FETCH_N:
8772 case BUILT_IN_NAND_AND_FETCH_N:
8773 case BUILT_IN_BOOL_COMPARE_AND_SWAP_N:
8774 case BUILT_IN_VAL_COMPARE_AND_SWAP_N:
8775 case BUILT_IN_LOCK_TEST_AND_SET_N:
8776 case BUILT_IN_LOCK_RELEASE_N:
8777 {
8778 int n = sync_resolve_size (function, params);
8779 tree new_function, first_param, result;
8780
8781 if (n == 0)
8782 return error_mark_node;
8783
8784 new_function = built_in_decls[orig_code + exact_log2 (n) + 1];
8785 if (!sync_resolve_params (function, new_function, params))
8786 return error_mark_node;
8787
8788 first_param = VEC_index (tree, params, 0);
8789 result = build_function_call_vec (new_function, params, NULL);
8790 if (orig_code != BUILT_IN_BOOL_COMPARE_AND_SWAP_N
8791 && orig_code != BUILT_IN_LOCK_RELEASE_N)
8792 result = sync_resolve_return (first_param, result);
8793
8794 return result;
8795 }
8796
8797 default:
8798 return NULL_TREE;
8799 }
8800}
8801
8802/* Ignoring their sign, return true if two scalar types are the same. */
8803bool
8804same_scalar_type_ignoring_signedness (tree t1, tree t2)
8805{
8806 enum tree_code c1 = TREE_CODE (t1), c2 = TREE_CODE (t2);
8807
8808 gcc_assert ((c1 == INTEGER_TYPE || c1 == REAL_TYPE || c1 == FIXED_POINT_TYPE)
8809 && (c2 == INTEGER_TYPE || c2 == REAL_TYPE
8810 || c2 == FIXED_POINT_TYPE));
8811
8812 /* Equality works here because c_common_signed_type uses
8813 TYPE_MAIN_VARIANT. */
8814 return c_common_signed_type (t1)
8815 == c_common_signed_type (t2);
8816}
8817
8818/* Check for missing format attributes on function pointers. LTYPE is
8819 the new type or left-hand side type. RTYPE is the old type or
8820 right-hand side type. Returns TRUE if LTYPE is missing the desired
8821 attribute. */
8822
8823bool
8824check_missing_format_attribute (tree ltype, tree rtype)
8825{
8826 tree const ttr = TREE_TYPE (rtype), ttl = TREE_TYPE (ltype);
8827 tree ra;
8828
8829 for (ra = TYPE_ATTRIBUTES (ttr); ra; ra = TREE_CHAIN (ra))
8830 if (is_attribute_p ("format", TREE_PURPOSE (ra)))
8831 break;
8832 if (ra)
8833 {
8834 tree la;
8835 for (la = TYPE_ATTRIBUTES (ttl); la; la = TREE_CHAIN (la))
8836 if (is_attribute_p ("format", TREE_PURPOSE (la)))
8837 break;
8838 return !la;
8839 }
8840 else
8841 return false;
8842}
8843
8844/* Subscripting with type char is likely to lose on a machine where
8845 chars are signed. So warn on any machine, but optionally. Don't
8846 warn for unsigned char since that type is safe. Don't warn for
8847 signed char because anyone who uses that must have done so
8848 deliberately. Furthermore, we reduce the false positive load by
8849 warning only for non-constant value of type char. */
8850
8851void
8852warn_array_subscript_with_type_char (tree index)
8853{
8854 if (TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node
8855 && TREE_CODE (index) != INTEGER_CST)
8856 warning (OPT_Wchar_subscripts, "array subscript has type %<char%>");
8857}
8858
8859/* Implement -Wparentheses for the unexpected C precedence rules, to
8860 cover cases like x + y << z which readers are likely to
8861 misinterpret. We have seen an expression in which CODE is a binary
8862 operator used to combine expressions ARG_LEFT and ARG_RIGHT, which
8863 before folding had CODE_LEFT and CODE_RIGHT. CODE_LEFT and
8864 CODE_RIGHT may be ERROR_MARK, which means that that side of the
8865 expression was not formed using a binary or unary operator, or it
8866 was enclosed in parentheses. */
8867
8868void
8869warn_about_parentheses (enum tree_code code,
8870 enum tree_code code_left, tree arg_left,
8871 enum tree_code code_right, tree arg_right)
8872{
8873 if (!warn_parentheses)
8874 return;
8875
8876 /* This macro tests that the expression ARG with original tree code
8877 CODE appears to be a boolean expression. or the result of folding a
8878 boolean expression. */
8879#define APPEARS_TO_BE_BOOLEAN_EXPR_P(CODE, ARG) \
8880 (truth_value_p (TREE_CODE (ARG)) \
8881 || TREE_CODE (TREE_TYPE (ARG)) == BOOLEAN_TYPE \
8882 /* Folding may create 0 or 1 integers from other expressions. */ \
8883 || ((CODE) != INTEGER_CST \
8884 && (integer_onep (ARG) || integer_zerop (ARG))))
8885
8886 switch (code)
8887 {
8888 case LSHIFT_EXPR:
8889 if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
8890 warning (OPT_Wparentheses,
8891 "suggest parentheses around %<+%> inside %<<<%>");
8892 else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
8893 warning (OPT_Wparentheses,
8894 "suggest parentheses around %<-%> inside %<<<%>");
8895 return;
8896
8897 case RSHIFT_EXPR:
8898 if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
8899 warning (OPT_Wparentheses,
8900 "suggest parentheses around %<+%> inside %<>>%>");
8901 else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
8902 warning (OPT_Wparentheses,
8903 "suggest parentheses around %<-%> inside %<>>%>");
8904 return;
8905
8906 case TRUTH_ORIF_EXPR:
8907 if (code_left == TRUTH_ANDIF_EXPR || code_right == TRUTH_ANDIF_EXPR)
8908 warning (OPT_Wparentheses,
8909 "suggest parentheses around %<&&%> within %<||%>");
8910 return;
8911
8912 case BIT_IOR_EXPR:
8913 if (code_left == BIT_AND_EXPR || code_left == BIT_XOR_EXPR
8914 || code_left == PLUS_EXPR || code_left == MINUS_EXPR
8915 || code_right == BIT_AND_EXPR || code_right == BIT_XOR_EXPR
8916 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
8917 warning (OPT_Wparentheses,
8918 "suggest parentheses around arithmetic in operand of %<|%>");
8919 /* Check cases like x|y==z */
8920 else if (TREE_CODE_CLASS (code_left) == tcc_comparison
8921 || TREE_CODE_CLASS (code_right) == tcc_comparison)
8922 warning (OPT_Wparentheses,
8923 "suggest parentheses around comparison in operand of %<|%>");
8924 /* Check cases like !x | y */
8925 else if (code_left == TRUTH_NOT_EXPR
8926 && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right, arg_right))
8927 warning (OPT_Wparentheses, "suggest parentheses around operand of "
8928 "%<!%> or change %<|%> to %<||%> or %<!%> to %<~%>");
8929 return;
8930
8931 case BIT_XOR_EXPR:
8932 if (code_left == BIT_AND_EXPR
8933 || code_left == PLUS_EXPR || code_left == MINUS_EXPR
8934 || code_right == BIT_AND_EXPR
8935 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
8936 warning (OPT_Wparentheses,
8937 "suggest parentheses around arithmetic in operand of %<^%>");
8938 /* Check cases like x^y==z */
8939 else if (TREE_CODE_CLASS (code_left) == tcc_comparison
8940 || TREE_CODE_CLASS (code_right) == tcc_comparison)
8941 warning (OPT_Wparentheses,
8942 "suggest parentheses around comparison in operand of %<^%>");
8943 return;
8944
8945 case BIT_AND_EXPR:
8946 if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
8947 warning (OPT_Wparentheses,
8948 "suggest parentheses around %<+%> in operand of %<&%>");
8949 else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
8950 warning (OPT_Wparentheses,
8951 "suggest parentheses around %<-%> in operand of %<&%>");
8952 /* Check cases like x&y==z */
8953 else if (TREE_CODE_CLASS (code_left) == tcc_comparison
8954 || TREE_CODE_CLASS (code_right) == tcc_comparison)
8955 warning (OPT_Wparentheses,
8956 "suggest parentheses around comparison in operand of %<&%>");
8957 /* Check cases like !x & y */
8958 else if (code_left == TRUTH_NOT_EXPR
8959 && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right, arg_right))
8960 warning (OPT_Wparentheses, "suggest parentheses around operand of "
8961 "%<!%> or change %<&%> to %<&&%> or %<!%> to %<~%>");
8962 return;
8963
8964 case EQ_EXPR:
8965 if (TREE_CODE_CLASS (code_left) == tcc_comparison
8966 || TREE_CODE_CLASS (code_right) == tcc_comparison)
8967 warning (OPT_Wparentheses,
8968 "suggest parentheses around comparison in operand of %<==%>");
8969 return;
8970 case NE_EXPR:
8971 if (TREE_CODE_CLASS (code_left) == tcc_comparison
8972 || TREE_CODE_CLASS (code_right) == tcc_comparison)
8973 warning (OPT_Wparentheses,
8974 "suggest parentheses around comparison in operand of %<!=%>");
8975 return;
8976
8977 default:
8978 if (TREE_CODE_CLASS (code) == tcc_comparison
8979 && ((TREE_CODE_CLASS (code_left) == tcc_comparison
8980 && code_left != NE_EXPR && code_left != EQ_EXPR
8981 && INTEGRAL_TYPE_P (TREE_TYPE (arg_left)))
8982 || (TREE_CODE_CLASS (code_right) == tcc_comparison
8983 && code_right != NE_EXPR && code_right != EQ_EXPR
8984 && INTEGRAL_TYPE_P (TREE_TYPE (arg_right)))))
8985 warning (OPT_Wparentheses, "comparisons like %<X<=Y<=Z%> do not "
8986 "have their mathematical meaning");
8987 return;
8988 }
8989#undef NOT_A_BOOLEAN_EXPR_P
8990}
8991
8992/* If LABEL (a LABEL_DECL) has not been used, issue a warning. */
8993
8994void
8995warn_for_unused_label (tree label)
8996{
8997 if (!TREE_USED (label))
8998 {
8999 if (DECL_INITIAL (label))
9000 warning (OPT_Wunused_label, "label %q+D defined but not used", label);
9001 else
9002 warning (OPT_Wunused_label, "label %q+D declared but not defined", label);
9003 }
9004}
9005
9006#ifndef TARGET_HAS_TARGETCM
9007struct gcc_targetcm targetcm = TARGETCM_INITIALIZER;
9008#endif
9009
9010/* Warn for division by zero according to the value of DIVISOR. LOC
9011 is the location of the division operator. */
9012
9013void
9014warn_for_div_by_zero (location_t loc, tree divisor)
9015{
9016 /* If DIVISOR is zero, and has integral or fixed-point type, issue a warning
9017 about division by zero. Do not issue a warning if DIVISOR has a
9018 floating-point type, since we consider 0.0/0.0 a valid way of
9019 generating a NaN. */
9020 if (skip_evaluation == 0
9021 && (integer_zerop (divisor) || fixed_zerop (divisor)))
9022 warning_at (loc, OPT_Wdiv_by_zero, "division by zero");
9023}
9024
9025/* Subroutine of build_binary_op. Give warnings for comparisons
9026 between signed and unsigned quantities that may fail. Do the
9027 checking based on the original operand trees ORIG_OP0 and ORIG_OP1,
9028 so that casts will be considered, but default promotions won't
9029 be.
9030
9031 LOCATION is the location of the comparison operator.
9032
9033 The arguments of this function map directly to local variables
9034 of build_binary_op. */
9035
9036void
9037warn_for_sign_compare (location_t location,
9038 tree orig_op0, tree orig_op1,
9039 tree op0, tree op1,
9040 tree result_type, enum tree_code resultcode)
9041{
9042 int op0_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op0));
9043 int op1_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op1));
9044 int unsignedp0, unsignedp1;
9045
9046 /* In C++, check for comparison of different enum types. */
9047 if (c_dialect_cxx()
9048 && TREE_CODE (TREE_TYPE (orig_op0)) == ENUMERAL_TYPE
9049 && TREE_CODE (TREE_TYPE (orig_op1)) == ENUMERAL_TYPE
9050 && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0))
9051 != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1)))
9052 {
9053 warning_at (location,
9054 OPT_Wsign_compare, "comparison between types %qT and %qT",
9055 TREE_TYPE (orig_op0), TREE_TYPE (orig_op1));
9056 }
9057
9058 /* Do not warn if the comparison is being done in a signed type,
9059 since the signed type will only be chosen if it can represent
9060 all the values of the unsigned type. */
9061 if (!TYPE_UNSIGNED (result_type))
9062 /* OK */;
9063 /* Do not warn if both operands are unsigned. */
9064 else if (op0_signed == op1_signed)
9065 /* OK */;
9066 else
9067 {
9068 tree sop, uop, base_type;
9069 bool ovf;
9070
9071 if (op0_signed)
9072 sop = orig_op0, uop = orig_op1;
9073 else
9074 sop = orig_op1, uop = orig_op0;
9075
9076 STRIP_TYPE_NOPS (sop);
9077 STRIP_TYPE_NOPS (uop);
9078 base_type = (TREE_CODE (result_type) == COMPLEX_TYPE
9079 ? TREE_TYPE (result_type) : result_type);
9080
9081 /* Do not warn if the signed quantity is an unsuffixed integer
9082 literal (or some static constant expression involving such
9083 literals or a conditional expression involving such literals)
9084 and it is non-negative. */
9085 if (tree_expr_nonnegative_warnv_p (sop, &ovf))
9086 /* OK */;
9087 /* Do not warn if the comparison is an equality operation, the
9088 unsigned quantity is an integral constant, and it would fit
9089 in the result if the result were signed. */
9090 else if (TREE_CODE (uop) == INTEGER_CST
9091 && (resultcode == EQ_EXPR || resultcode == NE_EXPR)
9092 && int_fits_type_p (uop, c_common_signed_type (base_type)))
9093 /* OK */;
9094 /* In C, do not warn if the unsigned quantity is an enumeration
9095 constant and its maximum value would fit in the result if the
9096 result were signed. */
9097 else if (!c_dialect_cxx() && TREE_CODE (uop) == INTEGER_CST
9098 && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE
9099 && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE (uop)),
9100 c_common_signed_type (base_type)))
9101 /* OK */;
9102 else
9103 warning_at (location,
9104 OPT_Wsign_compare,
9105 "comparison between signed and unsigned integer expressions");
9106 }
9107
9108 /* Warn if two unsigned values are being compared in a size larger
9109 than their original size, and one (and only one) is the result of
9110 a `~' operator. This comparison will always fail.
9111
9112 Also warn if one operand is a constant, and the constant does not
9113 have all bits set that are set in the ~ operand when it is
9114 extended. */
9115
9116 op0 = get_narrower (op0, &unsignedp0);
9117 op1 = get_narrower (op1, &unsignedp1);
9118
9119 if ((TREE_CODE (op0) == BIT_NOT_EXPR)
9120 ^ (TREE_CODE (op1) == BIT_NOT_EXPR))
9121 {
9122 if (TREE_CODE (op0) == BIT_NOT_EXPR)
9123 op0 = get_narrower (TREE_OPERAND (op0, 0), &unsignedp0);
9124 if (TREE_CODE (op1) == BIT_NOT_EXPR)
9125 op1 = get_narrower (TREE_OPERAND (op1, 0), &unsignedp1);
9126
9127 if (host_integerp (op0, 0) || host_integerp (op1, 0))
9128 {
9129 tree primop;
9130 HOST_WIDE_INT constant, mask;
9131 int unsignedp;
9132 unsigned int bits;
9133
9134 if (host_integerp (op0, 0))
9135 {
9136 primop = op1;
9137 unsignedp = unsignedp1;
9138 constant = tree_low_cst (op0, 0);
9139 }
9140 else
9141 {
9142 primop = op0;
9143 unsignedp = unsignedp0;
9144 constant = tree_low_cst (op1, 0);
9145 }
9146
9147 bits = TYPE_PRECISION (TREE_TYPE (primop));
9148 if (bits < TYPE_PRECISION (result_type)
9149 && bits < HOST_BITS_PER_LONG && unsignedp)
9150 {
9151 mask = (~ (HOST_WIDE_INT) 0) << bits;
9152 if ((mask & constant) != mask)
9153 {
9154 if (constant == 0)
9155 warning (OPT_Wsign_compare,
9156 "promoted ~unsigned is always non-zero");
9157 else
9158 warning_at (location, OPT_Wsign_compare,
9159 "comparison of promoted ~unsigned with constant");
9160 }
9161 }
9162 }
9163 else if (unsignedp0 && unsignedp1
9164 && (TYPE_PRECISION (TREE_TYPE (op0))
9165 < TYPE_PRECISION (result_type))
9166 && (TYPE_PRECISION (TREE_TYPE (op1))
9167 < TYPE_PRECISION (result_type)))
9168 warning_at (location, OPT_Wsign_compare,
9169 "comparison of promoted ~unsigned with unsigned");
9170 }
9171}
9172
9173/* Setup a TYPE_DECL node as a typedef representation.
9174
9175 X is a TYPE_DECL for a typedef statement. Create a brand new
9176 ..._TYPE node (which will be just a variant of the existing
9177 ..._TYPE node with identical properties) and then install X
9178 as the TYPE_NAME of this brand new (duplicate) ..._TYPE node.
9179
9180 The whole point here is to end up with a situation where each
9181 and every ..._TYPE node the compiler creates will be uniquely
9182 associated with AT MOST one node representing a typedef name.
9183 This way, even though the compiler substitutes corresponding
9184 ..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very
9185 early on, later parts of the compiler can always do the reverse
9186 translation and get back the corresponding typedef name. For
9187 example, given:
9188
9189 typedef struct S MY_TYPE;
9190 MY_TYPE object;
9191
9192 Later parts of the compiler might only know that `object' was of
9193 type `struct S' if it were not for code just below. With this
9194 code however, later parts of the compiler see something like:
9195
9196 struct S' == struct S
9197 typedef struct S' MY_TYPE;
9198 struct S' object;
9199
9200 And they can then deduce (from the node for type struct S') that
9201 the original object declaration was:
9202
9203 MY_TYPE object;
9204
9205 Being able to do this is important for proper support of protoize,
9206 and also for generating precise symbolic debugging information
9207 which takes full account of the programmer's (typedef) vocabulary.
9208
9209 Obviously, we don't want to generate a duplicate ..._TYPE node if
9210 the TYPE_DECL node that we are now processing really represents a
9211 standard built-in type. */
9212
9213void
9214set_underlying_type (tree x)
9215{
9216 if (x == error_mark_node)
9217 return;
9218 if (DECL_IS_BUILTIN (x))
9219 {
9220 if (TYPE_NAME (TREE_TYPE (x)) == 0)
9221 TYPE_NAME (TREE_TYPE (x)) = x;
9222 }
9223 else if (TREE_TYPE (x) != error_mark_node
9224 && DECL_ORIGINAL_TYPE (x) == NULL_TREE)
9225 {
9226 tree tt = TREE_TYPE (x);
9227 DECL_ORIGINAL_TYPE (x) = tt;
9228 tt = build_variant_type_copy (tt);
9229 TYPE_STUB_DECL (tt) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
9230 TYPE_NAME (tt) = x;
9231 TREE_USED (tt) = TREE_USED (x);
9232 TREE_TYPE (x) = tt;
9233 }
9234}
9235
9236/* Returns true if X is a typedef decl. */
9237
9238bool
9239is_typedef_decl (tree x)
9240{
9241 return (x && TREE_CODE (x) == TYPE_DECL
9242 && DECL_ORIGINAL_TYPE (x) != NULL_TREE);
9243}
9244
9245#include "gt-c-common.h"
Mirror of https://gcc.gnu.org/git/gcc.git