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