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 Free Software Foundation, Inc.
4
5 This file is part of GCC.
6
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
10 version.
11
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
20 02110-1301, USA. */
21
22 #include "config.h"
23 #include "system.h"
24 #include "coretypes.h"
25 #include "tm.h"
26 #include "intl.h"
27 #include "tree.h"
28 #include "flags.h"
29 #include "output.h"
30 #include "c-pragma.h"
31 #include "rtl.h"
32 #include "ggc.h"
33 #include "varray.h"
34 #include "expr.h"
35 #include "c-common.h"
36 #include "diagnostic.h"
37 #include "tm_p.h"
38 #include "obstack.h"
39 #include "cpplib.h"
40 #include "target.h"
41 #include "langhooks.h"
42 #include "tree-inline.h"
43 #include "c-tree.h"
44 #include "toplev.h"
45 #include "tree-iterator.h"
46 #include "hashtab.h"
47 #include "tree-mudflap.h"
48 #include "opts.h"
49 #include "real.h"
50 #include "cgraph.h"
51
52 cpp_reader *parse_in; /* Declared in c-pragma.h. */
53
54 /* We let tm.h override the types used here, to handle trivial differences
55 such as the choice of unsigned int or long unsigned int for size_t.
56 When machines start needing nontrivial differences in the size type,
57 it would be best to do something here to figure out automatically
58 from other information what type to use. */
59
60 #ifndef SIZE_TYPE
61 #define SIZE_TYPE "long unsigned int"
62 #endif
63
64 #ifndef PID_TYPE
65 #define PID_TYPE "int"
66 #endif
67
68 #ifndef WCHAR_TYPE
69 #define WCHAR_TYPE "int"
70 #endif
71
72 /* WCHAR_TYPE gets overridden by -fshort-wchar. */
73 #define MODIFIED_WCHAR_TYPE \
74 (flag_short_wchar ? "short unsigned int" : WCHAR_TYPE)
75
76 #ifndef PTRDIFF_TYPE
77 #define PTRDIFF_TYPE "long int"
78 #endif
79
80 #ifndef WINT_TYPE
81 #define WINT_TYPE "unsigned int"
82 #endif
83
84 #ifndef INTMAX_TYPE
85 #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
86 ? "int" \
87 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
88 ? "long int" \
89 : "long long int"))
90 #endif
91
92 #ifndef UINTMAX_TYPE
93 #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
94 ? "unsigned int" \
95 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
96 ? "long unsigned int" \
97 : "long long unsigned int"))
98 #endif
99
100 /* The following symbols are subsumed in the c_global_trees array, and
101 listed here individually for documentation purposes.
102
103 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
104
105 tree short_integer_type_node;
106 tree long_integer_type_node;
107 tree long_long_integer_type_node;
108
109 tree short_unsigned_type_node;
110 tree long_unsigned_type_node;
111 tree long_long_unsigned_type_node;
112
113 tree truthvalue_type_node;
114 tree truthvalue_false_node;
115 tree truthvalue_true_node;
116
117 tree ptrdiff_type_node;
118
119 tree unsigned_char_type_node;
120 tree signed_char_type_node;
121 tree wchar_type_node;
122 tree signed_wchar_type_node;
123 tree unsigned_wchar_type_node;
124
125 tree float_type_node;
126 tree double_type_node;
127 tree long_double_type_node;
128
129 tree complex_integer_type_node;
130 tree complex_float_type_node;
131 tree complex_double_type_node;
132 tree complex_long_double_type_node;
133
134 tree dfloat32_type_node;
135 tree dfloat64_type_node;
136 tree_dfloat128_type_node;
137
138 tree intQI_type_node;
139 tree intHI_type_node;
140 tree intSI_type_node;
141 tree intDI_type_node;
142 tree intTI_type_node;
143
144 tree unsigned_intQI_type_node;
145 tree unsigned_intHI_type_node;
146 tree unsigned_intSI_type_node;
147 tree unsigned_intDI_type_node;
148 tree unsigned_intTI_type_node;
149
150 tree widest_integer_literal_type_node;
151 tree widest_unsigned_literal_type_node;
152
153 Nodes for types `void *' and `const void *'.
154
155 tree ptr_type_node, const_ptr_type_node;
156
157 Nodes for types `char *' and `const char *'.
158
159 tree string_type_node, const_string_type_node;
160
161 Type `char[SOMENUMBER]'.
162 Used when an array of char is needed and the size is irrelevant.
163
164 tree char_array_type_node;
165
166 Type `int[SOMENUMBER]' or something like it.
167 Used when an array of int needed and the size is irrelevant.
168
169 tree int_array_type_node;
170
171 Type `wchar_t[SOMENUMBER]' or something like it.
172 Used when a wide string literal is created.
173
174 tree wchar_array_type_node;
175
176 Type `int ()' -- used for implicit declaration of functions.
177
178 tree default_function_type;
179
180 A VOID_TYPE node, packaged in a TREE_LIST.
181
182 tree void_list_node;
183
184 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
185 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
186 VAR_DECLS, but C++ does.)
187
188 tree function_name_decl_node;
189 tree pretty_function_name_decl_node;
190 tree c99_function_name_decl_node;
191
192 Stack of nested function name VAR_DECLs.
193
194 tree saved_function_name_decls;
195
196 */
197
198 tree c_global_trees[CTI_MAX];
199
200 /* Switches common to the C front ends. */
201
202 /* Nonzero if prepreprocessing only. */
203
204 int flag_preprocess_only;
205
206 /* Nonzero means don't output line number information. */
207
208 char flag_no_line_commands;
209
210 /* Nonzero causes -E output not to be done, but directives such as
211 #define that have side effects are still obeyed. */
212
213 char flag_no_output;
214
215 /* Nonzero means dump macros in some fashion. */
216
217 char flag_dump_macros;
218
219 /* Nonzero means pass #include lines through to the output. */
220
221 char flag_dump_includes;
222
223 /* Nonzero means process PCH files while preprocessing. */
224
225 bool flag_pch_preprocess;
226
227 /* The file name to which we should write a precompiled header, or
228 NULL if no header will be written in this compile. */
229
230 const char *pch_file;
231
232 /* Nonzero if an ISO standard was selected. It rejects macros in the
233 user's namespace. */
234 int flag_iso;
235
236 /* Nonzero if -undef was given. It suppresses target built-in macros
237 and assertions. */
238 int flag_undef;
239
240 /* Nonzero means don't recognize the non-ANSI builtin functions. */
241
242 int flag_no_builtin;
243
244 /* Nonzero means don't recognize the non-ANSI builtin functions.
245 -ansi sets this. */
246
247 int flag_no_nonansi_builtin;
248
249 /* Nonzero means give `double' the same size as `float'. */
250
251 int flag_short_double;
252
253 /* Nonzero means give `wchar_t' the same size as `short'. */
254
255 int flag_short_wchar;
256
257 /* Nonzero means allow implicit conversions between vectors with
258 differing numbers of subparts and/or differing element types. */
259 int flag_lax_vector_conversions;
260
261 /* Nonzero means allow Microsoft extensions without warnings or errors. */
262 int flag_ms_extensions;
263
264 /* Nonzero means don't recognize the keyword `asm'. */
265
266 int flag_no_asm;
267
268 /* Nonzero means to treat bitfields as signed unless they say `unsigned'. */
269
270 int flag_signed_bitfields = 1;
271
272 /* Warn about #pragma directives that are not recognized. */
273
274 int warn_unknown_pragmas; /* Tri state variable. */
275
276 /* Warn about format/argument anomalies in calls to formatted I/O functions
277 (*printf, *scanf, strftime, strfmon, etc.). */
278
279 int warn_format;
280
281 /* Warn about using __null (as NULL in C++) as sentinel. For code compiled
282 with GCC this doesn't matter as __null is guaranteed to have the right
283 size. */
284
285 int warn_strict_null_sentinel;
286
287 /* Zero means that faster, ...NonNil variants of objc_msgSend...
288 calls will be used in ObjC; passing nil receivers to such calls
289 will most likely result in crashes. */
290 int flag_nil_receivers = 1;
291
292 /* Nonzero means that code generation will be altered to support
293 "zero-link" execution. This currently affects ObjC only, but may
294 affect other languages in the future. */
295 int flag_zero_link = 0;
296
297 /* Nonzero means emit an '__OBJC, __image_info' for the current translation
298 unit. It will inform the ObjC runtime that class definition(s) herein
299 contained are to replace one(s) previously loaded. */
300 int flag_replace_objc_classes = 0;
301
302 /* C/ObjC language option variables. */
303
304
305 /* Nonzero means allow type mismatches in conditional expressions;
306 just make their values `void'. */
307
308 int flag_cond_mismatch;
309
310 /* Nonzero means enable C89 Amendment 1 features. */
311
312 int flag_isoc94;
313
314 /* Nonzero means use the ISO C99 dialect of C. */
315
316 int flag_isoc99;
317
318 /* Nonzero means that we have builtin functions, and main is an int. */
319
320 int flag_hosted = 1;
321
322 /* Warn if main is suspicious. */
323
324 int warn_main;
325
326
327 /* ObjC language option variables. */
328
329
330 /* Open and close the file for outputting class declarations, if
331 requested (ObjC). */
332
333 int flag_gen_declaration;
334
335 /* Tells the compiler that this is a special run. Do not perform any
336 compiling, instead we are to test some platform dependent features
337 and output a C header file with appropriate definitions. */
338
339 int print_struct_values;
340
341 /* Tells the compiler what is the constant string class for Objc. */
342
343 const char *constant_string_class_name;
344
345
346 /* C++ language option variables. */
347
348
349 /* Nonzero means don't recognize any extension keywords. */
350
351 int flag_no_gnu_keywords;
352
353 /* Nonzero means do emit exported implementations of functions even if
354 they can be inlined. */
355
356 int flag_implement_inlines = 1;
357
358 /* Nonzero means that implicit instantiations will be emitted if needed. */
359
360 int flag_implicit_templates = 1;
361
362 /* Nonzero means that implicit instantiations of inline templates will be
363 emitted if needed, even if instantiations of non-inline templates
364 aren't. */
365
366 int flag_implicit_inline_templates = 1;
367
368 /* Nonzero means generate separate instantiation control files and
369 juggle them at link time. */
370
371 int flag_use_repository;
372
373 /* Nonzero if we want to issue diagnostics that the standard says are not
374 required. */
375
376 int flag_optional_diags = 1;
377
378 /* Nonzero means we should attempt to elide constructors when possible. */
379
380 int flag_elide_constructors = 1;
381
382 /* Nonzero means that member functions defined in class scope are
383 inline by default. */
384
385 int flag_default_inline = 1;
386
387 /* Controls whether compiler generates 'type descriptor' that give
388 run-time type information. */
389
390 int flag_rtti = 1;
391
392 /* Nonzero if we want to conserve space in the .o files. We do this
393 by putting uninitialized data and runtime initialized data into
394 .common instead of .data at the expense of not flagging multiple
395 definitions. */
396
397 int flag_conserve_space;
398
399 /* Nonzero if we want to obey access control semantics. */
400
401 int flag_access_control = 1;
402
403 /* Nonzero if we want to check the return value of new and avoid calling
404 constructors if it is a null pointer. */
405
406 int flag_check_new;
407
408 /* Nonzero if we want the new ISO rules for pushing a new scope for `for'
409 initialization variables.
410 0: Old rules, set by -fno-for-scope.
411 2: New ISO rules, set by -ffor-scope.
412 1: Try to implement new ISO rules, but with backup compatibility
413 (and warnings). This is the default, for now. */
414
415 int flag_new_for_scope = 1;
416
417 /* Nonzero if we want to emit defined symbols with common-like linkage as
418 weak symbols where possible, in order to conform to C++ semantics.
419 Otherwise, emit them as local symbols. */
420
421 int flag_weak = 1;
422
423 /* 0 means we want the preprocessor to not emit line directives for
424 the current working directory. 1 means we want it to do it. -1
425 means we should decide depending on whether debugging information
426 is being emitted or not. */
427
428 int flag_working_directory = -1;
429
430 /* Nonzero to use __cxa_atexit, rather than atexit, to register
431 destructors for local statics and global objects. '2' means it has been
432 set nonzero as a default, not by a command-line flag. */
433
434 int flag_use_cxa_atexit = DEFAULT_USE_CXA_ATEXIT;
435
436 /* Nonzero to use __cxa_get_exception_ptr in C++ exception-handling
437 code. '2' means it has not been set explicitly on the command line. */
438
439 int flag_use_cxa_get_exception_ptr = 2;
440
441 /* Nonzero means make the default pedwarns warnings instead of errors.
442 The value of this flag is ignored if -pedantic is specified. */
443
444 int flag_permissive;
445
446 /* Nonzero means to implement standard semantics for exception
447 specifications, calling unexpected if an exception is thrown that
448 doesn't match the specification. Zero means to treat them as
449 assertions and optimize accordingly, but not check them. */
450
451 int flag_enforce_eh_specs = 1;
452
453 /* Nonzero means to generate thread-safe code for initializing local
454 statics. */
455
456 int flag_threadsafe_statics = 1;
457
458 /* Nonzero means warn about implicit declarations. */
459
460 int warn_implicit = 1;
461
462 /* Maximum template instantiation depth. This limit is rather
463 arbitrary, but it exists to limit the time it takes to notice
464 infinite template instantiations. */
465
466 int max_tinst_depth = 500;
467
468
469
470 /* The elements of `ridpointers' are identifier nodes for the reserved
471 type names and storage classes. It is indexed by a RID_... value. */
472 tree *ridpointers;
473
474 tree (*make_fname_decl) (tree, int);
475
476 /* Nonzero means the expression being parsed will never be evaluated.
477 This is a count, since unevaluated expressions can nest. */
478 int skip_evaluation;
479
480 /* Information about how a function name is generated. */
481 struct fname_var_t
482 {
483 tree *const decl; /* pointer to the VAR_DECL. */
484 const unsigned rid; /* RID number for the identifier. */
485 const int pretty; /* How pretty is it? */
486 };
487
488 /* The three ways of getting then name of the current function. */
489
490 const struct fname_var_t fname_vars[] =
491 {
492 /* C99 compliant __func__, must be first. */
493 {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
494 /* GCC __FUNCTION__ compliant. */
495 {&function_name_decl_node, RID_FUNCTION_NAME, 0},
496 /* GCC __PRETTY_FUNCTION__ compliant. */
497 {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
498 {NULL, 0, 0},
499 };
500
501 static int constant_fits_type_p (tree, tree);
502 static tree check_case_value (tree);
503 static bool check_case_bounds (tree, tree, tree *, tree *);
504
505 static tree handle_packed_attribute (tree *, tree, tree, int, bool *);
506 static tree handle_nocommon_attribute (tree *, tree, tree, int, bool *);
507 static tree handle_common_attribute (tree *, tree, tree, int, bool *);
508 static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
509 static tree handle_noinline_attribute (tree *, tree, tree, int, bool *);
510 static tree handle_always_inline_attribute (tree *, tree, tree, int,
511 bool *);
512 static tree handle_gnu_inline_attribute (tree *, tree, tree, int,
513 bool *);
514 static tree handle_flatten_attribute (tree *, tree, tree, int, bool *);
515 static tree handle_used_attribute (tree *, tree, tree, int, bool *);
516 static tree handle_unused_attribute (tree *, tree, tree, int, bool *);
517 static tree handle_externally_visible_attribute (tree *, tree, tree, int,
518 bool *);
519 static tree handle_const_attribute (tree *, tree, tree, int, bool *);
520 static tree handle_transparent_union_attribute (tree *, tree, tree,
521 int, bool *);
522 static tree handle_constructor_attribute (tree *, tree, tree, int, bool *);
523 static tree handle_destructor_attribute (tree *, tree, tree, int, bool *);
524 static tree handle_mode_attribute (tree *, tree, tree, int, bool *);
525 static tree handle_section_attribute (tree *, tree, tree, int, bool *);
526 static tree handle_aligned_attribute (tree *, tree, tree, int, bool *);
527 static tree handle_weak_attribute (tree *, tree, tree, int, bool *) ;
528 static tree handle_alias_attribute (tree *, tree, tree, int, bool *);
529 static tree handle_weakref_attribute (tree *, tree, tree, int, bool *) ;
530 static tree handle_visibility_attribute (tree *, tree, tree, int,
531 bool *);
532 static tree handle_tls_model_attribute (tree *, tree, tree, int,
533 bool *);
534 static tree handle_no_instrument_function_attribute (tree *, tree,
535 tree, int, bool *);
536 static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);
537 static tree handle_returns_twice_attribute (tree *, tree, tree, int, bool *);
538 static tree handle_no_limit_stack_attribute (tree *, tree, tree, int,
539 bool *);
540 static tree handle_pure_attribute (tree *, tree, tree, int, bool *);
541 static tree handle_novops_attribute (tree *, tree, tree, int, bool *);
542 static tree handle_deprecated_attribute (tree *, tree, tree, int,
543 bool *);
544 /* APPLE LOCAL begin "unavailable" attribute (Radar 2809697) --ilr */
545 static tree handle_unavailable_attribute (tree *, tree, tree, int, bool *);
546 /* APPLE LOCAL end "unavailable" attribute --ilr */
547 static tree handle_vector_size_attribute (tree *, tree, tree, int,
548 bool *);
549 static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
550 static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
551 static tree handle_cleanup_attribute (tree *, tree, tree, int, bool *);
552 static tree handle_warn_unused_result_attribute (tree *, tree, tree, int,
553 bool *);
554 static tree handle_sentinel_attribute (tree *, tree, tree, int, bool *);
555 /* APPLE LOCAL radar 5932809 - copyable byref blocks */
556 static tree handle_blocks_attribute (tree *, tree, tree, int, bool *);
557
558 static void check_function_nonnull (tree, tree);
559 static void check_nonnull_arg (void *, tree, unsigned HOST_WIDE_INT);
560 static bool nonnull_check_p (tree, unsigned HOST_WIDE_INT);
561 static bool get_nonnull_operand (tree, unsigned HOST_WIDE_INT *);
562 static int resort_field_decl_cmp (const void *, const void *);
563
564 /* Table of machine-independent attributes common to all C-like languages. */
565 const struct attribute_spec c_common_attribute_table[] =
566 {
567 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
568 { "packed", 0, 0, false, false, false,
569 handle_packed_attribute },
570 { "nocommon", 0, 0, true, false, false,
571 handle_nocommon_attribute },
572 { "common", 0, 0, true, false, false,
573 handle_common_attribute },
574 /* FIXME: logically, noreturn attributes should be listed as
575 "false, true, true" and apply to function types. But implementing this
576 would require all the places in the compiler that use TREE_THIS_VOLATILE
577 on a decl to identify non-returning functions to be located and fixed
578 to check the function type instead. */
579 { "noreturn", 0, 0, true, false, false,
580 handle_noreturn_attribute },
581 { "volatile", 0, 0, true, false, false,
582 handle_noreturn_attribute },
583 { "noinline", 0, 0, true, false, false,
584 handle_noinline_attribute },
585 { "always_inline", 0, 0, true, false, false,
586 handle_always_inline_attribute },
587 { "gnu_inline", 0, 0, true, false, false,
588 handle_gnu_inline_attribute },
589 { "flatten", 0, 0, true, false, false,
590 handle_flatten_attribute },
591 { "used", 0, 0, true, false, false,
592 handle_used_attribute },
593 { "unused", 0, 0, false, false, false,
594 handle_unused_attribute },
595 { "externally_visible", 0, 0, true, false, false,
596 handle_externally_visible_attribute },
597 /* The same comments as for noreturn attributes apply to const ones. */
598 { "const", 0, 0, true, false, false,
599 handle_const_attribute },
600 { "transparent_union", 0, 0, false, false, false,
601 handle_transparent_union_attribute },
602 { "constructor", 0, 0, true, false, false,
603 handle_constructor_attribute },
604 { "destructor", 0, 0, true, false, false,
605 handle_destructor_attribute },
606 { "mode", 1, 1, false, true, false,
607 handle_mode_attribute },
608 { "section", 1, 1, true, false, false,
609 handle_section_attribute },
610 { "aligned", 0, 1, false, false, false,
611 handle_aligned_attribute },
612 /* APPLE LOCAL weak types 5954418 */
613 { "weak", 0, 0, false, false, false,
614 handle_weak_attribute },
615 { "alias", 1, 1, true, false, false,
616 handle_alias_attribute },
617 { "weakref", 0, 1, true, false, false,
618 handle_weakref_attribute },
619 { "no_instrument_function", 0, 0, true, false, false,
620 handle_no_instrument_function_attribute },
621 { "malloc", 0, 0, true, false, false,
622 handle_malloc_attribute },
623 { "returns_twice", 0, 0, true, false, false,
624 handle_returns_twice_attribute },
625 { "no_stack_limit", 0, 0, true, false, false,
626 handle_no_limit_stack_attribute },
627 { "pure", 0, 0, true, false, false,
628 handle_pure_attribute },
629 /* For internal use (marking of builtins) only. The name contains space
630 to prevent its usage in source code. */
631 { "no vops", 0, 0, true, false, false,
632 handle_novops_attribute },
633 { "deprecated", 0, 0, false, false, false,
634 handle_deprecated_attribute },
635 /* APPLE LOCAL begin "unavailable" attribute (Radar 2809697) --ilr */
636 { "unavailable", 0, 0, false, false, false,
637 handle_unavailable_attribute },
638 /* APPLE LOCAL end "unavailable" attribute --ilr */
639 { "vector_size", 1, 1, false, true, false,
640 handle_vector_size_attribute },
641 { "visibility", 1, 1, false, false, false,
642 handle_visibility_attribute },
643 { "tls_model", 1, 1, true, false, false,
644 handle_tls_model_attribute },
645 { "nonnull", 0, -1, false, true, true,
646 handle_nonnull_attribute },
647 { "nothrow", 0, 0, true, false, false,
648 handle_nothrow_attribute },
649 { "may_alias", 0, 0, false, true, false, NULL },
650 { "cleanup", 1, 1, true, false, false,
651 handle_cleanup_attribute },
652 { "warn_unused_result", 0, 0, false, true, true,
653 handle_warn_unused_result_attribute },
654 { "sentinel", 0, 1, false, true, true,
655 handle_sentinel_attribute },
656 /* APPLE LOCAL radar 5932809 - copyable byref blocks */
657 { "blocks", 1, 1, true, false, false, handle_blocks_attribute },
658 { NULL, 0, 0, false, false, false, NULL }
659 };
660
661 /* Give the specifications for the format attributes, used by C and all
662 descendants. */
663
664 const struct attribute_spec c_common_format_attribute_table[] =
665 {
666 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
667 { "format", 3, 3, false, true, true,
668 handle_format_attribute },
669 { "format_arg", 1, 1, false, true, true,
670 handle_format_arg_attribute },
671 { NULL, 0, 0, false, false, false, NULL }
672 };
673
674 /* Push current bindings for the function name VAR_DECLS. */
675
676 void
start_fname_decls(void)677 start_fname_decls (void)
678 {
679 unsigned ix;
680 tree saved = NULL_TREE;
681
682 for (ix = 0; fname_vars[ix].decl; ix++)
683 {
684 tree decl = *fname_vars[ix].decl;
685
686 if (decl)
687 {
688 saved = tree_cons (decl, build_int_cst (NULL_TREE, ix), saved);
689 *fname_vars[ix].decl = NULL_TREE;
690 }
691 }
692 if (saved || saved_function_name_decls)
693 /* Normally they'll have been NULL, so only push if we've got a
694 stack, or they are non-NULL. */
695 saved_function_name_decls = tree_cons (saved, NULL_TREE,
696 saved_function_name_decls);
697 }
698
699 /* Finish up the current bindings, adding them into the current function's
700 statement tree. This must be done _before_ finish_stmt_tree is called.
701 If there is no current function, we must be at file scope and no statements
702 are involved. Pop the previous bindings. */
703
704 void
finish_fname_decls(void)705 finish_fname_decls (void)
706 {
707 unsigned ix;
708 tree stmts = NULL_TREE;
709 tree stack = saved_function_name_decls;
710
711 for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
712 append_to_statement_list (TREE_VALUE (stack), &stmts);
713
714 if (stmts)
715 {
716 tree *bodyp = &DECL_SAVED_TREE (current_function_decl);
717
718 if (TREE_CODE (*bodyp) == BIND_EXPR)
719 bodyp = &BIND_EXPR_BODY (*bodyp);
720
721 append_to_statement_list_force (*bodyp, &stmts);
722 *bodyp = stmts;
723 }
724
725 for (ix = 0; fname_vars[ix].decl; ix++)
726 *fname_vars[ix].decl = NULL_TREE;
727
728 if (stack)
729 {
730 /* We had saved values, restore them. */
731 tree saved;
732
733 for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
734 {
735 tree decl = TREE_PURPOSE (saved);
736 unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
737
738 *fname_vars[ix].decl = decl;
739 }
740 stack = TREE_CHAIN (stack);
741 }
742 saved_function_name_decls = stack;
743 }
744
745 /* Return the text name of the current function, suitably prettified
746 by PRETTY_P. Return string must be freed by caller. */
747
748 const char *
fname_as_string(int pretty_p)749 fname_as_string (int pretty_p)
750 {
751 const char *name = "top level";
752 char *namep;
753 int vrb = 2;
754
755 if (!pretty_p)
756 {
757 name = "";
758 vrb = 0;
759 }
760
761 if (current_function_decl)
762 name = lang_hooks.decl_printable_name (current_function_decl, vrb);
763
764 if (c_lex_string_translate)
765 {
766 int len = strlen (name) + 3; /* Two for '"'s. One for NULL. */
767 cpp_string cstr = { 0, 0 }, strname;
768
769 namep = XNEWVEC (char, len);
770 snprintf (namep, len, "\"%s\"", name);
771 strname.text = (unsigned char *) namep;
772 strname.len = len - 1;
773
774 if (cpp_interpret_string (parse_in, &strname, 1, &cstr, false))
775 {
776 XDELETEVEC (namep);
777 return (char *) cstr.text;
778 }
779 }
780 else
781 namep = xstrdup (name);
782
783 return namep;
784 }
785
786 /* Expand DECL if it declares an entity not handled by the
787 common code. */
788
789 int
c_expand_decl(tree decl)790 c_expand_decl (tree decl)
791 {
792 if (TREE_CODE (decl) == VAR_DECL && !TREE_STATIC (decl))
793 {
794 /* Let the back-end know about this variable. */
795 if (!anon_aggr_type_p (TREE_TYPE (decl)))
796 emit_local_var (decl);
797 else
798 expand_anon_union_decl (decl, NULL_TREE,
799 DECL_ANON_UNION_ELEMS (decl));
800 }
801 else
802 return 0;
803
804 return 1;
805 }
806
807
808 /* Return the VAR_DECL for a const char array naming the current
809 function. If the VAR_DECL has not yet been created, create it
810 now. RID indicates how it should be formatted and IDENTIFIER_NODE
811 ID is its name (unfortunately C and C++ hold the RID values of
812 keywords in different places, so we can't derive RID from ID in
813 this language independent code. */
814
815 tree
fname_decl(unsigned int rid,tree id)816 fname_decl (unsigned int rid, tree id)
817 {
818 unsigned ix;
819 tree decl = NULL_TREE;
820
821 for (ix = 0; fname_vars[ix].decl; ix++)
822 if (fname_vars[ix].rid == rid)
823 break;
824
825 decl = *fname_vars[ix].decl;
826 if (!decl)
827 {
828 /* If a tree is built here, it would normally have the lineno of
829 the current statement. Later this tree will be moved to the
830 beginning of the function and this line number will be wrong.
831 To avoid this problem set the lineno to 0 here; that prevents
832 it from appearing in the RTL. */
833 tree stmts;
834 location_t saved_location = input_location;
835 #ifdef USE_MAPPED_LOCATION
836 input_location = UNKNOWN_LOCATION;
837 #else
838 input_line = 0;
839 #endif
840
841 stmts = push_stmt_list ();
842 decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
843 stmts = pop_stmt_list (stmts);
844 if (!IS_EMPTY_STMT (stmts))
845 saved_function_name_decls
846 = tree_cons (decl, stmts, saved_function_name_decls);
847 *fname_vars[ix].decl = decl;
848 input_location = saved_location;
849 }
850 if (!ix && !current_function_decl)
851 pedwarn ("%qD is not defined outside of function scope", decl);
852
853 return decl;
854 }
855
856 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
857
858 tree
fix_string_type(tree value)859 fix_string_type (tree value)
860 {
861 const int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
862 const int wide_flag = TREE_TYPE (value) == wchar_array_type_node;
863 int length = TREE_STRING_LENGTH (value);
864 int nchars;
865 tree e_type, i_type, a_type;
866
867 /* Compute the number of elements, for the array type. */
868 nchars = wide_flag ? length / wchar_bytes : length;
869
870 /* C89 2.2.4.1, C99 5.2.4.1 (Translation limits). The analogous
871 limit in C++98 Annex B is very large (65536) and is not normative,
872 so we do not diagnose it (warn_overlength_strings is forced off
873 in c_common_post_options). */
874 if (warn_overlength_strings)
875 {
876 const int nchars_max = flag_isoc99 ? 4095 : 509;
877 const int relevant_std = flag_isoc99 ? 99 : 90;
878 if (nchars - 1 > nchars_max)
879 /* Translators: The %d after 'ISO C' will be 90 or 99. Do not
880 separate the %d from the 'C'. 'ISO' should not be
881 translated, but it may be moved after 'C%d' in languages
882 where modifiers follow nouns. */
883 pedwarn ("string length %qd is greater than the length %qd "
884 "ISO C%d compilers are required to support",
885 nchars - 1, nchars_max, relevant_std);
886 }
887
888 /* Create the array type for the string constant. The ISO C++
889 standard says that a string literal has type `const char[N]' or
890 `const wchar_t[N]'. We use the same logic when invoked as a C
891 front-end with -Wwrite-strings.
892 ??? We should change the type of an expression depending on the
893 state of a warning flag. We should just be warning -- see how
894 this is handled in the C++ front-end for the deprecated implicit
895 conversion from string literals to `char*' or `wchar_t*'.
896
897 The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified
898 array type being the unqualified version of that type.
899 Therefore, if we are constructing an array of const char, we must
900 construct the matching unqualified array type first. The C front
901 end does not require this, but it does no harm, so we do it
902 unconditionally. */
903 e_type = wide_flag ? wchar_type_node : char_type_node;
904 i_type = build_index_type (build_int_cst (NULL_TREE, nchars - 1));
905 a_type = build_array_type (e_type, i_type);
906 if (c_dialect_cxx() || warn_write_strings)
907 a_type = c_build_qualified_type (a_type, TYPE_QUAL_CONST);
908
909 TREE_TYPE (value) = a_type;
910 TREE_CONSTANT (value) = 1;
911 TREE_INVARIANT (value) = 1;
912 TREE_READONLY (value) = 1;
913 TREE_STATIC (value) = 1;
914 return value;
915 }
916
917 /* Print a warning if a constant expression had overflow in folding.
918 Invoke this function on every expression that the language
919 requires to be a constant expression.
920 Note the ANSI C standard says it is erroneous for a
921 constant expression to overflow. */
922
923 void
constant_expression_warning(tree value)924 constant_expression_warning (tree value)
925 {
926 if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
927 || TREE_CODE (value) == VECTOR_CST
928 || TREE_CODE (value) == COMPLEX_CST)
929 && TREE_CONSTANT_OVERFLOW (value)
930 && warn_overflow
931 && pedantic)
932 pedwarn ("overflow in constant expression");
933 }
934
935 /* Print a warning if an expression had overflow in folding and its
936 operands hadn't.
937
938 Invoke this function on every expression that
939 (1) appears in the source code, and
940 (2) is a constant expression that overflowed, and
941 (3) is not already checked by convert_and_check;
942 however, do not invoke this function on operands of explicit casts
943 or when the expression is the result of an operator and any operand
944 already overflowed. */
945
946 void
overflow_warning(tree value)947 overflow_warning (tree value)
948 {
949 if (skip_evaluation) return;
950
951 switch (TREE_CODE (value))
952 {
953 case INTEGER_CST:
954 warning (OPT_Woverflow, "integer overflow in expression");
955 break;
956
957 case REAL_CST:
958 warning (OPT_Woverflow, "floating point overflow in expression");
959 break;
960
961 case VECTOR_CST:
962 warning (OPT_Woverflow, "vector overflow in expression");
963 break;
964
965 case COMPLEX_CST:
966 if (TREE_CODE (TREE_REALPART (value)) == INTEGER_CST)
967 warning (OPT_Woverflow, "complex integer overflow in expression");
968 else if (TREE_CODE (TREE_REALPART (value)) == REAL_CST)
969 warning (OPT_Woverflow, "complex floating point overflow in expression");
970 break;
971
972 default:
973 break;
974 }
975 }
976
977 /* Print a warning if a large constant is truncated to unsigned,
978 or if -Wconversion is used and a constant < 0 is converted to unsigned.
979 Invoke this function on every expression that might be implicitly
980 converted to an unsigned type. */
981
982 static void
unsigned_conversion_warning(tree result,tree operand)983 unsigned_conversion_warning (tree result, tree operand)
984 {
985 tree type = TREE_TYPE (result);
986
987 if (TREE_CODE (operand) == INTEGER_CST
988 && TREE_CODE (type) == INTEGER_TYPE
989 && TYPE_UNSIGNED (type)
990 && skip_evaluation == 0
991 && !int_fits_type_p (operand, type))
992 {
993 if (!int_fits_type_p (operand, c_common_signed_type (type)))
994 /* This detects cases like converting -129 or 256 to unsigned char. */
995 warning (OPT_Woverflow,
996 "large integer implicitly truncated to unsigned type");
997 else
998 warning (OPT_Wconversion,
999 "negative integer implicitly converted to unsigned type");
1000 }
1001 }
1002
1003 /* Print a warning about casts that might indicate violation
1004 of strict aliasing rules if -Wstrict-aliasing is used and
1005 strict aliasing mode is in effect. OTYPE is the original
1006 TREE_TYPE of EXPR, and TYPE the type we're casting to. */
1007
1008 bool
strict_aliasing_warning(tree otype,tree type,tree expr)1009 strict_aliasing_warning (tree otype, tree type, tree expr)
1010 {
1011 if (!(flag_strict_aliasing && POINTER_TYPE_P (type)
1012 && POINTER_TYPE_P (otype) && !VOID_TYPE_P (TREE_TYPE (type))))
1013 return false;
1014
1015 if ((warn_strict_aliasing > 1) && TREE_CODE (expr) == ADDR_EXPR
1016 && (DECL_P (TREE_OPERAND (expr, 0))
1017 || handled_component_p (TREE_OPERAND (expr, 0))))
1018 {
1019 /* Casting the address of an object to non void pointer. Warn
1020 if the cast breaks type based aliasing. */
1021 if (!COMPLETE_TYPE_P (TREE_TYPE (type)) && warn_strict_aliasing == 2)
1022 {
1023 warning (OPT_Wstrict_aliasing, "type-punning to incomplete type "
1024 "might break strict-aliasing rules");
1025 return true;
1026 }
1027 else
1028 {
1029 /* warn_strict_aliasing >= 3. This includes the default (3).
1030 Only warn if the cast is dereferenced immediately. */
1031 HOST_WIDE_INT set1 =
1032 get_alias_set (TREE_TYPE (TREE_OPERAND (expr, 0)));
1033 HOST_WIDE_INT set2 = get_alias_set (TREE_TYPE (type));
1034
1035 if (!alias_sets_conflict_p (set1, set2))
1036 {
1037 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1038 "pointer will break strict-aliasing rules");
1039 return true;
1040 }
1041 else if (warn_strict_aliasing == 2
1042 && !alias_sets_might_conflict_p (set1, set2))
1043 {
1044 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1045 "pointer might break strict-aliasing rules");
1046 return true;
1047 }
1048 }
1049 }
1050 else
1051 if ((warn_strict_aliasing == 1) && !VOID_TYPE_P (TREE_TYPE (otype)))
1052 {
1053 /* At this level, warn for any conversions, even if an address is
1054 not taken in the same statement. This will likely produce many
1055 false positives, but could be useful to pinpoint problems that
1056 are not revealed at higher levels. */
1057 HOST_WIDE_INT set1 = get_alias_set (TREE_TYPE (otype));
1058 HOST_WIDE_INT set2 = get_alias_set (TREE_TYPE (type));
1059 if (!COMPLETE_TYPE_P(type)
1060 || !alias_sets_might_conflict_p (set1, set2))
1061 {
1062 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1063 "pointer might break strict-aliasing rules");
1064 return true;
1065 }
1066 }
1067
1068 return false;
1069 }
1070
1071
1072 /* Print a warning about if (); or if () .. else; constructs
1073 via the special empty statement node that we create. INNER_THEN
1074 and INNER_ELSE are the statement lists of the if and the else
1075 block. */
1076
1077 void
empty_body_warning(tree inner_then,tree inner_else)1078 empty_body_warning (tree inner_then, tree inner_else)
1079 {
1080 if (extra_warnings)
1081 {
1082 if (TREE_CODE (inner_then) == STATEMENT_LIST
1083 && STATEMENT_LIST_TAIL (inner_then))
1084 inner_then = STATEMENT_LIST_TAIL (inner_then)->stmt;
1085
1086 if (inner_else && TREE_CODE (inner_else) == STATEMENT_LIST
1087 && STATEMENT_LIST_TAIL (inner_else))
1088 inner_else = STATEMENT_LIST_TAIL (inner_else)->stmt;
1089
1090 if (IS_EMPTY_STMT (inner_then) && !inner_else)
1091 warning (OPT_Wextra, "%Hempty body in an if-statement",
1092 EXPR_LOCUS (inner_then));
1093
1094 if (inner_else && IS_EMPTY_STMT (inner_else))
1095 warning (OPT_Wextra, "%Hempty body in an else-statement",
1096 EXPR_LOCUS (inner_else));
1097 }
1098 }
1099
1100
1101 /* Nonzero if constant C has a value that is permissible
1102 for type TYPE (an INTEGER_TYPE). */
1103
1104 static int
constant_fits_type_p(tree c,tree type)1105 constant_fits_type_p (tree c, tree type)
1106 {
1107 if (TREE_CODE (c) == INTEGER_CST)
1108 return int_fits_type_p (c, type);
1109
1110 c = convert (type, c);
1111 return !TREE_OVERFLOW (c);
1112 }
1113
1114
1115 /* True if vector types T1 and T2 can be converted to each other
1116 without an explicit cast. If EMIT_LAX_NOTE is true, and T1 and T2
1117 can only be converted with -flax-vector-conversions yet that is not
1118 in effect, emit a note telling the user about that option if such
1119 a note has not previously been emitted. */
1120 bool
vector_types_convertible_p(tree t1,tree t2,bool emit_lax_note)1121 vector_types_convertible_p (tree t1, tree t2, bool emit_lax_note)
1122 {
1123 static bool emitted_lax_note = false;
1124 bool convertible_lax;
1125
1126 if ((targetm.vector_opaque_p (t1) || targetm.vector_opaque_p (t2))
1127 && tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2)))
1128 return true;
1129
1130 convertible_lax =
1131 (tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2))
1132 && (TREE_CODE (TREE_TYPE (t1)) != REAL_TYPE ||
1133 TYPE_PRECISION (t1) == TYPE_PRECISION (t2))
1134 && (INTEGRAL_TYPE_P (TREE_TYPE (t1))
1135 == INTEGRAL_TYPE_P (TREE_TYPE (t2))));
1136
1137 if (!convertible_lax || flag_lax_vector_conversions)
1138 return convertible_lax;
1139
1140 if (TYPE_VECTOR_SUBPARTS (t1) == TYPE_VECTOR_SUBPARTS (t2)
1141 && comptypes (TREE_TYPE (t1), TREE_TYPE (t2)))
1142 return true;
1143
1144 if (emit_lax_note && !emitted_lax_note)
1145 {
1146 emitted_lax_note = true;
1147 inform ("use -flax-vector-conversions to permit "
1148 "conversions between vectors with differing "
1149 "element types or numbers of subparts");
1150 }
1151
1152 return false;
1153 }
1154
1155 /* Convert EXPR to TYPE, warning about conversion problems with constants.
1156 Invoke this function on every expression that is converted implicitly,
1157 i.e. because of language rules and not because of an explicit cast. */
1158
1159 tree
convert_and_check(tree type,tree expr)1160 convert_and_check (tree type, tree expr)
1161 {
1162 tree t = convert (type, expr);
1163 if (TREE_CODE (t) == INTEGER_CST)
1164 {
1165 if (TREE_OVERFLOW (t))
1166 {
1167 TREE_OVERFLOW (t) = 0;
1168
1169 /* Do not diagnose overflow in a constant expression merely
1170 because a conversion overflowed. */
1171 TREE_CONSTANT_OVERFLOW (t) = CONSTANT_CLASS_P (expr)
1172 && TREE_CONSTANT_OVERFLOW (expr);
1173
1174 /* No warning for converting 0x80000000 to int. */
1175 if (!(TYPE_UNSIGNED (type) < TYPE_UNSIGNED (TREE_TYPE (expr))
1176 && TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
1177 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr))))
1178 /* If EXPR fits in the unsigned version of TYPE,
1179 don't warn unless pedantic. */
1180 if ((pedantic
1181 || TYPE_UNSIGNED (type)
1182 || !constant_fits_type_p (expr,
1183 c_common_unsigned_type (type)))
1184 && skip_evaluation == 0)
1185 warning (OPT_Woverflow,
1186 "overflow in implicit constant conversion");
1187 }
1188 else
1189 unsigned_conversion_warning (t, expr);
1190 }
1191 return t;
1192 }
1193
1194 /* A node in a list that describes references to variables (EXPR), which are
1195 either read accesses if WRITER is zero, or write accesses, in which case
1196 WRITER is the parent of EXPR. */
1197 struct tlist
1198 {
1199 struct tlist *next;
1200 tree expr, writer;
1201 };
1202
1203 /* Used to implement a cache the results of a call to verify_tree. We only
1204 use this for SAVE_EXPRs. */
1205 struct tlist_cache
1206 {
1207 struct tlist_cache *next;
1208 struct tlist *cache_before_sp;
1209 struct tlist *cache_after_sp;
1210 tree expr;
1211 };
1212
1213 /* Obstack to use when allocating tlist structures, and corresponding
1214 firstobj. */
1215 static struct obstack tlist_obstack;
1216 static char *tlist_firstobj = 0;
1217
1218 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
1219 warnings. */
1220 static struct tlist *warned_ids;
1221 /* SAVE_EXPRs need special treatment. We process them only once and then
1222 cache the results. */
1223 static struct tlist_cache *save_expr_cache;
1224
1225 static void add_tlist (struct tlist **, struct tlist *, tree, int);
1226 static void merge_tlist (struct tlist **, struct tlist *, int);
1227 static void verify_tree (tree, struct tlist **, struct tlist **, tree);
1228 static int warning_candidate_p (tree);
1229 static void warn_for_collisions (struct tlist *);
1230 static void warn_for_collisions_1 (tree, tree, struct tlist *, int);
1231 static struct tlist *new_tlist (struct tlist *, tree, tree);
1232
1233 /* Create a new struct tlist and fill in its fields. */
1234 static struct tlist *
new_tlist(struct tlist * next,tree t,tree writer)1235 new_tlist (struct tlist *next, tree t, tree writer)
1236 {
1237 struct tlist *l;
1238 l = XOBNEW (&tlist_obstack, struct tlist);
1239 l->next = next;
1240 l->expr = t;
1241 l->writer = writer;
1242 return l;
1243 }
1244
1245 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
1246 is nonnull, we ignore any node we find which has a writer equal to it. */
1247
1248 static void
add_tlist(struct tlist ** to,struct tlist * add,tree exclude_writer,int copy)1249 add_tlist (struct tlist **to, struct tlist *add, tree exclude_writer, int copy)
1250 {
1251 while (add)
1252 {
1253 struct tlist *next = add->next;
1254 if (!copy)
1255 add->next = *to;
1256 if (!exclude_writer || add->writer != exclude_writer)
1257 *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
1258 add = next;
1259 }
1260 }
1261
1262 /* Merge the nodes of ADD into TO. This merging process is done so that for
1263 each variable that already exists in TO, no new node is added; however if
1264 there is a write access recorded in ADD, and an occurrence on TO is only
1265 a read access, then the occurrence in TO will be modified to record the
1266 write. */
1267
1268 static void
merge_tlist(struct tlist ** to,struct tlist * add,int copy)1269 merge_tlist (struct tlist **to, struct tlist *add, int copy)
1270 {
1271 struct tlist **end = to;
1272
1273 while (*end)
1274 end = &(*end)->next;
1275
1276 while (add)
1277 {
1278 int found = 0;
1279 struct tlist *tmp2;
1280 struct tlist *next = add->next;
1281
1282 for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
1283 if (tmp2->expr == add->expr)
1284 {
1285 found = 1;
1286 if (!tmp2->writer)
1287 tmp2->writer = add->writer;
1288 }
1289 if (!found)
1290 {
1291 *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
1292 end = &(*end)->next;
1293 *end = 0;
1294 }
1295 add = next;
1296 }
1297 }
1298
1299 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
1300 references in list LIST conflict with it, excluding reads if ONLY writers
1301 is nonzero. */
1302
1303 static void
warn_for_collisions_1(tree written,tree writer,struct tlist * list,int only_writes)1304 warn_for_collisions_1 (tree written, tree writer, struct tlist *list,
1305 int only_writes)
1306 {
1307 struct tlist *tmp;
1308
1309 /* Avoid duplicate warnings. */
1310 for (tmp = warned_ids; tmp; tmp = tmp->next)
1311 if (tmp->expr == written)
1312 return;
1313
1314 while (list)
1315 {
1316 if (list->expr == written
1317 && list->writer != writer
1318 && (!only_writes || list->writer)
1319 && DECL_NAME (list->expr))
1320 {
1321 warned_ids = new_tlist (warned_ids, written, NULL_TREE);
1322 warning (0, "operation on %qE may be undefined", list->expr);
1323 }
1324 list = list->next;
1325 }
1326 }
1327
1328 /* Given a list LIST of references to variables, find whether any of these
1329 can cause conflicts due to missing sequence points. */
1330
1331 static void
warn_for_collisions(struct tlist * list)1332 warn_for_collisions (struct tlist *list)
1333 {
1334 struct tlist *tmp;
1335
1336 for (tmp = list; tmp; tmp = tmp->next)
1337 {
1338 if (tmp->writer)
1339 warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
1340 }
1341 }
1342
1343 /* Return nonzero if X is a tree that can be verified by the sequence point
1344 warnings. */
1345 static int
warning_candidate_p(tree x)1346 warning_candidate_p (tree x)
1347 {
1348 return TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == PARM_DECL;
1349 }
1350
1351 /* Walk the tree X, and record accesses to variables. If X is written by the
1352 parent tree, WRITER is the parent.
1353 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
1354 expression or its only operand forces a sequence point, then everything up
1355 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
1356 in PNO_SP.
1357 Once we return, we will have emitted warnings if any subexpression before
1358 such a sequence point could be undefined. On a higher level, however, the
1359 sequence point may not be relevant, and we'll merge the two lists.
1360
1361 Example: (b++, a) + b;
1362 The call that processes the COMPOUND_EXPR will store the increment of B
1363 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
1364 processes the PLUS_EXPR will need to merge the two lists so that
1365 eventually, all accesses end up on the same list (and we'll warn about the
1366 unordered subexpressions b++ and b.
1367
1368 A note on merging. If we modify the former example so that our expression
1369 becomes
1370 (b++, b) + a
1371 care must be taken not simply to add all three expressions into the final
1372 PNO_SP list. The function merge_tlist takes care of that by merging the
1373 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1374 way, so that no more than one access to B is recorded. */
1375
1376 static void
verify_tree(tree x,struct tlist ** pbefore_sp,struct tlist ** pno_sp,tree writer)1377 verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp,
1378 tree writer)
1379 {
1380 struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
1381 enum tree_code code;
1382 enum tree_code_class cl;
1383
1384 /* X may be NULL if it is the operand of an empty statement expression
1385 ({ }). */
1386 if (x == NULL)
1387 return;
1388
1389 restart:
1390 code = TREE_CODE (x);
1391 cl = TREE_CODE_CLASS (code);
1392
1393 if (warning_candidate_p (x))
1394 {
1395 *pno_sp = new_tlist (*pno_sp, x, writer);
1396 return;
1397 }
1398
1399 switch (code)
1400 {
1401 case CONSTRUCTOR:
1402 return;
1403
1404 case COMPOUND_EXPR:
1405 case TRUTH_ANDIF_EXPR:
1406 case TRUTH_ORIF_EXPR:
1407 tmp_before = tmp_nosp = tmp_list3 = 0;
1408 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1409 warn_for_collisions (tmp_nosp);
1410 merge_tlist (pbefore_sp, tmp_before, 0);
1411 merge_tlist (pbefore_sp, tmp_nosp, 0);
1412 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
1413 merge_tlist (pbefore_sp, tmp_list3, 0);
1414 return;
1415
1416 case COND_EXPR:
1417 tmp_before = tmp_list2 = 0;
1418 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
1419 warn_for_collisions (tmp_list2);
1420 merge_tlist (pbefore_sp, tmp_before, 0);
1421 merge_tlist (pbefore_sp, tmp_list2, 1);
1422
1423 tmp_list3 = tmp_nosp = 0;
1424 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
1425 warn_for_collisions (tmp_nosp);
1426 merge_tlist (pbefore_sp, tmp_list3, 0);
1427
1428 tmp_list3 = tmp_list2 = 0;
1429 verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
1430 warn_for_collisions (tmp_list2);
1431 merge_tlist (pbefore_sp, tmp_list3, 0);
1432 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1433 two first, to avoid warning for (a ? b++ : b++). */
1434 merge_tlist (&tmp_nosp, tmp_list2, 0);
1435 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1436 return;
1437
1438 case PREDECREMENT_EXPR:
1439 case PREINCREMENT_EXPR:
1440 case POSTDECREMENT_EXPR:
1441 case POSTINCREMENT_EXPR:
1442 verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
1443 return;
1444
1445 case MODIFY_EXPR:
1446 tmp_before = tmp_nosp = tmp_list3 = 0;
1447 verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
1448 verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
1449 /* Expressions inside the LHS are not ordered wrt. the sequence points
1450 in the RHS. Example:
1451 *a = (a++, 2)
1452 Despite the fact that the modification of "a" is in the before_sp
1453 list (tmp_before), it conflicts with the use of "a" in the LHS.
1454 We can handle this by adding the contents of tmp_list3
1455 to those of tmp_before, and redoing the collision warnings for that
1456 list. */
1457 add_tlist (&tmp_before, tmp_list3, x, 1);
1458 warn_for_collisions (tmp_before);
1459 /* Exclude the LHS itself here; we first have to merge it into the
1460 tmp_nosp list. This is done to avoid warning for "a = a"; if we
1461 didn't exclude the LHS, we'd get it twice, once as a read and once
1462 as a write. */
1463 add_tlist (pno_sp, tmp_list3, x, 0);
1464 warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
1465
1466 merge_tlist (pbefore_sp, tmp_before, 0);
1467 if (warning_candidate_p (TREE_OPERAND (x, 0)))
1468 merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
1469 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
1470 return;
1471
1472 case CALL_EXPR:
1473 /* We need to warn about conflicts among arguments and conflicts between
1474 args and the function address. Side effects of the function address,
1475 however, are not ordered by the sequence point of the call. */
1476 tmp_before = tmp_nosp = tmp_list2 = tmp_list3 = 0;
1477 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1478 if (TREE_OPERAND (x, 1))
1479 verify_tree (TREE_OPERAND (x, 1), &tmp_list2, &tmp_list3, NULL_TREE);
1480 merge_tlist (&tmp_list3, tmp_list2, 0);
1481 add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
1482 add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
1483 warn_for_collisions (tmp_before);
1484 add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
1485 return;
1486
1487 case TREE_LIST:
1488 /* Scan all the list, e.g. indices of multi dimensional array. */
1489 while (x)
1490 {
1491 tmp_before = tmp_nosp = 0;
1492 verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
1493 merge_tlist (&tmp_nosp, tmp_before, 0);
1494 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1495 x = TREE_CHAIN (x);
1496 }
1497 return;
1498
1499 case SAVE_EXPR:
1500 {
1501 struct tlist_cache *t;
1502 for (t = save_expr_cache; t; t = t->next)
1503 if (t->expr == x)
1504 break;
1505
1506 if (!t)
1507 {
1508 t = XOBNEW (&tlist_obstack, struct tlist_cache);
1509 t->next = save_expr_cache;
1510 t->expr = x;
1511 save_expr_cache = t;
1512
1513 tmp_before = tmp_nosp = 0;
1514 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1515 warn_for_collisions (tmp_nosp);
1516
1517 tmp_list3 = 0;
1518 while (tmp_nosp)
1519 {
1520 struct tlist *t = tmp_nosp;
1521 tmp_nosp = t->next;
1522 merge_tlist (&tmp_list3, t, 0);
1523 }
1524 t->cache_before_sp = tmp_before;
1525 t->cache_after_sp = tmp_list3;
1526 }
1527 merge_tlist (pbefore_sp, t->cache_before_sp, 1);
1528 add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
1529 return;
1530 }
1531
1532 default:
1533 /* For other expressions, simply recurse on their operands.
1534 Manual tail recursion for unary expressions.
1535 Other non-expressions need not be processed. */
1536 if (cl == tcc_unary)
1537 {
1538 x = TREE_OPERAND (x, 0);
1539 writer = 0;
1540 goto restart;
1541 }
1542 else if (IS_EXPR_CODE_CLASS (cl))
1543 {
1544 int lp;
1545 int max = TREE_CODE_LENGTH (TREE_CODE (x));
1546 for (lp = 0; lp < max; lp++)
1547 {
1548 tmp_before = tmp_nosp = 0;
1549 verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, 0);
1550 merge_tlist (&tmp_nosp, tmp_before, 0);
1551 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1552 }
1553 }
1554 return;
1555 }
1556 }
1557
1558 /* Try to warn for undefined behavior in EXPR due to missing sequence
1559 points. */
1560
1561 void
verify_sequence_points(tree expr)1562 verify_sequence_points (tree expr)
1563 {
1564 struct tlist *before_sp = 0, *after_sp = 0;
1565
1566 warned_ids = 0;
1567 save_expr_cache = 0;
1568 if (tlist_firstobj == 0)
1569 {
1570 gcc_obstack_init (&tlist_obstack);
1571 tlist_firstobj = (char *) obstack_alloc (&tlist_obstack, 0);
1572 }
1573
1574 verify_tree (expr, &before_sp, &after_sp, 0);
1575 warn_for_collisions (after_sp);
1576 obstack_free (&tlist_obstack, tlist_firstobj);
1577 }
1578
1579 /* Validate the expression after `case' and apply default promotions. */
1580
1581 static tree
check_case_value(tree value)1582 check_case_value (tree value)
1583 {
1584 if (value == NULL_TREE)
1585 return value;
1586
1587 /* ??? Can we ever get nops here for a valid case value? We
1588 shouldn't for C. */
1589 STRIP_TYPE_NOPS (value);
1590 /* In C++, the following is allowed:
1591
1592 const int i = 3;
1593 switch (...) { case i: ... }
1594
1595 So, we try to reduce the VALUE to a constant that way. */
1596 if (c_dialect_cxx ())
1597 {
1598 value = decl_constant_value (value);
1599 STRIP_TYPE_NOPS (value);
1600 value = fold (value);
1601 }
1602
1603 if (TREE_CODE (value) == INTEGER_CST)
1604 /* Promote char or short to int. */
1605 value = perform_integral_promotions (value);
1606 else if (value != error_mark_node)
1607 {
1608 error ("case label does not reduce to an integer constant");
1609 value = error_mark_node;
1610 }
1611
1612 constant_expression_warning (value);
1613
1614 return value;
1615 }
1616
1617 /* See if the case values LOW and HIGH are in the range of the original
1618 type (i.e. before the default conversion to int) of the switch testing
1619 expression.
1620 TYPE is the promoted type of the testing expression, and ORIG_TYPE is
1621 the type before promoting it. CASE_LOW_P is a pointer to the lower
1622 bound of the case label, and CASE_HIGH_P is the upper bound or NULL
1623 if the case is not a case range.
1624 The caller has to make sure that we are not called with NULL for
1625 CASE_LOW_P (i.e. the default case).
1626 Returns true if the case label is in range of ORIG_TYPE (saturated or
1627 untouched) or false if the label is out of range. */
1628
1629 static bool
check_case_bounds(tree type,tree orig_type,tree * case_low_p,tree * case_high_p)1630 check_case_bounds (tree type, tree orig_type,
1631 tree *case_low_p, tree *case_high_p)
1632 {
1633 tree min_value, max_value;
1634 tree case_low = *case_low_p;
1635 tree case_high = case_high_p ? *case_high_p : case_low;
1636
1637 /* If there was a problem with the original type, do nothing. */
1638 if (orig_type == error_mark_node)
1639 return true;
1640
1641 min_value = TYPE_MIN_VALUE (orig_type);
1642 max_value = TYPE_MAX_VALUE (orig_type);
1643
1644 /* Case label is less than minimum for type. */
1645 if (tree_int_cst_compare (case_low, min_value) < 0
1646 && tree_int_cst_compare (case_high, min_value) < 0)
1647 {
1648 warning (0, "case label value is less than minimum value for type");
1649 return false;
1650 }
1651
1652 /* Case value is greater than maximum for type. */
1653 if (tree_int_cst_compare (case_low, max_value) > 0
1654 && tree_int_cst_compare (case_high, max_value) > 0)
1655 {
1656 warning (0, "case label value exceeds maximum value for type");
1657 return false;
1658 }
1659
1660 /* Saturate lower case label value to minimum. */
1661 if (tree_int_cst_compare (case_high, min_value) >= 0
1662 && tree_int_cst_compare (case_low, min_value) < 0)
1663 {
1664 warning (0, "lower value in case label range"
1665 " less than minimum value for type");
1666 case_low = min_value;
1667 }
1668
1669 /* Saturate upper case label value to maximum. */
1670 if (tree_int_cst_compare (case_low, max_value) <= 0
1671 && tree_int_cst_compare (case_high, max_value) > 0)
1672 {
1673 warning (0, "upper value in case label range"
1674 " exceeds maximum value for type");
1675 case_high = max_value;
1676 }
1677
1678 if (*case_low_p != case_low)
1679 *case_low_p = convert (type, case_low);
1680 if (case_high_p && *case_high_p != case_high)
1681 *case_high_p = convert (type, case_high);
1682
1683 return true;
1684 }
1685
1686 /* Return an integer type with BITS bits of precision,
1687 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1688
1689 tree
c_common_type_for_size(unsigned int bits,int unsignedp)1690 c_common_type_for_size (unsigned int bits, int unsignedp)
1691 {
1692 if (bits == TYPE_PRECISION (integer_type_node))
1693 return unsignedp ? unsigned_type_node : integer_type_node;
1694
1695 if (bits == TYPE_PRECISION (signed_char_type_node))
1696 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1697
1698 if (bits == TYPE_PRECISION (short_integer_type_node))
1699 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1700
1701 if (bits == TYPE_PRECISION (long_integer_type_node))
1702 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1703
1704 if (bits == TYPE_PRECISION (long_long_integer_type_node))
1705 return (unsignedp ? long_long_unsigned_type_node
1706 : long_long_integer_type_node);
1707
1708 if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
1709 return (unsignedp ? widest_unsigned_literal_type_node
1710 : widest_integer_literal_type_node);
1711
1712 if (bits <= TYPE_PRECISION (intQI_type_node))
1713 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1714
1715 if (bits <= TYPE_PRECISION (intHI_type_node))
1716 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1717
1718 if (bits <= TYPE_PRECISION (intSI_type_node))
1719 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1720
1721 if (bits <= TYPE_PRECISION (intDI_type_node))
1722 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1723
1724 return 0;
1725 }
1726
1727 /* Used for communication between c_common_type_for_mode and
1728 c_register_builtin_type. */
1729 static GTY(()) tree registered_builtin_types;
1730
1731 /* Return a data type that has machine mode MODE.
1732 If the mode is an integer,
1733 then UNSIGNEDP selects between signed and unsigned types. */
1734
1735 tree
c_common_type_for_mode(enum machine_mode mode,int unsignedp)1736 c_common_type_for_mode (enum machine_mode mode, int unsignedp)
1737 {
1738 tree t;
1739
1740 if (mode == TYPE_MODE (integer_type_node))
1741 return unsignedp ? unsigned_type_node : integer_type_node;
1742
1743 if (mode == TYPE_MODE (signed_char_type_node))
1744 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1745
1746 if (mode == TYPE_MODE (short_integer_type_node))
1747 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1748
1749 if (mode == TYPE_MODE (long_integer_type_node))
1750 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1751
1752 if (mode == TYPE_MODE (long_long_integer_type_node))
1753 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
1754
1755 if (mode == TYPE_MODE (widest_integer_literal_type_node))
1756 return unsignedp ? widest_unsigned_literal_type_node
1757 : widest_integer_literal_type_node;
1758
1759 if (mode == QImode)
1760 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1761
1762 if (mode == HImode)
1763 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1764
1765 if (mode == SImode)
1766 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1767
1768 if (mode == DImode)
1769 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1770
1771 #if HOST_BITS_PER_WIDE_INT >= 64
1772 if (mode == TYPE_MODE (intTI_type_node))
1773 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1774 #endif
1775
1776 if (mode == TYPE_MODE (float_type_node))
1777 return float_type_node;
1778
1779 if (mode == TYPE_MODE (double_type_node))
1780 return double_type_node;
1781
1782 if (mode == TYPE_MODE (long_double_type_node))
1783 return long_double_type_node;
1784
1785 if (mode == TYPE_MODE (void_type_node))
1786 return void_type_node;
1787
1788 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
1789 return (unsignedp
1790 ? make_unsigned_type (GET_MODE_PRECISION (mode))
1791 : make_signed_type (GET_MODE_PRECISION (mode)));
1792
1793 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
1794 return (unsignedp
1795 ? make_unsigned_type (GET_MODE_PRECISION (mode))
1796 : make_signed_type (GET_MODE_PRECISION (mode)));
1797
1798 if (COMPLEX_MODE_P (mode))
1799 {
1800 enum machine_mode inner_mode;
1801 tree inner_type;
1802
1803 if (mode == TYPE_MODE (complex_float_type_node))
1804 return complex_float_type_node;
1805 if (mode == TYPE_MODE (complex_double_type_node))
1806 return complex_double_type_node;
1807 if (mode == TYPE_MODE (complex_long_double_type_node))
1808 return complex_long_double_type_node;
1809
1810 if (mode == TYPE_MODE (complex_integer_type_node) && !unsignedp)
1811 return complex_integer_type_node;
1812
1813 inner_mode = GET_MODE_INNER (mode);
1814 inner_type = c_common_type_for_mode (inner_mode, unsignedp);
1815 if (inner_type != NULL_TREE)
1816 return build_complex_type (inner_type);
1817 }
1818 else if (VECTOR_MODE_P (mode))
1819 {
1820 enum machine_mode inner_mode = GET_MODE_INNER (mode);
1821 tree inner_type = c_common_type_for_mode (inner_mode, unsignedp);
1822 if (inner_type != NULL_TREE)
1823 return build_vector_type_for_mode (inner_type, mode);
1824 }
1825
1826 if (mode == TYPE_MODE (dfloat32_type_node))
1827 return dfloat32_type_node;
1828 if (mode == TYPE_MODE (dfloat64_type_node))
1829 return dfloat64_type_node;
1830 if (mode == TYPE_MODE (dfloat128_type_node))
1831 return dfloat128_type_node;
1832
1833 for (t = registered_builtin_types; t; t = TREE_CHAIN (t))
1834 if (TYPE_MODE (TREE_VALUE (t)) == mode)
1835 return TREE_VALUE (t);
1836
1837 return 0;
1838 }
1839
1840 /* Return an unsigned type the same as TYPE in other respects. */
1841 tree
c_common_unsigned_type(tree type)1842 c_common_unsigned_type (tree type)
1843 {
1844 tree type1 = TYPE_MAIN_VARIANT (type);
1845 if (type1 == signed_char_type_node || type1 == char_type_node)
1846 return unsigned_char_type_node;
1847 if (type1 == integer_type_node)
1848 return unsigned_type_node;
1849 if (type1 == short_integer_type_node)
1850 return short_unsigned_type_node;
1851 if (type1 == long_integer_type_node)
1852 return long_unsigned_type_node;
1853 if (type1 == long_long_integer_type_node)
1854 return long_long_unsigned_type_node;
1855 if (type1 == widest_integer_literal_type_node)
1856 return widest_unsigned_literal_type_node;
1857 #if HOST_BITS_PER_WIDE_INT >= 64
1858 if (type1 == intTI_type_node)
1859 return unsigned_intTI_type_node;
1860 #endif
1861 if (type1 == intDI_type_node)
1862 return unsigned_intDI_type_node;
1863 if (type1 == intSI_type_node)
1864 return unsigned_intSI_type_node;
1865 if (type1 == intHI_type_node)
1866 return unsigned_intHI_type_node;
1867 if (type1 == intQI_type_node)
1868 return unsigned_intQI_type_node;
1869
1870 return c_common_signed_or_unsigned_type (1, type);
1871 }
1872
1873 /* Return a signed type the same as TYPE in other respects. */
1874
1875 tree
c_common_signed_type(tree type)1876 c_common_signed_type (tree type)
1877 {
1878 tree type1 = TYPE_MAIN_VARIANT (type);
1879 if (type1 == unsigned_char_type_node || type1 == char_type_node)
1880 return signed_char_type_node;
1881 if (type1 == unsigned_type_node)
1882 return integer_type_node;
1883 if (type1 == short_unsigned_type_node)
1884 return short_integer_type_node;
1885 if (type1 == long_unsigned_type_node)
1886 return long_integer_type_node;
1887 if (type1 == long_long_unsigned_type_node)
1888 return long_long_integer_type_node;
1889 if (type1 == widest_unsigned_literal_type_node)
1890 return widest_integer_literal_type_node;
1891 #if HOST_BITS_PER_WIDE_INT >= 64
1892 if (type1 == unsigned_intTI_type_node)
1893 return intTI_type_node;
1894 #endif
1895 if (type1 == unsigned_intDI_type_node)
1896 return intDI_type_node;
1897 if (type1 == unsigned_intSI_type_node)
1898 return intSI_type_node;
1899 if (type1 == unsigned_intHI_type_node)
1900 return intHI_type_node;
1901 if (type1 == unsigned_intQI_type_node)
1902 return intQI_type_node;
1903
1904 return c_common_signed_or_unsigned_type (0, type);
1905 }
1906
1907 /* Return a type the same as TYPE except unsigned or
1908 signed according to UNSIGNEDP. */
1909
1910 tree
c_common_signed_or_unsigned_type(int unsignedp,tree type)1911 c_common_signed_or_unsigned_type (int unsignedp, tree type)
1912 {
1913 if (!INTEGRAL_TYPE_P (type)
1914 || TYPE_UNSIGNED (type) == unsignedp)
1915 return type;
1916
1917 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
1918 the precision; they have precision set to match their range, but
1919 may use a wider mode to match an ABI. If we change modes, we may
1920 wind up with bad conversions. For INTEGER_TYPEs in C, must check
1921 the precision as well, so as to yield correct results for
1922 bit-field types. C++ does not have these separate bit-field
1923 types, and producing a signed or unsigned variant of an
1924 ENUMERAL_TYPE may cause other problems as well. */
1925
1926 #define TYPE_OK(node) \
1927 (TYPE_MODE (type) == TYPE_MODE (node) \
1928 && (c_dialect_cxx () || TYPE_PRECISION (type) == TYPE_PRECISION (node)))
1929 if (TYPE_OK (signed_char_type_node))
1930 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1931 if (TYPE_OK (integer_type_node))
1932 return unsignedp ? unsigned_type_node : integer_type_node;
1933 if (TYPE_OK (short_integer_type_node))
1934 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1935 if (TYPE_OK (long_integer_type_node))
1936 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1937 if (TYPE_OK (long_long_integer_type_node))
1938 return (unsignedp ? long_long_unsigned_type_node
1939 : long_long_integer_type_node);
1940 if (TYPE_OK (widest_integer_literal_type_node))
1941 return (unsignedp ? widest_unsigned_literal_type_node
1942 : widest_integer_literal_type_node);
1943
1944 #if HOST_BITS_PER_WIDE_INT >= 64
1945 if (TYPE_OK (intTI_type_node))
1946 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1947 #endif
1948 if (TYPE_OK (intDI_type_node))
1949 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1950 if (TYPE_OK (intSI_type_node))
1951 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1952 if (TYPE_OK (intHI_type_node))
1953 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1954 if (TYPE_OK (intQI_type_node))
1955 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1956 #undef TYPE_OK
1957
1958 if (c_dialect_cxx ())
1959 return type;
1960 else
1961 return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
1962 }
1963
1964 /* Build a bit-field integer type for the given WIDTH and UNSIGNEDP. */
1965
1966 tree
c_build_bitfield_integer_type(unsigned HOST_WIDE_INT width,int unsignedp)1967 c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width, int unsignedp)
1968 {
1969 /* Extended integer types of the same width as a standard type have
1970 lesser rank, so those of the same width as int promote to int or
1971 unsigned int and are valid for printf formats expecting int or
1972 unsigned int. To avoid such special cases, avoid creating
1973 extended integer types for bit-fields if a standard integer type
1974 is available. */
1975 if (width == TYPE_PRECISION (integer_type_node))
1976 return unsignedp ? unsigned_type_node : integer_type_node;
1977 if (width == TYPE_PRECISION (signed_char_type_node))
1978 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1979 if (width == TYPE_PRECISION (short_integer_type_node))
1980 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1981 if (width == TYPE_PRECISION (long_integer_type_node))
1982 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1983 if (width == TYPE_PRECISION (long_long_integer_type_node))
1984 return (unsignedp ? long_long_unsigned_type_node
1985 : long_long_integer_type_node);
1986 return build_nonstandard_integer_type (width, unsignedp);
1987 }
1988
1989 /* The C version of the register_builtin_type langhook. */
1990
1991 void
c_register_builtin_type(tree type,const char * name)1992 c_register_builtin_type (tree type, const char* name)
1993 {
1994 tree decl;
1995
1996 decl = build_decl (TYPE_DECL, get_identifier (name), type);
1997 DECL_ARTIFICIAL (decl) = 1;
1998 if (!TYPE_NAME (type))
1999 TYPE_NAME (type) = decl;
2000 pushdecl (decl);
2001
2002 registered_builtin_types = tree_cons (0, type, registered_builtin_types);
2003 }
2004
2005
2006 /* Return the minimum number of bits needed to represent VALUE in a
2007 signed or unsigned type, UNSIGNEDP says which. */
2008
2009 unsigned int
min_precision(tree value,int unsignedp)2010 min_precision (tree value, int unsignedp)
2011 {
2012 int log;
2013
2014 /* If the value is negative, compute its negative minus 1. The latter
2015 adjustment is because the absolute value of the largest negative value
2016 is one larger than the largest positive value. This is equivalent to
2017 a bit-wise negation, so use that operation instead. */
2018
2019 if (tree_int_cst_sgn (value) < 0)
2020 value = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (value), value);
2021
2022 /* Return the number of bits needed, taking into account the fact
2023 that we need one more bit for a signed than unsigned type. */
2024
2025 if (integer_zerop (value))
2026 log = 0;
2027 else
2028 log = tree_floor_log2 (value);
2029
2030 return log + 1 + !unsignedp;
2031 }
2032
2033 /* Print an error message for invalid operands to arith operation
2034 CODE with TYPE0 for operand 0, and TYPE1 for operand 1. */
2035
2036 void
binary_op_error(enum tree_code code,tree type0,tree type1)2037 binary_op_error (enum tree_code code, tree type0, tree type1)
2038 {
2039 const char *opname;
2040
2041 switch (code)
2042 {
2043 case PLUS_EXPR:
2044 opname = "+"; break;
2045 case MINUS_EXPR:
2046 opname = "-"; break;
2047 case MULT_EXPR:
2048 opname = "*"; break;
2049 case MAX_EXPR:
2050 opname = "max"; break;
2051 case MIN_EXPR:
2052 opname = "min"; break;
2053 case EQ_EXPR:
2054 opname = "=="; break;
2055 case NE_EXPR:
2056 opname = "!="; break;
2057 case LE_EXPR:
2058 opname = "<="; break;
2059 case GE_EXPR:
2060 opname = ">="; break;
2061 case LT_EXPR:
2062 opname = "<"; break;
2063 case GT_EXPR:
2064 opname = ">"; break;
2065 case LSHIFT_EXPR:
2066 opname = "<<"; break;
2067 case RSHIFT_EXPR:
2068 opname = ">>"; break;
2069 case TRUNC_MOD_EXPR:
2070 case FLOOR_MOD_EXPR:
2071 opname = "%"; break;
2072 case TRUNC_DIV_EXPR:
2073 case FLOOR_DIV_EXPR:
2074 opname = "/"; break;
2075 case BIT_AND_EXPR:
2076 opname = "&"; break;
2077 case BIT_IOR_EXPR:
2078 opname = "|"; break;
2079 case TRUTH_ANDIF_EXPR:
2080 opname = "&&"; break;
2081 case TRUTH_ORIF_EXPR:
2082 opname = "||"; break;
2083 case BIT_XOR_EXPR:
2084 opname = "^"; break;
2085 default:
2086 gcc_unreachable ();
2087 }
2088 error ("invalid operands to binary %s (have %qT and %qT)", opname,
2089 type0, type1);
2090 }
2091
2092 /* Subroutine of build_binary_op, used for comparison operations.
2093 See if the operands have both been converted from subword integer types
2094 and, if so, perhaps change them both back to their original type.
2095 This function is also responsible for converting the two operands
2096 to the proper common type for comparison.
2097
2098 The arguments of this function are all pointers to local variables
2099 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2100 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2101
2102 If this function returns nonzero, it means that the comparison has
2103 a constant value. What this function returns is an expression for
2104 that value. */
2105
2106 tree
shorten_compare(tree * op0_ptr,tree * op1_ptr,tree * restype_ptr,enum tree_code * rescode_ptr)2107 shorten_compare (tree *op0_ptr, tree *op1_ptr, tree *restype_ptr,
2108 enum tree_code *rescode_ptr)
2109 {
2110 tree type;
2111 tree op0 = *op0_ptr;
2112 tree op1 = *op1_ptr;
2113 int unsignedp0, unsignedp1;
2114 int real1, real2;
2115 tree primop0, primop1;
2116 enum tree_code code = *rescode_ptr;
2117
2118 /* Throw away any conversions to wider types
2119 already present in the operands. */
2120
2121 primop0 = get_narrower (op0, &unsignedp0);
2122 primop1 = get_narrower (op1, &unsignedp1);
2123
2124 /* Handle the case that OP0 does not *contain* a conversion
2125 but it *requires* conversion to FINAL_TYPE. */
2126
2127 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
2128 unsignedp0 = TYPE_UNSIGNED (TREE_TYPE (op0));
2129 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
2130 unsignedp1 = TYPE_UNSIGNED (TREE_TYPE (op1));
2131
2132 /* If one of the operands must be floated, we cannot optimize. */
2133 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
2134 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
2135
2136 /* If first arg is constant, swap the args (changing operation
2137 so value is preserved), for canonicalization. Don't do this if
2138 the second arg is 0. */
2139
2140 if (TREE_CONSTANT (primop0)
2141 && !integer_zerop (primop1) && !real_zerop (primop1))
2142 {
2143 tree tem = primop0;
2144 int temi = unsignedp0;
2145 primop0 = primop1;
2146 primop1 = tem;
2147 tem = op0;
2148 op0 = op1;
2149 op1 = tem;
2150 *op0_ptr = op0;
2151 *op1_ptr = op1;
2152 unsignedp0 = unsignedp1;
2153 unsignedp1 = temi;
2154 temi = real1;
2155 real1 = real2;
2156 real2 = temi;
2157
2158 switch (code)
2159 {
2160 case LT_EXPR:
2161 code = GT_EXPR;
2162 break;
2163 case GT_EXPR:
2164 code = LT_EXPR;
2165 break;
2166 case LE_EXPR:
2167 code = GE_EXPR;
2168 break;
2169 case GE_EXPR:
2170 code = LE_EXPR;
2171 break;
2172 default:
2173 break;
2174 }
2175 *rescode_ptr = code;
2176 }
2177
2178 /* If comparing an integer against a constant more bits wide,
2179 maybe we can deduce a value of 1 or 0 independent of the data.
2180 Or else truncate the constant now
2181 rather than extend the variable at run time.
2182
2183 This is only interesting if the constant is the wider arg.
2184 Also, it is not safe if the constant is unsigned and the
2185 variable arg is signed, since in this case the variable
2186 would be sign-extended and then regarded as unsigned.
2187 Our technique fails in this case because the lowest/highest
2188 possible unsigned results don't follow naturally from the
2189 lowest/highest possible values of the variable operand.
2190 For just EQ_EXPR and NE_EXPR there is another technique that
2191 could be used: see if the constant can be faithfully represented
2192 in the other operand's type, by truncating it and reextending it
2193 and see if that preserves the constant's value. */
2194
2195 if (!real1 && !real2
2196 && TREE_CODE (primop1) == INTEGER_CST
2197 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
2198 {
2199 int min_gt, max_gt, min_lt, max_lt;
2200 tree maxval, minval;
2201 /* 1 if comparison is nominally unsigned. */
2202 int unsignedp = TYPE_UNSIGNED (*restype_ptr);
2203 tree val;
2204
2205 type = c_common_signed_or_unsigned_type (unsignedp0,
2206 TREE_TYPE (primop0));
2207
2208 maxval = TYPE_MAX_VALUE (type);
2209 minval = TYPE_MIN_VALUE (type);
2210
2211 if (unsignedp && !unsignedp0)
2212 *restype_ptr = c_common_signed_type (*restype_ptr);
2213
2214 if (TREE_TYPE (primop1) != *restype_ptr)
2215 {
2216 /* Convert primop1 to target type, but do not introduce
2217 additional overflow. We know primop1 is an int_cst. */
2218 tree tmp = build_int_cst_wide (*restype_ptr,
2219 TREE_INT_CST_LOW (primop1),
2220 TREE_INT_CST_HIGH (primop1));
2221
2222 primop1 = force_fit_type (tmp, 0, TREE_OVERFLOW (primop1),
2223 TREE_CONSTANT_OVERFLOW (primop1));
2224 }
2225 if (type != *restype_ptr)
2226 {
2227 minval = convert (*restype_ptr, minval);
2228 maxval = convert (*restype_ptr, maxval);
2229 }
2230
2231 if (unsignedp && unsignedp0)
2232 {
2233 min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
2234 max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
2235 min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
2236 max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
2237 }
2238 else
2239 {
2240 min_gt = INT_CST_LT (primop1, minval);
2241 max_gt = INT_CST_LT (primop1, maxval);
2242 min_lt = INT_CST_LT (minval, primop1);
2243 max_lt = INT_CST_LT (maxval, primop1);
2244 }
2245
2246 val = 0;
2247 /* This used to be a switch, but Genix compiler can't handle that. */
2248 if (code == NE_EXPR)
2249 {
2250 if (max_lt || min_gt)
2251 val = truthvalue_true_node;
2252 }
2253 else if (code == EQ_EXPR)
2254 {
2255 if (max_lt || min_gt)
2256 val = truthvalue_false_node;
2257 }
2258 else if (code == LT_EXPR)
2259 {
2260 if (max_lt)
2261 val = truthvalue_true_node;
2262 if (!min_lt)
2263 val = truthvalue_false_node;
2264 }
2265 else if (code == GT_EXPR)
2266 {
2267 if (min_gt)
2268 val = truthvalue_true_node;
2269 if (!max_gt)
2270 val = truthvalue_false_node;
2271 }
2272 else if (code == LE_EXPR)
2273 {
2274 if (!max_gt)
2275 val = truthvalue_true_node;
2276 if (min_gt)
2277 val = truthvalue_false_node;
2278 }
2279 else if (code == GE_EXPR)
2280 {
2281 if (!min_lt)
2282 val = truthvalue_true_node;
2283 if (max_lt)
2284 val = truthvalue_false_node;
2285 }
2286
2287 /* If primop0 was sign-extended and unsigned comparison specd,
2288 we did a signed comparison above using the signed type bounds.
2289 But the comparison we output must be unsigned.
2290
2291 Also, for inequalities, VAL is no good; but if the signed
2292 comparison had *any* fixed result, it follows that the
2293 unsigned comparison just tests the sign in reverse
2294 (positive values are LE, negative ones GE).
2295 So we can generate an unsigned comparison
2296 against an extreme value of the signed type. */
2297
2298 if (unsignedp && !unsignedp0)
2299 {
2300 if (val != 0)
2301 switch (code)
2302 {
2303 case LT_EXPR:
2304 case GE_EXPR:
2305 primop1 = TYPE_MIN_VALUE (type);
2306 val = 0;
2307 break;
2308
2309 case LE_EXPR:
2310 case GT_EXPR:
2311 primop1 = TYPE_MAX_VALUE (type);
2312 val = 0;
2313 break;
2314
2315 default:
2316 break;
2317 }
2318 type = c_common_unsigned_type (type);
2319 }
2320
2321 if (TREE_CODE (primop0) != INTEGER_CST)
2322 {
2323 if (val == truthvalue_false_node)
2324 warning (0, "comparison is always false due to limited range of data type");
2325 if (val == truthvalue_true_node)
2326 warning (0, "comparison is always true due to limited range of data type");
2327 }
2328
2329 if (val != 0)
2330 {
2331 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2332 if (TREE_SIDE_EFFECTS (primop0))
2333 return build2 (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
2334 return val;
2335 }
2336
2337 /* Value is not predetermined, but do the comparison
2338 in the type of the operand that is not constant.
2339 TYPE is already properly set. */
2340 }
2341
2342 /* If either arg is decimal float and the other is float, find the
2343 proper common type to use for comparison. */
2344 else if (real1 && real2
2345 && (DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0)))
2346 || DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1)))))
2347 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2348
2349 else if (real1 && real2
2350 && (TYPE_PRECISION (TREE_TYPE (primop0))
2351 == TYPE_PRECISION (TREE_TYPE (primop1))))
2352 type = TREE_TYPE (primop0);
2353
2354 /* If args' natural types are both narrower than nominal type
2355 and both extend in the same manner, compare them
2356 in the type of the wider arg.
2357 Otherwise must actually extend both to the nominal
2358 common type lest different ways of extending
2359 alter the result.
2360 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
2361
2362 else if (unsignedp0 == unsignedp1 && real1 == real2
2363 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
2364 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
2365 {
2366 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2367 type = c_common_signed_or_unsigned_type (unsignedp0
2368 || TYPE_UNSIGNED (*restype_ptr),
2369 type);
2370 /* Make sure shorter operand is extended the right way
2371 to match the longer operand. */
2372 primop0
2373 = convert (c_common_signed_or_unsigned_type (unsignedp0,
2374 TREE_TYPE (primop0)),
2375 primop0);
2376 primop1
2377 = convert (c_common_signed_or_unsigned_type (unsignedp1,
2378 TREE_TYPE (primop1)),
2379 primop1);
2380 }
2381 else
2382 {
2383 /* Here we must do the comparison on the nominal type
2384 using the args exactly as we received them. */
2385 type = *restype_ptr;
2386 primop0 = op0;
2387 primop1 = op1;
2388
2389 if (!real1 && !real2 && integer_zerop (primop1)
2390 && TYPE_UNSIGNED (*restype_ptr))
2391 {
2392 tree value = 0;
2393 switch (code)
2394 {
2395 case GE_EXPR:
2396 /* All unsigned values are >= 0, so we warn if extra warnings
2397 are requested. However, if OP0 is a constant that is
2398 >= 0, the signedness of the comparison isn't an issue,
2399 so suppress the warning. */
2400 if (extra_warnings && !in_system_header
2401 && !(TREE_CODE (primop0) == INTEGER_CST
2402 && !TREE_OVERFLOW (convert (c_common_signed_type (type),
2403 primop0))))
2404 warning (0, "comparison of unsigned expression >= 0 is always true");
2405 value = truthvalue_true_node;
2406 break;
2407
2408 case LT_EXPR:
2409 if (extra_warnings && !in_system_header
2410 && !(TREE_CODE (primop0) == INTEGER_CST
2411 && !TREE_OVERFLOW (convert (c_common_signed_type (type),
2412 primop0))))
2413 warning (0, "comparison of unsigned expression < 0 is always false");
2414 value = truthvalue_false_node;
2415 break;
2416
2417 default:
2418 break;
2419 }
2420
2421 if (value != 0)
2422 {
2423 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2424 if (TREE_SIDE_EFFECTS (primop0))
2425 return build2 (COMPOUND_EXPR, TREE_TYPE (value),
2426 primop0, value);
2427 return value;
2428 }
2429 }
2430 }
2431
2432 *op0_ptr = convert (type, primop0);
2433 *op1_ptr = convert (type, primop1);
2434
2435 *restype_ptr = truthvalue_type_node;
2436
2437 return 0;
2438 }
2439
2440 /* Return a tree for the sum or difference (RESULTCODE says which)
2441 of pointer PTROP and integer INTOP. */
2442
2443 tree
pointer_int_sum(enum tree_code resultcode,tree ptrop,tree intop)2444 pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
2445 {
2446 tree size_exp, ret;
2447
2448 /* The result is a pointer of the same type that is being added. */
2449
2450 tree result_type = TREE_TYPE (ptrop);
2451
2452 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
2453 {
2454 if (pedantic || warn_pointer_arith)
2455 pedwarn ("pointer of type %<void *%> used in arithmetic");
2456 size_exp = integer_one_node;
2457 }
2458 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
2459 {
2460 if (pedantic || warn_pointer_arith)
2461 pedwarn ("pointer to a function used in arithmetic");
2462 size_exp = integer_one_node;
2463 }
2464 else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
2465 {
2466 if (pedantic || warn_pointer_arith)
2467 pedwarn ("pointer to member function used in arithmetic");
2468 size_exp = integer_one_node;
2469 }
2470 else
2471 size_exp = size_in_bytes (TREE_TYPE (result_type));
2472
2473 /* We are manipulating pointer values, so we don't need to warn
2474 about relying on undefined signed overflow. We disable the
2475 warning here because we use integer types so fold won't know that
2476 they are really pointers. */
2477 fold_defer_overflow_warnings ();
2478
2479 /* If what we are about to multiply by the size of the elements
2480 contains a constant term, apply distributive law
2481 and multiply that constant term separately.
2482 This helps produce common subexpressions. */
2483
2484 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
2485 && !TREE_CONSTANT (intop)
2486 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
2487 && TREE_CONSTANT (size_exp)
2488 /* If the constant comes from pointer subtraction,
2489 skip this optimization--it would cause an error. */
2490 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
2491 /* If the constant is unsigned, and smaller than the pointer size,
2492 then we must skip this optimization. This is because it could cause
2493 an overflow error if the constant is negative but INTOP is not. */
2494 && (!TYPE_UNSIGNED (TREE_TYPE (intop))
2495 || (TYPE_PRECISION (TREE_TYPE (intop))
2496 == TYPE_PRECISION (TREE_TYPE (ptrop)))))
2497 {
2498 enum tree_code subcode = resultcode;
2499 tree int_type = TREE_TYPE (intop);
2500 if (TREE_CODE (intop) == MINUS_EXPR)
2501 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
2502 /* Convert both subexpression types to the type of intop,
2503 because weird cases involving pointer arithmetic
2504 can result in a sum or difference with different type args. */
2505 ptrop = build_binary_op (subcode, ptrop,
2506 convert (int_type, TREE_OPERAND (intop, 1)), 1);
2507 intop = convert (int_type, TREE_OPERAND (intop, 0));
2508 }
2509
2510 /* Convert the integer argument to a type the same size as sizetype
2511 so the multiply won't overflow spuriously. */
2512
2513 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
2514 || TYPE_UNSIGNED (TREE_TYPE (intop)) != TYPE_UNSIGNED (sizetype))
2515 intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
2516 TYPE_UNSIGNED (sizetype)), intop);
2517
2518 /* Replace the integer argument with a suitable product by the object size.
2519 Do this multiplication as signed, then convert to the appropriate
2520 pointer type (actually unsigned integral). */
2521
2522 intop = convert (result_type,
2523 build_binary_op (MULT_EXPR, intop,
2524 convert (TREE_TYPE (intop), size_exp), 1));
2525
2526 /* Create the sum or difference. */
2527 ret = fold_build2 (resultcode, result_type, ptrop, intop);
2528
2529 fold_undefer_and_ignore_overflow_warnings ();
2530
2531 return ret;
2532 }
2533
2534 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2535 or for an `if' or `while' statement or ?..: exp. It should already
2536 have been validated to be of suitable type; otherwise, a bad
2537 diagnostic may result.
2538
2539 This preparation consists of taking the ordinary
2540 representation of an expression expr and producing a valid tree
2541 boolean expression describing whether expr is nonzero. We could
2542 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
2543 but we optimize comparisons, &&, ||, and !.
2544
2545 The resulting type should always be `truthvalue_type_node'. */
2546
2547 tree
c_common_truthvalue_conversion(tree expr)2548 c_common_truthvalue_conversion (tree expr)
2549 {
2550 switch (TREE_CODE (expr))
2551 {
2552 case EQ_EXPR: case NE_EXPR: case UNEQ_EXPR: case LTGT_EXPR:
2553 case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
2554 case UNLE_EXPR: case UNGE_EXPR: case UNLT_EXPR: case UNGT_EXPR:
2555 case ORDERED_EXPR: case UNORDERED_EXPR:
2556 if (TREE_TYPE (expr) == truthvalue_type_node)
2557 return expr;
2558 return build2 (TREE_CODE (expr), truthvalue_type_node,
2559 TREE_OPERAND (expr, 0), TREE_OPERAND (expr, 1));
2560
2561 case TRUTH_ANDIF_EXPR:
2562 case TRUTH_ORIF_EXPR:
2563 case TRUTH_AND_EXPR:
2564 case TRUTH_OR_EXPR:
2565 case TRUTH_XOR_EXPR:
2566 if (TREE_TYPE (expr) == truthvalue_type_node)
2567 return expr;
2568 return build2 (TREE_CODE (expr), truthvalue_type_node,
2569 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)),
2570 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)));
2571
2572 case TRUTH_NOT_EXPR:
2573 if (TREE_TYPE (expr) == truthvalue_type_node)
2574 return expr;
2575 return build1 (TREE_CODE (expr), truthvalue_type_node,
2576 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)));
2577
2578 case ERROR_MARK:
2579 return expr;
2580
2581 case INTEGER_CST:
2582 /* Avoid integer_zerop to ignore TREE_CONSTANT_OVERFLOW. */
2583 return (TREE_INT_CST_LOW (expr) != 0 || TREE_INT_CST_HIGH (expr) != 0)
2584 ? truthvalue_true_node
2585 : truthvalue_false_node;
2586
2587 case REAL_CST:
2588 return real_compare (NE_EXPR, &TREE_REAL_CST (expr), &dconst0)
2589 ? truthvalue_true_node
2590 : truthvalue_false_node;
2591
2592 case FUNCTION_DECL:
2593 expr = build_unary_op (ADDR_EXPR, expr, 0);
2594 /* Fall through. */
2595
2596 case ADDR_EXPR:
2597 {
2598 tree inner = TREE_OPERAND (expr, 0);
2599 if (DECL_P (inner)
2600 && (TREE_CODE (inner) == PARM_DECL
2601 || TREE_CODE (inner) == LABEL_DECL
2602 || !DECL_WEAK (inner)))
2603 {
2604 /* Common Ada/Pascal programmer's mistake. We always warn
2605 about this since it is so bad. */
2606 warning (OPT_Waddress,
2607 "the address of %qD will always evaluate as %<true%>",
2608 inner);
2609 return truthvalue_true_node;
2610 }
2611
2612 /* If we are taking the address of an external decl, it might be
2613 zero if it is weak, so we cannot optimize. */
2614 if (DECL_P (inner)
2615 && DECL_EXTERNAL (inner))
2616 break;
2617
2618 if (TREE_SIDE_EFFECTS (inner))
2619 return build2 (COMPOUND_EXPR, truthvalue_type_node,
2620 inner, truthvalue_true_node);
2621 else
2622 return truthvalue_true_node;
2623 }
2624
2625 case COMPLEX_EXPR:
2626 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
2627 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2628 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)),
2629 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2630 0);
2631
2632 case NEGATE_EXPR:
2633 case ABS_EXPR:
2634 case FLOAT_EXPR:
2635 /* These don't change whether an object is nonzero or zero. */
2636 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2637
2638 case LROTATE_EXPR:
2639 case RROTATE_EXPR:
2640 /* These don't change whether an object is zero or nonzero, but
2641 we can't ignore them if their second arg has side-effects. */
2642 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2643 return build2 (COMPOUND_EXPR, truthvalue_type_node,
2644 TREE_OPERAND (expr, 1),
2645 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)));
2646 else
2647 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2648
2649 case COND_EXPR:
2650 /* Distribute the conversion into the arms of a COND_EXPR. */
2651 return fold_build3 (COND_EXPR, truthvalue_type_node,
2652 TREE_OPERAND (expr, 0),
2653 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2654 c_common_truthvalue_conversion (TREE_OPERAND (expr, 2)));
2655
2656 case CONVERT_EXPR:
2657 case NOP_EXPR:
2658 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2659 since that affects how `default_conversion' will behave. */
2660 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
2661 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2662 break;
2663 /* If this is widening the argument, we can ignore it. */
2664 if (TYPE_PRECISION (TREE_TYPE (expr))
2665 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2666 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2667 break;
2668
2669 case MODIFY_EXPR:
2670 if (!TREE_NO_WARNING (expr)
2671 && warn_parentheses)
2672 {
2673 warning (OPT_Wparentheses,
2674 "suggest parentheses around assignment used as truth value");
2675 TREE_NO_WARNING (expr) = 1;
2676 }
2677 break;
2678
2679 default:
2680 break;
2681 }
2682
2683 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
2684 {
2685 tree t = save_expr (expr);
2686 return (build_binary_op
2687 ((TREE_SIDE_EFFECTS (expr)
2688 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2689 c_common_truthvalue_conversion (build_unary_op (REALPART_EXPR, t, 0)),
2690 c_common_truthvalue_conversion (build_unary_op (IMAGPART_EXPR, t, 0)),
2691 0));
2692 }
2693
2694 return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
2695 }
2696
2697 static void def_builtin_1 (enum built_in_function fncode,
2698 const char *name,
2699 enum built_in_class fnclass,
2700 tree fntype, tree libtype,
2701 bool both_p, bool fallback_p, bool nonansi_p,
2702 tree fnattrs, bool implicit_p);
2703
2704 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2705 down to the element type of an array. */
2706
2707 tree
c_build_qualified_type(tree type,int type_quals)2708 c_build_qualified_type (tree type, int type_quals)
2709 {
2710 if (type == error_mark_node)
2711 return type;
2712
2713 if (TREE_CODE (type) == ARRAY_TYPE)
2714 {
2715 tree t;
2716 tree element_type = c_build_qualified_type (TREE_TYPE (type),
2717 type_quals);
2718
2719 /* See if we already have an identically qualified type. */
2720 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
2721 {
2722 if (TYPE_QUALS (strip_array_types (t)) == type_quals
2723 && TYPE_NAME (t) == TYPE_NAME (type)
2724 && TYPE_CONTEXT (t) == TYPE_CONTEXT (type)
2725 && attribute_list_equal (TYPE_ATTRIBUTES (t),
2726 TYPE_ATTRIBUTES (type)))
2727 break;
2728 }
2729 if (!t)
2730 {
2731 t = build_variant_type_copy (type);
2732 TREE_TYPE (t) = element_type;
2733 }
2734 return t;
2735 }
2736
2737 /* A restrict-qualified pointer type must be a pointer to object or
2738 incomplete type. Note that the use of POINTER_TYPE_P also allows
2739 REFERENCE_TYPEs, which is appropriate for C++. */
2740 if ((type_quals & TYPE_QUAL_RESTRICT)
2741 && (!POINTER_TYPE_P (type)
2742 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
2743 {
2744 error ("invalid use of %<restrict%>");
2745 type_quals &= ~TYPE_QUAL_RESTRICT;
2746 }
2747
2748 return build_qualified_type (type, type_quals);
2749 }
2750
2751 /* Apply the TYPE_QUALS to the new DECL. */
2752
2753 void
c_apply_type_quals_to_decl(int type_quals,tree decl)2754 c_apply_type_quals_to_decl (int type_quals, tree decl)
2755 {
2756 tree type = TREE_TYPE (decl);
2757
2758 if (type == error_mark_node)
2759 return;
2760
2761 if (((type_quals & TYPE_QUAL_CONST)
2762 || (type && TREE_CODE (type) == REFERENCE_TYPE))
2763 /* An object declared 'const' is only readonly after it is
2764 initialized. We don't have any way of expressing this currently,
2765 so we need to be conservative and unset TREE_READONLY for types
2766 with constructors. Otherwise aliasing code will ignore stores in
2767 an inline constructor. */
2768 && !(type && TYPE_NEEDS_CONSTRUCTING (type)))
2769 TREE_READONLY (decl) = 1;
2770 if (type_quals & TYPE_QUAL_VOLATILE)
2771 {
2772 TREE_SIDE_EFFECTS (decl) = 1;
2773 TREE_THIS_VOLATILE (decl) = 1;
2774 }
2775 if (type_quals & TYPE_QUAL_RESTRICT)
2776 {
2777 while (type && TREE_CODE (type) == ARRAY_TYPE)
2778 /* Allow 'restrict' on arrays of pointers.
2779 FIXME currently we just ignore it. */
2780 type = TREE_TYPE (type);
2781 if (!type
2782 || !POINTER_TYPE_P (type)
2783 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type)))
2784 error ("invalid use of %<restrict%>");
2785 else if (flag_strict_aliasing && type == TREE_TYPE (decl))
2786 /* Indicate we need to make a unique alias set for this pointer.
2787 We can't do it here because it might be pointing to an
2788 incomplete type. */
2789 DECL_POINTER_ALIAS_SET (decl) = -2;
2790 }
2791 }
2792
2793 /* Hash function for the problem of multiple type definitions in
2794 different files. This must hash all types that will compare
2795 equal via comptypes to the same value. In practice it hashes
2796 on some of the simple stuff and leaves the details to comptypes. */
2797
2798 static hashval_t
c_type_hash(const void * p)2799 c_type_hash (const void *p)
2800 {
2801 int i = 0;
2802 int shift, size;
2803 tree t = (tree) p;
2804 tree t2;
2805 switch (TREE_CODE (t))
2806 {
2807 /* For pointers, hash on pointee type plus some swizzling. */
2808 case POINTER_TYPE:
2809 return c_type_hash (TREE_TYPE (t)) ^ 0x3003003;
2810 /* Hash on number of elements and total size. */
2811 case ENUMERAL_TYPE:
2812 shift = 3;
2813 t2 = TYPE_VALUES (t);
2814 break;
2815 case RECORD_TYPE:
2816 shift = 0;
2817 t2 = TYPE_FIELDS (t);
2818 break;
2819 case QUAL_UNION_TYPE:
2820 shift = 1;
2821 t2 = TYPE_FIELDS (t);
2822 break;
2823 case UNION_TYPE:
2824 shift = 2;
2825 t2 = TYPE_FIELDS (t);
2826 break;
2827 default:
2828 gcc_unreachable ();
2829 }
2830 for (; t2; t2 = TREE_CHAIN (t2))
2831 i++;
2832 size = TREE_INT_CST_LOW (TYPE_SIZE (t));
2833 return ((size << 24) | (i << shift));
2834 }
2835
2836 static GTY((param_is (union tree_node))) htab_t type_hash_table;
2837
2838 /* Return the typed-based alias set for T, which may be an expression
2839 or a type. Return -1 if we don't do anything special. */
2840
2841 HOST_WIDE_INT
c_common_get_alias_set(tree t)2842 c_common_get_alias_set (tree t)
2843 {
2844 tree u;
2845 PTR *slot;
2846
2847 /* Permit type-punning when accessing a union, provided the access
2848 is directly through the union. For example, this code does not
2849 permit taking the address of a union member and then storing
2850 through it. Even the type-punning allowed here is a GCC
2851 extension, albeit a common and useful one; the C standard says
2852 that such accesses have implementation-defined behavior. */
2853 for (u = t;
2854 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
2855 u = TREE_OPERAND (u, 0))
2856 if (TREE_CODE (u) == COMPONENT_REF
2857 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
2858 return 0;
2859
2860 /* That's all the expressions we handle specially. */
2861 if (!TYPE_P (t))
2862 return -1;
2863
2864 /* The C standard guarantees that any object may be accessed via an
2865 lvalue that has character type. */
2866 if (t == char_type_node
2867 || t == signed_char_type_node
2868 || t == unsigned_char_type_node)
2869 return 0;
2870
2871 /* If it has the may_alias attribute, it can alias anything. */
2872 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (t)))
2873 return 0;
2874
2875 /* The C standard specifically allows aliasing between signed and
2876 unsigned variants of the same type. We treat the signed
2877 variant as canonical. */
2878 if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
2879 {
2880 tree t1 = c_common_signed_type (t);
2881
2882 /* t1 == t can happen for boolean nodes which are always unsigned. */
2883 if (t1 != t)
2884 return get_alias_set (t1);
2885 }
2886 else if (POINTER_TYPE_P (t))
2887 {
2888 tree t1;
2889
2890 /* Unfortunately, there is no canonical form of a pointer type.
2891 In particular, if we have `typedef int I', then `int *', and
2892 `I *' are different types. So, we have to pick a canonical
2893 representative. We do this below.
2894
2895 Technically, this approach is actually more conservative that
2896 it needs to be. In particular, `const int *' and `int *'
2897 should be in different alias sets, according to the C and C++
2898 standard, since their types are not the same, and so,
2899 technically, an `int **' and `const int **' cannot point at
2900 the same thing.
2901
2902 But, the standard is wrong. In particular, this code is
2903 legal C++:
2904
2905 int *ip;
2906 int **ipp = &ip;
2907 const int* const* cipp = ipp;
2908
2909 And, it doesn't make sense for that to be legal unless you
2910 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
2911 the pointed-to types. This issue has been reported to the
2912 C++ committee. */
2913 t1 = build_type_no_quals (t);
2914 if (t1 != t)
2915 return get_alias_set (t1);
2916 }
2917
2918 /* Handle the case of multiple type nodes referring to "the same" type,
2919 which occurs with IMA. These share an alias set. FIXME: Currently only
2920 C90 is handled. (In C99 type compatibility is not transitive, which
2921 complicates things mightily. The alias set splay trees can theoretically
2922 represent this, but insertion is tricky when you consider all the
2923 different orders things might arrive in.) */
2924
2925 if (c_language != clk_c || flag_isoc99)
2926 return -1;
2927
2928 /* Save time if there's only one input file. */
2929 if (num_in_fnames == 1)
2930 return -1;
2931
2932 /* Pointers need special handling if they point to any type that
2933 needs special handling (below). */
2934 if (TREE_CODE (t) == POINTER_TYPE)
2935 {
2936 tree t2;
2937 /* Find bottom type under any nested POINTERs. */
2938 for (t2 = TREE_TYPE (t);
2939 TREE_CODE (t2) == POINTER_TYPE;
2940 t2 = TREE_TYPE (t2))
2941 ;
2942 if (TREE_CODE (t2) != RECORD_TYPE
2943 && TREE_CODE (t2) != ENUMERAL_TYPE
2944 && TREE_CODE (t2) != QUAL_UNION_TYPE
2945 && TREE_CODE (t2) != UNION_TYPE)
2946 return -1;
2947 if (TYPE_SIZE (t2) == 0)
2948 return -1;
2949 }
2950 /* These are the only cases that need special handling. */
2951 if (TREE_CODE (t) != RECORD_TYPE
2952 && TREE_CODE (t) != ENUMERAL_TYPE
2953 && TREE_CODE (t) != QUAL_UNION_TYPE
2954 && TREE_CODE (t) != UNION_TYPE
2955 && TREE_CODE (t) != POINTER_TYPE)
2956 return -1;
2957 /* Undefined? */
2958 if (TYPE_SIZE (t) == 0)
2959 return -1;
2960
2961 /* Look up t in hash table. Only one of the compatible types within each
2962 alias set is recorded in the table. */
2963 if (!type_hash_table)
2964 type_hash_table = htab_create_ggc (1021, c_type_hash,
2965 (htab_eq) lang_hooks.types_compatible_p,
2966 NULL);
2967 slot = htab_find_slot (type_hash_table, t, INSERT);
2968 if (*slot != NULL)
2969 {
2970 TYPE_ALIAS_SET (t) = TYPE_ALIAS_SET ((tree)*slot);
2971 return TYPE_ALIAS_SET ((tree)*slot);
2972 }
2973 else
2974 /* Our caller will assign and record (in t) a new alias set; all we need
2975 to do is remember t in the hash table. */
2976 *slot = t;
2977
2978 return -1;
2979 }
2980
2981 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
2982 second parameter indicates which OPERATOR is being applied. The COMPLAIN
2983 flag controls whether we should diagnose possibly ill-formed
2984 constructs or not. */
2985
2986 tree
c_sizeof_or_alignof_type(tree type,bool is_sizeof,int complain)2987 c_sizeof_or_alignof_type (tree type, bool is_sizeof, int complain)
2988 {
2989 const char *op_name;
2990 tree value = NULL;
2991 enum tree_code type_code = TREE_CODE (type);
2992
2993 op_name = is_sizeof ? "sizeof" : "__alignof__";
2994
2995 if (type_code == FUNCTION_TYPE)
2996 {
2997 if (is_sizeof)
2998 {
2999 if (complain && (pedantic || warn_pointer_arith))
3000 pedwarn ("invalid application of %<sizeof%> to a function type");
3001 value = size_one_node;
3002 }
3003 else
3004 value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
3005 }
3006 else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
3007 {
3008 if (type_code == VOID_TYPE
3009 && complain && (pedantic || warn_pointer_arith))
3010 pedwarn ("invalid application of %qs to a void type", op_name);
3011 value = size_one_node;
3012 }
3013 else if (!COMPLETE_TYPE_P (type))
3014 {
3015 if (complain)
3016 error ("invalid application of %qs to incomplete type %qT ",
3017 op_name, type);
3018 value = size_zero_node;
3019 }
3020 else
3021 {
3022 if (is_sizeof)
3023 /* Convert in case a char is more than one unit. */
3024 value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
3025 size_int (TYPE_PRECISION (char_type_node)
3026 / BITS_PER_UNIT));
3027 else
3028 value = size_int (TYPE_ALIGN_UNIT (type));
3029 }
3030
3031 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
3032 TYPE_IS_SIZETYPE means that certain things (like overflow) will
3033 never happen. However, this node should really have type
3034 `size_t', which is just a typedef for an ordinary integer type. */
3035 value = fold_convert (size_type_node, value);
3036 gcc_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)));
3037
3038 return value;
3039 }
3040
3041 /* Implement the __alignof keyword: Return the minimum required
3042 alignment of EXPR, measured in bytes. For VAR_DECLs,
3043 FUNCTION_DECLs and FIELD_DECLs return DECL_ALIGN (which can be set
3044 from an "aligned" __attribute__ specification). */
3045
3046 tree
c_alignof_expr(tree expr)3047 c_alignof_expr (tree expr)
3048 {
3049 tree t;
3050
3051 if (VAR_OR_FUNCTION_DECL_P (expr))
3052 t = size_int (DECL_ALIGN_UNIT (expr));
3053
3054 else if (TREE_CODE (expr) == COMPONENT_REF
3055 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
3056 {
3057 error ("%<__alignof%> applied to a bit-field");
3058 t = size_one_node;
3059 }
3060 else if (TREE_CODE (expr) == COMPONENT_REF
3061 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
3062 t = size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr, 1)));
3063
3064 else if (TREE_CODE (expr) == INDIRECT_REF)
3065 {
3066 tree t = TREE_OPERAND (expr, 0);
3067 tree best = t;
3068 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3069
3070 while ((TREE_CODE (t) == NOP_EXPR || TREE_CODE (t) == CONVERT_EXPR)
3071 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
3072 {
3073 int thisalign;
3074
3075 t = TREE_OPERAND (t, 0);
3076 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3077 if (thisalign > bestalign)
3078 best = t, bestalign = thisalign;
3079 }
3080 return c_alignof (TREE_TYPE (TREE_TYPE (best)));
3081 }
3082 else
3083 return c_alignof (TREE_TYPE (expr));
3084
3085 return fold_convert (size_type_node, t);
3086 }
3087
3088 /* Handle C and C++ default attributes. */
3089
3090 enum built_in_attribute
3091 {
3092 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
3093 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
3094 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
3095 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
3096 #include "builtin-attrs.def"
3097 #undef DEF_ATTR_NULL_TREE
3098 #undef DEF_ATTR_INT
3099 #undef DEF_ATTR_IDENT
3100 #undef DEF_ATTR_TREE_LIST
3101 ATTR_LAST
3102 };
3103
3104 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
3105
3106 static void c_init_attributes (void);
3107
3108 enum c_builtin_type
3109 {
3110 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
3111 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
3112 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
3113 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
3114 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3115 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3116 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
3117 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME,
3118 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME,
3119 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
3120 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
3121 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
3122 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3123 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3124 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
3125 NAME,
3126 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
3127 #include "builtin-types.def"
3128 #undef DEF_PRIMITIVE_TYPE
3129 #undef DEF_FUNCTION_TYPE_0
3130 #undef DEF_FUNCTION_TYPE_1
3131 #undef DEF_FUNCTION_TYPE_2
3132 #undef DEF_FUNCTION_TYPE_3
3133 #undef DEF_FUNCTION_TYPE_4
3134 #undef DEF_FUNCTION_TYPE_5
3135 #undef DEF_FUNCTION_TYPE_6
3136 #undef DEF_FUNCTION_TYPE_7
3137 #undef DEF_FUNCTION_TYPE_VAR_0
3138 #undef DEF_FUNCTION_TYPE_VAR_1
3139 #undef DEF_FUNCTION_TYPE_VAR_2
3140 #undef DEF_FUNCTION_TYPE_VAR_3
3141 #undef DEF_FUNCTION_TYPE_VAR_4
3142 #undef DEF_FUNCTION_TYPE_VAR_5
3143 #undef DEF_POINTER_TYPE
3144 BT_LAST
3145 };
3146
3147 typedef enum c_builtin_type builtin_type;
3148
3149 /* A temporary array for c_common_nodes_and_builtins. Used in
3150 communication with def_fn_type. */
3151 static tree builtin_types[(int) BT_LAST + 1];
3152
3153 /* A helper function for c_common_nodes_and_builtins. Build function type
3154 for DEF with return type RET and N arguments. If VAR is true, then the
3155 function should be variadic after those N arguments.
3156
3157 Takes special care not to ICE if any of the types involved are
3158 error_mark_node, which indicates that said type is not in fact available
3159 (see builtin_type_for_size). In which case the function type as a whole
3160 should be error_mark_node. */
3161
3162 static void
def_fn_type(builtin_type def,builtin_type ret,bool var,int n,...)3163 def_fn_type (builtin_type def, builtin_type ret, bool var, int n, ...)
3164 {
3165 tree args = NULL, t;
3166 va_list list;
3167 int i;
3168
3169 va_start (list, n);
3170 for (i = 0; i < n; ++i)
3171 {
3172 builtin_type a = va_arg (list, builtin_type);
3173 t = builtin_types[a];
3174 if (t == error_mark_node)
3175 goto egress;
3176 args = tree_cons (NULL_TREE, t, args);
3177 }
3178 va_end (list);
3179
3180 args = nreverse (args);
3181 if (!var)
3182 args = chainon (args, void_list_node);
3183
3184 t = builtin_types[ret];
3185 if (t == error_mark_node)
3186 goto egress;
3187 t = build_function_type (t, args);
3188
3189 egress:
3190 builtin_types[def] = t;
3191 }
3192
3193 /* Build builtin functions common to both C and C++ language
3194 frontends. */
3195
3196 static void
c_define_builtins(tree va_list_ref_type_node,tree va_list_arg_type_node)3197 c_define_builtins (tree va_list_ref_type_node, tree va_list_arg_type_node)
3198 {
3199 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3200 builtin_types[ENUM] = VALUE;
3201 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
3202 def_fn_type (ENUM, RETURN, 0, 0);
3203 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
3204 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
3205 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
3206 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
3207 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3208 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
3209 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3210 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
3211 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
3212 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
3213 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3214 ARG6) \
3215 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
3216 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3217 ARG6, ARG7) \
3218 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
3219 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
3220 def_fn_type (ENUM, RETURN, 1, 0);
3221 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
3222 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
3223 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
3224 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
3225 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3226 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
3227 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3228 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
3229 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
3230 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
3231 #define DEF_POINTER_TYPE(ENUM, TYPE) \
3232 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
3233
3234 #include "builtin-types.def"
3235
3236 #undef DEF_PRIMITIVE_TYPE
3237 #undef DEF_FUNCTION_TYPE_1
3238 #undef DEF_FUNCTION_TYPE_2
3239 #undef DEF_FUNCTION_TYPE_3
3240 #undef DEF_FUNCTION_TYPE_4
3241 #undef DEF_FUNCTION_TYPE_5
3242 #undef DEF_FUNCTION_TYPE_6
3243 #undef DEF_FUNCTION_TYPE_VAR_0
3244 #undef DEF_FUNCTION_TYPE_VAR_1
3245 #undef DEF_FUNCTION_TYPE_VAR_2
3246 #undef DEF_FUNCTION_TYPE_VAR_3
3247 #undef DEF_FUNCTION_TYPE_VAR_4
3248 #undef DEF_FUNCTION_TYPE_VAR_5
3249 #undef DEF_POINTER_TYPE
3250 builtin_types[(int) BT_LAST] = NULL_TREE;
3251
3252 c_init_attributes ();
3253
3254 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
3255 NONANSI_P, ATTRS, IMPLICIT, COND) \
3256 if (NAME && COND) \
3257 def_builtin_1 (ENUM, NAME, CLASS, \
3258 builtin_types[(int) TYPE], \
3259 builtin_types[(int) LIBTYPE], \
3260 BOTH_P, FALLBACK_P, NONANSI_P, \
3261 built_in_attributes[(int) ATTRS], IMPLICIT);
3262 #include "builtins.def"
3263 #undef DEF_BUILTIN
3264
3265 build_common_builtin_nodes ();
3266
3267 targetm.init_builtins ();
3268 if (flag_mudflap)
3269 mudflap_init ();
3270 }
3271
3272 /* Build tree nodes and builtin functions common to both C and C++ language
3273 frontends. */
3274
3275 void
c_common_nodes_and_builtins(void)3276 c_common_nodes_and_builtins (void)
3277 {
3278 int wchar_type_size;
3279 tree array_domain_type;
3280 tree va_list_ref_type_node;
3281 tree va_list_arg_type_node;
3282
3283 /* Define `int' and `char' first so that dbx will output them first. */
3284 record_builtin_type (RID_INT, NULL, integer_type_node);
3285 record_builtin_type (RID_CHAR, "char", char_type_node);
3286
3287 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
3288 "unsigned long", "long long unsigned" and "unsigned short" were in C++
3289 but not C. Are the conditionals here needed? */
3290 if (c_dialect_cxx ())
3291 record_builtin_type (RID_SIGNED, NULL, integer_type_node);
3292 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
3293 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
3294 record_builtin_type (RID_MAX, "long unsigned int",
3295 long_unsigned_type_node);
3296 if (c_dialect_cxx ())
3297 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
3298 record_builtin_type (RID_MAX, "long long int",
3299 long_long_integer_type_node);
3300 record_builtin_type (RID_MAX, "long long unsigned int",
3301 long_long_unsigned_type_node);
3302 if (c_dialect_cxx ())
3303 record_builtin_type (RID_MAX, "long long unsigned",
3304 long_long_unsigned_type_node);
3305 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
3306 record_builtin_type (RID_MAX, "short unsigned int",
3307 short_unsigned_type_node);
3308 if (c_dialect_cxx ())
3309 record_builtin_type (RID_MAX, "unsigned short",
3310 short_unsigned_type_node);
3311
3312 /* Define both `signed char' and `unsigned char'. */
3313 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
3314 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
3315
3316 /* These are types that c_common_type_for_size and
3317 c_common_type_for_mode use. */
3318 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3319 intQI_type_node));
3320 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3321 intHI_type_node));
3322 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3323 intSI_type_node));
3324 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3325 intDI_type_node));
3326 #if HOST_BITS_PER_WIDE_INT >= 64
3327 if (targetm.scalar_mode_supported_p (TImode))
3328 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3329 get_identifier ("__int128_t"),
3330 intTI_type_node));
3331 #endif
3332 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3333 unsigned_intQI_type_node));
3334 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3335 unsigned_intHI_type_node));
3336 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3337 unsigned_intSI_type_node));
3338 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3339 unsigned_intDI_type_node));
3340 #if HOST_BITS_PER_WIDE_INT >= 64
3341 if (targetm.scalar_mode_supported_p (TImode))
3342 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3343 get_identifier ("__uint128_t"),
3344 unsigned_intTI_type_node));
3345 #endif
3346
3347 /* Create the widest literal types. */
3348 widest_integer_literal_type_node
3349 = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
3350 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3351 widest_integer_literal_type_node));
3352
3353 widest_unsigned_literal_type_node
3354 = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
3355 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3356 widest_unsigned_literal_type_node));
3357
3358 /* `unsigned long' is the standard type for sizeof.
3359 Note that stddef.h uses `unsigned long',
3360 and this must agree, even if long and int are the same size. */
3361 size_type_node =
3362 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
3363 signed_size_type_node = c_common_signed_type (size_type_node);
3364 set_sizetype (size_type_node);
3365
3366 pid_type_node =
3367 TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE)));
3368
3369 build_common_tree_nodes_2 (flag_short_double);
3370
3371 record_builtin_type (RID_FLOAT, NULL, float_type_node);
3372 record_builtin_type (RID_DOUBLE, NULL, double_type_node);
3373 record_builtin_type (RID_MAX, "long double", long_double_type_node);
3374
3375 /* Only supported decimal floating point extension if the target
3376 actually supports underlying modes. */
3377 if (targetm.scalar_mode_supported_p (SDmode)
3378 && targetm.scalar_mode_supported_p (DDmode)
3379 && targetm.scalar_mode_supported_p (TDmode))
3380 {
3381 record_builtin_type (RID_DFLOAT32, NULL, dfloat32_type_node);
3382 record_builtin_type (RID_DFLOAT64, NULL, dfloat64_type_node);
3383 record_builtin_type (RID_DFLOAT128, NULL, dfloat128_type_node);
3384 }
3385
3386 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3387 get_identifier ("complex int"),
3388 complex_integer_type_node));
3389 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3390 get_identifier ("complex float"),
3391 complex_float_type_node));
3392 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3393 get_identifier ("complex double"),
3394 complex_double_type_node));
3395 lang_hooks.decls.pushdecl
3396 (build_decl (TYPE_DECL, get_identifier ("complex long double"),
3397 complex_long_double_type_node));
3398
3399 if (c_dialect_cxx ())
3400 /* For C++, make fileptr_type_node a distinct void * type until
3401 FILE type is defined. */
3402 fileptr_type_node = build_variant_type_copy (ptr_type_node);
3403
3404 record_builtin_type (RID_VOID, NULL, void_type_node);
3405
3406 /* This node must not be shared. */
3407 void_zero_node = make_node (INTEGER_CST);
3408 TREE_TYPE (void_zero_node) = void_type_node;
3409
3410 void_list_node = build_void_list_node ();
3411
3412 /* Make a type to be the domain of a few array types
3413 whose domains don't really matter.
3414 200 is small enough that it always fits in size_t
3415 and large enough that it can hold most function names for the
3416 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
3417 array_domain_type = build_index_type (size_int (200));
3418
3419 /* Make a type for arrays of characters.
3420 With luck nothing will ever really depend on the length of this
3421 array type. */
3422 char_array_type_node
3423 = build_array_type (char_type_node, array_domain_type);
3424
3425 /* Likewise for arrays of ints. */
3426 int_array_type_node
3427 = build_array_type (integer_type_node, array_domain_type);
3428
3429 string_type_node = build_pointer_type (char_type_node);
3430 const_string_type_node
3431 = build_pointer_type (build_qualified_type
3432 (char_type_node, TYPE_QUAL_CONST));
3433
3434 /* This is special for C++ so functions can be overloaded. */
3435 wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
3436 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
3437 wchar_type_size = TYPE_PRECISION (wchar_type_node);
3438 if (c_dialect_cxx ())
3439 {
3440 if (TYPE_UNSIGNED (wchar_type_node))
3441 wchar_type_node = make_unsigned_type (wchar_type_size);
3442 else
3443 wchar_type_node = make_signed_type (wchar_type_size);
3444 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
3445 }
3446 else
3447 {
3448 signed_wchar_type_node = c_common_signed_type (wchar_type_node);
3449 unsigned_wchar_type_node = c_common_unsigned_type (wchar_type_node);
3450 }
3451
3452 /* This is for wide string constants. */
3453 wchar_array_type_node
3454 = build_array_type (wchar_type_node, array_domain_type);
3455
3456 wint_type_node =
3457 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
3458
3459 intmax_type_node =
3460 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
3461 uintmax_type_node =
3462 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
3463
3464 default_function_type = build_function_type (integer_type_node, NULL_TREE);
3465 ptrdiff_type_node
3466 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
3467 unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
3468
3469 lang_hooks.decls.pushdecl
3470 (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
3471 va_list_type_node));
3472
3473 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
3474 {
3475 va_list_arg_type_node = va_list_ref_type_node =
3476 build_pointer_type (TREE_TYPE (va_list_type_node));
3477 }
3478 else
3479 {
3480 va_list_arg_type_node = va_list_type_node;
3481 va_list_ref_type_node = build_reference_type (va_list_type_node);
3482 }
3483
3484 if (!flag_preprocess_only)
3485 c_define_builtins (va_list_ref_type_node, va_list_arg_type_node);
3486
3487 main_identifier_node = get_identifier ("main");
3488
3489 /* Create the built-in __null node. It is important that this is
3490 not shared. */
3491 null_node = make_node (INTEGER_CST);
3492 TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0);
3493
3494 /* Since builtin_types isn't gc'ed, don't export these nodes. */
3495 memset (builtin_types, 0, sizeof (builtin_types));
3496 }
3497
3498 /* Look up the function in built_in_decls that corresponds to DECL
3499 and set ASMSPEC as its user assembler name. DECL must be a
3500 function decl that declares a builtin. */
3501
3502 void
set_builtin_user_assembler_name(tree decl,const char * asmspec)3503 set_builtin_user_assembler_name (tree decl, const char *asmspec)
3504 {
3505 tree builtin;
3506 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
3507 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
3508 && asmspec != 0);
3509
3510 builtin = built_in_decls [DECL_FUNCTION_CODE (decl)];
3511 set_user_assembler_name (builtin, asmspec);
3512 if (DECL_FUNCTION_CODE (decl) == BUILT_IN_MEMCPY)
3513 init_block_move_fn (asmspec);
3514 else if (DECL_FUNCTION_CODE (decl) == BUILT_IN_MEMSET)
3515 init_block_clear_fn (asmspec);
3516 }
3517
3518 /* The number of named compound-literals generated thus far. */
3519 static GTY(()) int compound_literal_number;
3520
3521 /* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal. */
3522
3523 void
set_compound_literal_name(tree decl)3524 set_compound_literal_name (tree decl)
3525 {
3526 char *name;
3527 ASM_FORMAT_PRIVATE_NAME (name, "__compound_literal",
3528 compound_literal_number);
3529 compound_literal_number++;
3530 DECL_NAME (decl) = get_identifier (name);
3531 }
3532
3533 tree
build_va_arg(tree expr,tree type)3534 build_va_arg (tree expr, tree type)
3535 {
3536 return build1 (VA_ARG_EXPR, type, expr);
3537 }
3538
3539
3540 /* Linked list of disabled built-in functions. */
3541
3542 typedef struct disabled_builtin
3543 {
3544 const char *name;
3545 struct disabled_builtin *next;
3546 } disabled_builtin;
3547 static disabled_builtin *disabled_builtins = NULL;
3548
3549 static bool builtin_function_disabled_p (const char *);
3550
3551 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
3552 begins with "__builtin_", give an error. */
3553
3554 void
disable_builtin_function(const char * name)3555 disable_builtin_function (const char *name)
3556 {
3557 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
3558 error ("cannot disable built-in function %qs", name);
3559 else
3560 {
3561 disabled_builtin *new_disabled_builtin = XNEW (disabled_builtin);
3562 new_disabled_builtin->name = name;
3563 new_disabled_builtin->next = disabled_builtins;
3564 disabled_builtins = new_disabled_builtin;
3565 }
3566 }
3567
3568
3569 /* Return true if the built-in function NAME has been disabled, false
3570 otherwise. */
3571
3572 static bool
builtin_function_disabled_p(const char * name)3573 builtin_function_disabled_p (const char *name)
3574 {
3575 disabled_builtin *p;
3576 for (p = disabled_builtins; p != NULL; p = p->next)
3577 {
3578 if (strcmp (name, p->name) == 0)
3579 return true;
3580 }
3581 return false;
3582 }
3583
3584
3585 /* Worker for DEF_BUILTIN.
3586 Possibly define a builtin function with one or two names.
3587 Does not declare a non-__builtin_ function if flag_no_builtin, or if
3588 nonansi_p and flag_no_nonansi_builtin. */
3589
3590 static void
def_builtin_1(enum built_in_function fncode,const char * name,enum built_in_class fnclass,tree fntype,tree libtype,bool both_p,bool fallback_p,bool nonansi_p,tree fnattrs,bool implicit_p)3591 def_builtin_1 (enum built_in_function fncode,
3592 const char *name,
3593 enum built_in_class fnclass,
3594 tree fntype, tree libtype,
3595 bool both_p, bool fallback_p, bool nonansi_p,
3596 tree fnattrs, bool implicit_p)
3597 {
3598 tree decl;
3599 const char *libname;
3600
3601 if (fntype == error_mark_node)
3602 return;
3603
3604 gcc_assert ((!both_p && !fallback_p)
3605 || !strncmp (name, "__builtin_",
3606 strlen ("__builtin_")));
3607
3608 libname = name + strlen ("__builtin_");
3609 decl = lang_hooks.builtin_function (name, fntype, fncode, fnclass,
3610 (fallback_p ? libname : NULL),
3611 fnattrs);
3612 if (both_p
3613 && !flag_no_builtin && !builtin_function_disabled_p (libname)
3614 && !(nonansi_p && flag_no_nonansi_builtin))
3615 lang_hooks.builtin_function (libname, libtype, fncode, fnclass,
3616 NULL, fnattrs);
3617
3618 built_in_decls[(int) fncode] = decl;
3619 if (implicit_p)
3620 implicit_built_in_decls[(int) fncode] = decl;
3621 }
3622
3623 /* Nonzero if the type T promotes to int. This is (nearly) the
3624 integral promotions defined in ISO C99 6.3.1.1/2. */
3625
3626 bool
c_promoting_integer_type_p(tree t)3627 c_promoting_integer_type_p (tree t)
3628 {
3629 switch (TREE_CODE (t))
3630 {
3631 case INTEGER_TYPE:
3632 return (TYPE_MAIN_VARIANT (t) == char_type_node
3633 || TYPE_MAIN_VARIANT (t) == signed_char_type_node
3634 || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
3635 || TYPE_MAIN_VARIANT (t) == short_integer_type_node
3636 || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
3637 || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
3638
3639 case ENUMERAL_TYPE:
3640 /* ??? Technically all enumerations not larger than an int
3641 promote to an int. But this is used along code paths
3642 that only want to notice a size change. */
3643 return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
3644
3645 case BOOLEAN_TYPE:
3646 return 1;
3647
3648 default:
3649 return 0;
3650 }
3651 }
3652
3653 /* Return 1 if PARMS specifies a fixed number of parameters
3654 and none of their types is affected by default promotions. */
3655
3656 int
self_promoting_args_p(tree parms)3657 self_promoting_args_p (tree parms)
3658 {
3659 tree t;
3660 for (t = parms; t; t = TREE_CHAIN (t))
3661 {
3662 tree type = TREE_VALUE (t);
3663
3664 if (type == error_mark_node)
3665 continue;
3666
3667 if (TREE_CHAIN (t) == 0 && type != void_type_node)
3668 return 0;
3669
3670 if (type == 0)
3671 return 0;
3672
3673 if (TYPE_MAIN_VARIANT (type) == float_type_node)
3674 return 0;
3675
3676 if (c_promoting_integer_type_p (type))
3677 return 0;
3678 }
3679 return 1;
3680 }
3681
3682 /* Recursively examines the array elements of TYPE, until a non-array
3683 element type is found. */
3684
3685 tree
strip_array_types(tree type)3686 strip_array_types (tree type)
3687 {
3688 while (TREE_CODE (type) == ARRAY_TYPE)
3689 type = TREE_TYPE (type);
3690
3691 return type;
3692 }
3693
3694 /* Recursively remove any '*' or '&' operator from TYPE. */
3695 tree
strip_pointer_operator(tree t)3696 strip_pointer_operator (tree t)
3697 {
3698 while (POINTER_TYPE_P (t))
3699 t = TREE_TYPE (t);
3700 return t;
3701 }
3702
3703 /* Used to compare case labels. K1 and K2 are actually tree nodes
3704 representing case labels, or NULL_TREE for a `default' label.
3705 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3706 K2, and 0 if K1 and K2 are equal. */
3707
3708 int
case_compare(splay_tree_key k1,splay_tree_key k2)3709 case_compare (splay_tree_key k1, splay_tree_key k2)
3710 {
3711 /* Consider a NULL key (such as arises with a `default' label) to be
3712 smaller than anything else. */
3713 if (!k1)
3714 return k2 ? -1 : 0;
3715 else if (!k2)
3716 return k1 ? 1 : 0;
3717
3718 return tree_int_cst_compare ((tree) k1, (tree) k2);
3719 }
3720
3721 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
3722 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3723 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
3724 case label was declared using the usual C/C++ syntax, rather than
3725 the GNU case range extension. CASES is a tree containing all the
3726 case ranges processed so far; COND is the condition for the
3727 switch-statement itself. Returns the CASE_LABEL_EXPR created, or
3728 ERROR_MARK_NODE if no CASE_LABEL_EXPR is created. */
3729
3730 tree
c_add_case_label(splay_tree cases,tree cond,tree orig_type,tree low_value,tree high_value)3731 c_add_case_label (splay_tree cases, tree cond, tree orig_type,
3732 tree low_value, tree high_value)
3733 {
3734 tree type;
3735 tree label;
3736 tree case_label;
3737 splay_tree_node node;
3738
3739 /* Create the LABEL_DECL itself. */
3740 label = create_artificial_label ();
3741
3742 /* If there was an error processing the switch condition, bail now
3743 before we get more confused. */
3744 if (!cond || cond == error_mark_node)
3745 goto error_out;
3746
3747 if ((low_value && TREE_TYPE (low_value)
3748 && POINTER_TYPE_P (TREE_TYPE (low_value)))
3749 || (high_value && TREE_TYPE (high_value)
3750 && POINTER_TYPE_P (TREE_TYPE (high_value))))
3751 {
3752 error ("pointers are not permitted as case values");
3753 goto error_out;
3754 }
3755
3756 /* Case ranges are a GNU extension. */
3757 if (high_value && pedantic)
3758 pedwarn ("range expressions in switch statements are non-standard");
3759
3760 type = TREE_TYPE (cond);
3761 if (low_value)
3762 {
3763 low_value = check_case_value (low_value);
3764 low_value = convert_and_check (type, low_value);
3765 if (low_value == error_mark_node)
3766 goto error_out;
3767 }
3768 if (high_value)
3769 {
3770 high_value = check_case_value (high_value);
3771 high_value = convert_and_check (type, high_value);
3772 if (high_value == error_mark_node)
3773 goto error_out;
3774 }
3775
3776 if (low_value && high_value)
3777 {
3778 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
3779 really a case range, even though it was written that way.
3780 Remove the HIGH_VALUE to simplify later processing. */
3781 if (tree_int_cst_equal (low_value, high_value))
3782 high_value = NULL_TREE;
3783 else if (!tree_int_cst_lt (low_value, high_value))
3784 warning (0, "empty range specified");
3785 }
3786
3787 /* See if the case is in range of the type of the original testing
3788 expression. If both low_value and high_value are out of range,
3789 don't insert the case label and return NULL_TREE. */
3790 if (low_value
3791 && !check_case_bounds (type, orig_type,
3792 &low_value, high_value ? &high_value : NULL))
3793 return NULL_TREE;
3794
3795 /* Look up the LOW_VALUE in the table of case labels we already
3796 have. */
3797 node = splay_tree_lookup (cases, (splay_tree_key) low_value);
3798 /* If there was not an exact match, check for overlapping ranges.
3799 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
3800 that's a `default' label and the only overlap is an exact match. */
3801 if (!node && (low_value || high_value))
3802 {
3803 splay_tree_node low_bound;
3804 splay_tree_node high_bound;
3805
3806 /* Even though there wasn't an exact match, there might be an
3807 overlap between this case range and another case range.
3808 Since we've (inductively) not allowed any overlapping case
3809 ranges, we simply need to find the greatest low case label
3810 that is smaller that LOW_VALUE, and the smallest low case
3811 label that is greater than LOW_VALUE. If there is an overlap
3812 it will occur in one of these two ranges. */
3813 low_bound = splay_tree_predecessor (cases,
3814 (splay_tree_key) low_value);
3815 high_bound = splay_tree_successor (cases,
3816 (splay_tree_key) low_value);
3817
3818 /* Check to see if the LOW_BOUND overlaps. It is smaller than
3819 the LOW_VALUE, so there is no need to check unless the
3820 LOW_BOUND is in fact itself a case range. */
3821 if (low_bound
3822 && CASE_HIGH ((tree) low_bound->value)
3823 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
3824 low_value) >= 0)
3825 node = low_bound;
3826 /* Check to see if the HIGH_BOUND overlaps. The low end of that
3827 range is bigger than the low end of the current range, so we
3828 are only interested if the current range is a real range, and
3829 not an ordinary case label. */
3830 else if (high_bound
3831 && high_value
3832 && (tree_int_cst_compare ((tree) high_bound->key,
3833 high_value)
3834 <= 0))
3835 node = high_bound;
3836 }
3837 /* If there was an overlap, issue an error. */
3838 if (node)
3839 {
3840 tree duplicate = CASE_LABEL ((tree) node->value);
3841
3842 if (high_value)
3843 {
3844 error ("duplicate (or overlapping) case value");
3845 error ("%Jthis is the first entry overlapping that value", duplicate);
3846 }
3847 else if (low_value)
3848 {
3849 error ("duplicate case value") ;
3850 error ("%Jpreviously used here", duplicate);
3851 }
3852 else
3853 {
3854 error ("multiple default labels in one switch");
3855 error ("%Jthis is the first default label", duplicate);
3856 }
3857 goto error_out;
3858 }
3859
3860 /* Add a CASE_LABEL to the statement-tree. */
3861 case_label = add_stmt (build_case_label (low_value, high_value, label));
3862 /* Register this case label in the splay tree. */
3863 splay_tree_insert (cases,
3864 (splay_tree_key) low_value,
3865 (splay_tree_value) case_label);
3866
3867 return case_label;
3868
3869 error_out:
3870 /* Add a label so that the back-end doesn't think that the beginning of
3871 the switch is unreachable. Note that we do not add a case label, as
3872 that just leads to duplicates and thence to failure later on. */
3873 if (!cases->root)
3874 {
3875 tree t = create_artificial_label ();
3876 add_stmt (build_stmt (LABEL_EXPR, t));
3877 }
3878 return error_mark_node;
3879 }
3880
3881 /* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
3882 Used to verify that case values match up with enumerator values. */
3883
3884 static void
match_case_to_enum_1(tree key,tree type,tree label)3885 match_case_to_enum_1 (tree key, tree type, tree label)
3886 {
3887 char buf[2 + 2*HOST_BITS_PER_WIDE_INT/4 + 1];
3888
3889 /* ??? Not working too hard to print the double-word value.
3890 Should perhaps be done with %lwd in the diagnostic routines? */
3891 if (TREE_INT_CST_HIGH (key) == 0)
3892 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_UNSIGNED,
3893 TREE_INT_CST_LOW (key));
3894 else if (!TYPE_UNSIGNED (type)
3895 && TREE_INT_CST_HIGH (key) == -1
3896 && TREE_INT_CST_LOW (key) != 0)
3897 snprintf (buf, sizeof (buf), "-" HOST_WIDE_INT_PRINT_UNSIGNED,
3898 -TREE_INT_CST_LOW (key));
3899 else
3900 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_DOUBLE_HEX,
3901 TREE_INT_CST_HIGH (key), TREE_INT_CST_LOW (key));
3902
3903 if (TYPE_NAME (type) == 0)
3904 warning (0, "%Jcase value %qs not in enumerated type",
3905 CASE_LABEL (label), buf);
3906 else
3907 warning (0, "%Jcase value %qs not in enumerated type %qT",
3908 CASE_LABEL (label), buf, type);
3909 }
3910
3911 /* Subroutine of c_do_switch_warnings, called via splay_tree_foreach.
3912 Used to verify that case values match up with enumerator values. */
3913
3914 static int
match_case_to_enum(splay_tree_node node,void * data)3915 match_case_to_enum (splay_tree_node node, void *data)
3916 {
3917 tree label = (tree) node->value;
3918 tree type = (tree) data;
3919
3920 /* Skip default case. */
3921 if (!CASE_LOW (label))
3922 return 0;
3923
3924 /* If CASE_LOW_SEEN is not set, that means CASE_LOW did not appear
3925 when we did our enum->case scan. Reset our scratch bit after. */
3926 if (!CASE_LOW_SEEN (label))
3927 match_case_to_enum_1 (CASE_LOW (label), type, label);
3928 else
3929 CASE_LOW_SEEN (label) = 0;
3930
3931 /* If CASE_HIGH is non-null, we have a range. If CASE_HIGH_SEEN is
3932 not set, that means that CASE_HIGH did not appear when we did our
3933 enum->case scan. Reset our scratch bit after. */
3934 if (CASE_HIGH (label))
3935 {
3936 if (!CASE_HIGH_SEEN (label))
3937 match_case_to_enum_1 (CASE_HIGH (label), type, label);
3938 else
3939 CASE_HIGH_SEEN (label) = 0;
3940 }
3941
3942 return 0;
3943 }
3944
3945 /* Handle -Wswitch*. Called from the front end after parsing the
3946 switch construct. */
3947 /* ??? Should probably be somewhere generic, since other languages
3948 besides C and C++ would want this. At the moment, however, C/C++
3949 are the only tree-ssa languages that support enumerations at all,
3950 so the point is moot. */
3951
3952 void
c_do_switch_warnings(splay_tree cases,location_t switch_location,tree type,tree cond)3953 c_do_switch_warnings (splay_tree cases, location_t switch_location,
3954 tree type, tree cond)
3955 {
3956 splay_tree_node default_node;
3957 splay_tree_node node;
3958 tree chain;
3959
3960 if (!warn_switch && !warn_switch_enum && !warn_switch_default)
3961 return;
3962
3963 default_node = splay_tree_lookup (cases, (splay_tree_key) NULL);
3964 if (!default_node)
3965 warning (OPT_Wswitch_default, "%Hswitch missing default case",
3966 &switch_location);
3967
3968 /* From here on, we only care about about enumerated types. */
3969 if (!type || TREE_CODE (type) != ENUMERAL_TYPE)
3970 return;
3971
3972 /* If the switch expression was an enumerated type, check that
3973 exactly all enumeration literals are covered by the cases.
3974 The check is made when -Wswitch was specified and there is no
3975 default case, or when -Wswitch-enum was specified. */
3976
3977 if (!warn_switch_enum
3978 && !(warn_switch && !default_node))
3979 return;
3980
3981 /* Clearing COND if it is not an integer constant simplifies
3982 the tests inside the loop below. */
3983 if (TREE_CODE (cond) != INTEGER_CST)
3984 cond = NULL_TREE;
3985
3986 /* The time complexity here is O(N*lg(N)) worst case, but for the
3987 common case of monotonically increasing enumerators, it is
3988 O(N), since the nature of the splay tree will keep the next
3989 element adjacent to the root at all times. */
3990
3991 for (chain = TYPE_VALUES (type); chain; chain = TREE_CHAIN (chain))
3992 {
3993 tree value = TREE_VALUE (chain);
3994 node = splay_tree_lookup (cases, (splay_tree_key) value);
3995 if (node)
3996 {
3997 /* Mark the CASE_LOW part of the case entry as seen. */
3998 tree label = (tree) node->value;
3999 CASE_LOW_SEEN (label) = 1;
4000 continue;
4001 }
4002
4003 /* Even though there wasn't an exact match, there might be a
4004 case range which includes the enumator's value. */
4005 node = splay_tree_predecessor (cases, (splay_tree_key) value);
4006 if (node && CASE_HIGH ((tree) node->value))
4007 {
4008 tree label = (tree) node->value;
4009 int cmp = tree_int_cst_compare (CASE_HIGH (label), value);
4010 if (cmp >= 0)
4011 {
4012 /* If we match the upper bound exactly, mark the CASE_HIGH
4013 part of the case entry as seen. */
4014 if (cmp == 0)
4015 CASE_HIGH_SEEN (label) = 1;
4016 continue;
4017 }
4018 }
4019
4020 /* We've now determined that this enumerated literal isn't
4021 handled by the case labels of the switch statement. */
4022
4023 /* If the switch expression is a constant, we only really care
4024 about whether that constant is handled by the switch. */
4025 if (cond && tree_int_cst_compare (cond, value))
4026 continue;
4027
4028 warning (0, "%Henumeration value %qE not handled in switch",
4029 &switch_location, TREE_PURPOSE (chain));
4030 }
4031
4032 /* Warn if there are case expressions that don't correspond to
4033 enumerators. This can occur since C and C++ don't enforce
4034 type-checking of assignments to enumeration variables.
4035
4036 The time complexity here is now always O(N) worst case, since
4037 we should have marked both the lower bound and upper bound of
4038 every disjoint case label, with CASE_LOW_SEEN and CASE_HIGH_SEEN
4039 above. This scan also resets those fields. */
4040 splay_tree_foreach (cases, match_case_to_enum, type);
4041 }
4042
4043 /* Finish an expression taking the address of LABEL (an
4044 IDENTIFIER_NODE). Returns an expression for the address. */
4045
4046 tree
finish_label_address_expr(tree label)4047 finish_label_address_expr (tree label)
4048 {
4049 tree result;
4050
4051 if (pedantic)
4052 pedwarn ("taking the address of a label is non-standard");
4053
4054 if (label == error_mark_node)
4055 return error_mark_node;
4056
4057 label = lookup_label (label);
4058 if (label == NULL_TREE)
4059 result = null_pointer_node;
4060 else
4061 {
4062 TREE_USED (label) = 1;
4063 result = build1 (ADDR_EXPR, ptr_type_node, label);
4064 /* The current function in not necessarily uninlinable.
4065 Computed gotos are incompatible with inlining, but the value
4066 here could be used only in a diagnostic, for example. */
4067 }
4068
4069 return result;
4070 }
4071
4072 /* Hook used by expand_expr to expand language-specific tree codes. */
4073 /* The only things that should go here are bits needed to expand
4074 constant initializers. Everything else should be handled by the
4075 gimplification routines. */
4076
4077 rtx
c_expand_expr(tree exp,rtx target,enum machine_mode tmode,int modifier,rtx * alt_rtl)4078 c_expand_expr (tree exp, rtx target, enum machine_mode tmode,
4079 int modifier /* Actually enum_modifier. */,
4080 rtx *alt_rtl)
4081 {
4082 switch (TREE_CODE (exp))
4083 {
4084 case COMPOUND_LITERAL_EXPR:
4085 {
4086 /* Initialize the anonymous variable declared in the compound
4087 literal, then return the variable. */
4088 tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
4089 emit_local_var (decl);
4090 return expand_expr_real (decl, target, tmode, modifier, alt_rtl);
4091 }
4092
4093 default:
4094 gcc_unreachable ();
4095 }
4096 }
4097
4098 /* Hook used by staticp to handle language-specific tree codes. */
4099
4100 tree
c_staticp(tree exp)4101 c_staticp (tree exp)
4102 {
4103 return (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR
4104 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp))
4105 ? exp : NULL);
4106 }
4107
4108
4109 /* Given a boolean expression ARG, return a tree representing an increment
4110 or decrement (as indicated by CODE) of ARG. The front end must check for
4111 invalid cases (e.g., decrement in C++). */
4112 tree
boolean_increment(enum tree_code code,tree arg)4113 boolean_increment (enum tree_code code, tree arg)
4114 {
4115 tree val;
4116 tree true_res = boolean_true_node;
4117
4118 arg = stabilize_reference (arg);
4119 switch (code)
4120 {
4121 case PREINCREMENT_EXPR:
4122 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4123 break;
4124 case POSTINCREMENT_EXPR:
4125 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4126 arg = save_expr (arg);
4127 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4128 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4129 break;
4130 case PREDECREMENT_EXPR:
4131 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
4132 invert_truthvalue (arg));
4133 break;
4134 case POSTDECREMENT_EXPR:
4135 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
4136 invert_truthvalue (arg));
4137 arg = save_expr (arg);
4138 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4139 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4140 break;
4141 default:
4142 gcc_unreachable ();
4143 }
4144 TREE_SIDE_EFFECTS (val) = 1;
4145 return val;
4146 }
4147
4148 /* Built-in macros for stddef.h, that require macros defined in this
4149 file. */
4150 void
c_stddef_cpp_builtins(void)4151 c_stddef_cpp_builtins(void)
4152 {
4153 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
4154 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
4155 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
4156 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
4157 builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE, 0);
4158 builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE, 0);
4159 }
4160
4161 static void
c_init_attributes(void)4162 c_init_attributes (void)
4163 {
4164 /* Fill in the built_in_attributes array. */
4165 #define DEF_ATTR_NULL_TREE(ENUM) \
4166 built_in_attributes[(int) ENUM] = NULL_TREE;
4167 #define DEF_ATTR_INT(ENUM, VALUE) \
4168 built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
4169 #define DEF_ATTR_IDENT(ENUM, STRING) \
4170 built_in_attributes[(int) ENUM] = get_identifier (STRING);
4171 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
4172 built_in_attributes[(int) ENUM] \
4173 = tree_cons (built_in_attributes[(int) PURPOSE], \
4174 built_in_attributes[(int) VALUE], \
4175 built_in_attributes[(int) CHAIN]);
4176 #include "builtin-attrs.def"
4177 #undef DEF_ATTR_NULL_TREE
4178 #undef DEF_ATTR_INT
4179 #undef DEF_ATTR_IDENT
4180 #undef DEF_ATTR_TREE_LIST
4181 }
4182
4183 /* Attribute handlers common to C front ends. */
4184
4185 /* Handle a "packed" attribute; arguments as in
4186 struct attribute_spec.handler. */
4187
4188 static tree
handle_packed_attribute(tree * node,tree name,tree ARG_UNUSED (args),int flags,bool * no_add_attrs)4189 handle_packed_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4190 int flags, bool *no_add_attrs)
4191 {
4192 if (TYPE_P (*node))
4193 {
4194 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4195 *node = build_variant_type_copy (*node);
4196 TYPE_PACKED (*node) = 1;
4197 }
4198 else if (TREE_CODE (*node) == FIELD_DECL)
4199 {
4200 if (TYPE_ALIGN (TREE_TYPE (*node)) <= BITS_PER_UNIT)
4201 warning (OPT_Wattributes,
4202 "%qE attribute ignored for field of type %qT",
4203 name, TREE_TYPE (*node));
4204 else
4205 DECL_PACKED (*node) = 1;
4206 }
4207 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
4208 used for DECL_REGISTER. It wouldn't mean anything anyway.
4209 We can't set DECL_PACKED on the type of a TYPE_DECL, because
4210 that changes what the typedef is typing. */
4211 else
4212 {
4213 warning (OPT_Wattributes, "%qE attribute ignored", name);
4214 *no_add_attrs = true;
4215 }
4216
4217 return NULL_TREE;
4218 }
4219
4220 /* Handle a "nocommon" attribute; arguments as in
4221 struct attribute_spec.handler. */
4222
4223 static tree
handle_nocommon_attribute(tree * node,tree name,tree ARG_UNUSED (args),int ARG_UNUSED (flags),bool * no_add_attrs)4224 handle_nocommon_attribute (tree *node, tree name,
4225 tree ARG_UNUSED (args),
4226 int ARG_UNUSED (flags), bool *no_add_attrs)
4227 {
4228 if (TREE_CODE (*node) == VAR_DECL)
4229 DECL_COMMON (*node) = 0;
4230 else
4231 {
4232 warning (OPT_Wattributes, "%qE attribute ignored", name);
4233 *no_add_attrs = true;
4234 }
4235
4236 return NULL_TREE;
4237 }
4238
4239 /* Handle a "common" attribute; arguments as in
4240 struct attribute_spec.handler. */
4241
4242 static tree
handle_common_attribute(tree * node,tree name,tree ARG_UNUSED (args),int ARG_UNUSED (flags),bool * no_add_attrs)4243 handle_common_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4244 int ARG_UNUSED (flags), bool *no_add_attrs)
4245 {
4246 if (TREE_CODE (*node) == VAR_DECL)
4247 DECL_COMMON (*node) = 1;
4248 else
4249 {
4250 warning (OPT_Wattributes, "%qE attribute ignored", name);
4251 *no_add_attrs = true;
4252 }
4253
4254 return NULL_TREE;
4255 }
4256
4257 /* Handle a "noreturn" attribute; arguments as in
4258 struct attribute_spec.handler. */
4259
4260 static tree
handle_noreturn_attribute(tree * node,tree name,tree ARG_UNUSED (args),int ARG_UNUSED (flags),bool * no_add_attrs)4261 handle_noreturn_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4262 int ARG_UNUSED (flags), bool *no_add_attrs)
4263 {
4264 tree type = TREE_TYPE (*node);
4265
4266 /* See FIXME comment in c_common_attribute_table. */
4267 /* APPLE LOCAL begin radar 4727659 */
4268 if (TREE_CODE (*node) == FUNCTION_DECL
4269 || objc_method_decl (TREE_CODE (*node)))
4270 /* APPLE LOCAL end radar 4727659 */
4271 TREE_THIS_VOLATILE (*node) = 1;
4272 else if (TREE_CODE (type) == POINTER_TYPE
4273 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4274 TREE_TYPE (*node)
4275 = build_pointer_type
4276 (build_type_variant (TREE_TYPE (type),
4277 TYPE_READONLY (TREE_TYPE (type)), 1));
4278 /* APPLE LOCAL begin radar 6237713 */
4279 else if (TREE_CODE (type) == BLOCK_POINTER_TYPE
4280 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4281 TREE_TYPE (*node)
4282 = build_block_pointer_type
4283 (build_type_variant (TREE_TYPE (type),
4284 TYPE_READONLY (TREE_TYPE (type)), 1));
4285 /* APPLE LOCAL end radar 6237713 */
4286 else
4287 {
4288 warning (OPT_Wattributes, "%qE attribute ignored", name);
4289 *no_add_attrs = true;
4290 }
4291
4292 return NULL_TREE;
4293 }
4294
4295 /* Handle a "noinline" attribute; arguments as in
4296 struct attribute_spec.handler. */
4297
4298 static tree
handle_noinline_attribute(tree * node,tree name,tree ARG_UNUSED (args),int ARG_UNUSED (flags),bool * no_add_attrs)4299 handle_noinline_attribute (tree *node, tree name,
4300 tree ARG_UNUSED (args),
4301 int ARG_UNUSED (flags), bool *no_add_attrs)
4302 {
4303 if (TREE_CODE (*node) == FUNCTION_DECL)
4304 DECL_UNINLINABLE (*node) = 1;
4305 else
4306 {
4307 warning (OPT_Wattributes, "%qE attribute ignored", name);
4308 *no_add_attrs = true;
4309 }
4310
4311 return NULL_TREE;
4312 }
4313
4314 /* Handle a "always_inline" attribute; arguments as in
4315 struct attribute_spec.handler. */
4316
4317 static tree
handle_always_inline_attribute(tree * node,tree name,tree ARG_UNUSED (args),int ARG_UNUSED (flags),bool * no_add_attrs)4318 handle_always_inline_attribute (tree *node, tree name,
4319 tree ARG_UNUSED (args),
4320 int ARG_UNUSED (flags),
4321 bool *no_add_attrs)
4322 {
4323 if (TREE_CODE (*node) == FUNCTION_DECL)
4324 {
4325 /* Do nothing else, just set the attribute. We'll get at
4326 it later with lookup_attribute. */
4327 }
4328 else
4329 {
4330 warning (OPT_Wattributes, "%qE attribute ignored", name);
4331 *no_add_attrs = true;
4332 }
4333
4334 return NULL_TREE;
4335 }
4336
4337 /* Handle a "gnu_inline" attribute; arguments as in
4338 struct attribute_spec.handler. */
4339
4340 static tree
handle_gnu_inline_attribute(tree * node,tree name,tree ARG_UNUSED (args),int ARG_UNUSED (flags),bool * no_add_attrs)4341 handle_gnu_inline_attribute (tree *node, tree name,
4342 tree ARG_UNUSED (args),
4343 int ARG_UNUSED (flags),
4344 bool *no_add_attrs)
4345 {
4346 if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
4347 {
4348 /* Do nothing else, just set the attribute. We'll get at
4349 it later with lookup_attribute. */
4350 }
4351 else
4352 {
4353 warning (OPT_Wattributes, "%qE attribute ignored", name);
4354 *no_add_attrs = true;
4355 }
4356
4357 return NULL_TREE;
4358 }
4359
4360 /* Handle a "flatten" attribute; arguments as in
4361 struct attribute_spec.handler. */
4362
4363 static tree
handle_flatten_attribute(tree * node,tree name,tree args ATTRIBUTE_UNUSED,int flags ATTRIBUTE_UNUSED,bool * no_add_attrs)4364 handle_flatten_attribute (tree *node, tree name,
4365 tree args ATTRIBUTE_UNUSED,
4366 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4367 {
4368 if (TREE_CODE (*node) == FUNCTION_DECL)
4369 /* Do nothing else, just set the attribute. We'll get at
4370 it later with lookup_attribute. */
4371 ;
4372 else
4373 {
4374 warning (OPT_Wattributes, "%qE attribute ignored", name);
4375 *no_add_attrs = true;
4376 }
4377
4378 return NULL_TREE;
4379 }
4380
4381
4382 /* Handle a "used" attribute; arguments as in
4383 struct attribute_spec.handler. */
4384
4385 static tree
handle_used_attribute(tree * pnode,tree name,tree ARG_UNUSED (args),int ARG_UNUSED (flags),bool * no_add_attrs)4386 handle_used_attribute (tree *pnode, tree name, tree ARG_UNUSED (args),
4387 int ARG_UNUSED (flags), bool *no_add_attrs)
4388 {
4389 tree node = *pnode;
4390
4391 if (TREE_CODE (node) == FUNCTION_DECL
4392 || (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node)))
4393 {
4394 TREE_USED (node) = 1;
4395 DECL_PRESERVE_P (node) = 1;
4396 }
4397 else
4398 {
4399 warning (OPT_Wattributes, "%qE attribute ignored", name);
4400 *no_add_attrs = true;
4401 }
4402
4403 return NULL_TREE;
4404 }
4405
4406 /* Handle a "unused" attribute; arguments as in
4407 struct attribute_spec.handler. */
4408
4409 static tree
handle_unused_attribute(tree * node,tree name,tree ARG_UNUSED (args),int flags,bool * no_add_attrs)4410 handle_unused_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4411 int flags, bool *no_add_attrs)
4412 {
4413 if (DECL_P (*node))
4414 {
4415 tree decl = *node;
4416
4417 if (TREE_CODE (decl) == PARM_DECL
4418 || TREE_CODE (decl) == VAR_DECL
4419 || TREE_CODE (decl) == FUNCTION_DECL
4420 /* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
4421 || (TREE_CODE (decl) == LABEL_DECL
4422 && ! DECL_ARTIFICIAL (decl))
4423 /* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
4424 || TREE_CODE (decl) == TYPE_DECL)
4425 TREE_USED (decl) = 1;
4426 else
4427 {
4428 warning (OPT_Wattributes, "%qE attribute ignored", name);
4429 *no_add_attrs = true;
4430 }
4431 }
4432 else
4433 {
4434 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4435 *node = build_variant_type_copy (*node);
4436 TREE_USED (*node) = 1;
4437 }
4438
4439 return NULL_TREE;
4440 }
4441
4442 /* Handle a "externally_visible" attribute; arguments as in
4443 struct attribute_spec.handler. */
4444
4445 static tree
handle_externally_visible_attribute(tree * pnode,tree name,tree ARG_UNUSED (args),int ARG_UNUSED (flags),bool * no_add_attrs)4446 handle_externally_visible_attribute (tree *pnode, tree name,
4447 tree ARG_UNUSED (args),
4448 int ARG_UNUSED (flags),
4449 bool *no_add_attrs)
4450 {
4451 tree node = *pnode;
4452
4453 if (TREE_CODE (node) == FUNCTION_DECL || TREE_CODE (node) == VAR_DECL)
4454 {
4455 if ((!TREE_STATIC (node) && TREE_CODE (node) != FUNCTION_DECL
4456 && !DECL_EXTERNAL (node)) || !TREE_PUBLIC (node))
4457 {
4458 warning (OPT_Wattributes,
4459 "%qE attribute have effect only on public objects", name);
4460 *no_add_attrs = true;
4461 }
4462 }
4463 else
4464 {
4465 warning (OPT_Wattributes, "%qE attribute ignored", name);
4466 *no_add_attrs = true;
4467 }
4468
4469 return NULL_TREE;
4470 }
4471
4472 /* Handle a "const" attribute; arguments as in
4473 struct attribute_spec.handler. */
4474
4475 static tree
handle_const_attribute(tree * node,tree name,tree ARG_UNUSED (args),int ARG_UNUSED (flags),bool * no_add_attrs)4476 handle_const_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4477 int ARG_UNUSED (flags), bool *no_add_attrs)
4478 {
4479 tree type = TREE_TYPE (*node);
4480
4481 /* See FIXME comment on noreturn in c_common_attribute_table. */
4482 if (TREE_CODE (*node) == FUNCTION_DECL)
4483 TREE_READONLY (*node) = 1;
4484 else if (TREE_CODE (type) == POINTER_TYPE
4485 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4486 TREE_TYPE (*node)
4487 = build_pointer_type
4488 (build_type_variant (TREE_TYPE (type), 1,
4489 TREE_THIS_VOLATILE (TREE_TYPE (type))));
4490 else
4491 {
4492 warning (OPT_Wattributes, "%qE attribute ignored", name);
4493 *no_add_attrs = true;
4494 }
4495
4496 return NULL_TREE;
4497 }
4498
4499 /* Handle a "transparent_union" attribute; arguments as in
4500 struct attribute_spec.handler. */
4501
4502 static tree
handle_transparent_union_attribute(tree * node,tree name,tree ARG_UNUSED (args),int flags,bool * no_add_attrs)4503 handle_transparent_union_attribute (tree *node, tree name,
4504 tree ARG_UNUSED (args), int flags,
4505 bool *no_add_attrs)
4506 {
4507 tree type = NULL;
4508
4509 *no_add_attrs = true;
4510
4511 if (DECL_P (*node))
4512 {
4513 if (TREE_CODE (*node) != TYPE_DECL)
4514 goto ignored;
4515 node = &TREE_TYPE (*node);
4516 type = *node;
4517 }
4518 else if (TYPE_P (*node))
4519 type = *node;
4520 else
4521 goto ignored;
4522
4523 if (TREE_CODE (type) == UNION_TYPE)
4524 {
4525 /* When IN_PLACE is set, leave the check for FIELDS and MODE to
4526 the code in finish_struct. */
4527 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4528 {
4529 if (TYPE_FIELDS (type) == NULL_TREE
4530 || TYPE_MODE (type) != DECL_MODE (TYPE_FIELDS (type)))
4531 goto ignored;
4532
4533 /* A type variant isn't good enough, since we don't a cast
4534 to such a type removed as a no-op. */
4535 *node = type = build_duplicate_type (type);
4536 }
4537
4538 TYPE_TRANSPARENT_UNION (type) = 1;
4539 return NULL_TREE;
4540 }
4541
4542 ignored:
4543 warning (OPT_Wattributes, "%qE attribute ignored", name);
4544 return NULL_TREE;
4545 }
4546
4547 /* Handle a "constructor" attribute; arguments as in
4548 struct attribute_spec.handler. */
4549
4550 static tree
handle_constructor_attribute(tree * node,tree name,tree ARG_UNUSED (args),int ARG_UNUSED (flags),bool * no_add_attrs)4551 handle_constructor_attribute (tree *node, tree name,
4552 tree ARG_UNUSED (args),
4553 int ARG_UNUSED (flags),
4554 bool *no_add_attrs)
4555 {
4556 tree decl = *node;
4557 tree type = TREE_TYPE (decl);
4558
4559 if (TREE_CODE (decl) == FUNCTION_DECL
4560 && TREE_CODE (type) == FUNCTION_TYPE
4561 && decl_function_context (decl) == 0)
4562 {
4563 DECL_STATIC_CONSTRUCTOR (decl) = 1;
4564 TREE_USED (decl) = 1;
4565 }
4566 else
4567 {
4568 warning (OPT_Wattributes, "%qE attribute ignored", name);
4569 *no_add_attrs = true;
4570 }
4571
4572 return NULL_TREE;
4573 }
4574
4575 /* Handle a "destructor" attribute; arguments as in
4576 struct attribute_spec.handler. */
4577
4578 static tree
handle_destructor_attribute(tree * node,tree name,tree ARG_UNUSED (args),int ARG_UNUSED (flags),bool * no_add_attrs)4579 handle_destructor_attribute (tree *node, tree name,
4580 tree ARG_UNUSED (args),
4581 int ARG_UNUSED (flags),
4582 bool *no_add_attrs)
4583 {
4584 tree decl = *node;
4585 tree type = TREE_TYPE (decl);
4586
4587 if (TREE_CODE (decl) == FUNCTION_DECL
4588 && TREE_CODE (type) == FUNCTION_TYPE
4589 && decl_function_context (decl) == 0)
4590 {
4591 DECL_STATIC_DESTRUCTOR (decl) = 1;
4592 TREE_USED (decl) = 1;
4593 }
4594 else
4595 {
4596 warning (OPT_Wattributes, "%qE attribute ignored", name);
4597 *no_add_attrs = true;
4598 }
4599
4600 return NULL_TREE;
4601 }
4602
4603 /* Handle a "mode" attribute; arguments as in
4604 struct attribute_spec.handler. */
4605
4606 static tree
handle_mode_attribute(tree * node,tree name,tree args,int ARG_UNUSED (flags),bool * no_add_attrs)4607 handle_mode_attribute (tree *node, tree name, tree args,
4608 int ARG_UNUSED (flags), bool *no_add_attrs)
4609 {
4610 tree type = *node;
4611
4612 *no_add_attrs = true;
4613
4614 if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
4615 warning (OPT_Wattributes, "%qE attribute ignored", name);
4616 else
4617 {
4618 int j;
4619 const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
4620 int len = strlen (p);
4621 enum machine_mode mode = VOIDmode;
4622 tree typefm;
4623 bool valid_mode;
4624
4625 if (len > 4 && p[0] == '_' && p[1] == '_'
4626 && p[len - 1] == '_' && p[len - 2] == '_')
4627 {
4628 char *newp = (char *) alloca (len - 1);
4629
4630 strcpy (newp, &p[2]);
4631 newp[len - 4] = '\0';
4632 p = newp;
4633 }
4634
4635 /* Change this type to have a type with the specified mode.
4636 First check for the special modes. */
4637 if (!strcmp (p, "byte"))
4638 mode = byte_mode;
4639 else if (!strcmp (p, "word"))
4640 mode = word_mode;
4641 else if (!strcmp (p, "pointer"))
4642 mode = ptr_mode;
4643 else
4644 for (j = 0; j < NUM_MACHINE_MODES; j++)
4645 if (!strcmp (p, GET_MODE_NAME (j)))
4646 {
4647 mode = (enum machine_mode) j;
4648 break;
4649 }
4650
4651 if (mode == VOIDmode)
4652 {
4653 error ("unknown machine mode %qs", p);
4654 return NULL_TREE;
4655 }
4656
4657 valid_mode = false;
4658 switch (GET_MODE_CLASS (mode))
4659 {
4660 case MODE_INT:
4661 case MODE_PARTIAL_INT:
4662 case MODE_FLOAT:
4663 case MODE_DECIMAL_FLOAT:
4664 valid_mode = targetm.scalar_mode_supported_p (mode);
4665 break;
4666
4667 case MODE_COMPLEX_INT:
4668 case MODE_COMPLEX_FLOAT:
4669 valid_mode = targetm.scalar_mode_supported_p (GET_MODE_INNER (mode));
4670 break;
4671
4672 case MODE_VECTOR_INT:
4673 case MODE_VECTOR_FLOAT:
4674 warning (OPT_Wattributes, "specifying vector types with "
4675 "__attribute__ ((mode)) is deprecated");
4676 warning (OPT_Wattributes,
4677 "use __attribute__ ((vector_size)) instead");
4678 valid_mode = vector_mode_valid_p (mode);
4679 break;
4680
4681 default:
4682 break;
4683 }
4684 if (!valid_mode)
4685 {
4686 error ("unable to emulate %qs", p);
4687 return NULL_TREE;
4688 }
4689
4690 if (POINTER_TYPE_P (type))
4691 {
4692 tree (*fn)(tree, enum machine_mode, bool);
4693
4694 if (!targetm.valid_pointer_mode (mode))
4695 {
4696 error ("invalid pointer mode %qs", p);
4697 return NULL_TREE;
4698 }
4699
4700 if (TREE_CODE (type) == POINTER_TYPE)
4701 fn = build_pointer_type_for_mode;
4702 else
4703 fn = build_reference_type_for_mode;
4704 typefm = fn (TREE_TYPE (type), mode, false);
4705 }
4706 else
4707 typefm = lang_hooks.types.type_for_mode (mode, TYPE_UNSIGNED (type));
4708
4709 if (typefm == NULL_TREE)
4710 {
4711 error ("no data type for mode %qs", p);
4712 return NULL_TREE;
4713 }
4714 else if (TREE_CODE (type) == ENUMERAL_TYPE)
4715 {
4716 /* For enumeral types, copy the precision from the integer
4717 type returned above. If not an INTEGER_TYPE, we can't use
4718 this mode for this type. */
4719 if (TREE_CODE (typefm) != INTEGER_TYPE)
4720 {
4721 error ("cannot use mode %qs for enumeral types", p);
4722 return NULL_TREE;
4723 }
4724
4725 if (flags & ATTR_FLAG_TYPE_IN_PLACE)
4726 {
4727 TYPE_PRECISION (type) = TYPE_PRECISION (typefm);
4728 typefm = type;
4729 }
4730 else
4731 {
4732 /* We cannot build a type variant, as there's code that assumes
4733 that TYPE_MAIN_VARIANT has the same mode. This includes the
4734 debug generators. Instead, create a subrange type. This
4735 results in all of the enumeral values being emitted only once
4736 in the original, and the subtype gets them by reference. */
4737 if (TYPE_UNSIGNED (type))
4738 typefm = make_unsigned_type (TYPE_PRECISION (typefm));
4739 else
4740 typefm = make_signed_type (TYPE_PRECISION (typefm));
4741 TREE_TYPE (typefm) = type;
4742 }
4743 }
4744 else if (VECTOR_MODE_P (mode)
4745 ? TREE_CODE (type) != TREE_CODE (TREE_TYPE (typefm))
4746 : TREE_CODE (type) != TREE_CODE (typefm))
4747 {
4748 error ("mode %qs applied to inappropriate type", p);
4749 return NULL_TREE;
4750 }
4751
4752 *node = typefm;
4753 }
4754
4755 return NULL_TREE;
4756 }
4757
4758 /* Handle a "section" attribute; arguments as in
4759 struct attribute_spec.handler. */
4760
4761 static tree
handle_section_attribute(tree * node,tree ARG_UNUSED (name),tree args,int ARG_UNUSED (flags),bool * no_add_attrs)4762 handle_section_attribute (tree *node, tree ARG_UNUSED (name), tree args,
4763 int ARG_UNUSED (flags), bool *no_add_attrs)
4764 {
4765 tree decl = *node;
4766
4767 if (targetm.have_named_sections)
4768 {
4769 user_defined_section_attribute = true;
4770
4771 if ((TREE_CODE (decl) == FUNCTION_DECL
4772 || TREE_CODE (decl) == VAR_DECL)
4773 && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
4774 {
4775 if (TREE_CODE (decl) == VAR_DECL
4776 && current_function_decl != NULL_TREE
4777 && !TREE_STATIC (decl))
4778 {
4779 error ("%Jsection attribute cannot be specified for "
4780 "local variables", decl);
4781 *no_add_attrs = true;
4782 }
4783
4784 /* The decl may have already been given a section attribute
4785 from a previous declaration. Ensure they match. */
4786 else if (DECL_SECTION_NAME (decl) != NULL_TREE
4787 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
4788 TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
4789 {
4790 error ("section of %q+D conflicts with previous declaration",
4791 *node);
4792 *no_add_attrs = true;
4793 }
4794 else
4795 DECL_SECTION_NAME (decl) = TREE_VALUE (args);
4796 }
4797 else
4798 {
4799 error ("section attribute not allowed for %q+D", *node);
4800 *no_add_attrs = true;
4801 }
4802 }
4803 else
4804 {
4805 error ("%Jsection attributes are not supported for this target", *node);
4806 *no_add_attrs = true;
4807 }
4808
4809 return NULL_TREE;
4810 }
4811
4812 /* Handle a "aligned" attribute; arguments as in
4813 struct attribute_spec.handler. */
4814
4815 static tree
handle_aligned_attribute(tree * node,tree ARG_UNUSED (name),tree args,int flags,bool * no_add_attrs)4816 handle_aligned_attribute (tree *node, tree ARG_UNUSED (name), tree args,
4817 int flags, bool *no_add_attrs)
4818 {
4819 tree decl = NULL_TREE;
4820 tree *type = NULL;
4821 int is_type = 0;
4822 tree align_expr = (args ? TREE_VALUE (args)
4823 : size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
4824 int i;
4825
4826 if (DECL_P (*node))
4827 {
4828 decl = *node;
4829 type = &TREE_TYPE (decl);
4830 is_type = TREE_CODE (*node) == TYPE_DECL;
4831 }
4832 else if (TYPE_P (*node))
4833 type = node, is_type = 1;
4834
4835 if (TREE_CODE (align_expr) != INTEGER_CST)
4836 {
4837 error ("requested alignment is not a constant");
4838 *no_add_attrs = true;
4839 }
4840 else if ((i = tree_log2 (align_expr)) == -1)
4841 {
4842 error ("requested alignment is not a power of 2");
4843 *no_add_attrs = true;
4844 }
4845 else if (i > HOST_BITS_PER_INT - 2)
4846 {
4847 error ("requested alignment is too large");
4848 *no_add_attrs = true;
4849 }
4850 else if (is_type)
4851 {
4852 /* If we have a TYPE_DECL, then copy the type, so that we
4853 don't accidentally modify a builtin type. See pushdecl. */
4854 if (decl && TREE_TYPE (decl) != error_mark_node
4855 && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
4856 {
4857 tree tt = TREE_TYPE (decl);
4858 *type = build_variant_type_copy (*type);
4859 DECL_ORIGINAL_TYPE (decl) = tt;
4860 TYPE_NAME (*type) = decl;
4861 TREE_USED (*type) = TREE_USED (decl);
4862 TREE_TYPE (decl) = *type;
4863 }
4864 else if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4865 *type = build_variant_type_copy (*type);
4866
4867 TYPE_ALIGN (*type) = (1 << i) * BITS_PER_UNIT;
4868 TYPE_USER_ALIGN (*type) = 1;
4869 }
4870 else if (! VAR_OR_FUNCTION_DECL_P (decl)
4871 /* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \
4872 && TREE_CODE (decl) != FIELD_DECL
4873 && TREE_CODE (decl) != LABEL_DECL)
4874 /* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \
4875 {
4876 error ("alignment may not be specified for %q+D", decl);
4877 *no_add_attrs = true;
4878 }
4879 else if (TREE_CODE (decl) == FUNCTION_DECL
4880 && DECL_ALIGN (decl) > (1 << i) * BITS_PER_UNIT)
4881 {
4882 if (DECL_USER_ALIGN (decl))
4883 error ("alignment for %q+D was previously specified as %d "
4884 "and may not be decreased", decl,
4885 DECL_ALIGN (decl) / BITS_PER_UNIT);
4886 else
4887 error ("alignment for %q+D must be at least %d", decl,
4888 DECL_ALIGN (decl) / BITS_PER_UNIT);
4889 *no_add_attrs = true;
4890 }
4891 else
4892 {
4893 DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
4894 DECL_USER_ALIGN (decl) = 1;
4895 }
4896
4897 return NULL_TREE;
4898 }
4899
4900 /* Handle a "weak" attribute; arguments as in
4901 struct attribute_spec.handler. */
4902
4903 static tree
handle_weak_attribute(tree * node,tree name,tree ARG_UNUSED (args),int ARG_UNUSED (flags),bool * ARG_UNUSED (no_add_attrs))4904 handle_weak_attribute (tree *node, tree name,
4905 tree ARG_UNUSED (args),
4906 int ARG_UNUSED (flags),
4907 bool * ARG_UNUSED (no_add_attrs))
4908 {
4909 if (TREE_CODE (*node) == FUNCTION_DECL
4910 || TREE_CODE (*node) == VAR_DECL)
4911 declare_weak (*node);
4912 /* APPLE LOCAL begin weak types 5954418 */
4913 else if (!DECL_P (*node)
4914 /* If the weak flag can be associated with something else,
4915 prefer that. */
4916 && (flags & (ATTR_FLAG_FUNCTION_NEXT
4917 |ATTR_FLAG_DECL_NEXT
4918 |ATTR_FLAG_ARRAY_NEXT)))
4919 {
4920 *no_add_attrs = true;
4921 return tree_cons (name, args, NULL_TREE);
4922 }
4923 else if (! targetm.cxx.class_data_always_comdat ()
4924 && TREE_CODE (*node) == RECORD_TYPE)
4925 {
4926 /* Leave on the type for the C++ front end */
4927 }
4928 /* APPLE LOCAL end weak types 5954418 */
4929 else
4930 warning (OPT_Wattributes, "%qE attribute ignored", name);
4931
4932
4933 return NULL_TREE;
4934 }
4935
4936 /* Handle an "alias" attribute; arguments as in
4937 struct attribute_spec.handler. */
4938
4939 static tree
handle_alias_attribute(tree * node,tree name,tree args,int ARG_UNUSED (flags),bool * no_add_attrs)4940 handle_alias_attribute (tree *node, tree name, tree args,
4941 int ARG_UNUSED (flags), bool *no_add_attrs)
4942 {
4943 tree decl = *node;
4944
4945 if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
4946 || (TREE_CODE (decl) != FUNCTION_DECL
4947 && TREE_PUBLIC (decl) && !DECL_EXTERNAL (decl))
4948 /* A static variable declaration is always a tentative definition,
4949 but the alias is a non-tentative definition which overrides. */
4950 || (TREE_CODE (decl) != FUNCTION_DECL
4951 && ! TREE_PUBLIC (decl) && DECL_INITIAL (decl)))
4952 {
4953 error ("%q+D defined both normally and as an alias", decl);
4954 *no_add_attrs = true;
4955 }
4956
4957 /* Note that the very first time we process a nested declaration,
4958 decl_function_context will not be set. Indeed, *would* never
4959 be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
4960 we do below. After such frobbery, pushdecl would set the context.
4961 In any case, this is never what we want. */
4962 else if (decl_function_context (decl) == 0 && current_function_decl == NULL)
4963 {
4964 tree id;
4965
4966 id = TREE_VALUE (args);
4967 if (TREE_CODE (id) != STRING_CST)
4968 {
4969 error ("alias argument not a string");
4970 *no_add_attrs = true;
4971 return NULL_TREE;
4972 }
4973 id = get_identifier (TREE_STRING_POINTER (id));
4974 /* This counts as a use of the object pointed to. */
4975 TREE_USED (id) = 1;
4976
4977 if (TREE_CODE (decl) == FUNCTION_DECL)
4978 DECL_INITIAL (decl) = error_mark_node;
4979 else
4980 {
4981 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
4982 DECL_EXTERNAL (decl) = 1;
4983 else
4984 DECL_EXTERNAL (decl) = 0;
4985 TREE_STATIC (decl) = 1;
4986 }
4987 }
4988 else
4989 {
4990 warning (OPT_Wattributes, "%qE attribute ignored", name);
4991 *no_add_attrs = true;
4992 }
4993
4994 return NULL_TREE;
4995 }
4996
4997 /* Handle a "weakref" attribute; arguments as in struct
4998 attribute_spec.handler. */
4999
5000 static tree
handle_weakref_attribute(tree * node,tree ARG_UNUSED (name),tree args,int flags,bool * no_add_attrs)5001 handle_weakref_attribute (tree *node, tree ARG_UNUSED (name), tree args,
5002 int flags, bool *no_add_attrs)
5003 {
5004 tree attr = NULL_TREE;
5005
5006 /* We must ignore the attribute when it is associated with
5007 local-scoped decls, since attribute alias is ignored and many
5008 such symbols do not even have a DECL_WEAK field. */
5009 if (decl_function_context (*node) || current_function_decl)
5010 {
5011 warning (OPT_Wattributes, "%qE attribute ignored", name);
5012 *no_add_attrs = true;
5013 return NULL_TREE;
5014 }
5015
5016 /* The idea here is that `weakref("name")' mutates into `weakref,
5017 alias("name")', and weakref without arguments, in turn,
5018 implicitly adds weak. */
5019
5020 if (args)
5021 {
5022 attr = tree_cons (get_identifier ("alias"), args, attr);
5023 attr = tree_cons (get_identifier ("weakref"), NULL_TREE, attr);
5024
5025 *no_add_attrs = true;
5026
5027 decl_attributes (node, attr, flags);
5028 }
5029 else
5030 {
5031 if (lookup_attribute ("alias", DECL_ATTRIBUTES (*node)))
5032 error ("%Jweakref attribute must appear before alias attribute",
5033 *node);
5034
5035 /* Can't call declare_weak because it wants this to be TREE_PUBLIC,
5036 and that isn't supported; and because it wants to add it to
5037 the list of weak decls, which isn't helpful. */
5038 DECL_WEAK (*node) = 1;
5039 }
5040
5041 return NULL_TREE;
5042 }
5043
5044 /* Handle an "visibility" attribute; arguments as in
5045 struct attribute_spec.handler. */
5046
5047 static tree
handle_visibility_attribute(tree * node,tree name,tree args,int ARG_UNUSED (flags),bool * ARG_UNUSED (no_add_attrs))5048 handle_visibility_attribute (tree *node, tree name, tree args,
5049 int ARG_UNUSED (flags),
5050 bool *ARG_UNUSED (no_add_attrs))
5051 {
5052 tree decl = *node;
5053 tree id = TREE_VALUE (args);
5054 enum symbol_visibility vis;
5055
5056 if (TYPE_P (*node))
5057 {
5058 if (TREE_CODE (*node) == ENUMERAL_TYPE)
5059 /* OK */;
5060 else if (TREE_CODE (*node) != RECORD_TYPE && TREE_CODE (*node) != UNION_TYPE)
5061 {
5062 warning (OPT_Wattributes, "%qE attribute ignored on non-class types",
5063 name);
5064 return NULL_TREE;
5065 }
5066 else if (TYPE_FIELDS (*node))
5067 {
5068 error ("%qE attribute ignored because %qT is already defined",
5069 name, *node);
5070 return NULL_TREE;
5071 }
5072 }
5073 else if (decl_function_context (decl) != 0 || !TREE_PUBLIC (decl))
5074 {
5075 warning (OPT_Wattributes, "%qE attribute ignored", name);
5076 return NULL_TREE;
5077 }
5078
5079 if (TREE_CODE (id) != STRING_CST)
5080 {
5081 error ("visibility argument not a string");
5082 return NULL_TREE;
5083 }
5084
5085 /* If this is a type, set the visibility on the type decl. */
5086 if (TYPE_P (decl))
5087 {
5088 decl = TYPE_NAME (decl);
5089 if (!decl)
5090 return NULL_TREE;
5091 if (TREE_CODE (decl) == IDENTIFIER_NODE)
5092 {
5093 warning (OPT_Wattributes, "%qE attribute ignored on types",
5094 name);
5095 return NULL_TREE;
5096 }
5097 }
5098
5099 if (strcmp (TREE_STRING_POINTER (id), "default") == 0)
5100 vis = VISIBILITY_DEFAULT;
5101 else if (strcmp (TREE_STRING_POINTER (id), "internal") == 0)
5102 vis = VISIBILITY_INTERNAL;
5103 else if (strcmp (TREE_STRING_POINTER (id), "hidden") == 0)
5104 vis = VISIBILITY_HIDDEN;
5105 else if (strcmp (TREE_STRING_POINTER (id), "protected") == 0)
5106 vis = VISIBILITY_PROTECTED;
5107 else
5108 {
5109 error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
5110 vis = VISIBILITY_DEFAULT;
5111 }
5112
5113 if (DECL_VISIBILITY_SPECIFIED (decl)
5114 && vis != DECL_VISIBILITY (decl)
5115 && lookup_attribute ("visibility", (TYPE_P (*node)
5116 ? TYPE_ATTRIBUTES (*node)
5117 : DECL_ATTRIBUTES (decl))))
5118 error ("%qD redeclared with different visibility", decl);
5119
5120 DECL_VISIBILITY (decl) = vis;
5121 DECL_VISIBILITY_SPECIFIED (decl) = 1;
5122
5123 /* Go ahead and attach the attribute to the node as well. This is needed
5124 so we can determine whether we have VISIBILITY_DEFAULT because the
5125 visibility was not specified, or because it was explicitly overridden
5126 from the containing scope. */
5127
5128 return NULL_TREE;
5129 }
5130
5131 /* Determine the ELF symbol visibility for DECL, which is either a
5132 variable or a function. It is an error to use this function if a
5133 definition of DECL is not available in this translation unit.
5134 Returns true if the final visibility has been determined by this
5135 function; false if the caller is free to make additional
5136 modifications. */
5137
5138 bool
c_determine_visibility(tree decl)5139 c_determine_visibility (tree decl)
5140 {
5141 gcc_assert (TREE_CODE (decl) == VAR_DECL
5142 || TREE_CODE (decl) == FUNCTION_DECL);
5143
5144 /* If the user explicitly specified the visibility with an
5145 attribute, honor that. DECL_VISIBILITY will have been set during
5146 the processing of the attribute. We check for an explicit
5147 attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
5148 to distinguish the use of an attribute from the use of a "#pragma
5149 GCC visibility push(...)"; in the latter case we still want other
5150 considerations to be able to overrule the #pragma. */
5151 if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl)))
5152 return true;
5153
5154 /* Anything that is exported must have default visibility. */
5155 if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
5156 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))
5157 {
5158 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
5159 DECL_VISIBILITY_SPECIFIED (decl) = 1;
5160 return true;
5161 }
5162
5163 /* Set default visibility to whatever the user supplied with
5164 visibility_specified depending on #pragma GCC visibility. */
5165 if (!DECL_VISIBILITY_SPECIFIED (decl))
5166 {
5167 DECL_VISIBILITY (decl) = default_visibility;
5168 DECL_VISIBILITY_SPECIFIED (decl) = visibility_options.inpragma;
5169 }
5170 return false;
5171 }
5172
5173 /* Handle an "tls_model" attribute; arguments as in
5174 struct attribute_spec.handler. */
5175
5176 static tree
handle_tls_model_attribute(tree * node,tree name,tree args,int ARG_UNUSED (flags),bool * no_add_attrs)5177 handle_tls_model_attribute (tree *node, tree name, tree args,
5178 int ARG_UNUSED (flags), bool *no_add_attrs)
5179 {
5180 tree id;
5181 tree decl = *node;
5182 enum tls_model kind;
5183
5184 *no_add_attrs = true;
5185
5186 if (!DECL_THREAD_LOCAL_P (decl))
5187 {
5188 warning (OPT_Wattributes, "%qE attribute ignored", name);
5189 return NULL_TREE;
5190 }
5191
5192 kind = DECL_TLS_MODEL (decl);
5193 id = TREE_VALUE (args);
5194 if (TREE_CODE (id) != STRING_CST)
5195 {
5196 error ("tls_model argument not a string");
5197 return NULL_TREE;
5198 }
5199
5200 if (!strcmp (TREE_STRING_POINTER (id), "local-exec"))
5201 kind = TLS_MODEL_LOCAL_EXEC;
5202 else if (!strcmp (TREE_STRING_POINTER (id), "initial-exec"))
5203 kind = TLS_MODEL_INITIAL_EXEC;
5204 else if (!strcmp (TREE_STRING_POINTER (id), "local-dynamic"))
5205 kind = optimize ? TLS_MODEL_LOCAL_DYNAMIC : TLS_MODEL_GLOBAL_DYNAMIC;
5206 else if (!strcmp (TREE_STRING_POINTER (id), "global-dynamic"))
5207 kind = TLS_MODEL_GLOBAL_DYNAMIC;
5208 else
5209 error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
5210
5211 DECL_TLS_MODEL (decl) = kind;
5212 return NULL_TREE;
5213 }
5214
5215 /* Handle a "no_instrument_function" attribute; arguments as in
5216 struct attribute_spec.handler. */
5217
5218 static tree
handle_no_instrument_function_attribute(tree * node,tree name,tree ARG_UNUSED (args),int ARG_UNUSED (flags),bool * no_add_attrs)5219 handle_no_instrument_function_attribute (tree *node, tree name,
5220 tree ARG_UNUSED (args),
5221 int ARG_UNUSED (flags),
5222 bool *no_add_attrs)
5223 {
5224 tree decl = *node;
5225
5226 if (TREE_CODE (decl) != FUNCTION_DECL)
5227 {
5228 error ("%J%qE attribute applies only to functions", decl, name);
5229 *no_add_attrs = true;
5230 }
5231 else if (DECL_INITIAL (decl))
5232 {
5233 error ("%Jcan%'t set %qE attribute after definition", decl, name);
5234 *no_add_attrs = true;
5235 }
5236 else
5237 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
5238
5239 return NULL_TREE;
5240 }
5241
5242 /* Handle a "malloc" attribute; arguments as in
5243 struct attribute_spec.handler. */
5244
5245 static tree
handle_malloc_attribute(tree * node,tree name,tree ARG_UNUSED (args),int ARG_UNUSED (flags),bool * no_add_attrs)5246 handle_malloc_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5247 int ARG_UNUSED (flags), bool *no_add_attrs)
5248 {
5249 if (TREE_CODE (*node) == FUNCTION_DECL
5250 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node))))
5251 DECL_IS_MALLOC (*node) = 1;
5252 else
5253 {
5254 warning (OPT_Wattributes, "%qE attribute ignored", name);
5255 *no_add_attrs = true;
5256 }
5257
5258 return NULL_TREE;
5259 }
5260
5261 /* Handle a "returns_twice" attribute; arguments as in
5262 struct attribute_spec.handler. */
5263
5264 static tree
handle_returns_twice_attribute(tree * node,tree name,tree ARG_UNUSED (args),int ARG_UNUSED (flags),bool * no_add_attrs)5265 handle_returns_twice_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5266 int ARG_UNUSED (flags), bool *no_add_attrs)
5267 {
5268 if (TREE_CODE (*node) == FUNCTION_DECL)
5269 DECL_IS_RETURNS_TWICE (*node) = 1;
5270 else
5271 {
5272 warning (OPT_Wattributes, "%qE attribute ignored", name);
5273 *no_add_attrs = true;
5274 }
5275
5276 return NULL_TREE;
5277 }
5278
5279 /* Handle a "no_limit_stack" attribute; arguments as in
5280 struct attribute_spec.handler. */
5281
5282 static tree
handle_no_limit_stack_attribute(tree * node,tree name,tree ARG_UNUSED (args),int ARG_UNUSED (flags),bool * no_add_attrs)5283 handle_no_limit_stack_attribute (tree *node, tree name,
5284 tree ARG_UNUSED (args),
5285 int ARG_UNUSED (flags),
5286 bool *no_add_attrs)
5287 {
5288 tree decl = *node;
5289
5290 if (TREE_CODE (decl) != FUNCTION_DECL)
5291 {
5292 error ("%J%qE attribute applies only to functions", decl, name);
5293 *no_add_attrs = true;
5294 }
5295 else if (DECL_INITIAL (decl))
5296 {
5297 error ("%Jcan%'t set %qE attribute after definition", decl, name);
5298 *no_add_attrs = true;
5299 }
5300 else
5301 DECL_NO_LIMIT_STACK (decl) = 1;
5302
5303 return NULL_TREE;
5304 }
5305
5306 /* Handle a "pure" attribute; arguments as in
5307 struct attribute_spec.handler. */
5308
5309 static tree
handle_pure_attribute(tree * node,tree name,tree ARG_UNUSED (args),int ARG_UNUSED (flags),bool * no_add_attrs)5310 handle_pure_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5311 int ARG_UNUSED (flags), bool *no_add_attrs)
5312 {
5313 if (TREE_CODE (*node) == FUNCTION_DECL)
5314 DECL_IS_PURE (*node) = 1;
5315 /* ??? TODO: Support types. */
5316 else
5317 {
5318 warning (OPT_Wattributes, "%qE attribute ignored", name);
5319 *no_add_attrs = true;
5320 }
5321
5322 return NULL_TREE;
5323 }
5324
5325 /* Handle a "no vops" attribute; arguments as in
5326 struct attribute_spec.handler. */
5327
5328 static tree
handle_novops_attribute(tree * node,tree ARG_UNUSED (name),tree ARG_UNUSED (args),int ARG_UNUSED (flags),bool * ARG_UNUSED (no_add_attrs))5329 handle_novops_attribute (tree *node, tree ARG_UNUSED (name),
5330 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
5331 bool *ARG_UNUSED (no_add_attrs))
5332 {
5333 gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
5334 DECL_IS_NOVOPS (*node) = 1;
5335 return NULL_TREE;
5336 }
5337
5338 /* Handle a "deprecated" attribute; arguments as in
5339 struct attribute_spec.handler. */
5340
5341 static tree
handle_deprecated_attribute(tree * node,tree name,tree ARG_UNUSED (args),int flags,bool * no_add_attrs)5342 handle_deprecated_attribute (tree *node, tree name,
5343 tree ARG_UNUSED (args), int flags,
5344 bool *no_add_attrs)
5345 {
5346 tree type = NULL_TREE;
5347 int warn = 0;
5348 tree what = NULL_TREE;
5349
5350 if (DECL_P (*node))
5351 {
5352 tree decl = *node;
5353 type = TREE_TYPE (decl);
5354
5355 if (TREE_CODE (decl) == TYPE_DECL
5356 || TREE_CODE (decl) == PARM_DECL
5357 || TREE_CODE (decl) == VAR_DECL
5358 || TREE_CODE (decl) == FUNCTION_DECL
5359 || TREE_CODE (decl) == FIELD_DECL)
5360 TREE_DEPRECATED (decl) = 1;
5361 else
5362 warn = 1;
5363 }
5364 else if (TYPE_P (*node))
5365 {
5366 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5367 *node = build_variant_type_copy (*node);
5368 TREE_DEPRECATED (*node) = 1;
5369 type = *node;
5370 }
5371 else
5372 warn = 1;
5373
5374 if (warn)
5375 {
5376 *no_add_attrs = true;
5377 if (type && TYPE_NAME (type))
5378 {
5379 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
5380 what = TYPE_NAME (*node);
5381 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
5382 && DECL_NAME (TYPE_NAME (type)))
5383 what = DECL_NAME (TYPE_NAME (type));
5384 }
5385 if (what)
5386 warning (OPT_Wattributes, "%qE attribute ignored for %qE", name, what);
5387 else
5388 warning (OPT_Wattributes, "%qE attribute ignored", name);
5389 }
5390
5391 return NULL_TREE;
5392 }
5393
5394 /* APPLE LOCAL begin "unavailable" attribute (Radar 2809697) --ilr */
5395 /* Handle a "unavailable" attribute; arguments as in
5396 struct attribute_spec.handler. */
5397
5398 static tree
handle_unavailable_attribute(tree * node,tree name,tree args ATTRIBUTE_UNUSED,int flags ATTRIBUTE_UNUSED,bool * no_add_attrs)5399 handle_unavailable_attribute (tree *node, tree name,
5400 tree args ATTRIBUTE_UNUSED,
5401 int flags ATTRIBUTE_UNUSED,
5402 bool *no_add_attrs)
5403 {
5404 tree type = NULL_TREE;
5405 int warn = 0;
5406 const char *what = NULL;
5407
5408 if (DECL_P (*node))
5409 {
5410 tree decl = *node;
5411 type = TREE_TYPE (decl);
5412
5413 if (TREE_CODE (decl) == TYPE_DECL
5414 || TREE_CODE (decl) == PARM_DECL
5415 || TREE_CODE (decl) == VAR_DECL
5416 || TREE_CODE (decl) == FUNCTION_DECL
5417 /* APPLE LOCAL begin radar 3803157 - objc attribute */
5418 || TREE_CODE (decl) == FIELD_DECL
5419 || objc_method_decl (TREE_CODE (decl)))
5420 /* APPLE LOCAL end radar 3803157 - objc attribute */
5421 {
5422 TREE_UNAVAILABLE (decl) = 1;
5423 }
5424 else
5425 warn = 1;
5426 }
5427 else if (TYPE_P (*node))
5428 {
5429 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5430 *node = build_variant_type_copy (*node);
5431 TREE_UNAVAILABLE (*node) = 1;
5432 type = *node;
5433 }
5434 else
5435 warn = 1;
5436
5437 if (warn)
5438 {
5439 *no_add_attrs = true;
5440 if (type && TYPE_NAME (type))
5441 {
5442 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
5443 what = IDENTIFIER_POINTER (TYPE_NAME (*node));
5444 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
5445 && DECL_NAME (TYPE_NAME (type)))
5446 what = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
5447 }
5448 if (what)
5449 warning (0, "`%s' attribute ignored for `%s'",
5450 IDENTIFIER_POINTER (name), what);
5451 else
5452 warning (0, "`%s' attribute ignored", IDENTIFIER_POINTER (name));
5453 }
5454
5455 return NULL_TREE;
5456 }
5457 /* APPLE LOCAL end "unavailable" attribute --ilr */
5458
5459 /* Handle a "vector_size" attribute; arguments as in
5460 struct attribute_spec.handler. */
5461
5462 static tree
handle_vector_size_attribute(tree * node,tree name,tree args,int ARG_UNUSED (flags),bool * no_add_attrs)5463 handle_vector_size_attribute (tree *node, tree name, tree args,
5464 int ARG_UNUSED (flags),
5465 bool *no_add_attrs)
5466 {
5467 unsigned HOST_WIDE_INT vecsize, nunits;
5468 enum machine_mode orig_mode;
5469 tree type = *node, new_type, size;
5470
5471 *no_add_attrs = true;
5472
5473 size = TREE_VALUE (args);
5474
5475 if (!host_integerp (size, 1))
5476 {
5477 warning (OPT_Wattributes, "%qE attribute ignored", name);
5478 return NULL_TREE;
5479 }
5480
5481 /* Get the vector size (in bytes). */
5482 vecsize = tree_low_cst (size, 1);
5483
5484 /* We need to provide for vector pointers, vector arrays, and
5485 functions returning vectors. For example:
5486
5487 __attribute__((vector_size(16))) short *foo;
5488
5489 In this case, the mode is SI, but the type being modified is
5490 HI, so we need to look further. */
5491
5492 while (POINTER_TYPE_P (type)
5493 || TREE_CODE (type) == FUNCTION_TYPE
5494 || TREE_CODE (type) == METHOD_TYPE
5495 || TREE_CODE (type) == ARRAY_TYPE)
5496 type = TREE_TYPE (type);
5497
5498 /* Get the mode of the type being modified. */
5499 orig_mode = TYPE_MODE (type);
5500
5501 if (TREE_CODE (type) == RECORD_TYPE
5502 || TREE_CODE (type) == UNION_TYPE
5503 || TREE_CODE (type) == VECTOR_TYPE
5504 || (!SCALAR_FLOAT_MODE_P (orig_mode)
5505 && GET_MODE_CLASS (orig_mode) != MODE_INT)
5506 || !host_integerp (TYPE_SIZE_UNIT (type), 1))
5507 {
5508 error ("invalid vector type for attribute %qE", name);
5509 return NULL_TREE;
5510 }
5511
5512 if (vecsize % tree_low_cst (TYPE_SIZE_UNIT (type), 1))
5513 {
5514 error ("vector size not an integral multiple of component size");
5515 return NULL;
5516 }
5517
5518 if (vecsize == 0)
5519 {
5520 error ("zero vector size");
5521 return NULL;
5522 }
5523
5524 /* Calculate how many units fit in the vector. */
5525 nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
5526 if (nunits & (nunits - 1))
5527 {
5528 error ("number of components of the vector not a power of two");
5529 return NULL_TREE;
5530 }
5531
5532 new_type = build_vector_type (type, nunits);
5533
5534 /* Build back pointers if needed. */
5535 *node = reconstruct_complex_type (*node, new_type);
5536
5537 return NULL_TREE;
5538 }
5539
5540 /* Handle the "nonnull" attribute. */
5541 static tree
handle_nonnull_attribute(tree * node,tree ARG_UNUSED (name),tree args,int ARG_UNUSED (flags),bool * no_add_attrs)5542 handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
5543 tree args, int ARG_UNUSED (flags),
5544 bool *no_add_attrs)
5545 {
5546 tree type = *node;
5547 unsigned HOST_WIDE_INT attr_arg_num;
5548
5549 /* If no arguments are specified, all pointer arguments should be
5550 non-null. Verify a full prototype is given so that the arguments
5551 will have the correct types when we actually check them later. */
5552 if (!args)
5553 {
5554 if (!TYPE_ARG_TYPES (type))
5555 {
5556 error ("nonnull attribute without arguments on a non-prototype");
5557 *no_add_attrs = true;
5558 }
5559 return NULL_TREE;
5560 }
5561
5562 /* Argument list specified. Verify that each argument number references
5563 a pointer argument. */
5564 for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
5565 {
5566 tree argument;
5567 unsigned HOST_WIDE_INT arg_num = 0, ck_num;
5568
5569 if (!get_nonnull_operand (TREE_VALUE (args), &arg_num))
5570 {
5571 error ("nonnull argument has invalid operand number (argument %lu)",
5572 (unsigned long) attr_arg_num);
5573 *no_add_attrs = true;
5574 return NULL_TREE;
5575 }
5576
5577 argument = TYPE_ARG_TYPES (type);
5578 if (argument)
5579 {
5580 for (ck_num = 1; ; ck_num++)
5581 {
5582 if (!argument || ck_num == arg_num)
5583 break;
5584 argument = TREE_CHAIN (argument);
5585 }
5586
5587 if (!argument
5588 || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
5589 {
5590 error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
5591 (unsigned long) attr_arg_num, (unsigned long) arg_num);
5592 *no_add_attrs = true;
5593 return NULL_TREE;
5594 }
5595
5596 /* APPLE LOCAL begin blocks 5925781 */
5597 if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE &&
5598 TREE_CODE (TREE_VALUE (argument)) != BLOCK_POINTER_TYPE)
5599 /* APPLE LOCAL end blocks 5925781 */
5600 {
5601 error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
5602 (unsigned long) attr_arg_num, (unsigned long) arg_num);
5603 *no_add_attrs = true;
5604 return NULL_TREE;
5605 }
5606 }
5607 }
5608
5609 return NULL_TREE;
5610 }
5611
5612 /* Check the argument list of a function call for null in argument slots
5613 that are marked as requiring a non-null pointer argument. */
5614
5615 static void
check_function_nonnull(tree attrs,tree params)5616 check_function_nonnull (tree attrs, tree params)
5617 {
5618 tree a, args, param;
5619 int param_num;
5620
5621 for (a = attrs; a; a = TREE_CHAIN (a))
5622 {
5623 if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
5624 {
5625 args = TREE_VALUE (a);
5626
5627 /* Walk the argument list. If we encounter an argument number we
5628 should check for non-null, do it. If the attribute has no args,
5629 then every pointer argument is checked (in which case the check
5630 for pointer type is done in check_nonnull_arg). */
5631 for (param = params, param_num = 1; ;
5632 param_num++, param = TREE_CHAIN (param))
5633 {
5634 if (!param)
5635 break;
5636 if (!args || nonnull_check_p (args, param_num))
5637 check_function_arguments_recurse (check_nonnull_arg, NULL,
5638 TREE_VALUE (param),
5639 param_num);
5640 }
5641 }
5642 }
5643 }
5644
5645 /* Check that the Nth argument of a function call (counting backwards
5646 from the end) is a (pointer)0. */
5647
5648 static void
check_function_sentinel(tree attrs,tree params,tree typelist)5649 check_function_sentinel (tree attrs, tree params, tree typelist)
5650 {
5651 tree attr = lookup_attribute ("sentinel", attrs);
5652
5653 if (attr)
5654 {
5655 /* Skip over the named arguments. */
5656 while (typelist && params)
5657 {
5658 typelist = TREE_CHAIN (typelist);
5659 params = TREE_CHAIN (params);
5660 }
5661
5662 if (typelist || !params)
5663 warning (OPT_Wformat,
5664 "not enough variable arguments to fit a sentinel");
5665 else
5666 {
5667 tree sentinel, end;
5668 unsigned pos = 0;
5669
5670 if (TREE_VALUE (attr))
5671 {
5672 tree p = TREE_VALUE (TREE_VALUE (attr));
5673 pos = TREE_INT_CST_LOW (p);
5674 }
5675
5676 sentinel = end = params;
5677
5678 /* Advance `end' ahead of `sentinel' by `pos' positions. */
5679 while (pos > 0 && TREE_CHAIN (end))
5680 {
5681 pos--;
5682 end = TREE_CHAIN (end);
5683 }
5684 if (pos > 0)
5685 {
5686 warning (OPT_Wformat,
5687 "not enough variable arguments to fit a sentinel");
5688 return;
5689 }
5690
5691 /* Now advance both until we find the last parameter. */
5692 while (TREE_CHAIN (end))
5693 {
5694 end = TREE_CHAIN (end);
5695 sentinel = TREE_CHAIN (sentinel);
5696 }
5697
5698 /* Validate the sentinel. */
5699 if ((!POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (sentinel)))
5700 || !integer_zerop (TREE_VALUE (sentinel)))
5701 /* Although __null (in C++) is only an integer we allow it
5702 nevertheless, as we are guaranteed that it's exactly
5703 as wide as a pointer, and we don't want to force
5704 users to cast the NULL they have written there.
5705 We warn with -Wstrict-null-sentinel, though. */
5706 && (warn_strict_null_sentinel
5707 || null_node != TREE_VALUE (sentinel)))
5708 warning (OPT_Wformat, "missing sentinel in function call");
5709 }
5710 }
5711 }
5712
5713 /* Helper for check_function_nonnull; given a list of operands which
5714 must be non-null in ARGS, determine if operand PARAM_NUM should be
5715 checked. */
5716
5717 static bool
nonnull_check_p(tree args,unsigned HOST_WIDE_INT param_num)5718 nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num)
5719 {
5720 unsigned HOST_WIDE_INT arg_num = 0;
5721
5722 for (; args; args = TREE_CHAIN (args))
5723 {
5724 bool found = get_nonnull_operand (TREE_VALUE (args), &arg_num);
5725
5726 gcc_assert (found);
5727
5728 if (arg_num == param_num)
5729 return true;
5730 }
5731 return false;
5732 }
5733
5734 /* Check that the function argument PARAM (which is operand number
5735 PARAM_NUM) is non-null. This is called by check_function_nonnull
5736 via check_function_arguments_recurse. */
5737
5738 static void
check_nonnull_arg(void * ARG_UNUSED (ctx),tree param,unsigned HOST_WIDE_INT param_num)5739 check_nonnull_arg (void * ARG_UNUSED (ctx), tree param,
5740 unsigned HOST_WIDE_INT param_num)
5741 {
5742 /* Just skip checking the argument if it's not a pointer. This can
5743 happen if the "nonnull" attribute was given without an operand
5744 list (which means to check every pointer argument). */
5745
5746 /* APPLE LOCAL begin blocks 5925781 */
5747 if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE &&
5748 TREE_CODE (TREE_TYPE (param)) != BLOCK_POINTER_TYPE)
5749 /* APPLE LOCAL end blocks 5925781 */
5750 return;
5751
5752 if (integer_zerop (param))
5753 warning (OPT_Wnonnull, "null argument where non-null required "
5754 "(argument %lu)", (unsigned long) param_num);
5755 }
5756
5757 /* Helper for nonnull attribute handling; fetch the operand number
5758 from the attribute argument list. */
5759
5760 static bool
get_nonnull_operand(tree arg_num_expr,unsigned HOST_WIDE_INT * valp)5761 get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
5762 {
5763 /* Verify the arg number is a constant. */
5764 if (TREE_CODE (arg_num_expr) != INTEGER_CST
5765 || TREE_INT_CST_HIGH (arg_num_expr) != 0)
5766 return false;
5767
5768 *valp = TREE_INT_CST_LOW (arg_num_expr);
5769 return true;
5770 }
5771
5772 /* Handle a "nothrow" attribute; arguments as in
5773 struct attribute_spec.handler. */
5774
5775 static tree
handle_nothrow_attribute(tree * node,tree name,tree ARG_UNUSED (args),int ARG_UNUSED (flags),bool * no_add_attrs)5776 handle_nothrow_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5777 int ARG_UNUSED (flags), bool *no_add_attrs)
5778 {
5779 if (TREE_CODE (*node) == FUNCTION_DECL)
5780 TREE_NOTHROW (*node) = 1;
5781 /* ??? TODO: Support types. */
5782 else
5783 {
5784 warning (OPT_Wattributes, "%qE attribute ignored", name);
5785 *no_add_attrs = true;
5786 }
5787
5788 return NULL_TREE;
5789 }
5790
5791 /* Handle a "cleanup" attribute; arguments as in
5792 struct attribute_spec.handler. */
5793
5794 static tree
handle_cleanup_attribute(tree * node,tree name,tree args,int ARG_UNUSED (flags),bool * no_add_attrs)5795 handle_cleanup_attribute (tree *node, tree name, tree args,
5796 int ARG_UNUSED (flags), bool *no_add_attrs)
5797 {
5798 tree decl = *node;
5799 tree cleanup_id, cleanup_decl;
5800
5801 /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
5802 for global destructors in C++. This requires infrastructure that
5803 we don't have generically at the moment. It's also not a feature
5804 we'd be missing too much, since we do have attribute constructor. */
5805 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
5806 {
5807 warning (OPT_Wattributes, "%qE attribute ignored", name);
5808 *no_add_attrs = true;
5809 return NULL_TREE;
5810 }
5811
5812 /* Verify that the argument is a function in scope. */
5813 /* ??? We could support pointers to functions here as well, if
5814 that was considered desirable. */
5815 cleanup_id = TREE_VALUE (args);
5816 if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE)
5817 {
5818 error ("cleanup argument not an identifier");
5819 *no_add_attrs = true;
5820 return NULL_TREE;
5821 }
5822 cleanup_decl = lookup_name (cleanup_id);
5823 if (!cleanup_decl || TREE_CODE (cleanup_decl) != FUNCTION_DECL)
5824 {
5825 error ("cleanup argument not a function");
5826 *no_add_attrs = true;
5827 return NULL_TREE;
5828 }
5829
5830 /* That the function has proper type is checked with the
5831 eventual call to build_function_call. */
5832
5833 return NULL_TREE;
5834 }
5835
5836 /* Handle a "warn_unused_result" attribute. No special handling. */
5837
5838 static tree
handle_warn_unused_result_attribute(tree * node,tree name,tree ARG_UNUSED (args),int ARG_UNUSED (flags),bool * no_add_attrs)5839 handle_warn_unused_result_attribute (tree *node, tree name,
5840 tree ARG_UNUSED (args),
5841 int ARG_UNUSED (flags), bool *no_add_attrs)
5842 {
5843 /* Ignore the attribute for functions not returning any value. */
5844 if (VOID_TYPE_P (TREE_TYPE (*node)))
5845 {
5846 warning (OPT_Wattributes, "%qE attribute ignored", name);
5847 *no_add_attrs = true;
5848 }
5849
5850 return NULL_TREE;
5851 }
5852
5853 /* APPLE LOCAL begin radar 5932809 - copyable byref blocks */
5854 /* Handle "blocks" attribute. */
5855 static tree
handle_blocks_attribute(tree * node,tree name,tree args,int ARG_UNUSED (flags),bool * no_add_attrs)5856 handle_blocks_attribute (tree *node, tree name,
5857 tree args,
5858 int ARG_UNUSED (flags), bool *no_add_attrs)
5859 {
5860 tree arg_ident;
5861 /* APPLE LOCAL radar 6217257 */
5862 tree type;
5863 *no_add_attrs = true;
5864 if (!(*node) || TREE_CODE (*node) != VAR_DECL)
5865 {
5866 error ("__block attribute can be specified on variables only");
5867 return NULL_TREE;
5868 }
5869 arg_ident = TREE_VALUE (args);
5870 gcc_assert (TREE_CODE (arg_ident) == IDENTIFIER_NODE);
5871 /* APPLE LOCAL radar 6096219 */
5872 if (strcmp (IDENTIFIER_POINTER (arg_ident), "byref"))
5873 {
5874 /* APPLE LOCAL radar 6096219 */
5875 warning (OPT_Wattributes, "Only \"byref\" is allowed - %qE attribute ignored",
5876 name);
5877 return NULL_TREE;
5878 }
5879 /* APPLE LOCAL begin radar 6217257 */
5880 type = TREE_TYPE (*node);
5881 if (TREE_CODE (type) == ERROR_MARK)
5882 return NULL_TREE;
5883 if (TREE_CODE (type) == ARRAY_TYPE)
5884 {
5885 if (!TYPE_SIZE (type) || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
5886 {
5887 error ("__block not allowed on a variable length array declaration");
5888 return NULL_TREE;
5889 }
5890 }
5891 /* APPLE LOCAL end radar 6217257 */
5892 COPYABLE_BYREF_LOCAL_VAR (*node) = 1;
5893 COPYABLE_BYREF_LOCAL_NONPOD (*node) = block_requires_copying (*node);
5894 return NULL_TREE;
5895 }
5896 /* APPLE LOCAL end radar 5932809 - copyable byref blocks */
5897
5898 /* APPLE LOCAL begin blocks 6040305 */
5899
5900 /* This routine builds:
5901 *(void **)(EXP+20) expression which references the object pointer.
5902 */
5903 tree
build_indirect_object_id_exp(tree exp)5904 build_indirect_object_id_exp (tree exp)
5905 {
5906 tree dst_obj;
5907 int int_size = int_cst_value (TYPE_SIZE_UNIT (unsigned_type_node));
5908 int offset;
5909 /* dst->object In thid case 'object' is the field
5910 of the object passed offset by: void * + void* + int + int + void* + void *
5911 This must match definition of Block_byref structs. */
5912 /* APPLE LOCAL radar 6244520 */
5913 offset = GET_MODE_SIZE (Pmode) + GET_MODE_SIZE (Pmode)
5914 + int_size + int_size + GET_MODE_SIZE (Pmode) +
5915 GET_MODE_SIZE (Pmode);
5916 dst_obj = build2 (PLUS_EXPR, ptr_type_node, exp,
5917 build_int_cst (NULL_TREE, offset));
5918 /* APPLE LOCAL begin radar 6180456 */
5919 /* Type case to: 'void **' */
5920 dst_obj = build_c_cast (build_pointer_type (ptr_type_node), dst_obj);
5921 dst_obj = build_indirect_ref (dst_obj, "unary *");
5922 /* APPLE LOCAL end radar 6180456 */
5923 return dst_obj;
5924 }
5925
5926 /* This routine builds call to:
5927 _Block_object_dispose(VAR_DECL.__forwarding, BLOCK_FIELD_IS_BYREF);
5928 and adds it to the statement list.
5929 */
5930 tree
build_block_byref_release_exp(tree var_decl)5931 build_block_byref_release_exp (tree var_decl)
5932 {
5933 tree exp = var_decl, call_exp;
5934 tree type = TREE_TYPE (var_decl);
5935 /* __block variables imported into Blocks are not _Block_object_dispose()
5936 from within the Block statement itself; otherwise, each envokation of
5937 the block causes a release. Make sure to release __block variables declared
5938 and used locally in the block though. */
5939 if (cur_block
5940 && (BLOCK_DECL_COPIED (var_decl) || BLOCK_DECL_BYREF (var_decl)))
5941 return NULL_TREE;
5942 if (BLOCK_DECL_BYREF (var_decl)) {
5943 /* This is a "struct Block_byref_X *" type. Get its pointee. */
5944 gcc_assert (POINTER_TYPE_P (type));
5945 type = TREE_TYPE (type);
5946 exp = build_indirect_ref (exp, "unary *");
5947 }
5948 TREE_USED (var_decl) = 1;
5949
5950 /* Declare: _Block_object_dispose(void*, BLOCK_FIELD_IS_BYREF) if not done already. */
5951 exp = build_component_ref (exp, get_identifier ("__forwarding"));
5952 call_exp = build_block_object_dispose_call_exp (exp, BLOCK_FIELD_IS_BYREF);
5953 return call_exp;
5954 }
5955 /* APPLE LOCAL end blocks 6040305 */
5956 /* APPLE LOCAL begin radar 5803600 */
5957 /** add_block_global_byref_list - Adds global variable decl to the list of
5958 byref global declarations in the current block.
5959 */
add_block_global_byref_list(tree decl)5960 void add_block_global_byref_list (tree decl)
5961 {
5962 cur_block->block_byref_global_decl_list =
5963 tree_cons (NULL_TREE, decl, cur_block->block_byref_global_decl_list);
5964 }
5965
5966 /** in_block_global_byref_list - returns TRUE if global variable is
5967 in the list of 'byref' declarations.
5968 */
in_block_global_byref_list(tree decl)5969 bool in_block_global_byref_list (tree decl)
5970 {
5971 tree chain;
5972 if (TREE_STATIC (decl)) {
5973 for (chain = cur_block->block_byref_global_decl_list; chain;
5974 chain = TREE_CHAIN (chain))
5975 if (TREE_VALUE (chain) == decl)
5976 return true;
5977 }
5978 return false;
5979 }
5980 /* APPLE LOCAL end radar 5803600 */
5981
5982 /* APPLE LOCAL begin radar 6160536 */
5983 tree
build_block_helper_name(int unique_count)5984 build_block_helper_name (int unique_count)
5985 {
5986 char *buf;
5987 if (!current_function_decl)
5988 {
5989 /* APPLE LOCAL begin radar 6411649 */
5990 static int global_count;
5991 buf = (char *)alloca (32);
5992 sprintf (buf, "__block_global_%d", ++global_count);
5993 /* APPLE LOCAL end radar 6411649 */
5994 }
5995 else
5996 {
5997 tree outer_decl = current_function_decl;
5998 /* APPLE LOCAL begin radar 6169580 */
5999 while (outer_decl &&
6000 DECL_CONTEXT (outer_decl) && TREE_CODE (DECL_CONTEXT (outer_decl)) == FUNCTION_DECL)
6001 /* APPLE LOCAL end radar 6169580 */
6002 outer_decl = DECL_CONTEXT (outer_decl);
6003 /* APPLE LOCAL begin radar 6411649 */
6004 if (!unique_count)
6005 unique_count = ++DECL_STRUCT_FUNCTION(outer_decl)->unqiue_block_number;
6006 /* APPLE LOCAL end radar 6411649 */
6007 buf = (char *)alloca (IDENTIFIER_LENGTH (DECL_NAME (outer_decl)) + 32);
6008 sprintf (buf, "__%s_block_invoke_%d",
6009 IDENTIFIER_POINTER (DECL_NAME (outer_decl)), unique_count);
6010 }
6011 return get_identifier (buf);
6012 }
6013 /* APPLE LOCAL end radar 6160536 */
6014
6015 /* Handle a "sentinel" attribute. */
6016
6017 static tree
handle_sentinel_attribute(tree * node,tree name,tree args,int ARG_UNUSED (flags),bool * no_add_attrs)6018 handle_sentinel_attribute (tree *node, tree name, tree args,
6019 int ARG_UNUSED (flags), bool *no_add_attrs)
6020 {
6021 tree params = TYPE_ARG_TYPES (*node);
6022
6023 if (!params)
6024 {
6025 warning (OPT_Wattributes,
6026 "%qE attribute requires prototypes with named arguments", name);
6027 *no_add_attrs = true;
6028 }
6029 else
6030 {
6031 while (TREE_CHAIN (params))
6032 params = TREE_CHAIN (params);
6033
6034 if (VOID_TYPE_P (TREE_VALUE (params)))
6035 {
6036 warning (OPT_Wattributes,
6037 "%qE attribute only applies to variadic functions", name);
6038 *no_add_attrs = true;
6039 }
6040 }
6041
6042 if (args)
6043 {
6044 tree position = TREE_VALUE (args);
6045
6046 if (TREE_CODE (position) != INTEGER_CST)
6047 {
6048 warning (0, "requested position is not an integer constant");
6049 *no_add_attrs = true;
6050 }
6051 else
6052 {
6053 if (tree_int_cst_lt (position, integer_zero_node))
6054 {
6055 warning (0, "requested position is less than zero");
6056 *no_add_attrs = true;
6057 }
6058 }
6059 }
6060
6061 return NULL_TREE;
6062 }
6063
6064 /* Check for valid arguments being passed to a function. */
6065 void
check_function_arguments(tree attrs,tree params,tree typelist)6066 check_function_arguments (tree attrs, tree params, tree typelist)
6067 {
6068 /* Check for null being passed in a pointer argument that must be
6069 non-null. We also need to do this if format checking is enabled. */
6070
6071 if (warn_nonnull)
6072 check_function_nonnull (attrs, params);
6073
6074 /* Check for errors in format strings. */
6075
6076 if (warn_format || warn_missing_format_attribute)
6077 check_function_format (attrs, params);
6078
6079 if (warn_format)
6080 check_function_sentinel (attrs, params, typelist);
6081 }
6082
6083 /* Generic argument checking recursion routine. PARAM is the argument to
6084 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
6085 once the argument is resolved. CTX is context for the callback. */
6086 void
check_function_arguments_recurse(void (* callback)(void *,tree,unsigned HOST_WIDE_INT),void * ctx,tree param,unsigned HOST_WIDE_INT param_num)6087 check_function_arguments_recurse (void (*callback)
6088 (void *, tree, unsigned HOST_WIDE_INT),
6089 void *ctx, tree param,
6090 unsigned HOST_WIDE_INT param_num)
6091 {
6092 if ((TREE_CODE (param) == NOP_EXPR || TREE_CODE (param) == CONVERT_EXPR)
6093 && (TYPE_PRECISION (TREE_TYPE (param))
6094 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (param, 0)))))
6095 {
6096 /* Strip coercion. */
6097 check_function_arguments_recurse (callback, ctx,
6098 TREE_OPERAND (param, 0), param_num);
6099 return;
6100 }
6101
6102 if (TREE_CODE (param) == CALL_EXPR)
6103 {
6104 tree type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (param, 0)));
6105 tree attrs;
6106 bool found_format_arg = false;
6107
6108 /* See if this is a call to a known internationalization function
6109 that modifies a format arg. Such a function may have multiple
6110 format_arg attributes (for example, ngettext). */
6111
6112 for (attrs = TYPE_ATTRIBUTES (type);
6113 attrs;
6114 attrs = TREE_CHAIN (attrs))
6115 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
6116 {
6117 tree inner_args;
6118 tree format_num_expr;
6119 int format_num;
6120 int i;
6121
6122 /* Extract the argument number, which was previously checked
6123 to be valid. */
6124 format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
6125
6126 gcc_assert (TREE_CODE (format_num_expr) == INTEGER_CST
6127 && !TREE_INT_CST_HIGH (format_num_expr));
6128
6129 format_num = TREE_INT_CST_LOW (format_num_expr);
6130
6131 for (inner_args = TREE_OPERAND (param, 1), i = 1;
6132 inner_args != 0;
6133 inner_args = TREE_CHAIN (inner_args), i++)
6134 if (i == format_num)
6135 {
6136 check_function_arguments_recurse (callback, ctx,
6137 TREE_VALUE (inner_args),
6138 param_num);
6139 found_format_arg = true;
6140 break;
6141 }
6142 }
6143
6144 /* If we found a format_arg attribute and did a recursive check,
6145 we are done with checking this argument. Otherwise, we continue
6146 and this will be considered a non-literal. */
6147 if (found_format_arg)
6148 return;
6149 }
6150
6151 if (TREE_CODE (param) == COND_EXPR)
6152 {
6153 /* Check both halves of the conditional expression. */
6154 check_function_arguments_recurse (callback, ctx,
6155 TREE_OPERAND (param, 1), param_num);
6156 check_function_arguments_recurse (callback, ctx,
6157 TREE_OPERAND (param, 2), param_num);
6158 return;
6159 }
6160
6161 (*callback) (ctx, param, param_num);
6162 }
6163
6164 /* Function to help qsort sort FIELD_DECLs by name order. */
6165
6166 int
field_decl_cmp(const void * x_p,const void * y_p)6167 field_decl_cmp (const void *x_p, const void *y_p)
6168 {
6169 const tree *const x = (const tree *const) x_p;
6170 const tree *const y = (const tree *const) y_p;
6171
6172 if (DECL_NAME (*x) == DECL_NAME (*y))
6173 /* A nontype is "greater" than a type. */
6174 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
6175 if (DECL_NAME (*x) == NULL_TREE)
6176 return -1;
6177 if (DECL_NAME (*y) == NULL_TREE)
6178 return 1;
6179 if (DECL_NAME (*x) < DECL_NAME (*y))
6180 return -1;
6181 return 1;
6182 }
6183
6184 static struct {
6185 gt_pointer_operator new_value;
6186 void *cookie;
6187 } resort_data;
6188
6189 /* This routine compares two fields like field_decl_cmp but using the
6190 pointer operator in resort_data. */
6191
6192 static int
resort_field_decl_cmp(const void * x_p,const void * y_p)6193 resort_field_decl_cmp (const void *x_p, const void *y_p)
6194 {
6195 const tree *const x = (const tree *const) x_p;
6196 const tree *const y = (const tree *const) y_p;
6197
6198 if (DECL_NAME (*x) == DECL_NAME (*y))
6199 /* A nontype is "greater" than a type. */
6200 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
6201 if (DECL_NAME (*x) == NULL_TREE)
6202 return -1;
6203 if (DECL_NAME (*y) == NULL_TREE)
6204 return 1;
6205 {
6206 tree d1 = DECL_NAME (*x);
6207 tree d2 = DECL_NAME (*y);
6208 resort_data.new_value (&d1, resort_data.cookie);
6209 resort_data.new_value (&d2, resort_data.cookie);
6210 if (d1 < d2)
6211 return -1;
6212 }
6213 return 1;
6214 }
6215
6216 /* Resort DECL_SORTED_FIELDS because pointers have been reordered. */
6217
6218 void
resort_sorted_fields(void * obj,void * ARG_UNUSED (orig_obj),gt_pointer_operator new_value,void * cookie)6219 resort_sorted_fields (void *obj,
6220 void * ARG_UNUSED (orig_obj),
6221 gt_pointer_operator new_value,
6222 void *cookie)
6223 {
6224 struct sorted_fields_type *sf = (struct sorted_fields_type *) obj;
6225 resort_data.new_value = new_value;
6226 resort_data.cookie = cookie;
6227 qsort (&sf->elts[0], sf->len, sizeof (tree),
6228 resort_field_decl_cmp);
6229 }
6230
6231 /* Subroutine of c_parse_error.
6232 Return the result of concatenating LHS and RHS. RHS is really
6233 a string literal, its first character is indicated by RHS_START and
6234 RHS_SIZE is its length (including the terminating NUL character).
6235
6236 The caller is responsible for deleting the returned pointer. */
6237
6238 static char *
catenate_strings(const char * lhs,const char * rhs_start,int rhs_size)6239 catenate_strings (const char *lhs, const char *rhs_start, int rhs_size)
6240 {
6241 const int lhs_size = strlen (lhs);
6242 char *result = XNEWVEC (char, lhs_size + rhs_size);
6243 strncpy (result, lhs, lhs_size);
6244 strncpy (result + lhs_size, rhs_start, rhs_size);
6245 return result;
6246 }
6247
6248 /* Issue the error given by GMSGID, indicating that it occurred before
6249 TOKEN, which had the associated VALUE. */
6250
6251 void
c_parse_error(const char * gmsgid,enum cpp_ttype token,tree value)6252 c_parse_error (const char *gmsgid, enum cpp_ttype token, tree value)
6253 {
6254 #define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
6255
6256 char *message = NULL;
6257
6258 if (token == CPP_EOF)
6259 message = catenate_messages (gmsgid, " at end of input");
6260 else if (token == CPP_CHAR || token == CPP_WCHAR)
6261 {
6262 unsigned int val = TREE_INT_CST_LOW (value);
6263 const char *const ell = (token == CPP_CHAR) ? "" : "L";
6264 if (val <= UCHAR_MAX && ISGRAPH (val))
6265 message = catenate_messages (gmsgid, " before %s'%c'");
6266 else
6267 message = catenate_messages (gmsgid, " before %s'\\x%x'");
6268
6269 error (message, ell, val);
6270 free (message);
6271 message = NULL;
6272 }
6273 else if (token == CPP_STRING || token == CPP_WSTRING)
6274 message = catenate_messages (gmsgid, " before string constant");
6275 else if (token == CPP_NUMBER)
6276 message = catenate_messages (gmsgid, " before numeric constant");
6277 else if (token == CPP_NAME)
6278 {
6279 message = catenate_messages (gmsgid, " before %qE");
6280 error (message, value);
6281 free (message);
6282 message = NULL;
6283 }
6284 else if (token == CPP_PRAGMA)
6285 message = catenate_messages (gmsgid, " before %<#pragma%>");
6286 else if (token == CPP_PRAGMA_EOL)
6287 message = catenate_messages (gmsgid, " before end of line");
6288 else if (token < N_TTYPES)
6289 {
6290 message = catenate_messages (gmsgid, " before %qs token");
6291 error (message, cpp_type2name (token));
6292 free (message);
6293 message = NULL;
6294 }
6295 else
6296 error (gmsgid, "");
6297
6298 if (message)
6299 {
6300 error (message, "");
6301 free (message);
6302 }
6303 #undef catenate_messages
6304 }
6305
6306 /* Walk a gimplified function and warn for functions whose return value is
6307 ignored and attribute((warn_unused_result)) is set. This is done before
6308 inlining, so we don't have to worry about that. */
6309
6310 void
c_warn_unused_result(tree * top_p)6311 c_warn_unused_result (tree *top_p)
6312 {
6313 tree t = *top_p;
6314 tree_stmt_iterator i;
6315 tree fdecl, ftype;
6316
6317 switch (TREE_CODE (t))
6318 {
6319 case STATEMENT_LIST:
6320 for (i = tsi_start (*top_p); !tsi_end_p (i); tsi_next (&i))
6321 c_warn_unused_result (tsi_stmt_ptr (i));
6322 break;
6323
6324 case COND_EXPR:
6325 c_warn_unused_result (&COND_EXPR_THEN (t));
6326 c_warn_unused_result (&COND_EXPR_ELSE (t));
6327 break;
6328 case BIND_EXPR:
6329 c_warn_unused_result (&BIND_EXPR_BODY (t));
6330 break;
6331 case TRY_FINALLY_EXPR:
6332 case TRY_CATCH_EXPR:
6333 c_warn_unused_result (&TREE_OPERAND (t, 0));
6334 c_warn_unused_result (&TREE_OPERAND (t, 1));
6335 break;
6336 case CATCH_EXPR:
6337 c_warn_unused_result (&CATCH_BODY (t));
6338 break;
6339 case EH_FILTER_EXPR:
6340 c_warn_unused_result (&EH_FILTER_FAILURE (t));
6341 break;
6342
6343 case CALL_EXPR:
6344 if (TREE_USED (t))
6345 break;
6346
6347 /* This is a naked call, as opposed to a CALL_EXPR nested inside
6348 a MODIFY_EXPR. All calls whose value is ignored should be
6349 represented like this. Look for the attribute. */
6350 fdecl = get_callee_fndecl (t);
6351 if (fdecl)
6352 ftype = TREE_TYPE (fdecl);
6353 else
6354 {
6355 ftype = TREE_TYPE (TREE_OPERAND (t, 0));
6356 /* Look past pointer-to-function to the function type itself. */
6357 ftype = TREE_TYPE (ftype);
6358 }
6359
6360 if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype)))
6361 {
6362 if (fdecl)
6363 warning (0, "%Hignoring return value of %qD, "
6364 "declared with attribute warn_unused_result",
6365 EXPR_LOCUS (t), fdecl);
6366 else
6367 warning (0, "%Hignoring return value of function "
6368 "declared with attribute warn_unused_result",
6369 EXPR_LOCUS (t));
6370 }
6371 break;
6372
6373 default:
6374 /* Not a container, not a call, or a call whose value is used. */
6375 break;
6376 }
6377 }
6378
6379 /* Convert a character from the host to the target execution character
6380 set. cpplib handles this, mostly. */
6381
6382 HOST_WIDE_INT
c_common_to_target_charset(HOST_WIDE_INT c)6383 c_common_to_target_charset (HOST_WIDE_INT c)
6384 {
6385 /* Character constants in GCC proper are sign-extended under -fsigned-char,
6386 zero-extended under -fno-signed-char. cpplib insists that characters
6387 and character constants are always unsigned. Hence we must convert
6388 back and forth. */
6389 cppchar_t uc = ((cppchar_t)c) & ((((cppchar_t)1) << CHAR_BIT)-1);
6390
6391 uc = cpp_host_to_exec_charset (parse_in, uc);
6392
6393 if (flag_signed_char)
6394 return ((HOST_WIDE_INT)uc) << (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE)
6395 >> (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE);
6396 else
6397 return uc;
6398 }
6399
6400 /* Build the result of __builtin_offsetof. EXPR is a nested sequence of
6401 component references, with STOP_REF, or alternatively an INDIRECT_REF of
6402 NULL, at the bottom; much like the traditional rendering of offsetof as a
6403 macro. Returns the folded and properly cast result. */
6404
6405 static tree
fold_offsetof_1(tree expr,tree stop_ref)6406 fold_offsetof_1 (tree expr, tree stop_ref)
6407 {
6408 enum tree_code code = PLUS_EXPR;
6409 tree base, off, t;
6410
6411 if (expr == stop_ref && TREE_CODE (expr) != ERROR_MARK)
6412 return size_zero_node;
6413
6414 switch (TREE_CODE (expr))
6415 {
6416 case ERROR_MARK:
6417 return expr;
6418
6419 case VAR_DECL:
6420 error ("cannot apply %<offsetof%> to static data member %qD", expr);
6421 return error_mark_node;
6422
6423 case CALL_EXPR:
6424 error ("cannot apply %<offsetof%> when %<operator[]%> is overloaded");
6425 return error_mark_node;
6426
6427 case INTEGER_CST:
6428 gcc_assert (integer_zerop (expr));
6429 return size_zero_node;
6430
6431 case NOP_EXPR:
6432 case INDIRECT_REF:
6433 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
6434 gcc_assert (base == error_mark_node || base == size_zero_node);
6435 return base;
6436
6437 case COMPONENT_REF:
6438 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
6439 if (base == error_mark_node)
6440 return base;
6441
6442 t = TREE_OPERAND (expr, 1);
6443 if (DECL_C_BIT_FIELD (t))
6444 {
6445 error ("attempt to take address of bit-field structure "
6446 "member %qD", t);
6447 return error_mark_node;
6448 }
6449 off = size_binop (PLUS_EXPR, DECL_FIELD_OFFSET (t),
6450 size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t), 1)
6451 / BITS_PER_UNIT));
6452 break;
6453
6454 case ARRAY_REF:
6455 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
6456 if (base == error_mark_node)
6457 return base;
6458
6459 t = TREE_OPERAND (expr, 1);
6460 if (TREE_CODE (t) == INTEGER_CST && tree_int_cst_sgn (t) < 0)
6461 {
6462 code = MINUS_EXPR;
6463 t = fold_build1 (NEGATE_EXPR, TREE_TYPE (t), t);
6464 }
6465 t = convert (sizetype, t);
6466 off = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (TREE_TYPE (expr)), t);
6467 break;
6468
6469 case COMPOUND_EXPR:
6470 /* Handle static members of volatile structs. */
6471 t = TREE_OPERAND (expr, 1);
6472 gcc_assert (TREE_CODE (t) == VAR_DECL);
6473 return fold_offsetof_1 (t, stop_ref);
6474
6475 default:
6476 gcc_unreachable ();
6477 }
6478
6479 return size_binop (code, base, off);
6480 }
6481
6482 tree
fold_offsetof(tree expr,tree stop_ref)6483 fold_offsetof (tree expr, tree stop_ref)
6484 {
6485 /* Convert back from the internal sizetype to size_t. */
6486 return convert (size_type_node, fold_offsetof_1 (expr, stop_ref));
6487 }
6488
6489 /* Print an error message for an invalid lvalue. USE says
6490 how the lvalue is being used and so selects the error message. */
6491
6492 void
lvalue_error(enum lvalue_use use)6493 lvalue_error (enum lvalue_use use)
6494 {
6495 switch (use)
6496 {
6497 case lv_assign:
6498 error ("lvalue required as left operand of assignment");
6499 break;
6500 case lv_increment:
6501 error ("lvalue required as increment operand");
6502 break;
6503 case lv_decrement:
6504 error ("lvalue required as decrement operand");
6505 break;
6506 case lv_addressof:
6507 error ("lvalue required as unary %<&%> operand");
6508 break;
6509 case lv_asm:
6510 error ("lvalue required in asm statement");
6511 break;
6512 default:
6513 gcc_unreachable ();
6514 }
6515 }
6516
6517 /* *PTYPE is an incomplete array. Complete it with a domain based on
6518 INITIAL_VALUE. If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
6519 is true. Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
6520 2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty. */
6521
6522 int
complete_array_type(tree * ptype,tree initial_value,bool do_default)6523 complete_array_type (tree *ptype, tree initial_value, bool do_default)
6524 {
6525 tree maxindex, type, main_type, elt, unqual_elt;
6526 int failure = 0, quals;
6527
6528 maxindex = size_zero_node;
6529 if (initial_value)
6530 {
6531 if (TREE_CODE (initial_value) == STRING_CST)
6532 {
6533 int eltsize
6534 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
6535 maxindex = size_int (TREE_STRING_LENGTH (initial_value)/eltsize - 1);
6536 }
6537 else if (TREE_CODE (initial_value) == CONSTRUCTOR)
6538 {
6539 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
6540
6541 if (VEC_empty (constructor_elt, v))
6542 {
6543 if (pedantic)
6544 failure = 3;
6545 maxindex = integer_minus_one_node;
6546 }
6547 else
6548 {
6549 tree curindex;
6550 unsigned HOST_WIDE_INT cnt;
6551 constructor_elt *ce;
6552
6553 if (VEC_index (constructor_elt, v, 0)->index)
6554 maxindex = fold_convert (sizetype,
6555 VEC_index (constructor_elt,
6556 v, 0)->index);
6557 curindex = maxindex;
6558
6559 for (cnt = 1;
6560 VEC_iterate (constructor_elt, v, cnt, ce);
6561 cnt++)
6562 {
6563 if (ce->index)
6564 curindex = fold_convert (sizetype, ce->index);
6565 else
6566 curindex = size_binop (PLUS_EXPR, curindex, size_one_node);
6567
6568 if (tree_int_cst_lt (maxindex, curindex))
6569 maxindex = curindex;
6570 }
6571 }
6572 }
6573 else
6574 {
6575 /* Make an error message unless that happened already. */
6576 if (initial_value != error_mark_node)
6577 failure = 1;
6578 }
6579 }
6580 else
6581 {
6582 failure = 2;
6583 if (!do_default)
6584 return failure;
6585 }
6586
6587 type = *ptype;
6588 elt = TREE_TYPE (type);
6589 quals = TYPE_QUALS (strip_array_types (elt));
6590 if (quals == 0)
6591 unqual_elt = elt;
6592 else
6593 unqual_elt = c_build_qualified_type (elt, TYPE_UNQUALIFIED);
6594
6595 /* Using build_distinct_type_copy and modifying things afterward instead
6596 of using build_array_type to create a new type preserves all of the
6597 TYPE_LANG_FLAG_? bits that the front end may have set. */
6598 main_type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
6599 TREE_TYPE (main_type) = unqual_elt;
6600 TYPE_DOMAIN (main_type) = build_index_type (maxindex);
6601 layout_type (main_type);
6602
6603 if (quals == 0)
6604 type = main_type;
6605 else
6606 type = c_build_qualified_type (main_type, quals);
6607
6608 *ptype = type;
6609 return failure;
6610 }
6611
6612
6613 /* Used to help initialize the builtin-types.def table. When a type of
6614 the correct size doesn't exist, use error_mark_node instead of NULL.
6615 The later results in segfaults even when a decl using the type doesn't
6616 get invoked. */
6617
6618 tree
builtin_type_for_size(int size,bool unsignedp)6619 builtin_type_for_size (int size, bool unsignedp)
6620 {
6621 tree type = lang_hooks.types.type_for_size (size, unsignedp);
6622 return type ? type : error_mark_node;
6623 }
6624
6625 /* A helper function for resolve_overloaded_builtin in resolving the
6626 overloaded __sync_ builtins. Returns a positive power of 2 if the
6627 first operand of PARAMS is a pointer to a supported data type.
6628 Returns 0 if an error is encountered. */
6629
6630 static int
sync_resolve_size(tree function,tree params)6631 sync_resolve_size (tree function, tree params)
6632 {
6633 tree type;
6634 int size;
6635
6636 if (params == NULL)
6637 {
6638 error ("too few arguments to function %qE", function);
6639 return 0;
6640 }
6641
6642 type = TREE_TYPE (TREE_VALUE (params));
6643 if (TREE_CODE (type) != POINTER_TYPE)
6644 goto incompatible;
6645
6646 type = TREE_TYPE (type);
6647 if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
6648 goto incompatible;
6649
6650 size = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
6651 if (size == 1 || size == 2 || size == 4 || size == 8 || size == 16)
6652 return size;
6653
6654 incompatible:
6655 error ("incompatible type for argument %d of %qE", 1, function);
6656 return 0;
6657 }
6658
6659 /* A helper function for resolve_overloaded_builtin. Adds casts to
6660 PARAMS to make arguments match up with those of FUNCTION. Drops
6661 the variadic arguments at the end. Returns false if some error
6662 was encountered; true on success. */
6663
6664 static bool
sync_resolve_params(tree orig_function,tree function,tree params)6665 sync_resolve_params (tree orig_function, tree function, tree params)
6666 {
6667 tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (function));
6668 tree ptype;
6669 int number;
6670
6671 /* We've declared the implementation functions to use "volatile void *"
6672 as the pointer parameter, so we shouldn't get any complaints from the
6673 call to check_function_arguments what ever type the user used. */
6674 arg_types = TREE_CHAIN (arg_types);
6675 ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params)));
6676 number = 2;
6677
6678 /* For the rest of the values, we need to cast these to FTYPE, so that we
6679 don't get warnings for passing pointer types, etc. */
6680 while (arg_types != void_list_node)
6681 {
6682 tree val;
6683
6684 params = TREE_CHAIN (params);
6685 if (params == NULL)
6686 {
6687 error ("too few arguments to function %qE", orig_function);
6688 return false;
6689 }
6690
6691 /* ??? Ideally for the first conversion we'd use convert_for_assignment
6692 so that we get warnings for anything that doesn't match the pointer
6693 type. This isn't portable across the C and C++ front ends atm. */
6694 val = TREE_VALUE (params);
6695 val = convert (ptype, val);
6696 val = convert (TREE_VALUE (arg_types), val);
6697 TREE_VALUE (params) = val;
6698
6699 arg_types = TREE_CHAIN (arg_types);
6700 number++;
6701 }
6702
6703 /* The definition of these primitives is variadic, with the remaining
6704 being "an optional list of variables protected by the memory barrier".
6705 No clue what that's supposed to mean, precisely, but we consider all
6706 call-clobbered variables to be protected so we're safe. */
6707 TREE_CHAIN (params) = NULL;
6708
6709 return true;
6710 }
6711
6712 /* A helper function for resolve_overloaded_builtin. Adds a cast to
6713 RESULT to make it match the type of the first pointer argument in
6714 PARAMS. */
6715
6716 static tree
sync_resolve_return(tree params,tree result)6717 sync_resolve_return (tree params, tree result)
6718 {
6719 tree ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params)));
6720 ptype = TYPE_MAIN_VARIANT (ptype);
6721 return convert (ptype, result);
6722 }
6723
6724 /* Some builtin functions are placeholders for other expressions. This
6725 function should be called immediately after parsing the call expression
6726 before surrounding code has committed to the type of the expression.
6727
6728 FUNCTION is the DECL that has been invoked; it is known to be a builtin.
6729 PARAMS is the argument list for the call. The return value is non-null
6730 when expansion is complete, and null if normal processing should
6731 continue. */
6732
6733 tree
resolve_overloaded_builtin(tree function,tree params)6734 resolve_overloaded_builtin (tree function, tree params)
6735 {
6736 enum built_in_function orig_code = DECL_FUNCTION_CODE (function);
6737 switch (DECL_BUILT_IN_CLASS (function))
6738 {
6739 case BUILT_IN_NORMAL:
6740 break;
6741 case BUILT_IN_MD:
6742 if (targetm.resolve_overloaded_builtin)
6743 return targetm.resolve_overloaded_builtin (function, params);
6744 else
6745 return NULL_TREE;
6746 default:
6747 return NULL_TREE;
6748 }
6749
6750 /* Handle BUILT_IN_NORMAL here. */
6751 switch (orig_code)
6752 {
6753 case BUILT_IN_FETCH_AND_ADD_N:
6754 case BUILT_IN_FETCH_AND_SUB_N:
6755 case BUILT_IN_FETCH_AND_OR_N:
6756 case BUILT_IN_FETCH_AND_AND_N:
6757 case BUILT_IN_FETCH_AND_XOR_N:
6758 case BUILT_IN_FETCH_AND_NAND_N:
6759 case BUILT_IN_ADD_AND_FETCH_N:
6760 case BUILT_IN_SUB_AND_FETCH_N:
6761 case BUILT_IN_OR_AND_FETCH_N:
6762 case BUILT_IN_AND_AND_FETCH_N:
6763 case BUILT_IN_XOR_AND_FETCH_N:
6764 case BUILT_IN_NAND_AND_FETCH_N:
6765 case BUILT_IN_BOOL_COMPARE_AND_SWAP_N:
6766 case BUILT_IN_VAL_COMPARE_AND_SWAP_N:
6767 case BUILT_IN_LOCK_TEST_AND_SET_N:
6768 case BUILT_IN_LOCK_RELEASE_N:
6769 {
6770 int n = sync_resolve_size (function, params);
6771 tree new_function, result;
6772
6773 if (n == 0)
6774 return error_mark_node;
6775
6776 new_function = built_in_decls[orig_code + exact_log2 (n) + 1];
6777 if (!sync_resolve_params (function, new_function, params))
6778 return error_mark_node;
6779
6780 result = build_function_call (new_function, params);
6781 if (orig_code != BUILT_IN_BOOL_COMPARE_AND_SWAP_N
6782 && orig_code != BUILT_IN_LOCK_RELEASE_N)
6783 result = sync_resolve_return (params, result);
6784
6785 return result;
6786 }
6787
6788 default:
6789 return NULL_TREE;
6790 }
6791 }
6792
6793 /* Ignoring their sign, return true if two scalar types are the same. */
6794 bool
same_scalar_type_ignoring_signedness(tree t1,tree t2)6795 same_scalar_type_ignoring_signedness (tree t1, tree t2)
6796 {
6797 enum tree_code c1 = TREE_CODE (t1), c2 = TREE_CODE (t2);
6798
6799 gcc_assert ((c1 == INTEGER_TYPE || c1 == REAL_TYPE)
6800 && (c2 == INTEGER_TYPE || c2 == REAL_TYPE));
6801
6802 /* Equality works here because c_common_signed_type uses
6803 TYPE_MAIN_VARIANT. */
6804 return lang_hooks.types.signed_type (t1)
6805 == lang_hooks.types.signed_type (t2);
6806 }
6807
6808 /* Check for missing format attributes on function pointers. LTYPE is
6809 the new type or left-hand side type. RTYPE is the old type or
6810 right-hand side type. Returns TRUE if LTYPE is missing the desired
6811 attribute. */
6812
6813 bool
check_missing_format_attribute(tree ltype,tree rtype)6814 check_missing_format_attribute (tree ltype, tree rtype)
6815 {
6816 tree const ttr = TREE_TYPE (rtype), ttl = TREE_TYPE (ltype);
6817 tree ra;
6818
6819 for (ra = TYPE_ATTRIBUTES (ttr); ra; ra = TREE_CHAIN (ra))
6820 if (is_attribute_p ("format", TREE_PURPOSE (ra)))
6821 break;
6822 if (ra)
6823 {
6824 tree la;
6825 for (la = TYPE_ATTRIBUTES (ttl); la; la = TREE_CHAIN (la))
6826 if (is_attribute_p ("format", TREE_PURPOSE (la)))
6827 break;
6828 return !la;
6829 }
6830 else
6831 return false;
6832 }
6833
6834 /* Subscripting with type char is likely to lose on a machine where
6835 chars are signed. So warn on any machine, but optionally. Don't
6836 warn for unsigned char since that type is safe. Don't warn for
6837 signed char because anyone who uses that must have done so
6838 deliberately. Furthermore, we reduce the false positive load by
6839 warning only for non-constant value of type char. */
6840
6841 void
warn_array_subscript_with_type_char(tree index)6842 warn_array_subscript_with_type_char (tree index)
6843 {
6844 if (TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node
6845 && TREE_CODE (index) != INTEGER_CST)
6846 warning (OPT_Wchar_subscripts, "array subscript has type %<char%>");
6847 }
6848
6849 /* Implement -Wparentheses for the unexpected C precedence rules, to
6850 cover cases like x + y << z which readers are likely to
6851 misinterpret. We have seen an expression in which CODE is a binary
6852 operator used to combine expressions headed by CODE_LEFT and
6853 CODE_RIGHT. CODE_LEFT and CODE_RIGHT may be ERROR_MARK, which
6854 means that that side of the expression was not formed using a
6855 binary operator, or it was enclosed in parentheses. */
6856
6857 void
warn_about_parentheses(enum tree_code code,enum tree_code code_left,enum tree_code code_right)6858 warn_about_parentheses (enum tree_code code, enum tree_code code_left,
6859 enum tree_code code_right)
6860 {
6861 if (!warn_parentheses)
6862 return;
6863
6864 if (code == LSHIFT_EXPR || code == RSHIFT_EXPR)
6865 {
6866 if (code_left == PLUS_EXPR || code_left == MINUS_EXPR
6867 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
6868 warning (OPT_Wparentheses,
6869 "suggest parentheses around + or - inside shift");
6870 }
6871
6872 if (code == TRUTH_ORIF_EXPR)
6873 {
6874 if (code_left == TRUTH_ANDIF_EXPR
6875 || code_right == TRUTH_ANDIF_EXPR)
6876 warning (OPT_Wparentheses,
6877 "suggest parentheses around && within ||");
6878 }
6879
6880 if (code == BIT_IOR_EXPR)
6881 {
6882 if (code_left == BIT_AND_EXPR || code_left == BIT_XOR_EXPR
6883 || code_left == PLUS_EXPR || code_left == MINUS_EXPR
6884 || code_right == BIT_AND_EXPR || code_right == BIT_XOR_EXPR
6885 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
6886 warning (OPT_Wparentheses,
6887 "suggest parentheses around arithmetic in operand of |");
6888 /* Check cases like x|y==z */
6889 if (TREE_CODE_CLASS (code_left) == tcc_comparison
6890 || TREE_CODE_CLASS (code_right) == tcc_comparison)
6891 warning (OPT_Wparentheses,
6892 "suggest parentheses around comparison in operand of |");
6893 }
6894
6895 if (code == BIT_XOR_EXPR)
6896 {
6897 if (code_left == BIT_AND_EXPR
6898 || code_left == PLUS_EXPR || code_left == MINUS_EXPR
6899 || code_right == BIT_AND_EXPR
6900 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
6901 warning (OPT_Wparentheses,
6902 "suggest parentheses around arithmetic in operand of ^");
6903 /* Check cases like x^y==z */
6904 if (TREE_CODE_CLASS (code_left) == tcc_comparison
6905 || TREE_CODE_CLASS (code_right) == tcc_comparison)
6906 warning (OPT_Wparentheses,
6907 "suggest parentheses around comparison in operand of ^");
6908 }
6909
6910 if (code == BIT_AND_EXPR)
6911 {
6912 if (code_left == PLUS_EXPR || code_left == MINUS_EXPR
6913 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
6914 warning (OPT_Wparentheses,
6915 "suggest parentheses around + or - in operand of &");
6916 /* Check cases like x&y==z */
6917 if (TREE_CODE_CLASS (code_left) == tcc_comparison
6918 || TREE_CODE_CLASS (code_right) == tcc_comparison)
6919 warning (OPT_Wparentheses,
6920 "suggest parentheses around comparison in operand of &");
6921 }
6922
6923 /* Similarly, check for cases like 1<=i<=10 that are probably errors. */
6924 if (TREE_CODE_CLASS (code) == tcc_comparison
6925 && (TREE_CODE_CLASS (code_left) == tcc_comparison
6926 || TREE_CODE_CLASS (code_right) == tcc_comparison))
6927 warning (OPT_Wparentheses, "comparisons like X<=Y<=Z do not "
6928 "have their mathematical meaning");
6929 }
6930
6931 /* APPLE LOCAL begin radar 6246527 */
6932 /* This routine is called for a "format" attribute. It adds the number of
6933 hidden argument ('1') to the format's 2nd and 3rd argument to compensate
6934 for these two arguments. This is to make rest of the "format" attribute
6935 processing done in the middle-end to work seemlessly. */
6936
6937 static void
block_delta_format_args(tree format)6938 block_delta_format_args (tree format)
6939 {
6940 tree format_num_expr, first_arg_num_expr;
6941 int val;
6942 tree args = TREE_VALUE (format);
6943 gcc_assert (TREE_CHAIN (args) && TREE_CHAIN (TREE_CHAIN (args)));
6944 format_num_expr = TREE_VALUE (TREE_CHAIN (args));
6945 first_arg_num_expr = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (args)));
6946 if (format_num_expr && TREE_CODE (format_num_expr) == INTEGER_CST)
6947 {
6948 val = TREE_INT_CST_LOW (format_num_expr);
6949 TREE_VALUE (TREE_CHAIN (args)) = build_int_cst (NULL_TREE, val+1);
6950 }
6951 if (first_arg_num_expr && TREE_CODE (first_arg_num_expr) == INTEGER_CST)
6952 {
6953 val = TREE_INT_CST_LOW (first_arg_num_expr);
6954 if (val != 0)
6955 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (args))) =
6956 build_int_cst (NULL_TREE, val+1);
6957 }
6958 }
6959
6960 /* This routine recognizes legal block attributes. In case of block's "format"
6961 attribute, it calls block_delta_format_args to compensate for hidden
6962 argument _self getting passed to block's helper function. */
6963 bool
any_recognized_block_attribute(tree attributes)6964 any_recognized_block_attribute (tree attributes)
6965 {
6966 tree chain;
6967 bool res = false;
6968 for (chain = attributes; chain; chain = TREE_CHAIN (chain))
6969 {
6970 if (is_attribute_p ("format", TREE_PURPOSE (chain)))
6971 {
6972 block_delta_format_args (chain);
6973 res = true;
6974 }
6975 else if (is_attribute_p ("sentinel", TREE_PURPOSE (chain)))
6976 res = true;
6977 }
6978 return res;
6979 }
6980 /* APPLE LOCAL end radar 6246527 */
6981 /* APPLE LOCAL begin radar 5847976 */
6982 static GTY(()) tree block_object_assign_decl;
6983 static GTY(()) tree block_object_dispose_func_decl;
6984 /* This routine declares:
6985 void _Block_object_assign (void *, void *, int) or uses an
6986 existing one.
6987 */
6988 static tree
build_block_object_assign_decl(void)6989 build_block_object_assign_decl (void)
6990 {
6991 tree func_type;
6992 if (block_object_assign_decl)
6993 return block_object_assign_decl;
6994 block_object_assign_decl = lookup_name (get_identifier ("_Block_object_assign"));
6995 if (block_object_assign_decl)
6996 return block_object_assign_decl;
6997 func_type =
6998 build_function_type (void_type_node,
6999 tree_cons (NULL_TREE, ptr_type_node,
7000 tree_cons (NULL_TREE, ptr_type_node,
7001 tree_cons (NULL_TREE, integer_type_node, void_list_node))));
7002
7003 block_object_assign_decl = builtin_function ("_Block_object_assign", func_type,
7004 0, NOT_BUILT_IN, 0, NULL_TREE);
7005 TREE_NOTHROW (block_object_assign_decl) = 0;
7006 return block_object_assign_decl;
7007 }
7008
7009 /* This routine builds:
7010 _Block_object_assign(dest, src, flag)
7011 */
build_block_object_assign_call_exp(tree dst,tree src,int flag)7012 tree build_block_object_assign_call_exp (tree dst, tree src, int flag)
7013 {
7014 tree func_params = tree_cons (NULL_TREE, dst,
7015 tree_cons (NULL_TREE, src,
7016 tree_cons (NULL_TREE,
7017 build_int_cst (integer_type_node, flag),
7018 NULL_TREE)));
7019 return build_function_call (build_block_object_assign_decl (), func_params);
7020 }
7021
7022 /* This routine declares:
7023 void _Block_object_dispose (void *, int) or uses an
7024 existing one.
7025 */
7026 static tree
build_block_object_dispose_decl(void)7027 build_block_object_dispose_decl (void)
7028 {
7029 tree func_type;
7030 if (block_object_dispose_func_decl)
7031 return block_object_dispose_func_decl;
7032 block_object_dispose_func_decl = lookup_name (get_identifier ("_Block_object_dispose"));
7033 if (block_object_dispose_func_decl)
7034 return block_object_dispose_func_decl;
7035 func_type =
7036 build_function_type (void_type_node,
7037 tree_cons (NULL_TREE, ptr_type_node,
7038 tree_cons (NULL_TREE, integer_type_node, void_list_node)));
7039
7040 block_object_dispose_func_decl = builtin_function ("_Block_object_dispose", func_type,
7041 0, NOT_BUILT_IN, 0, NULL_TREE);
7042 TREE_NOTHROW (block_object_dispose_func_decl) = 0;
7043 return block_object_dispose_func_decl;
7044 }
7045
7046 /* This routine builds the call tree:
7047 _Block_object_dispose(src, flag)
7048 */
build_block_object_dispose_call_exp(tree src,int flag)7049 tree build_block_object_dispose_call_exp (tree src, int flag)
7050 {
7051 tree func_params = tree_cons (NULL_TREE, src,
7052 tree_cons (NULL_TREE,
7053 build_int_cst (integer_type_node, flag),
7054 NULL_TREE));
7055 return build_function_call (build_block_object_dispose_decl (), func_params);
7056 }
7057 /* APPLE LOCAL end radar 5847976 */
7058 /* APPLE LOCAL begin radar 7760213 */
HasByrefArray(tree byrefType)7059 int HasByrefArray(tree byrefType)
7060 {
7061 tree s1;
7062 /* Check for possibility of an error condition. */
7063 if (TREE_CODE(byrefType) != RECORD_TYPE)
7064 return 0;
7065
7066 for (s1 = TYPE_FIELDS (byrefType); s1; s1 = TREE_CHAIN (s1))
7067 {
7068 if (TREE_CODE(TREE_TYPE(s1)) == ARRAY_TYPE)
7069 return 1;
7070 }
7071 return 0;
7072 }
7073 /* APPLE LOCAL end radar 7760213 */
7074 #include "gt-c-common.h"
7075