1 /* Subroutines shared by all languages that are variants of C.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
5 This file is part of GCC.
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 3, or (at your option) any later
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
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
35 #include "diagnostic.h"
40 #include "langhooks.h"
41 #include "tree-inline.h"
44 #include "tree-iterator.h"
46 #include "tree-mudflap.h"
50 #include "target-def.h"
51 #include "fixed-value.h"
53 cpp_reader
*parse_in
; /* Declared in c-pragma.h. */
55 /* We let tm.h override the types used here, to handle trivial differences
56 such as the choice of unsigned int or long unsigned int for size_t.
57 When machines start needing nontrivial differences in the size type,
58 it would be best to do something here to figure out automatically
59 from other information what type to use. */
62 #define SIZE_TYPE "long unsigned int"
66 #define PID_TYPE "int"
70 #define CHAR16_TYPE "short unsigned int"
74 #define CHAR32_TYPE "unsigned int"
78 #define WCHAR_TYPE "int"
81 /* WCHAR_TYPE gets overridden by -fshort-wchar. */
82 #define MODIFIED_WCHAR_TYPE \
83 (flag_short_wchar ? "short unsigned int" : WCHAR_TYPE)
86 #define PTRDIFF_TYPE "long int"
90 #define WINT_TYPE "unsigned int"
94 #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
96 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
102 #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
104 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
105 ? "long unsigned int" \
106 : "long long unsigned int"))
109 /* The following symbols are subsumed in the c_global_trees array, and
110 listed here individually for documentation purposes.
112 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
114 tree short_integer_type_node;
115 tree long_integer_type_node;
116 tree long_long_integer_type_node;
118 tree short_unsigned_type_node;
119 tree long_unsigned_type_node;
120 tree long_long_unsigned_type_node;
122 tree truthvalue_type_node;
123 tree truthvalue_false_node;
124 tree truthvalue_true_node;
126 tree ptrdiff_type_node;
128 tree unsigned_char_type_node;
129 tree signed_char_type_node;
130 tree wchar_type_node;
131 tree signed_wchar_type_node;
132 tree unsigned_wchar_type_node;
134 tree char16_type_node;
135 tree char32_type_node;
137 tree float_type_node;
138 tree double_type_node;
139 tree long_double_type_node;
141 tree complex_integer_type_node;
142 tree complex_float_type_node;
143 tree complex_double_type_node;
144 tree complex_long_double_type_node;
146 tree dfloat32_type_node;
147 tree dfloat64_type_node;
148 tree_dfloat128_type_node;
150 tree intQI_type_node;
151 tree intHI_type_node;
152 tree intSI_type_node;
153 tree intDI_type_node;
154 tree intTI_type_node;
156 tree unsigned_intQI_type_node;
157 tree unsigned_intHI_type_node;
158 tree unsigned_intSI_type_node;
159 tree unsigned_intDI_type_node;
160 tree unsigned_intTI_type_node;
162 tree widest_integer_literal_type_node;
163 tree widest_unsigned_literal_type_node;
165 Nodes for types `void *' and `const void *'.
167 tree ptr_type_node, const_ptr_type_node;
169 Nodes for types `char *' and `const char *'.
171 tree string_type_node, const_string_type_node;
173 Type `char[SOMENUMBER]'.
174 Used when an array of char is needed and the size is irrelevant.
176 tree char_array_type_node;
178 Type `int[SOMENUMBER]' or something like it.
179 Used when an array of int needed and the size is irrelevant.
181 tree int_array_type_node;
183 Type `wchar_t[SOMENUMBER]' or something like it.
184 Used when a wide string literal is created.
186 tree wchar_array_type_node;
188 Type `char16_t[SOMENUMBER]' or something like it.
189 Used when a UTF-16 string literal is created.
191 tree char16_array_type_node;
193 Type `char32_t[SOMENUMBER]' or something like it.
194 Used when a UTF-32 string literal is created.
196 tree char32_array_type_node;
198 Type `int ()' -- used for implicit declaration of functions.
200 tree default_function_type;
202 A VOID_TYPE node, packaged in a TREE_LIST.
206 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
207 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
208 VAR_DECLS, but C++ does.)
210 tree function_name_decl_node;
211 tree pretty_function_name_decl_node;
212 tree c99_function_name_decl_node;
214 Stack of nested function name VAR_DECLs.
216 tree saved_function_name_decls;
220 tree c_global_trees
[CTI_MAX
];
222 /* Switches common to the C front ends. */
224 /* Nonzero if prepreprocessing only. */
226 int flag_preprocess_only
;
228 /* Nonzero means don't output line number information. */
230 char flag_no_line_commands
;
232 /* Nonzero causes -E output not to be done, but directives such as
233 #define that have side effects are still obeyed. */
237 /* Nonzero means dump macros in some fashion. */
239 char flag_dump_macros
;
241 /* Nonzero means pass #include lines through to the output. */
243 char flag_dump_includes
;
245 /* Nonzero means process PCH files while preprocessing. */
247 bool flag_pch_preprocess
;
249 /* The file name to which we should write a precompiled header, or
250 NULL if no header will be written in this compile. */
252 const char *pch_file
;
254 /* Nonzero if an ISO standard was selected. It rejects macros in the
258 /* Nonzero if -undef was given. It suppresses target built-in macros
262 /* Nonzero means don't recognize the non-ANSI builtin functions. */
266 /* Nonzero means don't recognize the non-ANSI builtin functions.
269 int flag_no_nonansi_builtin
;
271 /* Nonzero means give `double' the same size as `float'. */
273 int flag_short_double
;
275 /* Nonzero means give `wchar_t' the same size as `short'. */
277 int flag_short_wchar
;
279 /* Nonzero means allow implicit conversions between vectors with
280 differing numbers of subparts and/or differing element types. */
281 int flag_lax_vector_conversions
;
283 /* Nonzero means allow Microsoft extensions without warnings or errors. */
284 int flag_ms_extensions
;
286 /* Nonzero means don't recognize the keyword `asm'. */
290 /* Nonzero means to treat bitfields as signed unless they say `unsigned'. */
292 int flag_signed_bitfields
= 1;
294 /* Warn about #pragma directives that are not recognized. */
296 int warn_unknown_pragmas
; /* Tri state variable. */
298 /* Warn about format/argument anomalies in calls to formatted I/O functions
299 (*printf, *scanf, strftime, strfmon, etc.). */
303 /* Warn about using __null (as NULL in C++) as sentinel. For code compiled
304 with GCC this doesn't matter as __null is guaranteed to have the right
307 int warn_strict_null_sentinel
;
309 /* Zero means that faster, ...NonNil variants of objc_msgSend...
310 calls will be used in ObjC; passing nil receivers to such calls
311 will most likely result in crashes. */
312 int flag_nil_receivers
= 1;
314 /* Nonzero means that code generation will be altered to support
315 "zero-link" execution. This currently affects ObjC only, but may
316 affect other languages in the future. */
317 int flag_zero_link
= 0;
319 /* Nonzero means emit an '__OBJC, __image_info' for the current translation
320 unit. It will inform the ObjC runtime that class definition(s) herein
321 contained are to replace one(s) previously loaded. */
322 int flag_replace_objc_classes
= 0;
324 /* C/ObjC language option variables. */
327 /* Nonzero means allow type mismatches in conditional expressions;
328 just make their values `void'. */
330 int flag_cond_mismatch
;
332 /* Nonzero means enable C89 Amendment 1 features. */
336 /* Nonzero means use the ISO C99 dialect of C. */
340 /* Nonzero means that we have builtin functions, and main is an int. */
344 /* Warn if main is suspicious. */
349 /* ObjC language option variables. */
352 /* Open and close the file for outputting class declarations, if
355 int flag_gen_declaration
;
357 /* Tells the compiler that this is a special run. Do not perform any
358 compiling, instead we are to test some platform dependent features
359 and output a C header file with appropriate definitions. */
361 int print_struct_values
;
363 /* Tells the compiler what is the constant string class for Objc. */
365 const char *constant_string_class_name
;
368 /* C++ language option variables. */
371 /* Nonzero means don't recognize any extension keywords. */
373 int flag_no_gnu_keywords
;
375 /* Nonzero means do emit exported implementations of functions even if
376 they can be inlined. */
378 int flag_implement_inlines
= 1;
380 /* Nonzero means that implicit instantiations will be emitted if needed. */
382 int flag_implicit_templates
= 1;
384 /* Nonzero means that implicit instantiations of inline templates will be
385 emitted if needed, even if instantiations of non-inline templates
388 int flag_implicit_inline_templates
= 1;
390 /* Nonzero means generate separate instantiation control files and
391 juggle them at link time. */
393 int flag_use_repository
;
395 /* Nonzero if we want to issue diagnostics that the standard says are not
398 int flag_optional_diags
= 1;
400 /* Nonzero means we should attempt to elide constructors when possible. */
402 int flag_elide_constructors
= 1;
404 /* Nonzero means that member functions defined in class scope are
405 inline by default. */
407 int flag_default_inline
= 1;
409 /* Controls whether compiler generates 'type descriptor' that give
410 run-time type information. */
414 /* Nonzero if we want to conserve space in the .o files. We do this
415 by putting uninitialized data and runtime initialized data into
416 .common instead of .data at the expense of not flagging multiple
419 int flag_conserve_space
;
421 /* Nonzero if we want to obey access control semantics. */
423 int flag_access_control
= 1;
425 /* Nonzero if we want to check the return value of new and avoid calling
426 constructors if it is a null pointer. */
430 /* The C++ dialect being used. C++98 is the default. */
432 enum cxx_dialect cxx_dialect
= cxx98
;
434 /* Nonzero if we want the new ISO rules for pushing a new scope for `for'
435 initialization variables.
436 0: Old rules, set by -fno-for-scope.
437 2: New ISO rules, set by -ffor-scope.
438 1: Try to implement new ISO rules, but with backup compatibility
439 (and warnings). This is the default, for now. */
441 int flag_new_for_scope
= 1;
443 /* Nonzero if we want to emit defined symbols with common-like linkage as
444 weak symbols where possible, in order to conform to C++ semantics.
445 Otherwise, emit them as local symbols. */
449 /* 0 means we want the preprocessor to not emit line directives for
450 the current working directory. 1 means we want it to do it. -1
451 means we should decide depending on whether debugging information
452 is being emitted or not. */
454 int flag_working_directory
= -1;
456 /* Nonzero to use __cxa_atexit, rather than atexit, to register
457 destructors for local statics and global objects. '2' means it has been
458 set nonzero as a default, not by a command-line flag. */
460 int flag_use_cxa_atexit
= DEFAULT_USE_CXA_ATEXIT
;
462 /* Nonzero to use __cxa_get_exception_ptr in C++ exception-handling
463 code. '2' means it has not been set explicitly on the command line. */
465 int flag_use_cxa_get_exception_ptr
= 2;
467 /* Nonzero means to implement standard semantics for exception
468 specifications, calling unexpected if an exception is thrown that
469 doesn't match the specification. Zero means to treat them as
470 assertions and optimize accordingly, but not check them. */
472 int flag_enforce_eh_specs
= 1;
474 /* Nonzero means to generate thread-safe code for initializing local
477 int flag_threadsafe_statics
= 1;
479 /* Nonzero means warn about implicit declarations. */
481 int warn_implicit
= 1;
483 /* Maximum template instantiation depth. This limit is rather
484 arbitrary, but it exists to limit the time it takes to notice
485 infinite template instantiations. */
487 int max_tinst_depth
= 500;
491 /* The elements of `ridpointers' are identifier nodes for the reserved
492 type names and storage classes. It is indexed by a RID_... value. */
495 tree (*make_fname_decl
) (tree
, int);
497 /* Nonzero means the expression being parsed will never be evaluated.
498 This is a count, since unevaluated expressions can nest. */
501 /* Information about how a function name is generated. */
504 tree
*const decl
; /* pointer to the VAR_DECL. */
505 const unsigned rid
; /* RID number for the identifier. */
506 const int pretty
; /* How pretty is it? */
509 /* The three ways of getting then name of the current function. */
511 const struct fname_var_t fname_vars
[] =
513 /* C99 compliant __func__, must be first. */
514 {&c99_function_name_decl_node
, RID_C99_FUNCTION_NAME
, 0},
515 /* GCC __FUNCTION__ compliant. */
516 {&function_name_decl_node
, RID_FUNCTION_NAME
, 0},
517 /* GCC __PRETTY_FUNCTION__ compliant. */
518 {&pretty_function_name_decl_node
, RID_PRETTY_FUNCTION_NAME
, 1},
522 static tree
check_case_value (tree
);
523 static bool check_case_bounds (tree
, tree
, tree
*, tree
*);
525 static tree
handle_packed_attribute (tree
*, tree
, tree
, int, bool *);
526 static tree
handle_nocommon_attribute (tree
*, tree
, tree
, int, bool *);
527 static tree
handle_common_attribute (tree
*, tree
, tree
, int, bool *);
528 static tree
handle_noreturn_attribute (tree
*, tree
, tree
, int, bool *);
529 static tree
handle_hot_attribute (tree
*, tree
, tree
, int, bool *);
530 static tree
handle_cold_attribute (tree
*, tree
, tree
, int, bool *);
531 static tree
handle_noinline_attribute (tree
*, tree
, tree
, int, bool *);
532 static tree
handle_always_inline_attribute (tree
*, tree
, tree
, int,
534 static tree
handle_gnu_inline_attribute (tree
*, tree
, tree
, int, bool *);
535 static tree
handle_artificial_attribute (tree
*, tree
, tree
, int, bool *);
536 static tree
handle_flatten_attribute (tree
*, tree
, tree
, int, bool *);
537 static tree
handle_error_attribute (tree
*, tree
, tree
, int, bool *);
538 static tree
handle_used_attribute (tree
*, tree
, tree
, int, bool *);
539 static tree
handle_unused_attribute (tree
*, tree
, tree
, int, bool *);
540 static tree
handle_externally_visible_attribute (tree
*, tree
, tree
, int,
542 static tree
handle_const_attribute (tree
*, tree
, tree
, int, bool *);
543 static tree
handle_transparent_union_attribute (tree
*, tree
, tree
,
545 static tree
handle_constructor_attribute (tree
*, tree
, tree
, int, bool *);
546 static tree
handle_destructor_attribute (tree
*, tree
, tree
, int, bool *);
547 static tree
handle_mode_attribute (tree
*, tree
, tree
, int, bool *);
548 static tree
handle_section_attribute (tree
*, tree
, tree
, int, bool *);
549 static tree
handle_aligned_attribute (tree
*, tree
, tree
, int, bool *);
550 static tree
handle_weak_attribute (tree
*, tree
, tree
, int, bool *) ;
551 static tree
handle_alias_attribute (tree
*, tree
, tree
, int, bool *);
552 static tree
handle_weakref_attribute (tree
*, tree
, tree
, int, bool *) ;
553 static tree
handle_visibility_attribute (tree
*, tree
, tree
, int,
555 static tree
handle_tls_model_attribute (tree
*, tree
, tree
, int,
557 static tree
handle_no_instrument_function_attribute (tree
*, tree
,
559 static tree
handle_malloc_attribute (tree
*, tree
, tree
, int, bool *);
560 static tree
handle_returns_twice_attribute (tree
*, tree
, tree
, int, bool *);
561 static tree
handle_no_limit_stack_attribute (tree
*, tree
, tree
, int,
563 static tree
handle_pure_attribute (tree
*, tree
, tree
, int, bool *);
564 static tree
handle_novops_attribute (tree
*, tree
, tree
, int, bool *);
565 static tree
handle_deprecated_attribute (tree
*, tree
, tree
, int,
567 static tree
handle_vector_size_attribute (tree
*, tree
, tree
, int,
569 static tree
handle_nonnull_attribute (tree
*, tree
, tree
, int, bool *);
570 static tree
handle_nothrow_attribute (tree
*, tree
, tree
, int, bool *);
571 static tree
handle_cleanup_attribute (tree
*, tree
, tree
, int, bool *);
572 static tree
handle_warn_unused_result_attribute (tree
*, tree
, tree
, int,
574 static tree
handle_sentinel_attribute (tree
*, tree
, tree
, int, bool *);
575 static tree
handle_type_generic_attribute (tree
*, tree
, tree
, int, bool *);
576 static tree
handle_alloc_size_attribute (tree
*, tree
, tree
, int, bool *);
578 static void check_function_nonnull (tree
, int, tree
*);
579 static void check_nonnull_arg (void *, tree
, unsigned HOST_WIDE_INT
);
580 static bool nonnull_check_p (tree
, unsigned HOST_WIDE_INT
);
581 static bool get_nonnull_operand (tree
, unsigned HOST_WIDE_INT
*);
582 static int resort_field_decl_cmp (const void *, const void *);
584 /* Table of machine-independent attributes common to all C-like languages. */
585 const struct attribute_spec c_common_attribute_table
[] =
587 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
588 { "packed", 0, 0, false, false, false,
589 handle_packed_attribute
},
590 { "nocommon", 0, 0, true, false, false,
591 handle_nocommon_attribute
},
592 { "common", 0, 0, true, false, false,
593 handle_common_attribute
},
594 /* FIXME: logically, noreturn attributes should be listed as
595 "false, true, true" and apply to function types. But implementing this
596 would require all the places in the compiler that use TREE_THIS_VOLATILE
597 on a decl to identify non-returning functions to be located and fixed
598 to check the function type instead. */
599 { "noreturn", 0, 0, true, false, false,
600 handle_noreturn_attribute
},
601 { "volatile", 0, 0, true, false, false,
602 handle_noreturn_attribute
},
603 { "noinline", 0, 0, true, false, false,
604 handle_noinline_attribute
},
605 { "always_inline", 0, 0, true, false, false,
606 handle_always_inline_attribute
},
607 { "gnu_inline", 0, 0, true, false, false,
608 handle_gnu_inline_attribute
},
609 { "artificial", 0, 0, true, false, false,
610 handle_artificial_attribute
},
611 { "flatten", 0, 0, true, false, false,
612 handle_flatten_attribute
},
613 { "used", 0, 0, true, false, false,
614 handle_used_attribute
},
615 { "unused", 0, 0, false, false, false,
616 handle_unused_attribute
},
617 { "externally_visible", 0, 0, true, false, false,
618 handle_externally_visible_attribute
},
619 /* The same comments as for noreturn attributes apply to const ones. */
620 { "const", 0, 0, true, false, false,
621 handle_const_attribute
},
622 { "transparent_union", 0, 0, false, false, false,
623 handle_transparent_union_attribute
},
624 { "constructor", 0, 1, true, false, false,
625 handle_constructor_attribute
},
626 { "destructor", 0, 1, true, false, false,
627 handle_destructor_attribute
},
628 { "mode", 1, 1, false, true, false,
629 handle_mode_attribute
},
630 { "section", 1, 1, true, false, false,
631 handle_section_attribute
},
632 { "aligned", 0, 1, false, false, false,
633 handle_aligned_attribute
},
634 { "weak", 0, 0, true, false, false,
635 handle_weak_attribute
},
636 { "alias", 1, 1, true, false, false,
637 handle_alias_attribute
},
638 { "weakref", 0, 1, true, false, false,
639 handle_weakref_attribute
},
640 { "no_instrument_function", 0, 0, true, false, false,
641 handle_no_instrument_function_attribute
},
642 { "malloc", 0, 0, true, false, false,
643 handle_malloc_attribute
},
644 { "returns_twice", 0, 0, true, false, false,
645 handle_returns_twice_attribute
},
646 { "no_stack_limit", 0, 0, true, false, false,
647 handle_no_limit_stack_attribute
},
648 { "pure", 0, 0, true, false, false,
649 handle_pure_attribute
},
650 /* For internal use (marking of builtins) only. The name contains space
651 to prevent its usage in source code. */
652 { "no vops", 0, 0, true, false, false,
653 handle_novops_attribute
},
654 { "deprecated", 0, 0, false, false, false,
655 handle_deprecated_attribute
},
656 { "vector_size", 1, 1, false, true, false,
657 handle_vector_size_attribute
},
658 { "visibility", 1, 1, false, false, false,
659 handle_visibility_attribute
},
660 { "tls_model", 1, 1, true, false, false,
661 handle_tls_model_attribute
},
662 { "nonnull", 0, -1, false, true, true,
663 handle_nonnull_attribute
},
664 { "nothrow", 0, 0, true, false, false,
665 handle_nothrow_attribute
},
666 { "may_alias", 0, 0, false, true, false, NULL
},
667 { "cleanup", 1, 1, true, false, false,
668 handle_cleanup_attribute
},
669 { "warn_unused_result", 0, 0, false, true, true,
670 handle_warn_unused_result_attribute
},
671 { "sentinel", 0, 1, false, true, true,
672 handle_sentinel_attribute
},
673 /* For internal use (marking of builtins) only. The name contains space
674 to prevent its usage in source code. */
675 { "type generic", 0, 0, false, true, true,
676 handle_type_generic_attribute
},
677 { "alloc_size", 1, 2, false, true, true,
678 handle_alloc_size_attribute
},
679 { "cold", 0, 0, true, false, false,
680 handle_cold_attribute
},
681 { "hot", 0, 0, true, false, false,
682 handle_hot_attribute
},
683 { "warning", 1, 1, true, false, false,
684 handle_error_attribute
},
685 { "error", 1, 1, true, false, false,
686 handle_error_attribute
},
687 { NULL
, 0, 0, false, false, false, NULL
}
690 /* Give the specifications for the format attributes, used by C and all
693 const struct attribute_spec c_common_format_attribute_table
[] =
695 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
696 { "format", 3, 3, false, true, true,
697 handle_format_attribute
},
698 { "format_arg", 1, 1, false, true, true,
699 handle_format_arg_attribute
},
700 { NULL
, 0, 0, false, false, false, NULL
}
703 /* Push current bindings for the function name VAR_DECLS. */
706 start_fname_decls (void)
709 tree saved
= NULL_TREE
;
711 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
713 tree decl
= *fname_vars
[ix
].decl
;
717 saved
= tree_cons (decl
, build_int_cst (NULL_TREE
, ix
), saved
);
718 *fname_vars
[ix
].decl
= NULL_TREE
;
721 if (saved
|| saved_function_name_decls
)
722 /* Normally they'll have been NULL, so only push if we've got a
723 stack, or they are non-NULL. */
724 saved_function_name_decls
= tree_cons (saved
, NULL_TREE
,
725 saved_function_name_decls
);
728 /* Finish up the current bindings, adding them into the current function's
729 statement tree. This must be done _before_ finish_stmt_tree is called.
730 If there is no current function, we must be at file scope and no statements
731 are involved. Pop the previous bindings. */
734 finish_fname_decls (void)
737 tree stmts
= NULL_TREE
;
738 tree stack
= saved_function_name_decls
;
740 for (; stack
&& TREE_VALUE (stack
); stack
= TREE_CHAIN (stack
))
741 append_to_statement_list (TREE_VALUE (stack
), &stmts
);
745 tree
*bodyp
= &DECL_SAVED_TREE (current_function_decl
);
747 if (TREE_CODE (*bodyp
) == BIND_EXPR
)
748 bodyp
= &BIND_EXPR_BODY (*bodyp
);
750 append_to_statement_list_force (*bodyp
, &stmts
);
754 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
755 *fname_vars
[ix
].decl
= NULL_TREE
;
759 /* We had saved values, restore them. */
762 for (saved
= TREE_PURPOSE (stack
); saved
; saved
= TREE_CHAIN (saved
))
764 tree decl
= TREE_PURPOSE (saved
);
765 unsigned ix
= TREE_INT_CST_LOW (TREE_VALUE (saved
));
767 *fname_vars
[ix
].decl
= decl
;
769 stack
= TREE_CHAIN (stack
);
771 saved_function_name_decls
= stack
;
774 /* Return the text name of the current function, suitably prettified
775 by PRETTY_P. Return string must be freed by caller. */
778 fname_as_string (int pretty_p
)
780 const char *name
= "top level";
783 cpp_string cstr
= { 0, 0 }, strname
;
791 if (current_function_decl
)
792 name
= lang_hooks
.decl_printable_name (current_function_decl
, vrb
);
794 len
= strlen (name
) + 3; /* Two for '"'s. One for NULL. */
796 namep
= XNEWVEC (char, len
);
797 snprintf (namep
, len
, "\"%s\"", name
);
798 strname
.text
= (unsigned char *) namep
;
799 strname
.len
= len
- 1;
801 if (cpp_interpret_string (parse_in
, &strname
, 1, &cstr
, CPP_STRING
))
804 return (const char *) cstr
.text
;
810 /* Expand DECL if it declares an entity not handled by the
814 c_expand_decl (tree decl
)
816 if (TREE_CODE (decl
) == VAR_DECL
&& !TREE_STATIC (decl
))
818 /* Let the back-end know about this variable. */
819 if (!anon_aggr_type_p (TREE_TYPE (decl
)))
820 emit_local_var (decl
);
822 expand_anon_union_decl (decl
, NULL_TREE
,
823 DECL_ANON_UNION_ELEMS (decl
));
832 /* Return the VAR_DECL for a const char array naming the current
833 function. If the VAR_DECL has not yet been created, create it
834 now. RID indicates how it should be formatted and IDENTIFIER_NODE
835 ID is its name (unfortunately C and C++ hold the RID values of
836 keywords in different places, so we can't derive RID from ID in
837 this language independent code. */
840 fname_decl (unsigned int rid
, tree id
)
843 tree decl
= NULL_TREE
;
845 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
846 if (fname_vars
[ix
].rid
== rid
)
849 decl
= *fname_vars
[ix
].decl
;
852 /* If a tree is built here, it would normally have the lineno of
853 the current statement. Later this tree will be moved to the
854 beginning of the function and this line number will be wrong.
855 To avoid this problem set the lineno to 0 here; that prevents
856 it from appearing in the RTL. */
858 location_t saved_location
= input_location
;
859 input_location
= UNKNOWN_LOCATION
;
861 stmts
= push_stmt_list ();
862 decl
= (*make_fname_decl
) (id
, fname_vars
[ix
].pretty
);
863 stmts
= pop_stmt_list (stmts
);
864 if (!IS_EMPTY_STMT (stmts
))
865 saved_function_name_decls
866 = tree_cons (decl
, stmts
, saved_function_name_decls
);
867 *fname_vars
[ix
].decl
= decl
;
868 input_location
= saved_location
;
870 if (!ix
&& !current_function_decl
)
871 pedwarn ("%qD is not defined outside of function scope", decl
);
876 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
879 fix_string_type (tree value
)
881 int length
= TREE_STRING_LENGTH (value
);
883 tree e_type
, i_type
, a_type
;
885 /* Compute the number of elements, for the array type. */
886 if (TREE_TYPE (value
) == char_array_type_node
|| !TREE_TYPE (value
))
889 e_type
= char_type_node
;
891 else if (TREE_TYPE (value
) == char16_array_type_node
)
893 nchars
= length
/ (TYPE_PRECISION (char16_type_node
) / BITS_PER_UNIT
);
894 e_type
= char16_type_node
;
896 else if (TREE_TYPE (value
) == char32_array_type_node
)
898 nchars
= length
/ (TYPE_PRECISION (char32_type_node
) / BITS_PER_UNIT
);
899 e_type
= char32_type_node
;
903 nchars
= length
/ (TYPE_PRECISION (wchar_type_node
) / BITS_PER_UNIT
);
904 e_type
= wchar_type_node
;
907 /* C89 2.2.4.1, C99 5.2.4.1 (Translation limits). The analogous
908 limit in C++98 Annex B is very large (65536) and is not normative,
909 so we do not diagnose it (warn_overlength_strings is forced off
910 in c_common_post_options). */
911 if (warn_overlength_strings
)
913 const int nchars_max
= flag_isoc99
? 4095 : 509;
914 const int relevant_std
= flag_isoc99
? 99 : 90;
915 if (nchars
- 1 > nchars_max
)
916 /* Translators: The %d after 'ISO C' will be 90 or 99. Do not
917 separate the %d from the 'C'. 'ISO' should not be
918 translated, but it may be moved after 'C%d' in languages
919 where modifiers follow nouns. */
920 pedwarn ("string length %qd is greater than the length %qd "
921 "ISO C%d compilers are required to support",
922 nchars
- 1, nchars_max
, relevant_std
);
925 /* Create the array type for the string constant. The ISO C++
926 standard says that a string literal has type `const char[N]' or
927 `const wchar_t[N]'. We use the same logic when invoked as a C
928 front-end with -Wwrite-strings.
929 ??? We should change the type of an expression depending on the
930 state of a warning flag. We should just be warning -- see how
931 this is handled in the C++ front-end for the deprecated implicit
932 conversion from string literals to `char*' or `wchar_t*'.
934 The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified
935 array type being the unqualified version of that type.
936 Therefore, if we are constructing an array of const char, we must
937 construct the matching unqualified array type first. The C front
938 end does not require this, but it does no harm, so we do it
940 i_type
= build_index_type (build_int_cst (NULL_TREE
, nchars
- 1));
941 a_type
= build_array_type (e_type
, i_type
);
942 if (c_dialect_cxx() || warn_write_strings
)
943 a_type
= c_build_qualified_type (a_type
, TYPE_QUAL_CONST
);
945 TREE_TYPE (value
) = a_type
;
946 TREE_CONSTANT (value
) = 1;
947 TREE_READONLY (value
) = 1;
948 TREE_STATIC (value
) = 1;
952 /* Print a warning if a constant expression had overflow in folding.
953 Invoke this function on every expression that the language
954 requires to be a constant expression.
955 Note the ANSI C standard says it is erroneous for a
956 constant expression to overflow. */
959 constant_expression_warning (tree value
)
961 if (warn_overflow
&& pedantic
962 && (TREE_CODE (value
) == INTEGER_CST
|| TREE_CODE (value
) == REAL_CST
963 || TREE_CODE (value
) == FIXED_CST
964 || TREE_CODE (value
) == VECTOR_CST
965 || TREE_CODE (value
) == COMPLEX_CST
)
966 && TREE_OVERFLOW (value
))
967 pedwarn ("overflow in constant expression");
970 /* The same as above but print an unconditional error. */
972 constant_expression_error (tree value
)
974 if ((TREE_CODE (value
) == INTEGER_CST
|| TREE_CODE (value
) == REAL_CST
975 || TREE_CODE (value
) == FIXED_CST
976 || TREE_CODE (value
) == VECTOR_CST
977 || TREE_CODE (value
) == COMPLEX_CST
)
978 && TREE_OVERFLOW (value
))
979 error ("overflow in constant expression");
982 /* Print a warning if an expression had overflow in folding and its
985 Invoke this function on every expression that
986 (1) appears in the source code, and
987 (2) is a constant expression that overflowed, and
988 (3) is not already checked by convert_and_check;
989 however, do not invoke this function on operands of explicit casts
990 or when the expression is the result of an operator and any operand
991 already overflowed. */
994 overflow_warning (tree value
)
996 if (skip_evaluation
) return;
998 switch (TREE_CODE (value
))
1001 warning (OPT_Woverflow
, "integer overflow in expression");
1005 warning (OPT_Woverflow
, "floating point overflow in expression");
1009 warning (OPT_Woverflow
, "fixed-point overflow in expression");
1013 warning (OPT_Woverflow
, "vector overflow in expression");
1017 if (TREE_CODE (TREE_REALPART (value
)) == INTEGER_CST
)
1018 warning (OPT_Woverflow
, "complex integer overflow in expression");
1019 else if (TREE_CODE (TREE_REALPART (value
)) == REAL_CST
)
1020 warning (OPT_Woverflow
, "complex floating point overflow in expression");
1029 /* Warn about use of a logical || / && operator being used in a
1030 context where it is likely that the bitwise equivalent was intended
1031 by the programmer. CODE is the TREE_CODE of the operator, ARG1
1032 and ARG2 the arguments. */
1035 warn_logical_operator (enum tree_code code
, tree arg1
, tree
1040 case TRUTH_ANDIF_EXPR
:
1041 case TRUTH_ORIF_EXPR
:
1043 case TRUTH_AND_EXPR
:
1044 if (!TREE_NO_WARNING (arg1
)
1045 && INTEGRAL_TYPE_P (TREE_TYPE (arg1
))
1046 && !CONSTANT_CLASS_P (arg1
)
1047 && TREE_CODE (arg2
) == INTEGER_CST
1048 && !integer_zerop (arg2
))
1050 warning (OPT_Wlogical_op
,
1051 "logical %<%s%> with non-zero constant "
1052 "will always evaluate as true",
1053 ((code
== TRUTH_ANDIF_EXPR
)
1054 || (code
== TRUTH_AND_EXPR
)) ? "&&" : "||");
1055 TREE_NO_WARNING (arg1
) = true;
1064 /* Print a warning about casts that might indicate violation
1065 of strict aliasing rules if -Wstrict-aliasing is used and
1066 strict aliasing mode is in effect. OTYPE is the original
1067 TREE_TYPE of EXPR, and TYPE the type we're casting to. */
1070 strict_aliasing_warning (tree otype
, tree type
, tree expr
)
1072 if (!(flag_strict_aliasing
&& POINTER_TYPE_P (type
)
1073 && POINTER_TYPE_P (otype
) && !VOID_TYPE_P (TREE_TYPE (type
))))
1076 if ((warn_strict_aliasing
> 1) && TREE_CODE (expr
) == ADDR_EXPR
1077 && (DECL_P (TREE_OPERAND (expr
, 0))
1078 || handled_component_p (TREE_OPERAND (expr
, 0))))
1080 /* Casting the address of an object to non void pointer. Warn
1081 if the cast breaks type based aliasing. */
1082 if (!COMPLETE_TYPE_P (TREE_TYPE (type
)) && warn_strict_aliasing
== 2)
1084 warning (OPT_Wstrict_aliasing
, "type-punning to incomplete type "
1085 "might break strict-aliasing rules");
1090 /* warn_strict_aliasing >= 3. This includes the default (3).
1091 Only warn if the cast is dereferenced immediately. */
1092 alias_set_type set1
=
1093 get_alias_set (TREE_TYPE (TREE_OPERAND (expr
, 0)));
1094 alias_set_type set2
= get_alias_set (TREE_TYPE (type
));
1096 if (!alias_sets_conflict_p (set1
, set2
))
1098 warning (OPT_Wstrict_aliasing
, "dereferencing type-punned "
1099 "pointer will break strict-aliasing rules");
1102 else if (warn_strict_aliasing
== 2
1103 && !alias_sets_must_conflict_p (set1
, set2
))
1105 warning (OPT_Wstrict_aliasing
, "dereferencing type-punned "
1106 "pointer might break strict-aliasing rules");
1112 if ((warn_strict_aliasing
== 1) && !VOID_TYPE_P (TREE_TYPE (otype
)))
1114 /* At this level, warn for any conversions, even if an address is
1115 not taken in the same statement. This will likely produce many
1116 false positives, but could be useful to pinpoint problems that
1117 are not revealed at higher levels. */
1118 alias_set_type set1
= get_alias_set (TREE_TYPE (otype
));
1119 alias_set_type set2
= get_alias_set (TREE_TYPE (type
));
1120 if (!COMPLETE_TYPE_P (type
)
1121 || !alias_sets_must_conflict_p (set1
, set2
))
1123 warning (OPT_Wstrict_aliasing
, "dereferencing type-punned "
1124 "pointer might break strict-aliasing rules");
1132 /* Print a warning about if (); or if () .. else; constructs
1133 via the special empty statement node that we create. INNER_THEN
1134 and INNER_ELSE are the statement lists of the if and the else
1138 empty_if_body_warning (tree inner_then
, tree inner_else
)
1140 if (TREE_CODE (inner_then
) == STATEMENT_LIST
1141 && STATEMENT_LIST_TAIL (inner_then
))
1142 inner_then
= STATEMENT_LIST_TAIL (inner_then
)->stmt
;
1144 if (inner_else
&& TREE_CODE (inner_else
) == STATEMENT_LIST
1145 && STATEMENT_LIST_TAIL (inner_else
))
1146 inner_else
= STATEMENT_LIST_TAIL (inner_else
)->stmt
;
1148 if (IS_EMPTY_STMT (inner_then
) && !inner_else
)
1149 warning (OPT_Wempty_body
, "%Hsuggest braces around empty body "
1150 "in an %<if%> statement", EXPR_LOCUS (inner_then
));
1152 else if (inner_else
&& IS_EMPTY_STMT (inner_else
))
1153 warning (OPT_Wempty_body
, "%Hsuggest braces around empty body "
1154 "in an %<else%> statement", EXPR_LOCUS (inner_else
));
1157 /* Warn for unlikely, improbable, or stupid DECL declarations
1161 check_main_parameter_types (tree decl
)
1166 for (args
= TYPE_ARG_TYPES (TREE_TYPE (decl
)); args
;
1167 args
= TREE_CHAIN (args
))
1169 tree type
= args
? TREE_VALUE (args
) : 0;
1171 if (type
== void_type_node
|| type
== error_mark_node
)
1178 if (TYPE_MAIN_VARIANT (type
) != integer_type_node
)
1179 pedwarn ("first argument of %q+D should be %<int%>", decl
);
1183 if (TREE_CODE (type
) != POINTER_TYPE
1184 || TREE_CODE (TREE_TYPE (type
)) != POINTER_TYPE
1185 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type
)))
1187 pedwarn ("second argument of %q+D should be %<char **%>",
1192 if (TREE_CODE (type
) != POINTER_TYPE
1193 || TREE_CODE (TREE_TYPE (type
)) != POINTER_TYPE
1194 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type
)))
1196 pedwarn ("third argument of %q+D should probably be "
1197 "%<char **%>", decl
);
1202 /* It is intentional that this message does not mention the third
1203 argument because it's only mentioned in an appendix of the
1205 if (argct
> 0 && (argct
< 2 || argct
> 3))
1206 pedwarn ("%q+D takes only zero or two arguments", decl
);
1209 /* True if vector types T1 and T2 can be converted to each other
1210 without an explicit cast. If EMIT_LAX_NOTE is true, and T1 and T2
1211 can only be converted with -flax-vector-conversions yet that is not
1212 in effect, emit a note telling the user about that option if such
1213 a note has not previously been emitted. */
1215 vector_types_convertible_p (const_tree t1
, const_tree t2
, bool emit_lax_note
)
1217 static bool emitted_lax_note
= false;
1218 bool convertible_lax
;
1220 if ((targetm
.vector_opaque_p (t1
) || targetm
.vector_opaque_p (t2
))
1221 && tree_int_cst_equal (TYPE_SIZE (t1
), TYPE_SIZE (t2
)))
1225 (tree_int_cst_equal (TYPE_SIZE (t1
), TYPE_SIZE (t2
))
1226 && (TREE_CODE (TREE_TYPE (t1
)) != REAL_TYPE
||
1227 TYPE_PRECISION (t1
) == TYPE_PRECISION (t2
))
1228 && (INTEGRAL_TYPE_P (TREE_TYPE (t1
))
1229 == INTEGRAL_TYPE_P (TREE_TYPE (t2
))));
1231 if (!convertible_lax
|| flag_lax_vector_conversions
)
1232 return convertible_lax
;
1234 if (TYPE_VECTOR_SUBPARTS (t1
) == TYPE_VECTOR_SUBPARTS (t2
)
1235 && lang_hooks
.types_compatible_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
1238 if (emit_lax_note
&& !emitted_lax_note
)
1240 emitted_lax_note
= true;
1241 inform ("use -flax-vector-conversions to permit "
1242 "conversions between vectors with differing "
1243 "element types or numbers of subparts");
1249 /* Warns if the conversion of EXPR to TYPE may alter a value.
1250 This is a helper function for warnings_for_convert_and_check. */
1253 conversion_warning (tree type
, tree expr
)
1255 bool give_warning
= false;
1257 unsigned int formal_prec
= TYPE_PRECISION (type
);
1259 if (!warn_conversion
&& !warn_sign_conversion
)
1262 if (TREE_CODE (expr
) == REAL_CST
|| TREE_CODE (expr
) == INTEGER_CST
)
1264 /* Warn for real constant that is not an exact integer converted
1266 if (TREE_CODE (TREE_TYPE (expr
)) == REAL_TYPE
1267 && TREE_CODE (type
) == INTEGER_TYPE
)
1269 if (!real_isinteger (TREE_REAL_CST_PTR (expr
), TYPE_MODE (TREE_TYPE (expr
))))
1270 give_warning
= true;
1272 /* Warn for an integer constant that does not fit into integer type. */
1273 else if (TREE_CODE (TREE_TYPE (expr
)) == INTEGER_TYPE
1274 && TREE_CODE (type
) == INTEGER_TYPE
1275 && !int_fits_type_p (expr
, type
))
1277 if (TYPE_UNSIGNED (type
) && !TYPE_UNSIGNED (TREE_TYPE (expr
)))
1278 warning (OPT_Wsign_conversion
,
1279 "negative integer implicitly converted to unsigned type");
1280 else if (!TYPE_UNSIGNED (type
) && TYPE_UNSIGNED (TREE_TYPE (expr
)))
1281 warning (OPT_Wsign_conversion
,
1282 "conversion of unsigned constant value to negative integer");
1284 give_warning
= true;
1286 else if (TREE_CODE (type
) == REAL_TYPE
)
1288 /* Warn for an integer constant that does not fit into real type. */
1289 if (TREE_CODE (TREE_TYPE (expr
)) == INTEGER_TYPE
)
1291 REAL_VALUE_TYPE a
= real_value_from_int_cst (0, expr
);
1292 if (!exact_real_truncate (TYPE_MODE (type
), &a
))
1293 give_warning
= true;
1295 /* Warn for a real constant that does not fit into a smaller
1297 else if (TREE_CODE (TREE_TYPE (expr
)) == REAL_TYPE
1298 && formal_prec
< TYPE_PRECISION (TREE_TYPE (expr
)))
1300 REAL_VALUE_TYPE a
= TREE_REAL_CST (expr
);
1301 if (!exact_real_truncate (TYPE_MODE (type
), &a
))
1302 give_warning
= true;
1307 warning (OPT_Wconversion
,
1308 "conversion to %qT alters %qT constant value",
1309 type
, TREE_TYPE (expr
));
1311 else /* 'expr' is not a constant. */
1313 /* Warn for real types converted to integer types. */
1314 if (TREE_CODE (TREE_TYPE (expr
)) == REAL_TYPE
1315 && TREE_CODE (type
) == INTEGER_TYPE
)
1316 give_warning
= true;
1318 else if (TREE_CODE (TREE_TYPE (expr
)) == INTEGER_TYPE
1319 && TREE_CODE (type
) == INTEGER_TYPE
)
1321 /* Don't warn about unsigned char y = 0xff, x = (int) y; */
1322 expr
= get_unwidened (expr
, 0);
1324 /* Warn for integer types converted to smaller integer types. */
1325 if (formal_prec
< TYPE_PRECISION (TREE_TYPE (expr
)))
1326 give_warning
= true;
1328 /* When they are the same width but different signedness,
1329 then the value may change. */
1330 else if ((formal_prec
== TYPE_PRECISION (TREE_TYPE (expr
))
1331 && TYPE_UNSIGNED (TREE_TYPE (expr
)) != TYPE_UNSIGNED (type
))
1332 /* Even when converted to a bigger type, if the type is
1333 unsigned but expr is signed, then negative values
1335 || (TYPE_UNSIGNED (type
) && !TYPE_UNSIGNED (TREE_TYPE (expr
))))
1336 warning (OPT_Wsign_conversion
,
1337 "conversion to %qT from %qT may change the sign of the result",
1338 type
, TREE_TYPE (expr
));
1341 /* Warn for integer types converted to real types if and only if
1342 all the range of values of the integer type cannot be
1343 represented by the real type. */
1344 else if (TREE_CODE (TREE_TYPE (expr
)) == INTEGER_TYPE
1345 && TREE_CODE (type
) == REAL_TYPE
)
1347 tree type_low_bound
= TYPE_MIN_VALUE (TREE_TYPE (expr
));
1348 tree type_high_bound
= TYPE_MAX_VALUE (TREE_TYPE (expr
));
1349 REAL_VALUE_TYPE real_low_bound
= real_value_from_int_cst (0, type_low_bound
);
1350 REAL_VALUE_TYPE real_high_bound
= real_value_from_int_cst (0, type_high_bound
);
1352 if (!exact_real_truncate (TYPE_MODE (type
), &real_low_bound
)
1353 || !exact_real_truncate (TYPE_MODE (type
), &real_high_bound
))
1354 give_warning
= true;
1357 /* Warn for real types converted to smaller real types. */
1358 else if (TREE_CODE (TREE_TYPE (expr
)) == REAL_TYPE
1359 && TREE_CODE (type
) == REAL_TYPE
1360 && formal_prec
< TYPE_PRECISION (TREE_TYPE (expr
)))
1361 give_warning
= true;
1365 warning (OPT_Wconversion
,
1366 "conversion to %qT from %qT may alter its value",
1367 type
, TREE_TYPE (expr
));
1371 /* Produce warnings after a conversion. RESULT is the result of
1372 converting EXPR to TYPE. This is a helper function for
1373 convert_and_check and cp_convert_and_check. */
1376 warnings_for_convert_and_check (tree type
, tree expr
, tree result
)
1378 if (TREE_CODE (expr
) == INTEGER_CST
1379 && (TREE_CODE (type
) == INTEGER_TYPE
1380 || TREE_CODE (type
) == ENUMERAL_TYPE
)
1381 && !int_fits_type_p (expr
, type
))
1383 /* Do not diagnose overflow in a constant expression merely
1384 because a conversion overflowed. */
1385 if (TREE_OVERFLOW (result
))
1386 TREE_OVERFLOW (result
) = TREE_OVERFLOW (expr
);
1388 if (TYPE_UNSIGNED (type
))
1390 /* This detects cases like converting -129 or 256 to
1392 if (!int_fits_type_p (expr
, c_common_signed_type (type
)))
1393 warning (OPT_Woverflow
,
1394 "large integer implicitly truncated to unsigned type");
1396 conversion_warning (type
, expr
);
1398 else if (!int_fits_type_p (expr
, c_common_unsigned_type (type
)))
1399 warning (OPT_Woverflow
,
1400 "overflow in implicit constant conversion");
1401 /* No warning for converting 0x80000000 to int. */
1403 && (TREE_CODE (TREE_TYPE (expr
)) != INTEGER_TYPE
1404 || TYPE_PRECISION (TREE_TYPE (expr
))
1405 != TYPE_PRECISION (type
)))
1406 warning (OPT_Woverflow
,
1407 "overflow in implicit constant conversion");
1410 conversion_warning (type
, expr
);
1412 else if ((TREE_CODE (result
) == INTEGER_CST
1413 || TREE_CODE (result
) == FIXED_CST
) && TREE_OVERFLOW (result
))
1414 warning (OPT_Woverflow
,
1415 "overflow in implicit constant conversion");
1417 conversion_warning (type
, expr
);
1421 /* Convert EXPR to TYPE, warning about conversion problems with constants.
1422 Invoke this function on every expression that is converted implicitly,
1423 i.e. because of language rules and not because of an explicit cast. */
1426 convert_and_check (tree type
, tree expr
)
1430 if (TREE_TYPE (expr
) == type
)
1433 result
= convert (type
, expr
);
1435 if (!skip_evaluation
&& !TREE_OVERFLOW_P (expr
) && result
!= error_mark_node
)
1436 warnings_for_convert_and_check (type
, expr
, result
);
1441 /* A node in a list that describes references to variables (EXPR), which are
1442 either read accesses if WRITER is zero, or write accesses, in which case
1443 WRITER is the parent of EXPR. */
1450 /* Used to implement a cache the results of a call to verify_tree. We only
1451 use this for SAVE_EXPRs. */
1454 struct tlist_cache
*next
;
1455 struct tlist
*cache_before_sp
;
1456 struct tlist
*cache_after_sp
;
1460 /* Obstack to use when allocating tlist structures, and corresponding
1462 static struct obstack tlist_obstack
;
1463 static char *tlist_firstobj
= 0;
1465 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
1467 static struct tlist
*warned_ids
;
1468 /* SAVE_EXPRs need special treatment. We process them only once and then
1469 cache the results. */
1470 static struct tlist_cache
*save_expr_cache
;
1472 static void add_tlist (struct tlist
**, struct tlist
*, tree
, int);
1473 static void merge_tlist (struct tlist
**, struct tlist
*, int);
1474 static void verify_tree (tree
, struct tlist
**, struct tlist
**, tree
);
1475 static int warning_candidate_p (tree
);
1476 static void warn_for_collisions (struct tlist
*);
1477 static void warn_for_collisions_1 (tree
, tree
, struct tlist
*, int);
1478 static struct tlist
*new_tlist (struct tlist
*, tree
, tree
);
1480 /* Create a new struct tlist and fill in its fields. */
1481 static struct tlist
*
1482 new_tlist (struct tlist
*next
, tree t
, tree writer
)
1485 l
= XOBNEW (&tlist_obstack
, struct tlist
);
1492 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
1493 is nonnull, we ignore any node we find which has a writer equal to it. */
1496 add_tlist (struct tlist
**to
, struct tlist
*add
, tree exclude_writer
, int copy
)
1500 struct tlist
*next
= add
->next
;
1503 if (!exclude_writer
|| add
->writer
!= exclude_writer
)
1504 *to
= copy
? new_tlist (*to
, add
->expr
, add
->writer
) : add
;
1509 /* Merge the nodes of ADD into TO. This merging process is done so that for
1510 each variable that already exists in TO, no new node is added; however if
1511 there is a write access recorded in ADD, and an occurrence on TO is only
1512 a read access, then the occurrence in TO will be modified to record the
1516 merge_tlist (struct tlist
**to
, struct tlist
*add
, int copy
)
1518 struct tlist
**end
= to
;
1521 end
= &(*end
)->next
;
1527 struct tlist
*next
= add
->next
;
1529 for (tmp2
= *to
; tmp2
; tmp2
= tmp2
->next
)
1530 if (tmp2
->expr
== add
->expr
)
1534 tmp2
->writer
= add
->writer
;
1538 *end
= copy
? add
: new_tlist (NULL
, add
->expr
, add
->writer
);
1539 end
= &(*end
)->next
;
1546 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
1547 references in list LIST conflict with it, excluding reads if ONLY writers
1551 warn_for_collisions_1 (tree written
, tree writer
, struct tlist
*list
,
1556 /* Avoid duplicate warnings. */
1557 for (tmp
= warned_ids
; tmp
; tmp
= tmp
->next
)
1558 if (tmp
->expr
== written
)
1563 if (list
->expr
== written
1564 && list
->writer
!= writer
1565 && (!only_writes
|| list
->writer
)
1566 && DECL_NAME (list
->expr
))
1568 warned_ids
= new_tlist (warned_ids
, written
, NULL_TREE
);
1569 warning (OPT_Wsequence_point
, "operation on %qE may be undefined",
1576 /* Given a list LIST of references to variables, find whether any of these
1577 can cause conflicts due to missing sequence points. */
1580 warn_for_collisions (struct tlist
*list
)
1584 for (tmp
= list
; tmp
; tmp
= tmp
->next
)
1587 warn_for_collisions_1 (tmp
->expr
, tmp
->writer
, list
, 0);
1591 /* Return nonzero if X is a tree that can be verified by the sequence point
1594 warning_candidate_p (tree x
)
1596 return TREE_CODE (x
) == VAR_DECL
|| TREE_CODE (x
) == PARM_DECL
;
1599 /* Walk the tree X, and record accesses to variables. If X is written by the
1600 parent tree, WRITER is the parent.
1601 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
1602 expression or its only operand forces a sequence point, then everything up
1603 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
1605 Once we return, we will have emitted warnings if any subexpression before
1606 such a sequence point could be undefined. On a higher level, however, the
1607 sequence point may not be relevant, and we'll merge the two lists.
1609 Example: (b++, a) + b;
1610 The call that processes the COMPOUND_EXPR will store the increment of B
1611 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
1612 processes the PLUS_EXPR will need to merge the two lists so that
1613 eventually, all accesses end up on the same list (and we'll warn about the
1614 unordered subexpressions b++ and b.
1616 A note on merging. If we modify the former example so that our expression
1619 care must be taken not simply to add all three expressions into the final
1620 PNO_SP list. The function merge_tlist takes care of that by merging the
1621 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1622 way, so that no more than one access to B is recorded. */
1625 verify_tree (tree x
, struct tlist
**pbefore_sp
, struct tlist
**pno_sp
,
1628 struct tlist
*tmp_before
, *tmp_nosp
, *tmp_list2
, *tmp_list3
;
1629 enum tree_code code
;
1630 enum tree_code_class cl
;
1632 /* X may be NULL if it is the operand of an empty statement expression
1638 code
= TREE_CODE (x
);
1639 cl
= TREE_CODE_CLASS (code
);
1641 if (warning_candidate_p (x
))
1643 *pno_sp
= new_tlist (*pno_sp
, x
, writer
);
1653 case TRUTH_ANDIF_EXPR
:
1654 case TRUTH_ORIF_EXPR
:
1655 tmp_before
= tmp_nosp
= tmp_list3
= 0;
1656 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1657 warn_for_collisions (tmp_nosp
);
1658 merge_tlist (pbefore_sp
, tmp_before
, 0);
1659 merge_tlist (pbefore_sp
, tmp_nosp
, 0);
1660 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, pno_sp
, NULL_TREE
);
1661 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1665 tmp_before
= tmp_list2
= 0;
1666 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_list2
, NULL_TREE
);
1667 warn_for_collisions (tmp_list2
);
1668 merge_tlist (pbefore_sp
, tmp_before
, 0);
1669 merge_tlist (pbefore_sp
, tmp_list2
, 1);
1671 tmp_list3
= tmp_nosp
= 0;
1672 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, &tmp_nosp
, NULL_TREE
);
1673 warn_for_collisions (tmp_nosp
);
1674 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1676 tmp_list3
= tmp_list2
= 0;
1677 verify_tree (TREE_OPERAND (x
, 2), &tmp_list3
, &tmp_list2
, NULL_TREE
);
1678 warn_for_collisions (tmp_list2
);
1679 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1680 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1681 two first, to avoid warning for (a ? b++ : b++). */
1682 merge_tlist (&tmp_nosp
, tmp_list2
, 0);
1683 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1686 case PREDECREMENT_EXPR
:
1687 case PREINCREMENT_EXPR
:
1688 case POSTDECREMENT_EXPR
:
1689 case POSTINCREMENT_EXPR
:
1690 verify_tree (TREE_OPERAND (x
, 0), pno_sp
, pno_sp
, x
);
1694 tmp_before
= tmp_nosp
= tmp_list3
= 0;
1695 verify_tree (TREE_OPERAND (x
, 1), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1696 verify_tree (TREE_OPERAND (x
, 0), &tmp_list3
, &tmp_list3
, x
);
1697 /* Expressions inside the LHS are not ordered wrt. the sequence points
1698 in the RHS. Example:
1700 Despite the fact that the modification of "a" is in the before_sp
1701 list (tmp_before), it conflicts with the use of "a" in the LHS.
1702 We can handle this by adding the contents of tmp_list3
1703 to those of tmp_before, and redoing the collision warnings for that
1705 add_tlist (&tmp_before
, tmp_list3
, x
, 1);
1706 warn_for_collisions (tmp_before
);
1707 /* Exclude the LHS itself here; we first have to merge it into the
1708 tmp_nosp list. This is done to avoid warning for "a = a"; if we
1709 didn't exclude the LHS, we'd get it twice, once as a read and once
1711 add_tlist (pno_sp
, tmp_list3
, x
, 0);
1712 warn_for_collisions_1 (TREE_OPERAND (x
, 0), x
, tmp_nosp
, 1);
1714 merge_tlist (pbefore_sp
, tmp_before
, 0);
1715 if (warning_candidate_p (TREE_OPERAND (x
, 0)))
1716 merge_tlist (&tmp_nosp
, new_tlist (NULL
, TREE_OPERAND (x
, 0), x
), 0);
1717 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 1);
1721 /* We need to warn about conflicts among arguments and conflicts between
1722 args and the function address. Side effects of the function address,
1723 however, are not ordered by the sequence point of the call. */
1725 call_expr_arg_iterator iter
;
1727 tmp_before
= tmp_nosp
= 0;
1728 verify_tree (CALL_EXPR_FN (x
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1729 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, x
)
1731 tmp_list2
= tmp_list3
= 0;
1732 verify_tree (arg
, &tmp_list2
, &tmp_list3
, NULL_TREE
);
1733 merge_tlist (&tmp_list3
, tmp_list2
, 0);
1734 add_tlist (&tmp_before
, tmp_list3
, NULL_TREE
, 0);
1736 add_tlist (&tmp_before
, tmp_nosp
, NULL_TREE
, 0);
1737 warn_for_collisions (tmp_before
);
1738 add_tlist (pbefore_sp
, tmp_before
, NULL_TREE
, 0);
1743 /* Scan all the list, e.g. indices of multi dimensional array. */
1746 tmp_before
= tmp_nosp
= 0;
1747 verify_tree (TREE_VALUE (x
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1748 merge_tlist (&tmp_nosp
, tmp_before
, 0);
1749 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1756 struct tlist_cache
*t
;
1757 for (t
= save_expr_cache
; t
; t
= t
->next
)
1763 t
= XOBNEW (&tlist_obstack
, struct tlist_cache
);
1764 t
->next
= save_expr_cache
;
1766 save_expr_cache
= t
;
1768 tmp_before
= tmp_nosp
= 0;
1769 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1770 warn_for_collisions (tmp_nosp
);
1775 struct tlist
*t
= tmp_nosp
;
1777 merge_tlist (&tmp_list3
, t
, 0);
1779 t
->cache_before_sp
= tmp_before
;
1780 t
->cache_after_sp
= tmp_list3
;
1782 merge_tlist (pbefore_sp
, t
->cache_before_sp
, 1);
1783 add_tlist (pno_sp
, t
->cache_after_sp
, NULL_TREE
, 1);
1788 /* For other expressions, simply recurse on their operands.
1789 Manual tail recursion for unary expressions.
1790 Other non-expressions need not be processed. */
1791 if (cl
== tcc_unary
)
1793 x
= TREE_OPERAND (x
, 0);
1797 else if (IS_EXPR_CODE_CLASS (cl
))
1800 int max
= TREE_OPERAND_LENGTH (x
);
1801 for (lp
= 0; lp
< max
; lp
++)
1803 tmp_before
= tmp_nosp
= 0;
1804 verify_tree (TREE_OPERAND (x
, lp
), &tmp_before
, &tmp_nosp
, 0);
1805 merge_tlist (&tmp_nosp
, tmp_before
, 0);
1806 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1813 /* Try to warn for undefined behavior in EXPR due to missing sequence
1817 verify_sequence_points (tree expr
)
1819 struct tlist
*before_sp
= 0, *after_sp
= 0;
1822 save_expr_cache
= 0;
1823 if (tlist_firstobj
== 0)
1825 gcc_obstack_init (&tlist_obstack
);
1826 tlist_firstobj
= (char *) obstack_alloc (&tlist_obstack
, 0);
1829 verify_tree (expr
, &before_sp
, &after_sp
, 0);
1830 warn_for_collisions (after_sp
);
1831 obstack_free (&tlist_obstack
, tlist_firstobj
);
1834 /* Validate the expression after `case' and apply default promotions. */
1837 check_case_value (tree value
)
1839 if (value
== NULL_TREE
)
1842 /* ??? Can we ever get nops here for a valid case value? We
1844 STRIP_TYPE_NOPS (value
);
1845 /* In C++, the following is allowed:
1848 switch (...) { case i: ... }
1850 So, we try to reduce the VALUE to a constant that way. */
1851 if (c_dialect_cxx ())
1853 value
= decl_constant_value (value
);
1854 STRIP_TYPE_NOPS (value
);
1855 value
= fold (value
);
1858 if (TREE_CODE (value
) == INTEGER_CST
)
1859 /* Promote char or short to int. */
1860 value
= perform_integral_promotions (value
);
1861 else if (value
!= error_mark_node
)
1863 error ("case label does not reduce to an integer constant");
1864 value
= error_mark_node
;
1867 constant_expression_warning (value
);
1872 /* See if the case values LOW and HIGH are in the range of the original
1873 type (i.e. before the default conversion to int) of the switch testing
1875 TYPE is the promoted type of the testing expression, and ORIG_TYPE is
1876 the type before promoting it. CASE_LOW_P is a pointer to the lower
1877 bound of the case label, and CASE_HIGH_P is the upper bound or NULL
1878 if the case is not a case range.
1879 The caller has to make sure that we are not called with NULL for
1880 CASE_LOW_P (i.e. the default case).
1881 Returns true if the case label is in range of ORIG_TYPE (saturated or
1882 untouched) or false if the label is out of range. */
1885 check_case_bounds (tree type
, tree orig_type
,
1886 tree
*case_low_p
, tree
*case_high_p
)
1888 tree min_value
, max_value
;
1889 tree case_low
= *case_low_p
;
1890 tree case_high
= case_high_p
? *case_high_p
: case_low
;
1892 /* If there was a problem with the original type, do nothing. */
1893 if (orig_type
== error_mark_node
)
1896 min_value
= TYPE_MIN_VALUE (orig_type
);
1897 max_value
= TYPE_MAX_VALUE (orig_type
);
1899 /* Case label is less than minimum for type. */
1900 if (tree_int_cst_compare (case_low
, min_value
) < 0
1901 && tree_int_cst_compare (case_high
, min_value
) < 0)
1903 warning (0, "case label value is less than minimum value for type");
1907 /* Case value is greater than maximum for type. */
1908 if (tree_int_cst_compare (case_low
, max_value
) > 0
1909 && tree_int_cst_compare (case_high
, max_value
) > 0)
1911 warning (0, "case label value exceeds maximum value for type");
1915 /* Saturate lower case label value to minimum. */
1916 if (tree_int_cst_compare (case_high
, min_value
) >= 0
1917 && tree_int_cst_compare (case_low
, min_value
) < 0)
1919 warning (0, "lower value in case label range"
1920 " less than minimum value for type");
1921 case_low
= min_value
;
1924 /* Saturate upper case label value to maximum. */
1925 if (tree_int_cst_compare (case_low
, max_value
) <= 0
1926 && tree_int_cst_compare (case_high
, max_value
) > 0)
1928 warning (0, "upper value in case label range"
1929 " exceeds maximum value for type");
1930 case_high
= max_value
;
1933 if (*case_low_p
!= case_low
)
1934 *case_low_p
= convert (type
, case_low
);
1935 if (case_high_p
&& *case_high_p
!= case_high
)
1936 *case_high_p
= convert (type
, case_high
);
1941 /* Return an integer type with BITS bits of precision,
1942 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1945 c_common_type_for_size (unsigned int bits
, int unsignedp
)
1947 if (bits
== TYPE_PRECISION (integer_type_node
))
1948 return unsignedp
? unsigned_type_node
: integer_type_node
;
1950 if (bits
== TYPE_PRECISION (signed_char_type_node
))
1951 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1953 if (bits
== TYPE_PRECISION (short_integer_type_node
))
1954 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1956 if (bits
== TYPE_PRECISION (long_integer_type_node
))
1957 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1959 if (bits
== TYPE_PRECISION (long_long_integer_type_node
))
1960 return (unsignedp
? long_long_unsigned_type_node
1961 : long_long_integer_type_node
);
1963 if (bits
== TYPE_PRECISION (widest_integer_literal_type_node
))
1964 return (unsignedp
? widest_unsigned_literal_type_node
1965 : widest_integer_literal_type_node
);
1967 if (bits
<= TYPE_PRECISION (intQI_type_node
))
1968 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
1970 if (bits
<= TYPE_PRECISION (intHI_type_node
))
1971 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
1973 if (bits
<= TYPE_PRECISION (intSI_type_node
))
1974 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
1976 if (bits
<= TYPE_PRECISION (intDI_type_node
))
1977 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
1982 /* Return a fixed-point type that has at least IBIT ibits and FBIT fbits
1983 that is unsigned if UNSIGNEDP is nonzero, otherwise signed;
1984 and saturating if SATP is nonzero, otherwise not saturating. */
1987 c_common_fixed_point_type_for_size (unsigned int ibit
, unsigned int fbit
,
1988 int unsignedp
, int satp
)
1990 enum machine_mode mode
;
1992 mode
= unsignedp
? UQQmode
: QQmode
;
1994 mode
= unsignedp
? UHAmode
: HAmode
;
1996 for (; mode
!= VOIDmode
; mode
= GET_MODE_WIDER_MODE (mode
))
1997 if (GET_MODE_IBIT (mode
) >= ibit
&& GET_MODE_FBIT (mode
) >= fbit
)
2000 if (mode
== VOIDmode
|| !targetm
.scalar_mode_supported_p (mode
))
2002 sorry ("GCC cannot support operators with integer types and "
2003 "fixed-point types that have too many integral and "
2004 "fractional bits together");
2008 return c_common_type_for_mode (mode
, satp
);
2011 /* Used for communication between c_common_type_for_mode and
2012 c_register_builtin_type. */
2013 static GTY(()) tree registered_builtin_types
;
2015 /* Return a data type that has machine mode MODE.
2016 If the mode is an integer,
2017 then UNSIGNEDP selects between signed and unsigned types.
2018 If the mode is a fixed-point mode,
2019 then UNSIGNEDP selects between saturating and nonsaturating types. */
2022 c_common_type_for_mode (enum machine_mode mode
, int unsignedp
)
2026 if (mode
== TYPE_MODE (integer_type_node
))
2027 return unsignedp
? unsigned_type_node
: integer_type_node
;
2029 if (mode
== TYPE_MODE (signed_char_type_node
))
2030 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2032 if (mode
== TYPE_MODE (short_integer_type_node
))
2033 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2035 if (mode
== TYPE_MODE (long_integer_type_node
))
2036 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2038 if (mode
== TYPE_MODE (long_long_integer_type_node
))
2039 return unsignedp
? long_long_unsigned_type_node
: long_long_integer_type_node
;
2041 if (mode
== TYPE_MODE (widest_integer_literal_type_node
))
2042 return unsignedp
? widest_unsigned_literal_type_node
2043 : widest_integer_literal_type_node
;
2046 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2049 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2052 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2055 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2057 #if HOST_BITS_PER_WIDE_INT >= 64
2058 if (mode
== TYPE_MODE (intTI_type_node
))
2059 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2062 if (mode
== TYPE_MODE (float_type_node
))
2063 return float_type_node
;
2065 if (mode
== TYPE_MODE (double_type_node
))
2066 return double_type_node
;
2068 if (mode
== TYPE_MODE (long_double_type_node
))
2069 return long_double_type_node
;
2071 if (mode
== TYPE_MODE (void_type_node
))
2072 return void_type_node
;
2074 if (mode
== TYPE_MODE (build_pointer_type (char_type_node
)))
2076 ? make_unsigned_type (GET_MODE_PRECISION (mode
))
2077 : make_signed_type (GET_MODE_PRECISION (mode
)));
2079 if (mode
== TYPE_MODE (build_pointer_type (integer_type_node
)))
2081 ? make_unsigned_type (GET_MODE_PRECISION (mode
))
2082 : make_signed_type (GET_MODE_PRECISION (mode
)));
2084 if (COMPLEX_MODE_P (mode
))
2086 enum machine_mode inner_mode
;
2089 if (mode
== TYPE_MODE (complex_float_type_node
))
2090 return complex_float_type_node
;
2091 if (mode
== TYPE_MODE (complex_double_type_node
))
2092 return complex_double_type_node
;
2093 if (mode
== TYPE_MODE (complex_long_double_type_node
))
2094 return complex_long_double_type_node
;
2096 if (mode
== TYPE_MODE (complex_integer_type_node
) && !unsignedp
)
2097 return complex_integer_type_node
;
2099 inner_mode
= GET_MODE_INNER (mode
);
2100 inner_type
= c_common_type_for_mode (inner_mode
, unsignedp
);
2101 if (inner_type
!= NULL_TREE
)
2102 return build_complex_type (inner_type
);
2104 else if (VECTOR_MODE_P (mode
))
2106 enum machine_mode inner_mode
= GET_MODE_INNER (mode
);
2107 tree inner_type
= c_common_type_for_mode (inner_mode
, unsignedp
);
2108 if (inner_type
!= NULL_TREE
)
2109 return build_vector_type_for_mode (inner_type
, mode
);
2112 if (mode
== TYPE_MODE (dfloat32_type_node
))
2113 return dfloat32_type_node
;
2114 if (mode
== TYPE_MODE (dfloat64_type_node
))
2115 return dfloat64_type_node
;
2116 if (mode
== TYPE_MODE (dfloat128_type_node
))
2117 return dfloat128_type_node
;
2119 if (ALL_SCALAR_FIXED_POINT_MODE_P (mode
))
2121 if (mode
== TYPE_MODE (short_fract_type_node
))
2122 return unsignedp
? sat_short_fract_type_node
: short_fract_type_node
;
2123 if (mode
== TYPE_MODE (fract_type_node
))
2124 return unsignedp
? sat_fract_type_node
: fract_type_node
;
2125 if (mode
== TYPE_MODE (long_fract_type_node
))
2126 return unsignedp
? sat_long_fract_type_node
: long_fract_type_node
;
2127 if (mode
== TYPE_MODE (long_long_fract_type_node
))
2128 return unsignedp
? sat_long_long_fract_type_node
2129 : long_long_fract_type_node
;
2131 if (mode
== TYPE_MODE (unsigned_short_fract_type_node
))
2132 return unsignedp
? sat_unsigned_short_fract_type_node
2133 : unsigned_short_fract_type_node
;
2134 if (mode
== TYPE_MODE (unsigned_fract_type_node
))
2135 return unsignedp
? sat_unsigned_fract_type_node
2136 : unsigned_fract_type_node
;
2137 if (mode
== TYPE_MODE (unsigned_long_fract_type_node
))
2138 return unsignedp
? sat_unsigned_long_fract_type_node
2139 : unsigned_long_fract_type_node
;
2140 if (mode
== TYPE_MODE (unsigned_long_long_fract_type_node
))
2141 return unsignedp
? sat_unsigned_long_long_fract_type_node
2142 : unsigned_long_long_fract_type_node
;
2144 if (mode
== TYPE_MODE (short_accum_type_node
))
2145 return unsignedp
? sat_short_accum_type_node
: short_accum_type_node
;
2146 if (mode
== TYPE_MODE (accum_type_node
))
2147 return unsignedp
? sat_accum_type_node
: accum_type_node
;
2148 if (mode
== TYPE_MODE (long_accum_type_node
))
2149 return unsignedp
? sat_long_accum_type_node
: long_accum_type_node
;
2150 if (mode
== TYPE_MODE (long_long_accum_type_node
))
2151 return unsignedp
? sat_long_long_accum_type_node
2152 : long_long_accum_type_node
;
2154 if (mode
== TYPE_MODE (unsigned_short_accum_type_node
))
2155 return unsignedp
? sat_unsigned_short_accum_type_node
2156 : unsigned_short_accum_type_node
;
2157 if (mode
== TYPE_MODE (unsigned_accum_type_node
))
2158 return unsignedp
? sat_unsigned_accum_type_node
2159 : unsigned_accum_type_node
;
2160 if (mode
== TYPE_MODE (unsigned_long_accum_type_node
))
2161 return unsignedp
? sat_unsigned_long_accum_type_node
2162 : unsigned_long_accum_type_node
;
2163 if (mode
== TYPE_MODE (unsigned_long_long_accum_type_node
))
2164 return unsignedp
? sat_unsigned_long_long_accum_type_node
2165 : unsigned_long_long_accum_type_node
;
2168 return unsignedp
? sat_qq_type_node
: qq_type_node
;
2170 return unsignedp
? sat_hq_type_node
: hq_type_node
;
2172 return unsignedp
? sat_sq_type_node
: sq_type_node
;
2174 return unsignedp
? sat_dq_type_node
: dq_type_node
;
2176 return unsignedp
? sat_tq_type_node
: tq_type_node
;
2178 if (mode
== UQQmode
)
2179 return unsignedp
? sat_uqq_type_node
: uqq_type_node
;
2180 if (mode
== UHQmode
)
2181 return unsignedp
? sat_uhq_type_node
: uhq_type_node
;
2182 if (mode
== USQmode
)
2183 return unsignedp
? sat_usq_type_node
: usq_type_node
;
2184 if (mode
== UDQmode
)
2185 return unsignedp
? sat_udq_type_node
: udq_type_node
;
2186 if (mode
== UTQmode
)
2187 return unsignedp
? sat_utq_type_node
: utq_type_node
;
2190 return unsignedp
? sat_ha_type_node
: ha_type_node
;
2192 return unsignedp
? sat_sa_type_node
: sa_type_node
;
2194 return unsignedp
? sat_da_type_node
: da_type_node
;
2196 return unsignedp
? sat_ta_type_node
: ta_type_node
;
2198 if (mode
== UHAmode
)
2199 return unsignedp
? sat_uha_type_node
: uha_type_node
;
2200 if (mode
== USAmode
)
2201 return unsignedp
? sat_usa_type_node
: usa_type_node
;
2202 if (mode
== UDAmode
)
2203 return unsignedp
? sat_uda_type_node
: uda_type_node
;
2204 if (mode
== UTAmode
)
2205 return unsignedp
? sat_uta_type_node
: uta_type_node
;
2208 for (t
= registered_builtin_types
; t
; t
= TREE_CHAIN (t
))
2209 if (TYPE_MODE (TREE_VALUE (t
)) == mode
)
2210 return TREE_VALUE (t
);
2216 c_common_unsigned_type (tree type
)
2218 return c_common_signed_or_unsigned_type (1, type
);
2221 /* Return a signed type the same as TYPE in other respects. */
2224 c_common_signed_type (tree type
)
2226 return c_common_signed_or_unsigned_type (0, type
);
2229 /* Return a type the same as TYPE except unsigned or
2230 signed according to UNSIGNEDP. */
2233 c_common_signed_or_unsigned_type (int unsignedp
, tree type
)
2237 /* This block of code emulates the behavior of the old
2238 c_common_unsigned_type. In particular, it returns
2239 long_unsigned_type_node if passed a long, even when a int would
2240 have the same size. This is necessary for warnings to work
2241 correctly in archs where sizeof(int) == sizeof(long) */
2243 type1
= TYPE_MAIN_VARIANT (type
);
2244 if (type1
== signed_char_type_node
|| type1
== char_type_node
|| type1
== unsigned_char_type_node
)
2245 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2246 if (type1
== integer_type_node
|| type1
== unsigned_type_node
)
2247 return unsignedp
? unsigned_type_node
: integer_type_node
;
2248 if (type1
== short_integer_type_node
|| type1
== short_unsigned_type_node
)
2249 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2250 if (type1
== long_integer_type_node
|| type1
== long_unsigned_type_node
)
2251 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2252 if (type1
== long_long_integer_type_node
|| type1
== long_long_unsigned_type_node
)
2253 return unsignedp
? long_long_unsigned_type_node
: long_long_integer_type_node
;
2254 if (type1
== widest_integer_literal_type_node
|| type1
== widest_unsigned_literal_type_node
)
2255 return unsignedp
? widest_unsigned_literal_type_node
: widest_integer_literal_type_node
;
2256 #if HOST_BITS_PER_WIDE_INT >= 64
2257 if (type1
== intTI_type_node
|| type1
== unsigned_intTI_type_node
)
2258 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2260 if (type1
== intDI_type_node
|| type1
== unsigned_intDI_type_node
)
2261 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2262 if (type1
== intSI_type_node
|| type1
== unsigned_intSI_type_node
)
2263 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2264 if (type1
== intHI_type_node
|| type1
== unsigned_intHI_type_node
)
2265 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2266 if (type1
== intQI_type_node
|| type1
== unsigned_intQI_type_node
)
2267 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2269 #define C_COMMON_FIXED_TYPES(SAT,NAME) \
2270 if (type1 == SAT ## short_ ## NAME ## _type_node \
2271 || type1 == SAT ## unsigned_short_ ## NAME ## _type_node) \
2272 return unsignedp ? SAT ## unsigned_short_ ## NAME ## _type_node \
2273 : SAT ## short_ ## NAME ## _type_node; \
2274 if (type1 == SAT ## NAME ## _type_node \
2275 || type1 == SAT ## unsigned_ ## NAME ## _type_node) \
2276 return unsignedp ? SAT ## unsigned_ ## NAME ## _type_node \
2277 : SAT ## NAME ## _type_node; \
2278 if (type1 == SAT ## long_ ## NAME ## _type_node \
2279 || type1 == SAT ## unsigned_long_ ## NAME ## _type_node) \
2280 return unsignedp ? SAT ## unsigned_long_ ## NAME ## _type_node \
2281 : SAT ## long_ ## NAME ## _type_node; \
2282 if (type1 == SAT ## long_long_ ## NAME ## _type_node \
2283 || type1 == SAT ## unsigned_long_long_ ## NAME ## _type_node) \
2284 return unsignedp ? SAT ## unsigned_long_long_ ## NAME ## _type_node \
2285 : SAT ## long_long_ ## NAME ## _type_node;
2287 #define C_COMMON_FIXED_MODE_TYPES(SAT,NAME) \
2288 if (type1 == SAT ## NAME ## _type_node \
2289 || type1 == SAT ## u ## NAME ## _type_node) \
2290 return unsignedp ? SAT ## u ## NAME ## _type_node \
2291 : SAT ## NAME ## _type_node;
2293 C_COMMON_FIXED_TYPES (, fract
);
2294 C_COMMON_FIXED_TYPES (sat_
, fract
);
2295 C_COMMON_FIXED_TYPES (, accum
);
2296 C_COMMON_FIXED_TYPES (sat_
, accum
);
2298 C_COMMON_FIXED_MODE_TYPES (, qq
);
2299 C_COMMON_FIXED_MODE_TYPES (, hq
);
2300 C_COMMON_FIXED_MODE_TYPES (, sq
);
2301 C_COMMON_FIXED_MODE_TYPES (, dq
);
2302 C_COMMON_FIXED_MODE_TYPES (, tq
);
2303 C_COMMON_FIXED_MODE_TYPES (sat_
, qq
);
2304 C_COMMON_FIXED_MODE_TYPES (sat_
, hq
);
2305 C_COMMON_FIXED_MODE_TYPES (sat_
, sq
);
2306 C_COMMON_FIXED_MODE_TYPES (sat_
, dq
);
2307 C_COMMON_FIXED_MODE_TYPES (sat_
, tq
);
2308 C_COMMON_FIXED_MODE_TYPES (, ha
);
2309 C_COMMON_FIXED_MODE_TYPES (, sa
);
2310 C_COMMON_FIXED_MODE_TYPES (, da
);
2311 C_COMMON_FIXED_MODE_TYPES (, ta
);
2312 C_COMMON_FIXED_MODE_TYPES (sat_
, ha
);
2313 C_COMMON_FIXED_MODE_TYPES (sat_
, sa
);
2314 C_COMMON_FIXED_MODE_TYPES (sat_
, da
);
2315 C_COMMON_FIXED_MODE_TYPES (sat_
, ta
);
2317 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
2318 the precision; they have precision set to match their range, but
2319 may use a wider mode to match an ABI. If we change modes, we may
2320 wind up with bad conversions. For INTEGER_TYPEs in C, must check
2321 the precision as well, so as to yield correct results for
2322 bit-field types. C++ does not have these separate bit-field
2323 types, and producing a signed or unsigned variant of an
2324 ENUMERAL_TYPE may cause other problems as well. */
2326 if (!INTEGRAL_TYPE_P (type
)
2327 || TYPE_UNSIGNED (type
) == unsignedp
)
2330 #define TYPE_OK(node) \
2331 (TYPE_MODE (type) == TYPE_MODE (node) \
2332 && (c_dialect_cxx () || TYPE_PRECISION (type) == TYPE_PRECISION (node)))
2333 if (TYPE_OK (signed_char_type_node
))
2334 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2335 if (TYPE_OK (integer_type_node
))
2336 return unsignedp
? unsigned_type_node
: integer_type_node
;
2337 if (TYPE_OK (short_integer_type_node
))
2338 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2339 if (TYPE_OK (long_integer_type_node
))
2340 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2341 if (TYPE_OK (long_long_integer_type_node
))
2342 return (unsignedp
? long_long_unsigned_type_node
2343 : long_long_integer_type_node
);
2344 if (TYPE_OK (widest_integer_literal_type_node
))
2345 return (unsignedp
? widest_unsigned_literal_type_node
2346 : widest_integer_literal_type_node
);
2348 #if HOST_BITS_PER_WIDE_INT >= 64
2349 if (TYPE_OK (intTI_type_node
))
2350 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2352 if (TYPE_OK (intDI_type_node
))
2353 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2354 if (TYPE_OK (intSI_type_node
))
2355 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2356 if (TYPE_OK (intHI_type_node
))
2357 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2358 if (TYPE_OK (intQI_type_node
))
2359 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2362 if (c_dialect_cxx ())
2365 return build_nonstandard_integer_type (TYPE_PRECISION (type
), unsignedp
);
2368 /* Build a bit-field integer type for the given WIDTH and UNSIGNEDP. */
2371 c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width
, int unsignedp
)
2373 /* Extended integer types of the same width as a standard type have
2374 lesser rank, so those of the same width as int promote to int or
2375 unsigned int and are valid for printf formats expecting int or
2376 unsigned int. To avoid such special cases, avoid creating
2377 extended integer types for bit-fields if a standard integer type
2379 if (width
== TYPE_PRECISION (integer_type_node
))
2380 return unsignedp
? unsigned_type_node
: integer_type_node
;
2381 if (width
== TYPE_PRECISION (signed_char_type_node
))
2382 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2383 if (width
== TYPE_PRECISION (short_integer_type_node
))
2384 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2385 if (width
== TYPE_PRECISION (long_integer_type_node
))
2386 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2387 if (width
== TYPE_PRECISION (long_long_integer_type_node
))
2388 return (unsignedp
? long_long_unsigned_type_node
2389 : long_long_integer_type_node
);
2390 return build_nonstandard_integer_type (width
, unsignedp
);
2393 /* The C version of the register_builtin_type langhook. */
2396 c_register_builtin_type (tree type
, const char* name
)
2400 decl
= build_decl (TYPE_DECL
, get_identifier (name
), type
);
2401 DECL_ARTIFICIAL (decl
) = 1;
2402 if (!TYPE_NAME (type
))
2403 TYPE_NAME (type
) = decl
;
2406 registered_builtin_types
= tree_cons (0, type
, registered_builtin_types
);
2410 /* Return the minimum number of bits needed to represent VALUE in a
2411 signed or unsigned type, UNSIGNEDP says which. */
2414 min_precision (tree value
, int unsignedp
)
2418 /* If the value is negative, compute its negative minus 1. The latter
2419 adjustment is because the absolute value of the largest negative value
2420 is one larger than the largest positive value. This is equivalent to
2421 a bit-wise negation, so use that operation instead. */
2423 if (tree_int_cst_sgn (value
) < 0)
2424 value
= fold_build1 (BIT_NOT_EXPR
, TREE_TYPE (value
), value
);
2426 /* Return the number of bits needed, taking into account the fact
2427 that we need one more bit for a signed than unsigned type. */
2429 if (integer_zerop (value
))
2432 log
= tree_floor_log2 (value
);
2434 return log
+ 1 + !unsignedp
;
2437 /* Print an error message for invalid operands to arith operation
2438 CODE with TYPE0 for operand 0, and TYPE1 for operand 1. */
2441 binary_op_error (enum tree_code code
, tree type0
, tree type1
)
2448 opname
= "+"; break;
2450 opname
= "-"; break;
2452 opname
= "*"; break;
2454 opname
= "max"; break;
2456 opname
= "min"; break;
2458 opname
= "=="; break;
2460 opname
= "!="; break;
2462 opname
= "<="; break;
2464 opname
= ">="; break;
2466 opname
= "<"; break;
2468 opname
= ">"; break;
2470 opname
= "<<"; break;
2472 opname
= ">>"; break;
2473 case TRUNC_MOD_EXPR
:
2474 case FLOOR_MOD_EXPR
:
2475 opname
= "%"; break;
2476 case TRUNC_DIV_EXPR
:
2477 case FLOOR_DIV_EXPR
:
2478 opname
= "/"; break;
2480 opname
= "&"; break;
2482 opname
= "|"; break;
2483 case TRUTH_ANDIF_EXPR
:
2484 opname
= "&&"; break;
2485 case TRUTH_ORIF_EXPR
:
2486 opname
= "||"; break;
2488 opname
= "^"; break;
2492 error ("invalid operands to binary %s (have %qT and %qT)", opname
,
2496 /* Subroutine of build_binary_op, used for comparison operations.
2497 See if the operands have both been converted from subword integer types
2498 and, if so, perhaps change them both back to their original type.
2499 This function is also responsible for converting the two operands
2500 to the proper common type for comparison.
2502 The arguments of this function are all pointers to local variables
2503 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2504 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2506 If this function returns nonzero, it means that the comparison has
2507 a constant value. What this function returns is an expression for
2511 shorten_compare (tree
*op0_ptr
, tree
*op1_ptr
, tree
*restype_ptr
,
2512 enum tree_code
*rescode_ptr
)
2515 tree op0
= *op0_ptr
;
2516 tree op1
= *op1_ptr
;
2517 int unsignedp0
, unsignedp1
;
2519 tree primop0
, primop1
;
2520 enum tree_code code
= *rescode_ptr
;
2522 /* Throw away any conversions to wider types
2523 already present in the operands. */
2525 primop0
= get_narrower (op0
, &unsignedp0
);
2526 primop1
= get_narrower (op1
, &unsignedp1
);
2528 /* Handle the case that OP0 does not *contain* a conversion
2529 but it *requires* conversion to FINAL_TYPE. */
2531 if (op0
== primop0
&& TREE_TYPE (op0
) != *restype_ptr
)
2532 unsignedp0
= TYPE_UNSIGNED (TREE_TYPE (op0
));
2533 if (op1
== primop1
&& TREE_TYPE (op1
) != *restype_ptr
)
2534 unsignedp1
= TYPE_UNSIGNED (TREE_TYPE (op1
));
2536 /* If one of the operands must be floated, we cannot optimize. */
2537 real1
= TREE_CODE (TREE_TYPE (primop0
)) == REAL_TYPE
;
2538 real2
= TREE_CODE (TREE_TYPE (primop1
)) == REAL_TYPE
;
2540 /* If first arg is constant, swap the args (changing operation
2541 so value is preserved), for canonicalization. Don't do this if
2542 the second arg is 0. */
2544 if (TREE_CONSTANT (primop0
)
2545 && !integer_zerop (primop1
) && !real_zerop (primop1
)
2546 && !fixed_zerop (primop1
))
2549 int temi
= unsignedp0
;
2557 unsignedp0
= unsignedp1
;
2580 *rescode_ptr
= code
;
2583 /* If comparing an integer against a constant more bits wide,
2584 maybe we can deduce a value of 1 or 0 independent of the data.
2585 Or else truncate the constant now
2586 rather than extend the variable at run time.
2588 This is only interesting if the constant is the wider arg.
2589 Also, it is not safe if the constant is unsigned and the
2590 variable arg is signed, since in this case the variable
2591 would be sign-extended and then regarded as unsigned.
2592 Our technique fails in this case because the lowest/highest
2593 possible unsigned results don't follow naturally from the
2594 lowest/highest possible values of the variable operand.
2595 For just EQ_EXPR and NE_EXPR there is another technique that
2596 could be used: see if the constant can be faithfully represented
2597 in the other operand's type, by truncating it and reextending it
2598 and see if that preserves the constant's value. */
2600 if (!real1
&& !real2
2601 && TREE_CODE (TREE_TYPE (primop0
)) != FIXED_POINT_TYPE
2602 && TREE_CODE (primop1
) == INTEGER_CST
2603 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
))
2605 int min_gt
, max_gt
, min_lt
, max_lt
;
2606 tree maxval
, minval
;
2607 /* 1 if comparison is nominally unsigned. */
2608 int unsignedp
= TYPE_UNSIGNED (*restype_ptr
);
2611 type
= c_common_signed_or_unsigned_type (unsignedp0
,
2612 TREE_TYPE (primop0
));
2614 maxval
= TYPE_MAX_VALUE (type
);
2615 minval
= TYPE_MIN_VALUE (type
);
2617 if (unsignedp
&& !unsignedp0
)
2618 *restype_ptr
= c_common_signed_type (*restype_ptr
);
2620 if (TREE_TYPE (primop1
) != *restype_ptr
)
2622 /* Convert primop1 to target type, but do not introduce
2623 additional overflow. We know primop1 is an int_cst. */
2624 primop1
= force_fit_type_double (*restype_ptr
,
2625 TREE_INT_CST_LOW (primop1
),
2626 TREE_INT_CST_HIGH (primop1
), 0,
2627 TREE_OVERFLOW (primop1
));
2629 if (type
!= *restype_ptr
)
2631 minval
= convert (*restype_ptr
, minval
);
2632 maxval
= convert (*restype_ptr
, maxval
);
2635 if (unsignedp
&& unsignedp0
)
2637 min_gt
= INT_CST_LT_UNSIGNED (primop1
, minval
);
2638 max_gt
= INT_CST_LT_UNSIGNED (primop1
, maxval
);
2639 min_lt
= INT_CST_LT_UNSIGNED (minval
, primop1
);
2640 max_lt
= INT_CST_LT_UNSIGNED (maxval
, primop1
);
2644 min_gt
= INT_CST_LT (primop1
, minval
);
2645 max_gt
= INT_CST_LT (primop1
, maxval
);
2646 min_lt
= INT_CST_LT (minval
, primop1
);
2647 max_lt
= INT_CST_LT (maxval
, primop1
);
2651 /* This used to be a switch, but Genix compiler can't handle that. */
2652 if (code
== NE_EXPR
)
2654 if (max_lt
|| min_gt
)
2655 val
= truthvalue_true_node
;
2657 else if (code
== EQ_EXPR
)
2659 if (max_lt
|| min_gt
)
2660 val
= truthvalue_false_node
;
2662 else if (code
== LT_EXPR
)
2665 val
= truthvalue_true_node
;
2667 val
= truthvalue_false_node
;
2669 else if (code
== GT_EXPR
)
2672 val
= truthvalue_true_node
;
2674 val
= truthvalue_false_node
;
2676 else if (code
== LE_EXPR
)
2679 val
= truthvalue_true_node
;
2681 val
= truthvalue_false_node
;
2683 else if (code
== GE_EXPR
)
2686 val
= truthvalue_true_node
;
2688 val
= truthvalue_false_node
;
2691 /* If primop0 was sign-extended and unsigned comparison specd,
2692 we did a signed comparison above using the signed type bounds.
2693 But the comparison we output must be unsigned.
2695 Also, for inequalities, VAL is no good; but if the signed
2696 comparison had *any* fixed result, it follows that the
2697 unsigned comparison just tests the sign in reverse
2698 (positive values are LE, negative ones GE).
2699 So we can generate an unsigned comparison
2700 against an extreme value of the signed type. */
2702 if (unsignedp
&& !unsignedp0
)
2709 primop1
= TYPE_MIN_VALUE (type
);
2715 primop1
= TYPE_MAX_VALUE (type
);
2722 type
= c_common_unsigned_type (type
);
2725 if (TREE_CODE (primop0
) != INTEGER_CST
)
2727 if (val
== truthvalue_false_node
)
2728 warning (OPT_Wtype_limits
, "comparison is always false due to limited range of data type");
2729 if (val
== truthvalue_true_node
)
2730 warning (OPT_Wtype_limits
, "comparison is always true due to limited range of data type");
2735 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2736 if (TREE_SIDE_EFFECTS (primop0
))
2737 return build2 (COMPOUND_EXPR
, TREE_TYPE (val
), primop0
, val
);
2741 /* Value is not predetermined, but do the comparison
2742 in the type of the operand that is not constant.
2743 TYPE is already properly set. */
2746 /* If either arg is decimal float and the other is float, find the
2747 proper common type to use for comparison. */
2748 else if (real1
&& real2
2749 && (DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0
)))
2750 || DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1
)))))
2751 type
= common_type (TREE_TYPE (primop0
), TREE_TYPE (primop1
));
2753 else if (real1
&& real2
2754 && (TYPE_PRECISION (TREE_TYPE (primop0
))
2755 == TYPE_PRECISION (TREE_TYPE (primop1
))))
2756 type
= TREE_TYPE (primop0
);
2758 /* If args' natural types are both narrower than nominal type
2759 and both extend in the same manner, compare them
2760 in the type of the wider arg.
2761 Otherwise must actually extend both to the nominal
2762 common type lest different ways of extending
2764 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
2766 else if (unsignedp0
== unsignedp1
&& real1
== real2
2767 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
)
2768 && TYPE_PRECISION (TREE_TYPE (primop1
)) < TYPE_PRECISION (*restype_ptr
))
2770 type
= common_type (TREE_TYPE (primop0
), TREE_TYPE (primop1
));
2771 type
= c_common_signed_or_unsigned_type (unsignedp0
2772 || TYPE_UNSIGNED (*restype_ptr
),
2774 /* Make sure shorter operand is extended the right way
2775 to match the longer operand. */
2777 = convert (c_common_signed_or_unsigned_type (unsignedp0
,
2778 TREE_TYPE (primop0
)),
2781 = convert (c_common_signed_or_unsigned_type (unsignedp1
,
2782 TREE_TYPE (primop1
)),
2787 /* Here we must do the comparison on the nominal type
2788 using the args exactly as we received them. */
2789 type
= *restype_ptr
;
2793 if (!real1
&& !real2
&& integer_zerop (primop1
)
2794 && TYPE_UNSIGNED (*restype_ptr
))
2800 /* All unsigned values are >= 0, so we warn. However,
2801 if OP0 is a constant that is >= 0, the signedness of
2802 the comparison isn't an issue, so suppress the
2804 if (warn_type_limits
&& !in_system_header
2805 && !(TREE_CODE (primop0
) == INTEGER_CST
2806 && !TREE_OVERFLOW (convert (c_common_signed_type (type
),
2808 warning (OPT_Wtype_limits
,
2809 "comparison of unsigned expression >= 0 is always true");
2810 value
= truthvalue_true_node
;
2814 if (warn_type_limits
&& !in_system_header
2815 && !(TREE_CODE (primop0
) == INTEGER_CST
2816 && !TREE_OVERFLOW (convert (c_common_signed_type (type
),
2818 warning (OPT_Wtype_limits
,
2819 "comparison of unsigned expression < 0 is always false");
2820 value
= truthvalue_false_node
;
2829 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2830 if (TREE_SIDE_EFFECTS (primop0
))
2831 return build2 (COMPOUND_EXPR
, TREE_TYPE (value
),
2838 *op0_ptr
= convert (type
, primop0
);
2839 *op1_ptr
= convert (type
, primop1
);
2841 *restype_ptr
= truthvalue_type_node
;
2846 /* Return a tree for the sum or difference (RESULTCODE says which)
2847 of pointer PTROP and integer INTOP. */
2850 pointer_int_sum (enum tree_code resultcode
, tree ptrop
, tree intop
)
2854 /* The result is a pointer of the same type that is being added. */
2855 tree result_type
= TREE_TYPE (ptrop
);
2857 if (TREE_CODE (TREE_TYPE (result_type
)) == VOID_TYPE
)
2859 if (pedantic
|| warn_pointer_arith
)
2860 pedwarn ("pointer of type %<void *%> used in arithmetic");
2861 size_exp
= integer_one_node
;
2863 else if (TREE_CODE (TREE_TYPE (result_type
)) == FUNCTION_TYPE
)
2865 if (pedantic
|| warn_pointer_arith
)
2866 pedwarn ("pointer to a function used in arithmetic");
2867 size_exp
= integer_one_node
;
2869 else if (TREE_CODE (TREE_TYPE (result_type
)) == METHOD_TYPE
)
2871 if (pedantic
|| warn_pointer_arith
)
2872 pedwarn ("pointer to member function used in arithmetic");
2873 size_exp
= integer_one_node
;
2876 size_exp
= size_in_bytes (TREE_TYPE (result_type
));
2878 /* We are manipulating pointer values, so we don't need to warn
2879 about relying on undefined signed overflow. We disable the
2880 warning here because we use integer types so fold won't know that
2881 they are really pointers. */
2882 fold_defer_overflow_warnings ();
2884 /* If what we are about to multiply by the size of the elements
2885 contains a constant term, apply distributive law
2886 and multiply that constant term separately.
2887 This helps produce common subexpressions. */
2888 if ((TREE_CODE (intop
) == PLUS_EXPR
|| TREE_CODE (intop
) == MINUS_EXPR
)
2889 && !TREE_CONSTANT (intop
)
2890 && TREE_CONSTANT (TREE_OPERAND (intop
, 1))
2891 && TREE_CONSTANT (size_exp
)
2892 /* If the constant comes from pointer subtraction,
2893 skip this optimization--it would cause an error. */
2894 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop
, 0))) == INTEGER_TYPE
2895 /* If the constant is unsigned, and smaller than the pointer size,
2896 then we must skip this optimization. This is because it could cause
2897 an overflow error if the constant is negative but INTOP is not. */
2898 && (!TYPE_UNSIGNED (TREE_TYPE (intop
))
2899 || (TYPE_PRECISION (TREE_TYPE (intop
))
2900 == TYPE_PRECISION (TREE_TYPE (ptrop
)))))
2902 enum tree_code subcode
= resultcode
;
2903 tree int_type
= TREE_TYPE (intop
);
2904 if (TREE_CODE (intop
) == MINUS_EXPR
)
2905 subcode
= (subcode
== PLUS_EXPR
? MINUS_EXPR
: PLUS_EXPR
);
2906 /* Convert both subexpression types to the type of intop,
2907 because weird cases involving pointer arithmetic
2908 can result in a sum or difference with different type args. */
2909 ptrop
= build_binary_op (subcode
, ptrop
,
2910 convert (int_type
, TREE_OPERAND (intop
, 1)), 1);
2911 intop
= convert (int_type
, TREE_OPERAND (intop
, 0));
2914 /* Convert the integer argument to a type the same size as sizetype
2915 so the multiply won't overflow spuriously. */
2916 if (TYPE_PRECISION (TREE_TYPE (intop
)) != TYPE_PRECISION (sizetype
)
2917 || TYPE_UNSIGNED (TREE_TYPE (intop
)) != TYPE_UNSIGNED (sizetype
))
2918 intop
= convert (c_common_type_for_size (TYPE_PRECISION (sizetype
),
2919 TYPE_UNSIGNED (sizetype
)), intop
);
2921 /* Replace the integer argument with a suitable product by the object size.
2922 Do this multiplication as signed, then convert to the appropriate
2923 type for the pointer operation. */
2924 intop
= convert (sizetype
,
2925 build_binary_op (MULT_EXPR
, intop
,
2926 convert (TREE_TYPE (intop
), size_exp
), 1));
2928 /* Create the sum or difference. */
2929 if (resultcode
== MINUS_EXPR
)
2930 intop
= fold_build1 (NEGATE_EXPR
, sizetype
, intop
);
2932 ret
= fold_build2 (POINTER_PLUS_EXPR
, result_type
, ptrop
, intop
);
2934 fold_undefer_and_ignore_overflow_warnings ();
2939 /* Return whether EXPR is a declaration whose address can never be
2943 decl_with_nonnull_addr_p (const_tree expr
)
2945 return (DECL_P (expr
)
2946 && (TREE_CODE (expr
) == PARM_DECL
2947 || TREE_CODE (expr
) == LABEL_DECL
2948 || !DECL_WEAK (expr
)));
2951 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2952 or for an `if' or `while' statement or ?..: exp. It should already
2953 have been validated to be of suitable type; otherwise, a bad
2954 diagnostic may result.
2956 This preparation consists of taking the ordinary
2957 representation of an expression expr and producing a valid tree
2958 boolean expression describing whether expr is nonzero. We could
2959 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
2960 but we optimize comparisons, &&, ||, and !.
2962 The resulting type should always be `truthvalue_type_node'. */
2965 c_common_truthvalue_conversion (tree expr
)
2967 switch (TREE_CODE (expr
))
2969 case EQ_EXPR
: case NE_EXPR
: case UNEQ_EXPR
: case LTGT_EXPR
:
2970 case LE_EXPR
: case GE_EXPR
: case LT_EXPR
: case GT_EXPR
:
2971 case UNLE_EXPR
: case UNGE_EXPR
: case UNLT_EXPR
: case UNGT_EXPR
:
2972 case ORDERED_EXPR
: case UNORDERED_EXPR
:
2973 if (TREE_TYPE (expr
) == truthvalue_type_node
)
2975 return build2 (TREE_CODE (expr
), truthvalue_type_node
,
2976 TREE_OPERAND (expr
, 0), TREE_OPERAND (expr
, 1));
2978 case TRUTH_ANDIF_EXPR
:
2979 case TRUTH_ORIF_EXPR
:
2980 case TRUTH_AND_EXPR
:
2982 case TRUTH_XOR_EXPR
:
2983 if (TREE_TYPE (expr
) == truthvalue_type_node
)
2985 return build2 (TREE_CODE (expr
), truthvalue_type_node
,
2986 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0)),
2987 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 1)));
2989 case TRUTH_NOT_EXPR
:
2990 if (TREE_TYPE (expr
) == truthvalue_type_node
)
2992 return build1 (TREE_CODE (expr
), truthvalue_type_node
,
2993 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0)));
2999 return integer_zerop (expr
) ? truthvalue_false_node
3000 : truthvalue_true_node
;
3003 return real_compare (NE_EXPR
, &TREE_REAL_CST (expr
), &dconst0
)
3004 ? truthvalue_true_node
3005 : truthvalue_false_node
;
3008 return fixed_compare (NE_EXPR
, &TREE_FIXED_CST (expr
),
3009 &FCONST0 (TYPE_MODE (TREE_TYPE (expr
))))
3010 ? truthvalue_true_node
3011 : truthvalue_false_node
;
3014 expr
= build_unary_op (ADDR_EXPR
, expr
, 0);
3019 tree inner
= TREE_OPERAND (expr
, 0);
3020 if (decl_with_nonnull_addr_p (inner
))
3022 /* Common Ada/Pascal programmer's mistake. */
3023 warning (OPT_Waddress
,
3024 "the address of %qD will always evaluate as %<true%>",
3026 return truthvalue_true_node
;
3029 /* If we still have a decl, it is possible for its address to
3030 be NULL, so we cannot optimize. */
3033 gcc_assert (DECL_WEAK (inner
));
3037 if (TREE_SIDE_EFFECTS (inner
))
3038 return build2 (COMPOUND_EXPR
, truthvalue_type_node
,
3039 inner
, truthvalue_true_node
);
3041 return truthvalue_true_node
;
3045 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1))
3046 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
3047 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0)),
3048 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 1)),
3054 /* These don't change whether an object is nonzero or zero. */
3055 return c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0));
3059 /* These don't change whether an object is zero or nonzero, but
3060 we can't ignore them if their second arg has side-effects. */
3061 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1)))
3062 return build2 (COMPOUND_EXPR
, truthvalue_type_node
,
3063 TREE_OPERAND (expr
, 1),
3064 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0)));
3066 return c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0));
3069 /* Distribute the conversion into the arms of a COND_EXPR. */
3070 return fold_build3 (COND_EXPR
, truthvalue_type_node
,
3071 TREE_OPERAND (expr
, 0),
3072 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 1)),
3073 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 2)));
3076 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
3077 since that affects how `default_conversion' will behave. */
3078 if (TREE_CODE (TREE_TYPE (expr
)) == REFERENCE_TYPE
3079 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == REFERENCE_TYPE
)
3081 /* If this is widening the argument, we can ignore it. */
3082 if (TYPE_PRECISION (TREE_TYPE (expr
))
3083 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr
, 0))))
3084 return c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0));
3088 if (!TREE_NO_WARNING (expr
)
3089 && warn_parentheses
)
3091 warning (OPT_Wparentheses
,
3092 "suggest parentheses around assignment used as truth value");
3093 TREE_NO_WARNING (expr
) = 1;
3101 if (TREE_CODE (TREE_TYPE (expr
)) == COMPLEX_TYPE
)
3103 tree t
= save_expr (expr
);
3104 return (build_binary_op
3105 ((TREE_SIDE_EFFECTS (expr
)
3106 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
3107 c_common_truthvalue_conversion (build_unary_op (REALPART_EXPR
, t
, 0)),
3108 c_common_truthvalue_conversion (build_unary_op (IMAGPART_EXPR
, t
, 0)),
3112 if (TREE_CODE (TREE_TYPE (expr
)) == FIXED_POINT_TYPE
)
3114 tree fixed_zero_node
= build_fixed (TREE_TYPE (expr
),
3116 (TREE_TYPE (expr
))));
3117 return build_binary_op (NE_EXPR
, expr
, fixed_zero_node
, 1);
3120 return build_binary_op (NE_EXPR
, expr
, integer_zero_node
, 1);
3123 static void def_builtin_1 (enum built_in_function fncode
,
3125 enum built_in_class fnclass
,
3126 tree fntype
, tree libtype
,
3127 bool both_p
, bool fallback_p
, bool nonansi_p
,
3128 tree fnattrs
, bool implicit_p
);
3131 /* Apply the TYPE_QUALS to the new DECL. */
3134 c_apply_type_quals_to_decl (int type_quals
, tree decl
)
3136 tree type
= TREE_TYPE (decl
);
3138 if (type
== error_mark_node
)
3141 if (((type_quals
& TYPE_QUAL_CONST
)
3142 || (type
&& TREE_CODE (type
) == REFERENCE_TYPE
))
3143 /* An object declared 'const' is only readonly after it is
3144 initialized. We don't have any way of expressing this currently,
3145 so we need to be conservative and unset TREE_READONLY for types
3146 with constructors. Otherwise aliasing code will ignore stores in
3147 an inline constructor. */
3148 && !(type
&& TYPE_NEEDS_CONSTRUCTING (type
)))
3149 TREE_READONLY (decl
) = 1;
3150 if (type_quals
& TYPE_QUAL_VOLATILE
)
3152 TREE_SIDE_EFFECTS (decl
) = 1;
3153 TREE_THIS_VOLATILE (decl
) = 1;
3155 if (type_quals
& TYPE_QUAL_RESTRICT
)
3157 while (type
&& TREE_CODE (type
) == ARRAY_TYPE
)
3158 /* Allow 'restrict' on arrays of pointers.
3159 FIXME currently we just ignore it. */
3160 type
= TREE_TYPE (type
);
3162 || !POINTER_TYPE_P (type
)
3163 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type
)))
3164 error ("invalid use of %<restrict%>");
3165 else if (flag_strict_aliasing
&& type
== TREE_TYPE (decl
))
3166 /* Indicate we need to make a unique alias set for this pointer.
3167 We can't do it here because it might be pointing to an
3169 DECL_POINTER_ALIAS_SET (decl
) = -2;
3173 /* Hash function for the problem of multiple type definitions in
3174 different files. This must hash all types that will compare
3175 equal via comptypes to the same value. In practice it hashes
3176 on some of the simple stuff and leaves the details to comptypes. */
3179 c_type_hash (const void *p
)
3183 const_tree
const t
= (const_tree
) p
;
3185 switch (TREE_CODE (t
))
3187 /* For pointers, hash on pointee type plus some swizzling. */
3189 return c_type_hash (TREE_TYPE (t
)) ^ 0x3003003;
3190 /* Hash on number of elements and total size. */
3193 t2
= TYPE_VALUES (t
);
3197 t2
= TYPE_FIELDS (t
);
3199 case QUAL_UNION_TYPE
:
3201 t2
= TYPE_FIELDS (t
);
3205 t2
= TYPE_FIELDS (t
);
3210 for (; t2
; t2
= TREE_CHAIN (t2
))
3212 /* We might have a VLA here. */
3213 if (TREE_CODE (TYPE_SIZE (t
)) != INTEGER_CST
)
3216 size
= TREE_INT_CST_LOW (TYPE_SIZE (t
));
3217 return ((size
<< 24) | (i
<< shift
));
3220 static GTY((param_is (union tree_node
))) htab_t type_hash_table
;
3222 /* Return the typed-based alias set for T, which may be an expression
3223 or a type. Return -1 if we don't do anything special. */
3226 c_common_get_alias_set (tree t
)
3231 /* Permit type-punning when accessing a union, provided the access
3232 is directly through the union. For example, this code does not
3233 permit taking the address of a union member and then storing
3234 through it. Even the type-punning allowed here is a GCC
3235 extension, albeit a common and useful one; the C standard says
3236 that such accesses have implementation-defined behavior. */
3238 TREE_CODE (u
) == COMPONENT_REF
|| TREE_CODE (u
) == ARRAY_REF
;
3239 u
= TREE_OPERAND (u
, 0))
3240 if (TREE_CODE (u
) == COMPONENT_REF
3241 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u
, 0))) == UNION_TYPE
)
3244 /* That's all the expressions we handle specially. */
3248 /* The C standard guarantees that any object may be accessed via an
3249 lvalue that has character type. */
3250 if (t
== char_type_node
3251 || t
== signed_char_type_node
3252 || t
== unsigned_char_type_node
)
3255 /* If it has the may_alias attribute, it can alias anything. */
3256 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (t
)))
3259 /* The C standard specifically allows aliasing between signed and
3260 unsigned variants of the same type. We treat the signed
3261 variant as canonical. */
3262 if (TREE_CODE (t
) == INTEGER_TYPE
&& TYPE_UNSIGNED (t
))
3264 tree t1
= c_common_signed_type (t
);
3266 /* t1 == t can happen for boolean nodes which are always unsigned. */
3268 return get_alias_set (t1
);
3270 else if (POINTER_TYPE_P (t
))
3274 /* Unfortunately, there is no canonical form of a pointer type.
3275 In particular, if we have `typedef int I', then `int *', and
3276 `I *' are different types. So, we have to pick a canonical
3277 representative. We do this below.
3279 Technically, this approach is actually more conservative that
3280 it needs to be. In particular, `const int *' and `int *'
3281 should be in different alias sets, according to the C and C++
3282 standard, since their types are not the same, and so,
3283 technically, an `int **' and `const int **' cannot point at
3286 But, the standard is wrong. In particular, this code is
3291 const int* const* cipp = ipp;
3293 And, it doesn't make sense for that to be legal unless you
3294 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
3295 the pointed-to types. This issue has been reported to the
3297 t1
= build_type_no_quals (t
);
3299 return get_alias_set (t1
);
3302 /* Handle the case of multiple type nodes referring to "the same" type,
3303 which occurs with IMA. These share an alias set. FIXME: Currently only
3304 C90 is handled. (In C99 type compatibility is not transitive, which
3305 complicates things mightily. The alias set splay trees can theoretically
3306 represent this, but insertion is tricky when you consider all the
3307 different orders things might arrive in.) */
3309 if (c_language
!= clk_c
|| flag_isoc99
)
3312 /* Save time if there's only one input file. */
3313 if (num_in_fnames
== 1)
3316 /* Pointers need special handling if they point to any type that
3317 needs special handling (below). */
3318 if (TREE_CODE (t
) == POINTER_TYPE
)
3321 /* Find bottom type under any nested POINTERs. */
3322 for (t2
= TREE_TYPE (t
);
3323 TREE_CODE (t2
) == POINTER_TYPE
;
3324 t2
= TREE_TYPE (t2
))
3326 if (TREE_CODE (t2
) != RECORD_TYPE
3327 && TREE_CODE (t2
) != ENUMERAL_TYPE
3328 && TREE_CODE (t2
) != QUAL_UNION_TYPE
3329 && TREE_CODE (t2
) != UNION_TYPE
)
3331 if (TYPE_SIZE (t2
) == 0)
3334 /* These are the only cases that need special handling. */
3335 if (TREE_CODE (t
) != RECORD_TYPE
3336 && TREE_CODE (t
) != ENUMERAL_TYPE
3337 && TREE_CODE (t
) != QUAL_UNION_TYPE
3338 && TREE_CODE (t
) != UNION_TYPE
3339 && TREE_CODE (t
) != POINTER_TYPE
)
3342 if (TYPE_SIZE (t
) == 0)
3345 /* Look up t in hash table. Only one of the compatible types within each
3346 alias set is recorded in the table. */
3347 if (!type_hash_table
)
3348 type_hash_table
= htab_create_ggc (1021, c_type_hash
,
3349 (htab_eq
) lang_hooks
.types_compatible_p
,
3351 slot
= htab_find_slot (type_hash_table
, t
, INSERT
);
3354 TYPE_ALIAS_SET (t
) = TYPE_ALIAS_SET ((tree
)*slot
);
3355 return TYPE_ALIAS_SET ((tree
)*slot
);
3358 /* Our caller will assign and record (in t) a new alias set; all we need
3359 to do is remember t in the hash table. */
3365 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
3366 second parameter indicates which OPERATOR is being applied. The COMPLAIN
3367 flag controls whether we should diagnose possibly ill-formed
3368 constructs or not. */
3371 c_sizeof_or_alignof_type (tree type
, bool is_sizeof
, int complain
)
3373 const char *op_name
;
3375 enum tree_code type_code
= TREE_CODE (type
);
3377 op_name
= is_sizeof
? "sizeof" : "__alignof__";
3379 if (type_code
== FUNCTION_TYPE
)
3383 if (complain
&& (pedantic
|| warn_pointer_arith
))
3384 pedwarn ("invalid application of %<sizeof%> to a function type");
3386 return error_mark_node
;
3387 value
= size_one_node
;
3390 value
= size_int (FUNCTION_BOUNDARY
/ BITS_PER_UNIT
);
3392 else if (type_code
== VOID_TYPE
|| type_code
== ERROR_MARK
)
3394 if (type_code
== VOID_TYPE
3395 && complain
&& (pedantic
|| warn_pointer_arith
))
3396 pedwarn ("invalid application of %qs to a void type", op_name
);
3398 return error_mark_node
;
3399 value
= size_one_node
;
3401 else if (!COMPLETE_TYPE_P (type
))
3404 error ("invalid application of %qs to incomplete type %qT ",
3406 value
= size_zero_node
;
3411 /* Convert in case a char is more than one unit. */
3412 value
= size_binop (CEIL_DIV_EXPR
, TYPE_SIZE_UNIT (type
),
3413 size_int (TYPE_PRECISION (char_type_node
)
3416 value
= size_int (TYPE_ALIGN_UNIT (type
));
3419 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
3420 TYPE_IS_SIZETYPE means that certain things (like overflow) will
3421 never happen. However, this node should really have type
3422 `size_t', which is just a typedef for an ordinary integer type. */
3423 value
= fold_convert (size_type_node
, value
);
3424 gcc_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value
)));
3429 /* Implement the __alignof keyword: Return the minimum required
3430 alignment of EXPR, measured in bytes. For VAR_DECLs,
3431 FUNCTION_DECLs and FIELD_DECLs return DECL_ALIGN (which can be set
3432 from an "aligned" __attribute__ specification). */
3435 c_alignof_expr (tree expr
)
3439 if (VAR_OR_FUNCTION_DECL_P (expr
))
3440 t
= size_int (DECL_ALIGN_UNIT (expr
));
3442 else if (TREE_CODE (expr
) == COMPONENT_REF
3443 && DECL_C_BIT_FIELD (TREE_OPERAND (expr
, 1)))
3445 error ("%<__alignof%> applied to a bit-field");
3448 else if (TREE_CODE (expr
) == COMPONENT_REF
3449 && TREE_CODE (TREE_OPERAND (expr
, 1)) == FIELD_DECL
)
3450 t
= size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr
, 1)));
3452 else if (TREE_CODE (expr
) == INDIRECT_REF
)
3454 tree t
= TREE_OPERAND (expr
, 0);
3456 int bestalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
3458 while (CONVERT_EXPR_P (t
)
3459 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0))) == POINTER_TYPE
)
3463 t
= TREE_OPERAND (t
, 0);
3464 thisalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
3465 if (thisalign
> bestalign
)
3466 best
= t
, bestalign
= thisalign
;
3468 return c_alignof (TREE_TYPE (TREE_TYPE (best
)));
3471 return c_alignof (TREE_TYPE (expr
));
3473 return fold_convert (size_type_node
, t
);
3476 /* Handle C and C++ default attributes. */
3478 enum built_in_attribute
3480 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
3481 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
3482 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
3483 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
3484 #include "builtin-attrs.def"
3485 #undef DEF_ATTR_NULL_TREE
3487 #undef DEF_ATTR_IDENT
3488 #undef DEF_ATTR_TREE_LIST
3492 static GTY(()) tree built_in_attributes
[(int) ATTR_LAST
];
3494 static void c_init_attributes (void);
3498 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
3499 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
3500 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
3501 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
3502 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3503 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3504 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
3505 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME,
3506 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME,
3507 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
3508 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
3509 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
3510 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3511 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3512 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
3514 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
3515 #include "builtin-types.def"
3516 #undef DEF_PRIMITIVE_TYPE
3517 #undef DEF_FUNCTION_TYPE_0
3518 #undef DEF_FUNCTION_TYPE_1
3519 #undef DEF_FUNCTION_TYPE_2
3520 #undef DEF_FUNCTION_TYPE_3
3521 #undef DEF_FUNCTION_TYPE_4
3522 #undef DEF_FUNCTION_TYPE_5
3523 #undef DEF_FUNCTION_TYPE_6
3524 #undef DEF_FUNCTION_TYPE_7
3525 #undef DEF_FUNCTION_TYPE_VAR_0
3526 #undef DEF_FUNCTION_TYPE_VAR_1
3527 #undef DEF_FUNCTION_TYPE_VAR_2
3528 #undef DEF_FUNCTION_TYPE_VAR_3
3529 #undef DEF_FUNCTION_TYPE_VAR_4
3530 #undef DEF_FUNCTION_TYPE_VAR_5
3531 #undef DEF_POINTER_TYPE
3535 typedef enum c_builtin_type builtin_type
;
3537 /* A temporary array for c_common_nodes_and_builtins. Used in
3538 communication with def_fn_type. */
3539 static tree builtin_types
[(int) BT_LAST
+ 1];
3541 /* A helper function for c_common_nodes_and_builtins. Build function type
3542 for DEF with return type RET and N arguments. If VAR is true, then the
3543 function should be variadic after those N arguments.
3545 Takes special care not to ICE if any of the types involved are
3546 error_mark_node, which indicates that said type is not in fact available
3547 (see builtin_type_for_size). In which case the function type as a whole
3548 should be error_mark_node. */
3551 def_fn_type (builtin_type def
, builtin_type ret
, bool var
, int n
, ...)
3553 tree args
= NULL
, t
;
3558 for (i
= 0; i
< n
; ++i
)
3560 builtin_type a
= va_arg (list
, builtin_type
);
3561 t
= builtin_types
[a
];
3562 if (t
== error_mark_node
)
3564 args
= tree_cons (NULL_TREE
, t
, args
);
3568 args
= nreverse (args
);
3570 args
= chainon (args
, void_list_node
);
3572 t
= builtin_types
[ret
];
3573 if (t
== error_mark_node
)
3575 t
= build_function_type (t
, args
);
3578 builtin_types
[def
] = t
;
3581 /* Build builtin functions common to both C and C++ language
3585 c_define_builtins (tree va_list_ref_type_node
, tree va_list_arg_type_node
)
3587 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3588 builtin_types[ENUM] = VALUE;
3589 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
3590 def_fn_type (ENUM, RETURN, 0, 0);
3591 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
3592 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
3593 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
3594 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
3595 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3596 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
3597 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3598 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
3599 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
3600 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
3601 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3603 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
3604 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3606 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
3607 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
3608 def_fn_type (ENUM, RETURN, 1, 0);
3609 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
3610 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
3611 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
3612 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
3613 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3614 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
3615 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3616 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
3617 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
3618 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
3619 #define DEF_POINTER_TYPE(ENUM, TYPE) \
3620 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
3622 #include "builtin-types.def"
3624 #undef DEF_PRIMITIVE_TYPE
3625 #undef DEF_FUNCTION_TYPE_1
3626 #undef DEF_FUNCTION_TYPE_2
3627 #undef DEF_FUNCTION_TYPE_3
3628 #undef DEF_FUNCTION_TYPE_4
3629 #undef DEF_FUNCTION_TYPE_5
3630 #undef DEF_FUNCTION_TYPE_6
3631 #undef DEF_FUNCTION_TYPE_VAR_0
3632 #undef DEF_FUNCTION_TYPE_VAR_1
3633 #undef DEF_FUNCTION_TYPE_VAR_2
3634 #undef DEF_FUNCTION_TYPE_VAR_3
3635 #undef DEF_FUNCTION_TYPE_VAR_4
3636 #undef DEF_FUNCTION_TYPE_VAR_5
3637 #undef DEF_POINTER_TYPE
3638 builtin_types
[(int) BT_LAST
] = NULL_TREE
;
3640 c_init_attributes ();
3642 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
3643 NONANSI_P, ATTRS, IMPLICIT, COND) \
3645 def_builtin_1 (ENUM, NAME, CLASS, \
3646 builtin_types[(int) TYPE], \
3647 builtin_types[(int) LIBTYPE], \
3648 BOTH_P, FALLBACK_P, NONANSI_P, \
3649 built_in_attributes[(int) ATTRS], IMPLICIT);
3650 #include "builtins.def"
3653 targetm
.init_builtins ();
3655 build_common_builtin_nodes ();
3661 /* Build tree nodes and builtin functions common to both C and C++ language
3665 c_common_nodes_and_builtins (void)
3667 int char16_type_size
;
3668 int char32_type_size
;
3669 int wchar_type_size
;
3670 tree array_domain_type
;
3671 tree va_list_ref_type_node
;
3672 tree va_list_arg_type_node
;
3674 /* Define `int' and `char' first so that dbx will output them first. */
3675 record_builtin_type (RID_INT
, NULL
, integer_type_node
);
3676 record_builtin_type (RID_CHAR
, "char", char_type_node
);
3678 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
3679 "unsigned long", "long long unsigned" and "unsigned short" were in C++
3680 but not C. Are the conditionals here needed? */
3681 if (c_dialect_cxx ())
3682 record_builtin_type (RID_SIGNED
, NULL
, integer_type_node
);
3683 record_builtin_type (RID_LONG
, "long int", long_integer_type_node
);
3684 record_builtin_type (RID_UNSIGNED
, "unsigned int", unsigned_type_node
);
3685 record_builtin_type (RID_MAX
, "long unsigned int",
3686 long_unsigned_type_node
);
3687 if (c_dialect_cxx ())
3688 record_builtin_type (RID_MAX
, "unsigned long", long_unsigned_type_node
);
3689 record_builtin_type (RID_MAX
, "long long int",
3690 long_long_integer_type_node
);
3691 record_builtin_type (RID_MAX
, "long long unsigned int",
3692 long_long_unsigned_type_node
);
3693 if (c_dialect_cxx ())
3694 record_builtin_type (RID_MAX
, "long long unsigned",
3695 long_long_unsigned_type_node
);
3696 record_builtin_type (RID_SHORT
, "short int", short_integer_type_node
);
3697 record_builtin_type (RID_MAX
, "short unsigned int",
3698 short_unsigned_type_node
);
3699 if (c_dialect_cxx ())
3700 record_builtin_type (RID_MAX
, "unsigned short",
3701 short_unsigned_type_node
);
3703 /* Define both `signed char' and `unsigned char'. */
3704 record_builtin_type (RID_MAX
, "signed char", signed_char_type_node
);
3705 record_builtin_type (RID_MAX
, "unsigned char", unsigned_char_type_node
);
3707 /* These are types that c_common_type_for_size and
3708 c_common_type_for_mode use. */
3709 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3711 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3713 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3715 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3717 #if HOST_BITS_PER_WIDE_INT >= 64
3718 if (targetm
.scalar_mode_supported_p (TImode
))
3719 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
3720 get_identifier ("__int128_t"),
3723 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3724 unsigned_intQI_type_node
));
3725 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3726 unsigned_intHI_type_node
));
3727 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3728 unsigned_intSI_type_node
));
3729 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3730 unsigned_intDI_type_node
));
3731 #if HOST_BITS_PER_WIDE_INT >= 64
3732 if (targetm
.scalar_mode_supported_p (TImode
))
3733 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
3734 get_identifier ("__uint128_t"),
3735 unsigned_intTI_type_node
));
3738 /* Create the widest literal types. */
3739 widest_integer_literal_type_node
3740 = make_signed_type (HOST_BITS_PER_WIDE_INT
* 2);
3741 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3742 widest_integer_literal_type_node
));
3744 widest_unsigned_literal_type_node
3745 = make_unsigned_type (HOST_BITS_PER_WIDE_INT
* 2);
3746 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3747 widest_unsigned_literal_type_node
));
3749 /* `unsigned long' is the standard type for sizeof.
3750 Note that stddef.h uses `unsigned long',
3751 and this must agree, even if long and int are the same size. */
3753 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE
)));
3754 signed_size_type_node
= c_common_signed_type (size_type_node
);
3755 set_sizetype (size_type_node
);
3758 TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE
)));
3760 build_common_tree_nodes_2 (flag_short_double
);
3762 record_builtin_type (RID_FLOAT
, NULL
, float_type_node
);
3763 record_builtin_type (RID_DOUBLE
, NULL
, double_type_node
);
3764 record_builtin_type (RID_MAX
, "long double", long_double_type_node
);
3766 /* Only supported decimal floating point extension if the target
3767 actually supports underlying modes. */
3768 if (targetm
.scalar_mode_supported_p (SDmode
)
3769 && targetm
.scalar_mode_supported_p (DDmode
)
3770 && targetm
.scalar_mode_supported_p (TDmode
))
3772 record_builtin_type (RID_DFLOAT32
, NULL
, dfloat32_type_node
);
3773 record_builtin_type (RID_DFLOAT64
, NULL
, dfloat64_type_node
);
3774 record_builtin_type (RID_DFLOAT128
, NULL
, dfloat128_type_node
);
3777 if (targetm
.fixed_point_supported_p ())
3779 record_builtin_type (RID_MAX
, "short _Fract", short_fract_type_node
);
3780 record_builtin_type (RID_FRACT
, NULL
, fract_type_node
);
3781 record_builtin_type (RID_MAX
, "long _Fract", long_fract_type_node
);
3782 record_builtin_type (RID_MAX
, "long long _Fract",
3783 long_long_fract_type_node
);
3784 record_builtin_type (RID_MAX
, "unsigned short _Fract",
3785 unsigned_short_fract_type_node
);
3786 record_builtin_type (RID_MAX
, "unsigned _Fract",
3787 unsigned_fract_type_node
);
3788 record_builtin_type (RID_MAX
, "unsigned long _Fract",
3789 unsigned_long_fract_type_node
);
3790 record_builtin_type (RID_MAX
, "unsigned long long _Fract",
3791 unsigned_long_long_fract_type_node
);
3792 record_builtin_type (RID_MAX
, "_Sat short _Fract",
3793 sat_short_fract_type_node
);
3794 record_builtin_type (RID_MAX
, "_Sat _Fract", sat_fract_type_node
);
3795 record_builtin_type (RID_MAX
, "_Sat long _Fract",
3796 sat_long_fract_type_node
);
3797 record_builtin_type (RID_MAX
, "_Sat long long _Fract",
3798 sat_long_long_fract_type_node
);
3799 record_builtin_type (RID_MAX
, "_Sat unsigned short _Fract",
3800 sat_unsigned_short_fract_type_node
);
3801 record_builtin_type (RID_MAX
, "_Sat unsigned _Fract",
3802 sat_unsigned_fract_type_node
);
3803 record_builtin_type (RID_MAX
, "_Sat unsigned long _Fract",
3804 sat_unsigned_long_fract_type_node
);
3805 record_builtin_type (RID_MAX
, "_Sat unsigned long long _Fract",
3806 sat_unsigned_long_long_fract_type_node
);
3807 record_builtin_type (RID_MAX
, "short _Accum", short_accum_type_node
);
3808 record_builtin_type (RID_ACCUM
, NULL
, accum_type_node
);
3809 record_builtin_type (RID_MAX
, "long _Accum", long_accum_type_node
);
3810 record_builtin_type (RID_MAX
, "long long _Accum",
3811 long_long_accum_type_node
);
3812 record_builtin_type (RID_MAX
, "unsigned short _Accum",
3813 unsigned_short_accum_type_node
);
3814 record_builtin_type (RID_MAX
, "unsigned _Accum",
3815 unsigned_accum_type_node
);
3816 record_builtin_type (RID_MAX
, "unsigned long _Accum",
3817 unsigned_long_accum_type_node
);
3818 record_builtin_type (RID_MAX
, "unsigned long long _Accum",
3819 unsigned_long_long_accum_type_node
);
3820 record_builtin_type (RID_MAX
, "_Sat short _Accum",
3821 sat_short_accum_type_node
);
3822 record_builtin_type (RID_MAX
, "_Sat _Accum", sat_accum_type_node
);
3823 record_builtin_type (RID_MAX
, "_Sat long _Accum",
3824 sat_long_accum_type_node
);
3825 record_builtin_type (RID_MAX
, "_Sat long long _Accum",
3826 sat_long_long_accum_type_node
);
3827 record_builtin_type (RID_MAX
, "_Sat unsigned short _Accum",
3828 sat_unsigned_short_accum_type_node
);
3829 record_builtin_type (RID_MAX
, "_Sat unsigned _Accum",
3830 sat_unsigned_accum_type_node
);
3831 record_builtin_type (RID_MAX
, "_Sat unsigned long _Accum",
3832 sat_unsigned_long_accum_type_node
);
3833 record_builtin_type (RID_MAX
, "_Sat unsigned long long _Accum",
3834 sat_unsigned_long_long_accum_type_node
);
3838 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
3839 get_identifier ("complex int"),
3840 complex_integer_type_node
));
3841 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
3842 get_identifier ("complex float"),
3843 complex_float_type_node
));
3844 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
3845 get_identifier ("complex double"),
3846 complex_double_type_node
));
3847 lang_hooks
.decls
.pushdecl
3848 (build_decl (TYPE_DECL
, get_identifier ("complex long double"),
3849 complex_long_double_type_node
));
3851 if (c_dialect_cxx ())
3852 /* For C++, make fileptr_type_node a distinct void * type until
3853 FILE type is defined. */
3854 fileptr_type_node
= build_variant_type_copy (ptr_type_node
);
3856 record_builtin_type (RID_VOID
, NULL
, void_type_node
);
3858 /* Set the TYPE_NAME for any variants that were built before
3859 record_builtin_type gave names to the built-in types. */
3861 tree void_name
= TYPE_NAME (void_type_node
);
3862 TYPE_NAME (void_type_node
) = NULL_TREE
;
3863 TYPE_NAME (build_qualified_type (void_type_node
, TYPE_QUAL_CONST
))
3865 TYPE_NAME (void_type_node
) = void_name
;
3868 /* This node must not be shared. */
3869 void_zero_node
= make_node (INTEGER_CST
);
3870 TREE_TYPE (void_zero_node
) = void_type_node
;
3872 void_list_node
= build_void_list_node ();
3874 /* Make a type to be the domain of a few array types
3875 whose domains don't really matter.
3876 200 is small enough that it always fits in size_t
3877 and large enough that it can hold most function names for the
3878 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
3879 array_domain_type
= build_index_type (size_int (200));
3881 /* Make a type for arrays of characters.
3882 With luck nothing will ever really depend on the length of this
3884 char_array_type_node
3885 = build_array_type (char_type_node
, array_domain_type
);
3887 /* Likewise for arrays of ints. */
3889 = build_array_type (integer_type_node
, array_domain_type
);
3891 string_type_node
= build_pointer_type (char_type_node
);
3892 const_string_type_node
3893 = build_pointer_type (build_qualified_type
3894 (char_type_node
, TYPE_QUAL_CONST
));
3896 /* This is special for C++ so functions can be overloaded. */
3897 wchar_type_node
= get_identifier (MODIFIED_WCHAR_TYPE
);
3898 wchar_type_node
= TREE_TYPE (identifier_global_value (wchar_type_node
));
3899 wchar_type_size
= TYPE_PRECISION (wchar_type_node
);
3900 if (c_dialect_cxx ())
3902 if (TYPE_UNSIGNED (wchar_type_node
))
3903 wchar_type_node
= make_unsigned_type (wchar_type_size
);
3905 wchar_type_node
= make_signed_type (wchar_type_size
);
3906 record_builtin_type (RID_WCHAR
, "wchar_t", wchar_type_node
);
3910 signed_wchar_type_node
= c_common_signed_type (wchar_type_node
);
3911 unsigned_wchar_type_node
= c_common_unsigned_type (wchar_type_node
);
3914 /* This is for wide string constants. */
3915 wchar_array_type_node
3916 = build_array_type (wchar_type_node
, array_domain_type
);
3918 /* Define 'char16_t'. */
3919 char16_type_node
= get_identifier (CHAR16_TYPE
);
3920 char16_type_node
= TREE_TYPE (identifier_global_value (char16_type_node
));
3921 char16_type_size
= TYPE_PRECISION (char16_type_node
);
3922 if (c_dialect_cxx ())
3924 char16_type_node
= make_unsigned_type (char16_type_size
);
3926 if (cxx_dialect
== cxx0x
)
3927 record_builtin_type (RID_CHAR16
, "char16_t", char16_type_node
);
3930 /* This is for UTF-16 string constants. */
3931 char16_array_type_node
3932 = build_array_type (char16_type_node
, array_domain_type
);
3934 /* Define 'char32_t'. */
3935 char32_type_node
= get_identifier (CHAR32_TYPE
);
3936 char32_type_node
= TREE_TYPE (identifier_global_value (char32_type_node
));
3937 char32_type_size
= TYPE_PRECISION (char32_type_node
);
3938 if (c_dialect_cxx ())
3940 char32_type_node
= make_unsigned_type (char32_type_size
);
3942 if (cxx_dialect
== cxx0x
)
3943 record_builtin_type (RID_CHAR32
, "char32_t", char32_type_node
);
3946 /* This is for UTF-32 string constants. */
3947 char32_array_type_node
3948 = build_array_type (char32_type_node
, array_domain_type
);
3951 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE
)));
3954 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE
)));
3956 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE
)));
3958 default_function_type
= build_function_type (integer_type_node
, NULL_TREE
);
3960 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE
)));
3961 unsigned_ptrdiff_type_node
= c_common_unsigned_type (ptrdiff_type_node
);
3963 lang_hooks
.decls
.pushdecl
3964 (build_decl (TYPE_DECL
, get_identifier ("__builtin_va_list"),
3965 va_list_type_node
));
3967 if (TREE_CODE (va_list_type_node
) == ARRAY_TYPE
)
3969 va_list_arg_type_node
= va_list_ref_type_node
=
3970 build_pointer_type (TREE_TYPE (va_list_type_node
));
3974 va_list_arg_type_node
= va_list_type_node
;
3975 va_list_ref_type_node
= build_reference_type (va_list_type_node
);
3978 if (!flag_preprocess_only
)
3979 c_define_builtins (va_list_ref_type_node
, va_list_arg_type_node
);
3981 main_identifier_node
= get_identifier ("main");
3983 /* Create the built-in __null node. It is important that this is
3985 null_node
= make_node (INTEGER_CST
);
3986 TREE_TYPE (null_node
) = c_common_type_for_size (POINTER_SIZE
, 0);
3988 /* Since builtin_types isn't gc'ed, don't export these nodes. */
3989 memset (builtin_types
, 0, sizeof (builtin_types
));
3992 /* Look up the function in built_in_decls that corresponds to DECL
3993 and set ASMSPEC as its user assembler name. DECL must be a
3994 function decl that declares a builtin. */
3997 set_builtin_user_assembler_name (tree decl
, const char *asmspec
)
4000 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
4001 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
4004 builtin
= built_in_decls
[DECL_FUNCTION_CODE (decl
)];
4005 set_user_assembler_name (builtin
, asmspec
);
4006 if (DECL_FUNCTION_CODE (decl
) == BUILT_IN_MEMCPY
)
4007 init_block_move_fn (asmspec
);
4008 else if (DECL_FUNCTION_CODE (decl
) == BUILT_IN_MEMSET
)
4009 init_block_clear_fn (asmspec
);
4012 /* The number of named compound-literals generated thus far. */
4013 static GTY(()) int compound_literal_number
;
4015 /* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal. */
4018 set_compound_literal_name (tree decl
)
4021 ASM_FORMAT_PRIVATE_NAME (name
, "__compound_literal",
4022 compound_literal_number
);
4023 compound_literal_number
++;
4024 DECL_NAME (decl
) = get_identifier (name
);
4028 build_va_arg (tree expr
, tree type
)
4030 return build1 (VA_ARG_EXPR
, type
, expr
);
4034 /* Linked list of disabled built-in functions. */
4036 typedef struct disabled_builtin
4039 struct disabled_builtin
*next
;
4041 static disabled_builtin
*disabled_builtins
= NULL
;
4043 static bool builtin_function_disabled_p (const char *);
4045 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
4046 begins with "__builtin_", give an error. */
4049 disable_builtin_function (const char *name
)
4051 if (strncmp (name
, "__builtin_", strlen ("__builtin_")) == 0)
4052 error ("cannot disable built-in function %qs", name
);
4055 disabled_builtin
*new_disabled_builtin
= XNEW (disabled_builtin
);
4056 new_disabled_builtin
->name
= name
;
4057 new_disabled_builtin
->next
= disabled_builtins
;
4058 disabled_builtins
= new_disabled_builtin
;
4063 /* Return true if the built-in function NAME has been disabled, false
4067 builtin_function_disabled_p (const char *name
)
4069 disabled_builtin
*p
;
4070 for (p
= disabled_builtins
; p
!= NULL
; p
= p
->next
)
4072 if (strcmp (name
, p
->name
) == 0)
4079 /* Worker for DEF_BUILTIN.
4080 Possibly define a builtin function with one or two names.
4081 Does not declare a non-__builtin_ function if flag_no_builtin, or if
4082 nonansi_p and flag_no_nonansi_builtin. */
4085 def_builtin_1 (enum built_in_function fncode
,
4087 enum built_in_class fnclass
,
4088 tree fntype
, tree libtype
,
4089 bool both_p
, bool fallback_p
, bool nonansi_p
,
4090 tree fnattrs
, bool implicit_p
)
4093 const char *libname
;
4095 if (fntype
== error_mark_node
)
4098 gcc_assert ((!both_p
&& !fallback_p
)
4099 || !strncmp (name
, "__builtin_",
4100 strlen ("__builtin_")));
4102 libname
= name
+ strlen ("__builtin_");
4103 decl
= add_builtin_function (name
, fntype
, fncode
, fnclass
,
4104 (fallback_p
? libname
: NULL
),
4107 && !flag_no_builtin
&& !builtin_function_disabled_p (libname
)
4108 && !(nonansi_p
&& flag_no_nonansi_builtin
))
4109 add_builtin_function (libname
, libtype
, fncode
, fnclass
,
4112 built_in_decls
[(int) fncode
] = decl
;
4114 implicit_built_in_decls
[(int) fncode
] = decl
;
4117 /* Nonzero if the type T promotes to int. This is (nearly) the
4118 integral promotions defined in ISO C99 6.3.1.1/2. */
4121 c_promoting_integer_type_p (const_tree t
)
4123 switch (TREE_CODE (t
))
4126 return (TYPE_MAIN_VARIANT (t
) == char_type_node
4127 || TYPE_MAIN_VARIANT (t
) == signed_char_type_node
4128 || TYPE_MAIN_VARIANT (t
) == unsigned_char_type_node
4129 || TYPE_MAIN_VARIANT (t
) == short_integer_type_node
4130 || TYPE_MAIN_VARIANT (t
) == short_unsigned_type_node
4131 || TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
));
4134 /* ??? Technically all enumerations not larger than an int
4135 promote to an int. But this is used along code paths
4136 that only want to notice a size change. */
4137 return TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
);
4147 /* Return 1 if PARMS specifies a fixed number of parameters
4148 and none of their types is affected by default promotions. */
4151 self_promoting_args_p (const_tree parms
)
4154 for (t
= parms
; t
; t
= TREE_CHAIN (t
))
4156 tree type
= TREE_VALUE (t
);
4158 if (type
== error_mark_node
)
4161 if (TREE_CHAIN (t
) == 0 && type
!= void_type_node
)
4167 if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
4170 if (c_promoting_integer_type_p (type
))
4176 /* Recursively remove any '*' or '&' operator from TYPE. */
4178 strip_pointer_operator (tree t
)
4180 while (POINTER_TYPE_P (t
))
4185 /* Recursively remove pointer or array type from TYPE. */
4187 strip_pointer_or_array_types (tree t
)
4189 while (TREE_CODE (t
) == ARRAY_TYPE
|| POINTER_TYPE_P (t
))
4194 /* Used to compare case labels. K1 and K2 are actually tree nodes
4195 representing case labels, or NULL_TREE for a `default' label.
4196 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
4197 K2, and 0 if K1 and K2 are equal. */
4200 case_compare (splay_tree_key k1
, splay_tree_key k2
)
4202 /* Consider a NULL key (such as arises with a `default' label) to be
4203 smaller than anything else. */
4209 return tree_int_cst_compare ((tree
) k1
, (tree
) k2
);
4212 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
4213 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
4214 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
4215 case label was declared using the usual C/C++ syntax, rather than
4216 the GNU case range extension. CASES is a tree containing all the
4217 case ranges processed so far; COND is the condition for the
4218 switch-statement itself. Returns the CASE_LABEL_EXPR created, or
4219 ERROR_MARK_NODE if no CASE_LABEL_EXPR is created. */
4222 c_add_case_label (splay_tree cases
, tree cond
, tree orig_type
,
4223 tree low_value
, tree high_value
)
4228 splay_tree_node node
;
4230 /* Create the LABEL_DECL itself. */
4231 label
= create_artificial_label ();
4233 /* If there was an error processing the switch condition, bail now
4234 before we get more confused. */
4235 if (!cond
|| cond
== error_mark_node
)
4238 if ((low_value
&& TREE_TYPE (low_value
)
4239 && POINTER_TYPE_P (TREE_TYPE (low_value
)))
4240 || (high_value
&& TREE_TYPE (high_value
)
4241 && POINTER_TYPE_P (TREE_TYPE (high_value
))))
4243 error ("pointers are not permitted as case values");
4247 /* Case ranges are a GNU extension. */
4248 if (high_value
&& pedantic
)
4249 pedwarn ("range expressions in switch statements are non-standard");
4251 type
= TREE_TYPE (cond
);
4254 low_value
= check_case_value (low_value
);
4255 low_value
= convert_and_check (type
, low_value
);
4256 if (low_value
== error_mark_node
)
4261 high_value
= check_case_value (high_value
);
4262 high_value
= convert_and_check (type
, high_value
);
4263 if (high_value
== error_mark_node
)
4267 if (low_value
&& high_value
)
4269 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
4270 really a case range, even though it was written that way.
4271 Remove the HIGH_VALUE to simplify later processing. */
4272 if (tree_int_cst_equal (low_value
, high_value
))
4273 high_value
= NULL_TREE
;
4274 else if (!tree_int_cst_lt (low_value
, high_value
))
4275 warning (0, "empty range specified");
4278 /* See if the case is in range of the type of the original testing
4279 expression. If both low_value and high_value are out of range,
4280 don't insert the case label and return NULL_TREE. */
4282 && !check_case_bounds (type
, orig_type
,
4283 &low_value
, high_value
? &high_value
: NULL
))
4286 /* Look up the LOW_VALUE in the table of case labels we already
4288 node
= splay_tree_lookup (cases
, (splay_tree_key
) low_value
);
4289 /* If there was not an exact match, check for overlapping ranges.
4290 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
4291 that's a `default' label and the only overlap is an exact match. */
4292 if (!node
&& (low_value
|| high_value
))
4294 splay_tree_node low_bound
;
4295 splay_tree_node high_bound
;
4297 /* Even though there wasn't an exact match, there might be an
4298 overlap between this case range and another case range.
4299 Since we've (inductively) not allowed any overlapping case
4300 ranges, we simply need to find the greatest low case label
4301 that is smaller that LOW_VALUE, and the smallest low case
4302 label that is greater than LOW_VALUE. If there is an overlap
4303 it will occur in one of these two ranges. */
4304 low_bound
= splay_tree_predecessor (cases
,
4305 (splay_tree_key
) low_value
);
4306 high_bound
= splay_tree_successor (cases
,
4307 (splay_tree_key
) low_value
);
4309 /* Check to see if the LOW_BOUND overlaps. It is smaller than
4310 the LOW_VALUE, so there is no need to check unless the
4311 LOW_BOUND is in fact itself a case range. */
4313 && CASE_HIGH ((tree
) low_bound
->value
)
4314 && tree_int_cst_compare (CASE_HIGH ((tree
) low_bound
->value
),
4317 /* Check to see if the HIGH_BOUND overlaps. The low end of that
4318 range is bigger than the low end of the current range, so we
4319 are only interested if the current range is a real range, and
4320 not an ordinary case label. */
4323 && (tree_int_cst_compare ((tree
) high_bound
->key
,
4328 /* If there was an overlap, issue an error. */
4331 tree duplicate
= CASE_LABEL ((tree
) node
->value
);
4335 error ("duplicate (or overlapping) case value");
4336 error ("%Jthis is the first entry overlapping that value", duplicate
);
4340 error ("duplicate case value") ;
4341 error ("%Jpreviously used here", duplicate
);
4345 error ("multiple default labels in one switch");
4346 error ("%Jthis is the first default label", duplicate
);
4351 /* Add a CASE_LABEL to the statement-tree. */
4352 case_label
= add_stmt (build_case_label (low_value
, high_value
, label
));
4353 /* Register this case label in the splay tree. */
4354 splay_tree_insert (cases
,
4355 (splay_tree_key
) low_value
,
4356 (splay_tree_value
) case_label
);
4361 /* Add a label so that the back-end doesn't think that the beginning of
4362 the switch is unreachable. Note that we do not add a case label, as
4363 that just leads to duplicates and thence to failure later on. */
4366 tree t
= create_artificial_label ();
4367 add_stmt (build_stmt (LABEL_EXPR
, t
));
4369 return error_mark_node
;
4372 /* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
4373 Used to verify that case values match up with enumerator values. */
4376 match_case_to_enum_1 (tree key
, tree type
, tree label
)
4378 char buf
[2 + 2*HOST_BITS_PER_WIDE_INT
/4 + 1];
4380 /* ??? Not working too hard to print the double-word value.
4381 Should perhaps be done with %lwd in the diagnostic routines? */
4382 if (TREE_INT_CST_HIGH (key
) == 0)
4383 snprintf (buf
, sizeof (buf
), HOST_WIDE_INT_PRINT_UNSIGNED
,
4384 TREE_INT_CST_LOW (key
));
4385 else if (!TYPE_UNSIGNED (type
)
4386 && TREE_INT_CST_HIGH (key
) == -1
4387 && TREE_INT_CST_LOW (key
) != 0)
4388 snprintf (buf
, sizeof (buf
), "-" HOST_WIDE_INT_PRINT_UNSIGNED
,
4389 -TREE_INT_CST_LOW (key
));
4391 snprintf (buf
, sizeof (buf
), HOST_WIDE_INT_PRINT_DOUBLE_HEX
,
4392 (unsigned HOST_WIDE_INT
) TREE_INT_CST_HIGH (key
),
4393 (unsigned HOST_WIDE_INT
) TREE_INT_CST_LOW (key
));
4395 if (TYPE_NAME (type
) == 0)
4396 warning (warn_switch
? OPT_Wswitch
: OPT_Wswitch_enum
,
4397 "%Jcase value %qs not in enumerated type",
4398 CASE_LABEL (label
), buf
);
4400 warning (warn_switch
? OPT_Wswitch
: OPT_Wswitch_enum
,
4401 "%Jcase value %qs not in enumerated type %qT",
4402 CASE_LABEL (label
), buf
, type
);
4405 /* Subroutine of c_do_switch_warnings, called via splay_tree_foreach.
4406 Used to verify that case values match up with enumerator values. */
4409 match_case_to_enum (splay_tree_node node
, void *data
)
4411 tree label
= (tree
) node
->value
;
4412 tree type
= (tree
) data
;
4414 /* Skip default case. */
4415 if (!CASE_LOW (label
))
4418 /* If CASE_LOW_SEEN is not set, that means CASE_LOW did not appear
4419 when we did our enum->case scan. Reset our scratch bit after. */
4420 if (!CASE_LOW_SEEN (label
))
4421 match_case_to_enum_1 (CASE_LOW (label
), type
, label
);
4423 CASE_LOW_SEEN (label
) = 0;
4425 /* If CASE_HIGH is non-null, we have a range. If CASE_HIGH_SEEN is
4426 not set, that means that CASE_HIGH did not appear when we did our
4427 enum->case scan. Reset our scratch bit after. */
4428 if (CASE_HIGH (label
))
4430 if (!CASE_HIGH_SEEN (label
))
4431 match_case_to_enum_1 (CASE_HIGH (label
), type
, label
);
4433 CASE_HIGH_SEEN (label
) = 0;
4439 /* Handle -Wswitch*. Called from the front end after parsing the
4440 switch construct. */
4441 /* ??? Should probably be somewhere generic, since other languages
4442 besides C and C++ would want this. At the moment, however, C/C++
4443 are the only tree-ssa languages that support enumerations at all,
4444 so the point is moot. */
4447 c_do_switch_warnings (splay_tree cases
, location_t switch_location
,
4448 tree type
, tree cond
)
4450 splay_tree_node default_node
;
4451 splay_tree_node node
;
4453 int saved_warn_switch
;
4455 if (!warn_switch
&& !warn_switch_enum
&& !warn_switch_default
)
4458 default_node
= splay_tree_lookup (cases
, (splay_tree_key
) NULL
);
4460 warning (OPT_Wswitch_default
, "%Hswitch missing default case",
4463 /* From here on, we only care about about enumerated types. */
4464 if (!type
|| TREE_CODE (type
) != ENUMERAL_TYPE
)
4467 /* If the switch expression was an enumerated type, check that
4468 exactly all enumeration literals are covered by the cases.
4469 The check is made when -Wswitch was specified and there is no
4470 default case, or when -Wswitch-enum was specified. */
4472 if (!warn_switch_enum
4473 && !(warn_switch
&& !default_node
))
4476 /* Clearing COND if it is not an integer constant simplifies
4477 the tests inside the loop below. */
4478 if (TREE_CODE (cond
) != INTEGER_CST
)
4481 /* The time complexity here is O(N*lg(N)) worst case, but for the
4482 common case of monotonically increasing enumerators, it is
4483 O(N), since the nature of the splay tree will keep the next
4484 element adjacent to the root at all times. */
4486 for (chain
= TYPE_VALUES (type
); chain
; chain
= TREE_CHAIN (chain
))
4488 tree value
= TREE_VALUE (chain
);
4489 node
= splay_tree_lookup (cases
, (splay_tree_key
) value
);
4492 /* Mark the CASE_LOW part of the case entry as seen. */
4493 tree label
= (tree
) node
->value
;
4494 CASE_LOW_SEEN (label
) = 1;
4498 /* Even though there wasn't an exact match, there might be a
4499 case range which includes the enumator's value. */
4500 node
= splay_tree_predecessor (cases
, (splay_tree_key
) value
);
4501 if (node
&& CASE_HIGH ((tree
) node
->value
))
4503 tree label
= (tree
) node
->value
;
4504 int cmp
= tree_int_cst_compare (CASE_HIGH (label
), value
);
4507 /* If we match the upper bound exactly, mark the CASE_HIGH
4508 part of the case entry as seen. */
4510 CASE_HIGH_SEEN (label
) = 1;
4515 /* We've now determined that this enumerated literal isn't
4516 handled by the case labels of the switch statement. */
4518 /* If the switch expression is a constant, we only really care
4519 about whether that constant is handled by the switch. */
4520 if (cond
&& tree_int_cst_compare (cond
, value
))
4523 /* If there is a default_node, the only relevant option is
4524 Wswitch-enum. Otherwise, if both are enabled then we prefer
4525 to warn using -Wswitch because -Wswitch is enabled by -Wall
4526 while -Wswitch-enum is explicit. */
4527 warning ((default_node
|| !warn_switch
)
4528 ? OPT_Wswitch_enum
: OPT_Wswitch
,
4529 "%Henumeration value %qE not handled in switch",
4530 &switch_location
, TREE_PURPOSE (chain
));
4533 /* Warn if there are case expressions that don't correspond to
4534 enumerators. This can occur since C and C++ don't enforce
4535 type-checking of assignments to enumeration variables.
4537 The time complexity here is now always O(N) worst case, since
4538 we should have marked both the lower bound and upper bound of
4539 every disjoint case label, with CASE_LOW_SEEN and CASE_HIGH_SEEN
4540 above. This scan also resets those fields. */
4542 /* If there is a default_node, the only relevant option is
4543 Wswitch-enum. Otherwise, if both are enabled then we prefer
4544 to warn using -Wswitch because -Wswitch is enabled by -Wall
4545 while -Wswitch-enum is explicit. */
4546 saved_warn_switch
= warn_switch
;
4549 splay_tree_foreach (cases
, match_case_to_enum
, type
);
4550 warn_switch
= saved_warn_switch
;
4554 /* Finish an expression taking the address of LABEL (an
4555 IDENTIFIER_NODE). Returns an expression for the address. */
4558 finish_label_address_expr (tree label
)
4563 pedwarn ("taking the address of a label is non-standard");
4565 if (label
== error_mark_node
)
4566 return error_mark_node
;
4568 label
= lookup_label (label
);
4569 if (label
== NULL_TREE
)
4570 result
= null_pointer_node
;
4573 TREE_USED (label
) = 1;
4574 result
= build1 (ADDR_EXPR
, ptr_type_node
, label
);
4575 /* The current function in not necessarily uninlinable.
4576 Computed gotos are incompatible with inlining, but the value
4577 here could be used only in a diagnostic, for example. */
4583 /* Hook used by expand_expr to expand language-specific tree codes. */
4584 /* The only things that should go here are bits needed to expand
4585 constant initializers. Everything else should be handled by the
4586 gimplification routines. */
4589 c_expand_expr (tree exp
, rtx target
, enum machine_mode tmode
,
4590 int modifier
/* Actually enum_modifier. */,
4593 switch (TREE_CODE (exp
))
4595 case COMPOUND_LITERAL_EXPR
:
4597 /* Initialize the anonymous variable declared in the compound
4598 literal, then return the variable. */
4599 tree decl
= COMPOUND_LITERAL_EXPR_DECL (exp
);
4600 emit_local_var (decl
);
4601 return expand_expr_real (decl
, target
, tmode
, modifier
, alt_rtl
);
4609 /* Hook used by staticp to handle language-specific tree codes. */
4612 c_staticp (tree exp
)
4614 return (TREE_CODE (exp
) == COMPOUND_LITERAL_EXPR
4615 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp
))
4620 /* Given a boolean expression ARG, return a tree representing an increment
4621 or decrement (as indicated by CODE) of ARG. The front end must check for
4622 invalid cases (e.g., decrement in C++). */
4624 boolean_increment (enum tree_code code
, tree arg
)
4627 tree true_res
= build_int_cst (TREE_TYPE (arg
), 1);
4629 arg
= stabilize_reference (arg
);
4632 case PREINCREMENT_EXPR
:
4633 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
4635 case POSTINCREMENT_EXPR
:
4636 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
4637 arg
= save_expr (arg
);
4638 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
4639 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
4641 case PREDECREMENT_EXPR
:
4642 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
,
4643 invert_truthvalue (arg
));
4645 case POSTDECREMENT_EXPR
:
4646 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
,
4647 invert_truthvalue (arg
));
4648 arg
= save_expr (arg
);
4649 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
4650 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
4655 TREE_SIDE_EFFECTS (val
) = 1;
4659 /* Built-in macros for stddef.h, that require macros defined in this
4662 c_stddef_cpp_builtins(void)
4664 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE
, 0);
4665 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE
, 0);
4666 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE
, 0);
4667 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE
, 0);
4668 builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE
, 0);
4669 builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE
, 0);
4673 c_init_attributes (void)
4675 /* Fill in the built_in_attributes array. */
4676 #define DEF_ATTR_NULL_TREE(ENUM) \
4677 built_in_attributes[(int) ENUM] = NULL_TREE;
4678 #define DEF_ATTR_INT(ENUM, VALUE) \
4679 built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
4680 #define DEF_ATTR_IDENT(ENUM, STRING) \
4681 built_in_attributes[(int) ENUM] = get_identifier (STRING);
4682 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
4683 built_in_attributes[(int) ENUM] \
4684 = tree_cons (built_in_attributes[(int) PURPOSE], \
4685 built_in_attributes[(int) VALUE], \
4686 built_in_attributes[(int) CHAIN]);
4687 #include "builtin-attrs.def"
4688 #undef DEF_ATTR_NULL_TREE
4690 #undef DEF_ATTR_IDENT
4691 #undef DEF_ATTR_TREE_LIST
4694 /* Attribute handlers common to C front ends. */
4696 /* Handle a "packed" attribute; arguments as in
4697 struct attribute_spec.handler. */
4700 handle_packed_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
4701 int flags
, bool *no_add_attrs
)
4705 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
4706 *node
= build_variant_type_copy (*node
);
4707 TYPE_PACKED (*node
) = 1;
4709 else if (TREE_CODE (*node
) == FIELD_DECL
)
4711 if (TYPE_ALIGN (TREE_TYPE (*node
)) <= BITS_PER_UNIT
)
4712 warning (OPT_Wattributes
,
4713 "%qE attribute ignored for field of type %qT",
4714 name
, TREE_TYPE (*node
));
4716 DECL_PACKED (*node
) = 1;
4718 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
4719 used for DECL_REGISTER. It wouldn't mean anything anyway.
4720 We can't set DECL_PACKED on the type of a TYPE_DECL, because
4721 that changes what the typedef is typing. */
4724 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4725 *no_add_attrs
= true;
4731 /* Handle a "nocommon" attribute; arguments as in
4732 struct attribute_spec.handler. */
4735 handle_nocommon_attribute (tree
*node
, tree name
,
4736 tree
ARG_UNUSED (args
),
4737 int ARG_UNUSED (flags
), bool *no_add_attrs
)
4739 if (TREE_CODE (*node
) == VAR_DECL
)
4740 DECL_COMMON (*node
) = 0;
4743 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4744 *no_add_attrs
= true;
4750 /* Handle a "common" attribute; arguments as in
4751 struct attribute_spec.handler. */
4754 handle_common_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
4755 int ARG_UNUSED (flags
), bool *no_add_attrs
)
4757 if (TREE_CODE (*node
) == VAR_DECL
)
4758 DECL_COMMON (*node
) = 1;
4761 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4762 *no_add_attrs
= true;
4768 /* Handle a "noreturn" attribute; arguments as in
4769 struct attribute_spec.handler. */
4772 handle_noreturn_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
4773 int ARG_UNUSED (flags
), bool *no_add_attrs
)
4775 tree type
= TREE_TYPE (*node
);
4777 /* See FIXME comment in c_common_attribute_table. */
4778 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4779 TREE_THIS_VOLATILE (*node
) = 1;
4780 else if (TREE_CODE (type
) == POINTER_TYPE
4781 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
4783 = build_pointer_type
4784 (build_type_variant (TREE_TYPE (type
),
4785 TYPE_READONLY (TREE_TYPE (type
)), 1));
4788 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4789 *no_add_attrs
= true;
4795 /* Handle a "hot" and attribute; arguments as in
4796 struct attribute_spec.handler. */
4799 handle_hot_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
4800 int ARG_UNUSED (flags
), bool *no_add_attrs
)
4802 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4804 if (lookup_attribute ("cold", DECL_ATTRIBUTES (*node
)) != NULL
)
4806 warning (OPT_Wattributes
, "%qE attribute conflicts with attribute %s",
4808 *no_add_attrs
= true;
4810 /* Do nothing else, just set the attribute. We'll get at
4811 it later with lookup_attribute. */
4815 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4816 *no_add_attrs
= true;
4821 /* Handle a "cold" and attribute; arguments as in
4822 struct attribute_spec.handler. */
4825 handle_cold_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
4826 int ARG_UNUSED (flags
), bool *no_add_attrs
)
4828 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4830 if (lookup_attribute ("hot", DECL_ATTRIBUTES (*node
)) != NULL
)
4832 warning (OPT_Wattributes
, "%qE attribute conflicts with attribute %s",
4834 *no_add_attrs
= true;
4836 /* Do nothing else, just set the attribute. We'll get at
4837 it later with lookup_attribute. */
4841 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4842 *no_add_attrs
= true;
4848 /* Handle a "noinline" attribute; arguments as in
4849 struct attribute_spec.handler. */
4852 handle_noinline_attribute (tree
*node
, tree name
,
4853 tree
ARG_UNUSED (args
),
4854 int ARG_UNUSED (flags
), bool *no_add_attrs
)
4856 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4857 DECL_UNINLINABLE (*node
) = 1;
4860 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4861 *no_add_attrs
= true;
4867 /* Handle a "always_inline" attribute; arguments as in
4868 struct attribute_spec.handler. */
4871 handle_always_inline_attribute (tree
*node
, tree name
,
4872 tree
ARG_UNUSED (args
),
4873 int ARG_UNUSED (flags
),
4876 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4878 /* Set the attribute and mark it for disregarding inline
4880 DECL_DISREGARD_INLINE_LIMITS (*node
) = 1;
4884 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4885 *no_add_attrs
= true;
4891 /* Handle a "gnu_inline" attribute; arguments as in
4892 struct attribute_spec.handler. */
4895 handle_gnu_inline_attribute (tree
*node
, tree name
,
4896 tree
ARG_UNUSED (args
),
4897 int ARG_UNUSED (flags
),
4900 if (TREE_CODE (*node
) == FUNCTION_DECL
&& DECL_DECLARED_INLINE_P (*node
))
4902 /* Do nothing else, just set the attribute. We'll get at
4903 it later with lookup_attribute. */
4907 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4908 *no_add_attrs
= true;
4914 /* Handle an "artificial" attribute; arguments as in
4915 struct attribute_spec.handler. */
4918 handle_artificial_attribute (tree
*node
, tree name
,
4919 tree
ARG_UNUSED (args
),
4920 int ARG_UNUSED (flags
),
4923 if (TREE_CODE (*node
) == FUNCTION_DECL
&& DECL_DECLARED_INLINE_P (*node
))
4925 /* Do nothing else, just set the attribute. We'll get at
4926 it later with lookup_attribute. */
4930 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4931 *no_add_attrs
= true;
4937 /* Handle a "flatten" attribute; arguments as in
4938 struct attribute_spec.handler. */
4941 handle_flatten_attribute (tree
*node
, tree name
,
4942 tree args ATTRIBUTE_UNUSED
,
4943 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
4945 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4946 /* Do nothing else, just set the attribute. We'll get at
4947 it later with lookup_attribute. */
4951 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4952 *no_add_attrs
= true;
4958 /* Handle a "warning" or "error" attribute; arguments as in
4959 struct attribute_spec.handler. */
4962 handle_error_attribute (tree
*node
, tree name
, tree args
,
4963 int ARG_UNUSED (flags
), bool *no_add_attrs
)
4965 if (TREE_CODE (*node
) == FUNCTION_DECL
4966 || TREE_CODE (TREE_VALUE (args
)) == STRING_CST
)
4967 /* Do nothing else, just set the attribute. We'll get at
4968 it later with lookup_attribute. */
4972 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4973 *no_add_attrs
= true;
4979 /* Handle a "used" attribute; arguments as in
4980 struct attribute_spec.handler. */
4983 handle_used_attribute (tree
*pnode
, tree name
, tree
ARG_UNUSED (args
),
4984 int ARG_UNUSED (flags
), bool *no_add_attrs
)
4988 if (TREE_CODE (node
) == FUNCTION_DECL
4989 || (TREE_CODE (node
) == VAR_DECL
&& TREE_STATIC (node
)))
4991 TREE_USED (node
) = 1;
4992 DECL_PRESERVE_P (node
) = 1;
4996 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4997 *no_add_attrs
= true;
5003 /* Handle a "unused" attribute; arguments as in
5004 struct attribute_spec.handler. */
5007 handle_unused_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5008 int flags
, bool *no_add_attrs
)
5014 if (TREE_CODE (decl
) == PARM_DECL
5015 || TREE_CODE (decl
) == VAR_DECL
5016 || TREE_CODE (decl
) == FUNCTION_DECL
5017 || TREE_CODE (decl
) == LABEL_DECL
5018 || TREE_CODE (decl
) == TYPE_DECL
)
5019 TREE_USED (decl
) = 1;
5022 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5023 *no_add_attrs
= true;
5028 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
5029 *node
= build_variant_type_copy (*node
);
5030 TREE_USED (*node
) = 1;
5036 /* Handle a "externally_visible" attribute; arguments as in
5037 struct attribute_spec.handler. */
5040 handle_externally_visible_attribute (tree
*pnode
, tree name
,
5041 tree
ARG_UNUSED (args
),
5042 int ARG_UNUSED (flags
),
5047 if (TREE_CODE (node
) == FUNCTION_DECL
|| TREE_CODE (node
) == VAR_DECL
)
5049 if ((!TREE_STATIC (node
) && TREE_CODE (node
) != FUNCTION_DECL
5050 && !DECL_EXTERNAL (node
)) || !TREE_PUBLIC (node
))
5052 warning (OPT_Wattributes
,
5053 "%qE attribute have effect only on public objects", name
);
5054 *no_add_attrs
= true;
5059 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5060 *no_add_attrs
= true;
5066 /* Handle a "const" attribute; arguments as in
5067 struct attribute_spec.handler. */
5070 handle_const_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5071 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5073 tree type
= TREE_TYPE (*node
);
5075 /* See FIXME comment on noreturn in c_common_attribute_table. */
5076 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5077 TREE_READONLY (*node
) = 1;
5078 else if (TREE_CODE (type
) == POINTER_TYPE
5079 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
5081 = build_pointer_type
5082 (build_type_variant (TREE_TYPE (type
), 1,
5083 TREE_THIS_VOLATILE (TREE_TYPE (type
))));
5086 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5087 *no_add_attrs
= true;
5093 /* Handle a "transparent_union" attribute; arguments as in
5094 struct attribute_spec.handler. */
5097 handle_transparent_union_attribute (tree
*node
, tree name
,
5098 tree
ARG_UNUSED (args
), int flags
,
5103 *no_add_attrs
= true;
5105 if (TREE_CODE (*node
) == TYPE_DECL
)
5106 node
= &TREE_TYPE (*node
);
5109 if (TREE_CODE (type
) == UNION_TYPE
)
5111 /* When IN_PLACE is set, leave the check for FIELDS and MODE to
5112 the code in finish_struct. */
5113 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
5115 if (TYPE_FIELDS (type
) == NULL_TREE
5116 || TYPE_MODE (type
) != DECL_MODE (TYPE_FIELDS (type
)))
5119 /* A type variant isn't good enough, since we don't a cast
5120 to such a type removed as a no-op. */
5121 *node
= type
= build_duplicate_type (type
);
5124 TYPE_TRANSPARENT_UNION (type
) = 1;
5129 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5133 /* Subroutine of handle_{con,de}structor_attribute. Evaluate ARGS to
5134 get the requested priority for a constructor or destructor,
5135 possibly issuing diagnostics for invalid or reserved
5138 static priority_type
5139 get_priority (tree args
, bool is_destructor
)
5145 return DEFAULT_INIT_PRIORITY
;
5147 if (!SUPPORTS_INIT_PRIORITY
)
5150 error ("destructor priorities are not supported");
5152 error ("constructor priorities are not supported");
5153 return DEFAULT_INIT_PRIORITY
;
5156 arg
= TREE_VALUE (args
);
5157 if (!host_integerp (arg
, /*pos=*/0)
5158 || !INTEGRAL_TYPE_P (TREE_TYPE (arg
)))
5161 pri
= tree_low_cst (TREE_VALUE (args
), /*pos=*/0);
5162 if (pri
< 0 || pri
> MAX_INIT_PRIORITY
)
5165 if (pri
<= MAX_RESERVED_INIT_PRIORITY
)
5169 "destructor priorities from 0 to %d are reserved "
5170 "for the implementation",
5171 MAX_RESERVED_INIT_PRIORITY
);
5174 "constructor priorities from 0 to %d are reserved "
5175 "for the implementation",
5176 MAX_RESERVED_INIT_PRIORITY
);
5182 error ("destructor priorities must be integers from 0 to %d inclusive",
5185 error ("constructor priorities must be integers from 0 to %d inclusive",
5187 return DEFAULT_INIT_PRIORITY
;
5190 /* Handle a "constructor" attribute; arguments as in
5191 struct attribute_spec.handler. */
5194 handle_constructor_attribute (tree
*node
, tree name
, tree args
,
5195 int ARG_UNUSED (flags
),
5199 tree type
= TREE_TYPE (decl
);
5201 if (TREE_CODE (decl
) == FUNCTION_DECL
5202 && TREE_CODE (type
) == FUNCTION_TYPE
5203 && decl_function_context (decl
) == 0)
5205 priority_type priority
;
5206 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
5207 priority
= get_priority (args
, /*is_destructor=*/false);
5208 SET_DECL_INIT_PRIORITY (decl
, priority
);
5209 TREE_USED (decl
) = 1;
5213 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5214 *no_add_attrs
= true;
5220 /* Handle a "destructor" attribute; arguments as in
5221 struct attribute_spec.handler. */
5224 handle_destructor_attribute (tree
*node
, tree name
, tree args
,
5225 int ARG_UNUSED (flags
),
5229 tree type
= TREE_TYPE (decl
);
5231 if (TREE_CODE (decl
) == FUNCTION_DECL
5232 && TREE_CODE (type
) == FUNCTION_TYPE
5233 && decl_function_context (decl
) == 0)
5235 priority_type priority
;
5236 DECL_STATIC_DESTRUCTOR (decl
) = 1;
5237 priority
= get_priority (args
, /*is_destructor=*/true);
5238 SET_DECL_FINI_PRIORITY (decl
, priority
);
5239 TREE_USED (decl
) = 1;
5243 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5244 *no_add_attrs
= true;
5250 /* Handle a "mode" attribute; arguments as in
5251 struct attribute_spec.handler. */
5254 handle_mode_attribute (tree
*node
, tree name
, tree args
,
5255 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5259 *no_add_attrs
= true;
5261 if (TREE_CODE (TREE_VALUE (args
)) != IDENTIFIER_NODE
)
5262 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5266 const char *p
= IDENTIFIER_POINTER (TREE_VALUE (args
));
5267 int len
= strlen (p
);
5268 enum machine_mode mode
= VOIDmode
;
5272 if (len
> 4 && p
[0] == '_' && p
[1] == '_'
5273 && p
[len
- 1] == '_' && p
[len
- 2] == '_')
5275 char *newp
= (char *) alloca (len
- 1);
5277 strcpy (newp
, &p
[2]);
5278 newp
[len
- 4] = '\0';
5282 /* Change this type to have a type with the specified mode.
5283 First check for the special modes. */
5284 if (!strcmp (p
, "byte"))
5286 else if (!strcmp (p
, "word"))
5288 else if (!strcmp (p
, "pointer"))
5290 else if (!strcmp (p
, "libgcc_cmp_return"))
5291 mode
= targetm
.libgcc_cmp_return_mode ();
5292 else if (!strcmp (p
, "libgcc_shift_count"))
5293 mode
= targetm
.libgcc_shift_count_mode ();
5295 for (j
= 0; j
< NUM_MACHINE_MODES
; j
++)
5296 if (!strcmp (p
, GET_MODE_NAME (j
)))
5298 mode
= (enum machine_mode
) j
;
5302 if (mode
== VOIDmode
)
5304 error ("unknown machine mode %qs", p
);
5309 switch (GET_MODE_CLASS (mode
))
5312 case MODE_PARTIAL_INT
:
5314 case MODE_DECIMAL_FLOAT
:
5319 valid_mode
= targetm
.scalar_mode_supported_p (mode
);
5322 case MODE_COMPLEX_INT
:
5323 case MODE_COMPLEX_FLOAT
:
5324 valid_mode
= targetm
.scalar_mode_supported_p (GET_MODE_INNER (mode
));
5327 case MODE_VECTOR_INT
:
5328 case MODE_VECTOR_FLOAT
:
5329 case MODE_VECTOR_FRACT
:
5330 case MODE_VECTOR_UFRACT
:
5331 case MODE_VECTOR_ACCUM
:
5332 case MODE_VECTOR_UACCUM
:
5333 warning (OPT_Wattributes
, "specifying vector types with "
5334 "__attribute__ ((mode)) is deprecated");
5335 warning (OPT_Wattributes
,
5336 "use __attribute__ ((vector_size)) instead");
5337 valid_mode
= vector_mode_valid_p (mode
);
5345 error ("unable to emulate %qs", p
);
5349 if (POINTER_TYPE_P (type
))
5351 tree (*fn
)(tree
, enum machine_mode
, bool);
5353 if (!targetm
.valid_pointer_mode (mode
))
5355 error ("invalid pointer mode %qs", p
);
5359 if (TREE_CODE (type
) == POINTER_TYPE
)
5360 fn
= build_pointer_type_for_mode
;
5362 fn
= build_reference_type_for_mode
;
5363 typefm
= fn (TREE_TYPE (type
), mode
, false);
5367 /* For fixed-point modes, we need to test if the signness of type
5368 and the machine mode are consistent. */
5369 if (ALL_FIXED_POINT_MODE_P (mode
)
5370 && TYPE_UNSIGNED (type
) != UNSIGNED_FIXED_POINT_MODE_P (mode
))
5372 error ("signness of type and machine mode %qs don't match", p
);
5375 /* For fixed-point modes, we need to pass saturating info. */
5376 typefm
= lang_hooks
.types
.type_for_mode (mode
,
5377 ALL_FIXED_POINT_MODE_P (mode
) ? TYPE_SATURATING (type
)
5378 : TYPE_UNSIGNED (type
));
5381 if (typefm
== NULL_TREE
)
5383 error ("no data type for mode %qs", p
);
5386 else if (TREE_CODE (type
) == ENUMERAL_TYPE
)
5388 /* For enumeral types, copy the precision from the integer
5389 type returned above. If not an INTEGER_TYPE, we can't use
5390 this mode for this type. */
5391 if (TREE_CODE (typefm
) != INTEGER_TYPE
)
5393 error ("cannot use mode %qs for enumeral types", p
);
5397 if (flags
& ATTR_FLAG_TYPE_IN_PLACE
)
5399 TYPE_PRECISION (type
) = TYPE_PRECISION (typefm
);
5404 /* We cannot build a type variant, as there's code that assumes
5405 that TYPE_MAIN_VARIANT has the same mode. This includes the
5406 debug generators. Instead, create a subrange type. This
5407 results in all of the enumeral values being emitted only once
5408 in the original, and the subtype gets them by reference. */
5409 if (TYPE_UNSIGNED (type
))
5410 typefm
= make_unsigned_type (TYPE_PRECISION (typefm
));
5412 typefm
= make_signed_type (TYPE_PRECISION (typefm
));
5413 TREE_TYPE (typefm
) = type
;
5416 else if (VECTOR_MODE_P (mode
)
5417 ? TREE_CODE (type
) != TREE_CODE (TREE_TYPE (typefm
))
5418 : TREE_CODE (type
) != TREE_CODE (typefm
))
5420 error ("mode %qs applied to inappropriate type", p
);
5430 /* Handle a "section" attribute; arguments as in
5431 struct attribute_spec.handler. */
5434 handle_section_attribute (tree
*node
, tree
ARG_UNUSED (name
), tree args
,
5435 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5439 if (targetm
.have_named_sections
)
5441 user_defined_section_attribute
= true;
5443 if ((TREE_CODE (decl
) == FUNCTION_DECL
5444 || TREE_CODE (decl
) == VAR_DECL
)
5445 && TREE_CODE (TREE_VALUE (args
)) == STRING_CST
)
5447 if (TREE_CODE (decl
) == VAR_DECL
5448 && current_function_decl
!= NULL_TREE
5449 && !TREE_STATIC (decl
))
5451 error ("%Jsection attribute cannot be specified for "
5452 "local variables", decl
);
5453 *no_add_attrs
= true;
5456 /* The decl may have already been given a section attribute
5457 from a previous declaration. Ensure they match. */
5458 else if (DECL_SECTION_NAME (decl
) != NULL_TREE
5459 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl
)),
5460 TREE_STRING_POINTER (TREE_VALUE (args
))) != 0)
5462 error ("section of %q+D conflicts with previous declaration",
5464 *no_add_attrs
= true;
5466 else if (TREE_CODE (decl
) == VAR_DECL
5467 && !targetm
.have_tls
&& targetm
.emutls
.tmpl_section
5468 && DECL_THREAD_LOCAL_P (decl
))
5470 error ("section of %q+D cannot be overridden", *node
);
5471 *no_add_attrs
= true;
5474 DECL_SECTION_NAME (decl
) = TREE_VALUE (args
);
5478 error ("section attribute not allowed for %q+D", *node
);
5479 *no_add_attrs
= true;
5484 error ("%Jsection attributes are not supported for this target", *node
);
5485 *no_add_attrs
= true;
5491 /* Handle a "aligned" attribute; arguments as in
5492 struct attribute_spec.handler. */
5495 handle_aligned_attribute (tree
*node
, tree
ARG_UNUSED (name
), tree args
,
5496 int flags
, bool *no_add_attrs
)
5498 tree decl
= NULL_TREE
;
5501 tree align_expr
= (args
? TREE_VALUE (args
)
5502 : size_int (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
));
5508 type
= &TREE_TYPE (decl
);
5509 is_type
= TREE_CODE (*node
) == TYPE_DECL
;
5511 else if (TYPE_P (*node
))
5512 type
= node
, is_type
= 1;
5514 if (TREE_CODE (align_expr
) != INTEGER_CST
)
5516 error ("requested alignment is not a constant");
5517 *no_add_attrs
= true;
5519 else if ((i
= tree_log2 (align_expr
)) == -1)
5521 error ("requested alignment is not a power of 2");
5522 *no_add_attrs
= true;
5524 else if (i
> HOST_BITS_PER_INT
- 2)
5526 error ("requested alignment is too large");
5527 *no_add_attrs
= true;
5531 /* If we have a TYPE_DECL, then copy the type, so that we
5532 don't accidentally modify a builtin type. See pushdecl. */
5533 if (decl
&& TREE_TYPE (decl
) != error_mark_node
5534 && DECL_ORIGINAL_TYPE (decl
) == NULL_TREE
)
5536 tree tt
= TREE_TYPE (decl
);
5537 *type
= build_variant_type_copy (*type
);
5538 DECL_ORIGINAL_TYPE (decl
) = tt
;
5539 TYPE_NAME (*type
) = decl
;
5540 TREE_USED (*type
) = TREE_USED (decl
);
5541 TREE_TYPE (decl
) = *type
;
5543 else if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
5544 *type
= build_variant_type_copy (*type
);
5546 TYPE_ALIGN (*type
) = (1 << i
) * BITS_PER_UNIT
;
5547 TYPE_USER_ALIGN (*type
) = 1;
5549 else if (! VAR_OR_FUNCTION_DECL_P (decl
)
5550 && TREE_CODE (decl
) != FIELD_DECL
)
5552 error ("alignment may not be specified for %q+D", decl
);
5553 *no_add_attrs
= true;
5555 else if (TREE_CODE (decl
) == FUNCTION_DECL
5556 && DECL_ALIGN (decl
) > (1 << i
) * BITS_PER_UNIT
)
5558 if (DECL_USER_ALIGN (decl
))
5559 error ("alignment for %q+D was previously specified as %d "
5560 "and may not be decreased", decl
,
5561 DECL_ALIGN (decl
) / BITS_PER_UNIT
);
5563 error ("alignment for %q+D must be at least %d", decl
,
5564 DECL_ALIGN (decl
) / BITS_PER_UNIT
);
5565 *no_add_attrs
= true;
5569 DECL_ALIGN (decl
) = (1 << i
) * BITS_PER_UNIT
;
5570 DECL_USER_ALIGN (decl
) = 1;
5576 /* Handle a "weak" attribute; arguments as in
5577 struct attribute_spec.handler. */
5580 handle_weak_attribute (tree
*node
, tree name
,
5581 tree
ARG_UNUSED (args
),
5582 int ARG_UNUSED (flags
),
5583 bool * ARG_UNUSED (no_add_attrs
))
5585 if (TREE_CODE (*node
) == FUNCTION_DECL
5586 && DECL_DECLARED_INLINE_P (*node
))
5588 error ("inline function %q+D cannot be declared weak", *node
);
5589 *no_add_attrs
= true;
5591 else if (TREE_CODE (*node
) == FUNCTION_DECL
5592 || TREE_CODE (*node
) == VAR_DECL
)
5593 declare_weak (*node
);
5595 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5600 /* Handle an "alias" attribute; arguments as in
5601 struct attribute_spec.handler. */
5604 handle_alias_attribute (tree
*node
, tree name
, tree args
,
5605 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5609 if ((TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_INITIAL (decl
))
5610 || (TREE_CODE (decl
) != FUNCTION_DECL
5611 && TREE_PUBLIC (decl
) && !DECL_EXTERNAL (decl
))
5612 /* A static variable declaration is always a tentative definition,
5613 but the alias is a non-tentative definition which overrides. */
5614 || (TREE_CODE (decl
) != FUNCTION_DECL
5615 && ! TREE_PUBLIC (decl
) && DECL_INITIAL (decl
)))
5617 error ("%q+D defined both normally and as an alias", decl
);
5618 *no_add_attrs
= true;
5621 /* Note that the very first time we process a nested declaration,
5622 decl_function_context will not be set. Indeed, *would* never
5623 be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
5624 we do below. After such frobbery, pushdecl would set the context.
5625 In any case, this is never what we want. */
5626 else if (decl_function_context (decl
) == 0 && current_function_decl
== NULL
)
5630 id
= TREE_VALUE (args
);
5631 if (TREE_CODE (id
) != STRING_CST
)
5633 error ("alias argument not a string");
5634 *no_add_attrs
= true;
5637 id
= get_identifier (TREE_STRING_POINTER (id
));
5638 /* This counts as a use of the object pointed to. */
5641 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5642 DECL_INITIAL (decl
) = error_mark_node
;
5645 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
)))
5646 DECL_EXTERNAL (decl
) = 1;
5648 DECL_EXTERNAL (decl
) = 0;
5649 TREE_STATIC (decl
) = 1;
5654 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5655 *no_add_attrs
= true;
5661 /* Handle a "weakref" attribute; arguments as in struct
5662 attribute_spec.handler. */
5665 handle_weakref_attribute (tree
*node
, tree
ARG_UNUSED (name
), tree args
,
5666 int flags
, bool *no_add_attrs
)
5668 tree attr
= NULL_TREE
;
5670 /* We must ignore the attribute when it is associated with
5671 local-scoped decls, since attribute alias is ignored and many
5672 such symbols do not even have a DECL_WEAK field. */
5673 if (decl_function_context (*node
) || current_function_decl
)
5675 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5676 *no_add_attrs
= true;
5680 /* The idea here is that `weakref("name")' mutates into `weakref,
5681 alias("name")', and weakref without arguments, in turn,
5682 implicitly adds weak. */
5686 attr
= tree_cons (get_identifier ("alias"), args
, attr
);
5687 attr
= tree_cons (get_identifier ("weakref"), NULL_TREE
, attr
);
5689 *no_add_attrs
= true;
5691 decl_attributes (node
, attr
, flags
);
5695 if (lookup_attribute ("alias", DECL_ATTRIBUTES (*node
)))
5696 error ("%Jweakref attribute must appear before alias attribute",
5699 /* Can't call declare_weak because it wants this to be TREE_PUBLIC,
5700 and that isn't supported; and because it wants to add it to
5701 the list of weak decls, which isn't helpful. */
5702 DECL_WEAK (*node
) = 1;
5708 /* Handle an "visibility" attribute; arguments as in
5709 struct attribute_spec.handler. */
5712 handle_visibility_attribute (tree
*node
, tree name
, tree args
,
5713 int ARG_UNUSED (flags
),
5714 bool *ARG_UNUSED (no_add_attrs
))
5717 tree id
= TREE_VALUE (args
);
5718 enum symbol_visibility vis
;
5722 if (TREE_CODE (*node
) == ENUMERAL_TYPE
)
5724 else if (TREE_CODE (*node
) != RECORD_TYPE
&& TREE_CODE (*node
) != UNION_TYPE
)
5726 warning (OPT_Wattributes
, "%qE attribute ignored on non-class types",
5730 else if (TYPE_FIELDS (*node
))
5732 error ("%qE attribute ignored because %qT is already defined",
5737 else if (decl_function_context (decl
) != 0 || !TREE_PUBLIC (decl
))
5739 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5743 if (TREE_CODE (id
) != STRING_CST
)
5745 error ("visibility argument not a string");
5749 /* If this is a type, set the visibility on the type decl. */
5752 decl
= TYPE_NAME (decl
);
5755 if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
5757 warning (OPT_Wattributes
, "%qE attribute ignored on types",
5763 if (strcmp (TREE_STRING_POINTER (id
), "default") == 0)
5764 vis
= VISIBILITY_DEFAULT
;
5765 else if (strcmp (TREE_STRING_POINTER (id
), "internal") == 0)
5766 vis
= VISIBILITY_INTERNAL
;
5767 else if (strcmp (TREE_STRING_POINTER (id
), "hidden") == 0)
5768 vis
= VISIBILITY_HIDDEN
;
5769 else if (strcmp (TREE_STRING_POINTER (id
), "protected") == 0)
5770 vis
= VISIBILITY_PROTECTED
;
5773 error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
5774 vis
= VISIBILITY_DEFAULT
;
5777 if (DECL_VISIBILITY_SPECIFIED (decl
)
5778 && vis
!= DECL_VISIBILITY (decl
))
5780 tree attributes
= (TYPE_P (*node
)
5781 ? TYPE_ATTRIBUTES (*node
)
5782 : DECL_ATTRIBUTES (decl
));
5783 if (lookup_attribute ("visibility", attributes
))
5784 error ("%qD redeclared with different visibility", decl
);
5785 else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
5786 && lookup_attribute ("dllimport", attributes
))
5787 error ("%qD was declared %qs which implies default visibility",
5789 else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
5790 && lookup_attribute ("dllexport", attributes
))
5791 error ("%qD was declared %qs which implies default visibility",
5795 DECL_VISIBILITY (decl
) = vis
;
5796 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
5798 /* Go ahead and attach the attribute to the node as well. This is needed
5799 so we can determine whether we have VISIBILITY_DEFAULT because the
5800 visibility was not specified, or because it was explicitly overridden
5801 from the containing scope. */
5806 /* Determine the ELF symbol visibility for DECL, which is either a
5807 variable or a function. It is an error to use this function if a
5808 definition of DECL is not available in this translation unit.
5809 Returns true if the final visibility has been determined by this
5810 function; false if the caller is free to make additional
5814 c_determine_visibility (tree decl
)
5816 gcc_assert (TREE_CODE (decl
) == VAR_DECL
5817 || TREE_CODE (decl
) == FUNCTION_DECL
);
5819 /* If the user explicitly specified the visibility with an
5820 attribute, honor that. DECL_VISIBILITY will have been set during
5821 the processing of the attribute. We check for an explicit
5822 attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
5823 to distinguish the use of an attribute from the use of a "#pragma
5824 GCC visibility push(...)"; in the latter case we still want other
5825 considerations to be able to overrule the #pragma. */
5826 if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl
))
5827 || (TARGET_DLLIMPORT_DECL_ATTRIBUTES
5828 && (lookup_attribute ("dllimport", DECL_ATTRIBUTES (decl
))
5829 || lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl
)))))
5832 /* Set default visibility to whatever the user supplied with
5833 visibility_specified depending on #pragma GCC visibility. */
5834 if (!DECL_VISIBILITY_SPECIFIED (decl
))
5836 DECL_VISIBILITY (decl
) = default_visibility
;
5837 DECL_VISIBILITY_SPECIFIED (decl
) = visibility_options
.inpragma
;
5842 /* Handle an "tls_model" attribute; arguments as in
5843 struct attribute_spec.handler. */
5846 handle_tls_model_attribute (tree
*node
, tree name
, tree args
,
5847 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5851 enum tls_model kind
;
5853 *no_add_attrs
= true;
5855 if (!DECL_THREAD_LOCAL_P (decl
))
5857 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5861 kind
= DECL_TLS_MODEL (decl
);
5862 id
= TREE_VALUE (args
);
5863 if (TREE_CODE (id
) != STRING_CST
)
5865 error ("tls_model argument not a string");
5869 if (!strcmp (TREE_STRING_POINTER (id
), "local-exec"))
5870 kind
= TLS_MODEL_LOCAL_EXEC
;
5871 else if (!strcmp (TREE_STRING_POINTER (id
), "initial-exec"))
5872 kind
= TLS_MODEL_INITIAL_EXEC
;
5873 else if (!strcmp (TREE_STRING_POINTER (id
), "local-dynamic"))
5874 kind
= optimize
? TLS_MODEL_LOCAL_DYNAMIC
: TLS_MODEL_GLOBAL_DYNAMIC
;
5875 else if (!strcmp (TREE_STRING_POINTER (id
), "global-dynamic"))
5876 kind
= TLS_MODEL_GLOBAL_DYNAMIC
;
5878 error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
5880 DECL_TLS_MODEL (decl
) = kind
;
5884 /* Handle a "no_instrument_function" attribute; arguments as in
5885 struct attribute_spec.handler. */
5888 handle_no_instrument_function_attribute (tree
*node
, tree name
,
5889 tree
ARG_UNUSED (args
),
5890 int ARG_UNUSED (flags
),
5895 if (TREE_CODE (decl
) != FUNCTION_DECL
)
5897 error ("%J%qE attribute applies only to functions", decl
, name
);
5898 *no_add_attrs
= true;
5900 else if (DECL_INITIAL (decl
))
5902 error ("%Jcan%'t set %qE attribute after definition", decl
, name
);
5903 *no_add_attrs
= true;
5906 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl
) = 1;
5911 /* Handle a "malloc" attribute; arguments as in
5912 struct attribute_spec.handler. */
5915 handle_malloc_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5916 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5918 if (TREE_CODE (*node
) == FUNCTION_DECL
5919 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node
))))
5920 DECL_IS_MALLOC (*node
) = 1;
5923 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5924 *no_add_attrs
= true;
5930 /* Handle a "alloc_size" attribute; arguments as in
5931 struct attribute_spec.handler. */
5934 handle_alloc_size_attribute (tree
*node
, tree
ARG_UNUSED (name
), tree args
,
5935 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5937 unsigned arg_count
= type_num_arguments (*node
);
5938 for (; args
; args
= TREE_CHAIN (args
))
5940 tree position
= TREE_VALUE (args
);
5942 if (TREE_CODE (position
) != INTEGER_CST
5943 || TREE_INT_CST_HIGH (position
)
5944 || TREE_INT_CST_LOW (position
) < 1
5945 || TREE_INT_CST_LOW (position
) > arg_count
)
5947 warning (OPT_Wattributes
,
5948 "alloc_size parameter outside range");
5949 *no_add_attrs
= true;
5956 /* Handle a "returns_twice" attribute; arguments as in
5957 struct attribute_spec.handler. */
5960 handle_returns_twice_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5961 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5963 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5964 DECL_IS_RETURNS_TWICE (*node
) = 1;
5967 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5968 *no_add_attrs
= true;
5974 /* Handle a "no_limit_stack" attribute; arguments as in
5975 struct attribute_spec.handler. */
5978 handle_no_limit_stack_attribute (tree
*node
, tree name
,
5979 tree
ARG_UNUSED (args
),
5980 int ARG_UNUSED (flags
),
5985 if (TREE_CODE (decl
) != FUNCTION_DECL
)
5987 error ("%J%qE attribute applies only to functions", decl
, name
);
5988 *no_add_attrs
= true;
5990 else if (DECL_INITIAL (decl
))
5992 error ("%Jcan%'t set %qE attribute after definition", decl
, name
);
5993 *no_add_attrs
= true;
5996 DECL_NO_LIMIT_STACK (decl
) = 1;
6001 /* Handle a "pure" attribute; arguments as in
6002 struct attribute_spec.handler. */
6005 handle_pure_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
6006 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6008 if (TREE_CODE (*node
) == FUNCTION_DECL
)
6009 DECL_PURE_P (*node
) = 1;
6010 /* ??? TODO: Support types. */
6013 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6014 *no_add_attrs
= true;
6020 /* Handle a "no vops" attribute; arguments as in
6021 struct attribute_spec.handler. */
6024 handle_novops_attribute (tree
*node
, tree
ARG_UNUSED (name
),
6025 tree
ARG_UNUSED (args
), int ARG_UNUSED (flags
),
6026 bool *ARG_UNUSED (no_add_attrs
))
6028 gcc_assert (TREE_CODE (*node
) == FUNCTION_DECL
);
6029 DECL_IS_NOVOPS (*node
) = 1;
6033 /* Handle a "deprecated" attribute; arguments as in
6034 struct attribute_spec.handler. */
6037 handle_deprecated_attribute (tree
*node
, tree name
,
6038 tree
ARG_UNUSED (args
), int flags
,
6041 tree type
= NULL_TREE
;
6043 tree what
= NULL_TREE
;
6048 type
= TREE_TYPE (decl
);
6050 if (TREE_CODE (decl
) == TYPE_DECL
6051 || TREE_CODE (decl
) == PARM_DECL
6052 || TREE_CODE (decl
) == VAR_DECL
6053 || TREE_CODE (decl
) == FUNCTION_DECL
6054 || TREE_CODE (decl
) == FIELD_DECL
)
6055 TREE_DEPRECATED (decl
) = 1;
6059 else if (TYPE_P (*node
))
6061 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
6062 *node
= build_variant_type_copy (*node
);
6063 TREE_DEPRECATED (*node
) = 1;
6071 *no_add_attrs
= true;
6072 if (type
&& TYPE_NAME (type
))
6074 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
6075 what
= TYPE_NAME (*node
);
6076 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
6077 && DECL_NAME (TYPE_NAME (type
)))
6078 what
= DECL_NAME (TYPE_NAME (type
));
6081 warning (OPT_Wattributes
, "%qE attribute ignored for %qE", name
, what
);
6083 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6089 /* Handle a "vector_size" attribute; arguments as in
6090 struct attribute_spec.handler. */
6093 handle_vector_size_attribute (tree
*node
, tree name
, tree args
,
6094 int ARG_UNUSED (flags
),
6097 unsigned HOST_WIDE_INT vecsize
, nunits
;
6098 enum machine_mode orig_mode
;
6099 tree type
= *node
, new_type
, size
;
6101 *no_add_attrs
= true;
6103 size
= TREE_VALUE (args
);
6105 if (!host_integerp (size
, 1))
6107 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6111 /* Get the vector size (in bytes). */
6112 vecsize
= tree_low_cst (size
, 1);
6114 /* We need to provide for vector pointers, vector arrays, and
6115 functions returning vectors. For example:
6117 __attribute__((vector_size(16))) short *foo;
6119 In this case, the mode is SI, but the type being modified is
6120 HI, so we need to look further. */
6122 while (POINTER_TYPE_P (type
)
6123 || TREE_CODE (type
) == FUNCTION_TYPE
6124 || TREE_CODE (type
) == METHOD_TYPE
6125 || TREE_CODE (type
) == ARRAY_TYPE
6126 || TREE_CODE (type
) == OFFSET_TYPE
)
6127 type
= TREE_TYPE (type
);
6129 /* Get the mode of the type being modified. */
6130 orig_mode
= TYPE_MODE (type
);
6132 if ((!INTEGRAL_TYPE_P (type
)
6133 && !SCALAR_FLOAT_TYPE_P (type
)
6134 && !FIXED_POINT_TYPE_P (type
))
6135 || (!SCALAR_FLOAT_MODE_P (orig_mode
)
6136 && GET_MODE_CLASS (orig_mode
) != MODE_INT
6137 && !ALL_SCALAR_FIXED_POINT_MODE_P (orig_mode
))
6138 || !host_integerp (TYPE_SIZE_UNIT (type
), 1))
6140 error ("invalid vector type for attribute %qE", name
);
6144 if (vecsize
% tree_low_cst (TYPE_SIZE_UNIT (type
), 1))
6146 error ("vector size not an integral multiple of component size");
6152 error ("zero vector size");
6156 /* Calculate how many units fit in the vector. */
6157 nunits
= vecsize
/ tree_low_cst (TYPE_SIZE_UNIT (type
), 1);
6158 if (nunits
& (nunits
- 1))
6160 error ("number of components of the vector not a power of two");
6164 new_type
= build_vector_type (type
, nunits
);
6166 /* Build back pointers if needed. */
6167 *node
= lang_hooks
.types
.reconstruct_complex_type (*node
, new_type
);
6172 /* Handle the "nonnull" attribute. */
6174 handle_nonnull_attribute (tree
*node
, tree
ARG_UNUSED (name
),
6175 tree args
, int ARG_UNUSED (flags
),
6179 unsigned HOST_WIDE_INT attr_arg_num
;
6181 /* If no arguments are specified, all pointer arguments should be
6182 non-null. Verify a full prototype is given so that the arguments
6183 will have the correct types when we actually check them later. */
6186 if (!TYPE_ARG_TYPES (type
))
6188 error ("nonnull attribute without arguments on a non-prototype");
6189 *no_add_attrs
= true;
6194 /* Argument list specified. Verify that each argument number references
6195 a pointer argument. */
6196 for (attr_arg_num
= 1; args
; args
= TREE_CHAIN (args
))
6199 unsigned HOST_WIDE_INT arg_num
= 0, ck_num
;
6201 if (!get_nonnull_operand (TREE_VALUE (args
), &arg_num
))
6203 error ("nonnull argument has invalid operand number (argument %lu)",
6204 (unsigned long) attr_arg_num
);
6205 *no_add_attrs
= true;
6209 argument
= TYPE_ARG_TYPES (type
);
6212 for (ck_num
= 1; ; ck_num
++)
6214 if (!argument
|| ck_num
== arg_num
)
6216 argument
= TREE_CHAIN (argument
);
6220 || TREE_CODE (TREE_VALUE (argument
)) == VOID_TYPE
)
6222 error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
6223 (unsigned long) attr_arg_num
, (unsigned long) arg_num
);
6224 *no_add_attrs
= true;
6228 if (TREE_CODE (TREE_VALUE (argument
)) != POINTER_TYPE
)
6230 error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
6231 (unsigned long) attr_arg_num
, (unsigned long) arg_num
);
6232 *no_add_attrs
= true;
6241 /* Check the argument list of a function call for null in argument slots
6242 that are marked as requiring a non-null pointer argument. The NARGS
6243 arguments are passed in the array ARGARRAY.
6247 check_function_nonnull (tree attrs
, int nargs
, tree
*argarray
)
6252 for (a
= attrs
; a
; a
= TREE_CHAIN (a
))
6254 if (is_attribute_p ("nonnull", TREE_PURPOSE (a
)))
6256 args
= TREE_VALUE (a
);
6258 /* Walk the argument list. If we encounter an argument number we
6259 should check for non-null, do it. If the attribute has no args,
6260 then every pointer argument is checked (in which case the check
6261 for pointer type is done in check_nonnull_arg). */
6262 for (i
= 0; i
< nargs
; i
++)
6264 if (!args
|| nonnull_check_p (args
, i
+ 1))
6265 check_function_arguments_recurse (check_nonnull_arg
, NULL
,
6273 /* Check that the Nth argument of a function call (counting backwards
6274 from the end) is a (pointer)0. The NARGS arguments are passed in the
6278 check_function_sentinel (tree attrs
, int nargs
, tree
*argarray
, tree typelist
)
6280 tree attr
= lookup_attribute ("sentinel", attrs
);
6288 /* Skip over the named arguments. */
6289 while (typelist
&& len
< nargs
)
6291 typelist
= TREE_CHAIN (typelist
);
6295 if (TREE_VALUE (attr
))
6297 tree p
= TREE_VALUE (TREE_VALUE (attr
));
6298 pos
= TREE_INT_CST_LOW (p
);
6301 /* The sentinel must be one of the varargs, i.e.
6302 in position >= the number of fixed arguments. */
6303 if ((nargs
- 1 - pos
) < len
)
6305 warning (OPT_Wformat
,
6306 "not enough variable arguments to fit a sentinel");
6310 /* Validate the sentinel. */
6311 sentinel
= argarray
[nargs
- 1 - pos
];
6312 if ((!POINTER_TYPE_P (TREE_TYPE (sentinel
))
6313 || !integer_zerop (sentinel
))
6314 /* Although __null (in C++) is only an integer we allow it
6315 nevertheless, as we are guaranteed that it's exactly
6316 as wide as a pointer, and we don't want to force
6317 users to cast the NULL they have written there.
6318 We warn with -Wstrict-null-sentinel, though. */
6319 && (warn_strict_null_sentinel
|| null_node
!= sentinel
))
6320 warning (OPT_Wformat
, "missing sentinel in function call");
6324 /* Helper for check_function_nonnull; given a list of operands which
6325 must be non-null in ARGS, determine if operand PARAM_NUM should be
6329 nonnull_check_p (tree args
, unsigned HOST_WIDE_INT param_num
)
6331 unsigned HOST_WIDE_INT arg_num
= 0;
6333 for (; args
; args
= TREE_CHAIN (args
))
6335 bool found
= get_nonnull_operand (TREE_VALUE (args
), &arg_num
);
6339 if (arg_num
== param_num
)
6345 /* Check that the function argument PARAM (which is operand number
6346 PARAM_NUM) is non-null. This is called by check_function_nonnull
6347 via check_function_arguments_recurse. */
6350 check_nonnull_arg (void * ARG_UNUSED (ctx
), tree param
,
6351 unsigned HOST_WIDE_INT param_num
)
6353 /* Just skip checking the argument if it's not a pointer. This can
6354 happen if the "nonnull" attribute was given without an operand
6355 list (which means to check every pointer argument). */
6357 if (TREE_CODE (TREE_TYPE (param
)) != POINTER_TYPE
)
6360 if (integer_zerop (param
))
6361 warning (OPT_Wnonnull
, "null argument where non-null required "
6362 "(argument %lu)", (unsigned long) param_num
);
6365 /* Helper for nonnull attribute handling; fetch the operand number
6366 from the attribute argument list. */
6369 get_nonnull_operand (tree arg_num_expr
, unsigned HOST_WIDE_INT
*valp
)
6371 /* Verify the arg number is a constant. */
6372 if (TREE_CODE (arg_num_expr
) != INTEGER_CST
6373 || TREE_INT_CST_HIGH (arg_num_expr
) != 0)
6376 *valp
= TREE_INT_CST_LOW (arg_num_expr
);
6380 /* Handle a "nothrow" attribute; arguments as in
6381 struct attribute_spec.handler. */
6384 handle_nothrow_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
6385 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6387 if (TREE_CODE (*node
) == FUNCTION_DECL
)
6388 TREE_NOTHROW (*node
) = 1;
6389 /* ??? TODO: Support types. */
6392 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6393 *no_add_attrs
= true;
6399 /* Handle a "cleanup" attribute; arguments as in
6400 struct attribute_spec.handler. */
6403 handle_cleanup_attribute (tree
*node
, tree name
, tree args
,
6404 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6407 tree cleanup_id
, cleanup_decl
;
6409 /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
6410 for global destructors in C++. This requires infrastructure that
6411 we don't have generically at the moment. It's also not a feature
6412 we'd be missing too much, since we do have attribute constructor. */
6413 if (TREE_CODE (decl
) != VAR_DECL
|| TREE_STATIC (decl
))
6415 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6416 *no_add_attrs
= true;
6420 /* Verify that the argument is a function in scope. */
6421 /* ??? We could support pointers to functions here as well, if
6422 that was considered desirable. */
6423 cleanup_id
= TREE_VALUE (args
);
6424 if (TREE_CODE (cleanup_id
) != IDENTIFIER_NODE
)
6426 error ("cleanup argument not an identifier");
6427 *no_add_attrs
= true;
6430 cleanup_decl
= lookup_name (cleanup_id
);
6431 if (!cleanup_decl
|| TREE_CODE (cleanup_decl
) != FUNCTION_DECL
)
6433 error ("cleanup argument not a function");
6434 *no_add_attrs
= true;
6438 /* That the function has proper type is checked with the
6439 eventual call to build_function_call. */
6444 /* Handle a "warn_unused_result" attribute. No special handling. */
6447 handle_warn_unused_result_attribute (tree
*node
, tree name
,
6448 tree
ARG_UNUSED (args
),
6449 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6451 /* Ignore the attribute for functions not returning any value. */
6452 if (VOID_TYPE_P (TREE_TYPE (*node
)))
6454 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6455 *no_add_attrs
= true;
6461 /* Handle a "sentinel" attribute. */
6464 handle_sentinel_attribute (tree
*node
, tree name
, tree args
,
6465 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6467 tree params
= TYPE_ARG_TYPES (*node
);
6471 warning (OPT_Wattributes
,
6472 "%qE attribute requires prototypes with named arguments", name
);
6473 *no_add_attrs
= true;
6477 while (TREE_CHAIN (params
))
6478 params
= TREE_CHAIN (params
);
6480 if (VOID_TYPE_P (TREE_VALUE (params
)))
6482 warning (OPT_Wattributes
,
6483 "%qE attribute only applies to variadic functions", name
);
6484 *no_add_attrs
= true;
6490 tree position
= TREE_VALUE (args
);
6492 if (TREE_CODE (position
) != INTEGER_CST
)
6494 warning (OPT_Wattributes
,
6495 "requested position is not an integer constant");
6496 *no_add_attrs
= true;
6500 if (tree_int_cst_lt (position
, integer_zero_node
))
6502 warning (OPT_Wattributes
,
6503 "requested position is less than zero");
6504 *no_add_attrs
= true;
6512 /* Handle a "type_generic" attribute. */
6515 handle_type_generic_attribute (tree
*node
, tree
ARG_UNUSED (name
),
6516 tree
ARG_UNUSED (args
), int ARG_UNUSED (flags
),
6517 bool * ARG_UNUSED (no_add_attrs
))
6521 /* Ensure we have a function type. */
6522 gcc_assert (TREE_CODE (*node
) == FUNCTION_TYPE
);
6524 params
= TYPE_ARG_TYPES (*node
);
6525 while (params
&& ! VOID_TYPE_P (TREE_VALUE (params
)))
6526 params
= TREE_CHAIN (params
);
6528 /* Ensure we have a variadic function. */
6529 gcc_assert (!params
);
6534 /* Check for valid arguments being passed to a function.
6535 ATTRS is a list of attributes. There are NARGS arguments in the array
6536 ARGARRAY. TYPELIST is the list of argument types for the function.
6539 check_function_arguments (tree attrs
, int nargs
, tree
*argarray
, tree typelist
)
6541 /* Check for null being passed in a pointer argument that must be
6542 non-null. We also need to do this if format checking is enabled. */
6545 check_function_nonnull (attrs
, nargs
, argarray
);
6547 /* Check for errors in format strings. */
6549 if (warn_format
|| warn_missing_format_attribute
)
6550 check_function_format (attrs
, nargs
, argarray
);
6553 check_function_sentinel (attrs
, nargs
, argarray
, typelist
);
6556 /* Generic argument checking recursion routine. PARAM is the argument to
6557 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
6558 once the argument is resolved. CTX is context for the callback. */
6560 check_function_arguments_recurse (void (*callback
)
6561 (void *, tree
, unsigned HOST_WIDE_INT
),
6562 void *ctx
, tree param
,
6563 unsigned HOST_WIDE_INT param_num
)
6565 if (CONVERT_EXPR_P (param
)
6566 && (TYPE_PRECISION (TREE_TYPE (param
))
6567 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (param
, 0)))))
6569 /* Strip coercion. */
6570 check_function_arguments_recurse (callback
, ctx
,
6571 TREE_OPERAND (param
, 0), param_num
);
6575 if (TREE_CODE (param
) == CALL_EXPR
)
6577 tree type
= TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (param
)));
6579 bool found_format_arg
= false;
6581 /* See if this is a call to a known internationalization function
6582 that modifies a format arg. Such a function may have multiple
6583 format_arg attributes (for example, ngettext). */
6585 for (attrs
= TYPE_ATTRIBUTES (type
);
6587 attrs
= TREE_CHAIN (attrs
))
6588 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs
)))
6591 tree format_num_expr
;
6594 call_expr_arg_iterator iter
;
6596 /* Extract the argument number, which was previously checked
6598 format_num_expr
= TREE_VALUE (TREE_VALUE (attrs
));
6600 gcc_assert (TREE_CODE (format_num_expr
) == INTEGER_CST
6601 && !TREE_INT_CST_HIGH (format_num_expr
));
6603 format_num
= TREE_INT_CST_LOW (format_num_expr
);
6605 for (inner_arg
= first_call_expr_arg (param
, &iter
), i
= 1;
6607 inner_arg
= next_call_expr_arg (&iter
), i
++)
6608 if (i
== format_num
)
6610 check_function_arguments_recurse (callback
, ctx
,
6611 inner_arg
, param_num
);
6612 found_format_arg
= true;
6617 /* If we found a format_arg attribute and did a recursive check,
6618 we are done with checking this argument. Otherwise, we continue
6619 and this will be considered a non-literal. */
6620 if (found_format_arg
)
6624 if (TREE_CODE (param
) == COND_EXPR
)
6626 /* Check both halves of the conditional expression. */
6627 check_function_arguments_recurse (callback
, ctx
,
6628 TREE_OPERAND (param
, 1), param_num
);
6629 check_function_arguments_recurse (callback
, ctx
,
6630 TREE_OPERAND (param
, 2), param_num
);
6634 (*callback
) (ctx
, param
, param_num
);
6637 /* Checks the number of arguments NARGS against the required number
6638 REQUIRED and issues an error if there is a mismatch. Returns true
6639 if the number of arguments is correct, otherwise false. */
6642 validate_nargs (tree fndecl
, int nargs
, int required
)
6644 if (nargs
< required
)
6646 error ("not enough arguments to function %qE", fndecl
);
6649 else if (nargs
> required
)
6651 error ("too many arguments to function %qE", fndecl
);
6657 /* Verifies the NARGS arguments ARGS to the builtin function FNDECL.
6658 Returns false if there was an error, otherwise true. */
6661 check_builtin_function_arguments (tree fndecl
, int nargs
, tree
*args
)
6663 if (!DECL_BUILT_IN (fndecl
)
6664 || DECL_BUILT_IN_CLASS (fndecl
) != BUILT_IN_NORMAL
)
6667 switch (DECL_FUNCTION_CODE (fndecl
))
6669 case BUILT_IN_CONSTANT_P
:
6670 return validate_nargs (fndecl
, nargs
, 1);
6672 case BUILT_IN_ISFINITE
:
6673 case BUILT_IN_ISINF
:
6674 case BUILT_IN_ISINF_SIGN
:
6675 case BUILT_IN_ISNAN
:
6676 case BUILT_IN_ISNORMAL
:
6677 if (validate_nargs (fndecl
, nargs
, 1))
6679 if (TREE_CODE (TREE_TYPE (args
[0])) != REAL_TYPE
)
6681 error ("non-floating-point argument in call to "
6682 "function %qE", fndecl
);
6689 case BUILT_IN_ISGREATER
:
6690 case BUILT_IN_ISGREATEREQUAL
:
6691 case BUILT_IN_ISLESS
:
6692 case BUILT_IN_ISLESSEQUAL
:
6693 case BUILT_IN_ISLESSGREATER
:
6694 case BUILT_IN_ISUNORDERED
:
6695 if (validate_nargs (fndecl
, nargs
, 2))
6697 enum tree_code code0
, code1
;
6698 code0
= TREE_CODE (TREE_TYPE (args
[0]));
6699 code1
= TREE_CODE (TREE_TYPE (args
[1]));
6700 if (!((code0
== REAL_TYPE
&& code1
== REAL_TYPE
)
6701 || (code0
== REAL_TYPE
&& code1
== INTEGER_TYPE
)
6702 || (code0
== INTEGER_TYPE
&& code1
== REAL_TYPE
)))
6704 error ("non-floating-point arguments in call to "
6705 "function %qE", fndecl
);
6712 case BUILT_IN_FPCLASSIFY
:
6713 if (validate_nargs (fndecl
, nargs
, 6))
6718 if (TREE_CODE (args
[i
]) != INTEGER_CST
)
6720 error ("non-const integer argument %u in call to function %qE",
6725 if (TREE_CODE (TREE_TYPE (args
[5])) != REAL_TYPE
)
6727 error ("non-floating-point argument in call to function %qE",
6740 /* Function to help qsort sort FIELD_DECLs by name order. */
6743 field_decl_cmp (const void *x_p
, const void *y_p
)
6745 const tree
*const x
= (const tree
*const) x_p
;
6746 const tree
*const y
= (const tree
*const) y_p
;
6748 if (DECL_NAME (*x
) == DECL_NAME (*y
))
6749 /* A nontype is "greater" than a type. */
6750 return (TREE_CODE (*y
) == TYPE_DECL
) - (TREE_CODE (*x
) == TYPE_DECL
);
6751 if (DECL_NAME (*x
) == NULL_TREE
)
6753 if (DECL_NAME (*y
) == NULL_TREE
)
6755 if (DECL_NAME (*x
) < DECL_NAME (*y
))
6761 gt_pointer_operator new_value
;
6765 /* This routine compares two fields like field_decl_cmp but using the
6766 pointer operator in resort_data. */
6769 resort_field_decl_cmp (const void *x_p
, const void *y_p
)
6771 const tree
*const x
= (const tree
*const) x_p
;
6772 const tree
*const y
= (const tree
*const) y_p
;
6774 if (DECL_NAME (*x
) == DECL_NAME (*y
))
6775 /* A nontype is "greater" than a type. */
6776 return (TREE_CODE (*y
) == TYPE_DECL
) - (TREE_CODE (*x
) == TYPE_DECL
);
6777 if (DECL_NAME (*x
) == NULL_TREE
)
6779 if (DECL_NAME (*y
) == NULL_TREE
)
6782 tree d1
= DECL_NAME (*x
);
6783 tree d2
= DECL_NAME (*y
);
6784 resort_data
.new_value (&d1
, resort_data
.cookie
);
6785 resort_data
.new_value (&d2
, resort_data
.cookie
);
6792 /* Resort DECL_SORTED_FIELDS because pointers have been reordered. */
6795 resort_sorted_fields (void *obj
,
6796 void * ARG_UNUSED (orig_obj
),
6797 gt_pointer_operator new_value
,
6800 struct sorted_fields_type
*sf
= (struct sorted_fields_type
*) obj
;
6801 resort_data
.new_value
= new_value
;
6802 resort_data
.cookie
= cookie
;
6803 qsort (&sf
->elts
[0], sf
->len
, sizeof (tree
),
6804 resort_field_decl_cmp
);
6807 /* Subroutine of c_parse_error.
6808 Return the result of concatenating LHS and RHS. RHS is really
6809 a string literal, its first character is indicated by RHS_START and
6810 RHS_SIZE is its length (including the terminating NUL character).
6812 The caller is responsible for deleting the returned pointer. */
6815 catenate_strings (const char *lhs
, const char *rhs_start
, int rhs_size
)
6817 const int lhs_size
= strlen (lhs
);
6818 char *result
= XNEWVEC (char, lhs_size
+ rhs_size
);
6819 strncpy (result
, lhs
, lhs_size
);
6820 strncpy (result
+ lhs_size
, rhs_start
, rhs_size
);
6824 /* Issue the error given by GMSGID, indicating that it occurred before
6825 TOKEN, which had the associated VALUE. */
6828 c_parse_error (const char *gmsgid
, enum cpp_ttype token
, tree value
)
6830 #define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
6832 char *message
= NULL
;
6834 if (token
== CPP_EOF
)
6835 message
= catenate_messages (gmsgid
, " at end of input");
6836 else if (token
== CPP_CHAR
|| token
== CPP_WCHAR
|| token
== CPP_CHAR16
6837 || token
== CPP_CHAR32
)
6839 unsigned int val
= TREE_INT_CST_LOW (value
);
6858 if (val
<= UCHAR_MAX
&& ISGRAPH (val
))
6859 message
= catenate_messages (gmsgid
, " before %s'%c'");
6861 message
= catenate_messages (gmsgid
, " before %s'\\x%x'");
6863 error (message
, prefix
, val
);
6867 else if (token
== CPP_STRING
|| token
== CPP_WSTRING
|| token
== CPP_STRING16
6868 || token
== CPP_STRING32
)
6869 message
= catenate_messages (gmsgid
, " before string constant");
6870 else if (token
== CPP_NUMBER
)
6871 message
= catenate_messages (gmsgid
, " before numeric constant");
6872 else if (token
== CPP_NAME
)
6874 message
= catenate_messages (gmsgid
, " before %qE");
6875 error (message
, value
);
6879 else if (token
== CPP_PRAGMA
)
6880 message
= catenate_messages (gmsgid
, " before %<#pragma%>");
6881 else if (token
== CPP_PRAGMA_EOL
)
6882 message
= catenate_messages (gmsgid
, " before end of line");
6883 else if (token
< N_TTYPES
)
6885 message
= catenate_messages (gmsgid
, " before %qs token");
6886 error (message
, cpp_type2name (token
));
6898 #undef catenate_messages
6901 /* Walk a gimplified function and warn for functions whose return value is
6902 ignored and attribute((warn_unused_result)) is set. This is done before
6903 inlining, so we don't have to worry about that. */
6906 c_warn_unused_result (tree
*top_p
)
6909 tree_stmt_iterator i
;
6912 switch (TREE_CODE (t
))
6914 case STATEMENT_LIST
:
6915 for (i
= tsi_start (*top_p
); !tsi_end_p (i
); tsi_next (&i
))
6916 c_warn_unused_result (tsi_stmt_ptr (i
));
6920 c_warn_unused_result (&COND_EXPR_THEN (t
));
6921 c_warn_unused_result (&COND_EXPR_ELSE (t
));
6924 c_warn_unused_result (&BIND_EXPR_BODY (t
));
6926 case TRY_FINALLY_EXPR
:
6927 case TRY_CATCH_EXPR
:
6928 c_warn_unused_result (&TREE_OPERAND (t
, 0));
6929 c_warn_unused_result (&TREE_OPERAND (t
, 1));
6932 c_warn_unused_result (&CATCH_BODY (t
));
6934 case EH_FILTER_EXPR
:
6935 c_warn_unused_result (&EH_FILTER_FAILURE (t
));
6942 /* This is a naked call, as opposed to a CALL_EXPR nested inside
6943 a MODIFY_EXPR. All calls whose value is ignored should be
6944 represented like this. Look for the attribute. */
6945 fdecl
= get_callee_fndecl (t
);
6947 ftype
= TREE_TYPE (fdecl
);
6950 ftype
= TREE_TYPE (CALL_EXPR_FN (t
));
6951 /* Look past pointer-to-function to the function type itself. */
6952 ftype
= TREE_TYPE (ftype
);
6955 if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype
)))
6958 warning (0, "%Hignoring return value of %qD, "
6959 "declared with attribute warn_unused_result",
6960 EXPR_LOCUS (t
), fdecl
);
6962 warning (0, "%Hignoring return value of function "
6963 "declared with attribute warn_unused_result",
6969 /* Not a container, not a call, or a call whose value is used. */
6974 /* Convert a character from the host to the target execution character
6975 set. cpplib handles this, mostly. */
6978 c_common_to_target_charset (HOST_WIDE_INT c
)
6980 /* Character constants in GCC proper are sign-extended under -fsigned-char,
6981 zero-extended under -fno-signed-char. cpplib insists that characters
6982 and character constants are always unsigned. Hence we must convert
6984 cppchar_t uc
= ((cppchar_t
)c
) & ((((cppchar_t
)1) << CHAR_BIT
)-1);
6986 uc
= cpp_host_to_exec_charset (parse_in
, uc
);
6988 if (flag_signed_char
)
6989 return ((HOST_WIDE_INT
)uc
) << (HOST_BITS_PER_WIDE_INT
- CHAR_TYPE_SIZE
)
6990 >> (HOST_BITS_PER_WIDE_INT
- CHAR_TYPE_SIZE
);
6995 /* Build the result of __builtin_offsetof. EXPR is a nested sequence of
6996 component references, with STOP_REF, or alternatively an INDIRECT_REF of
6997 NULL, at the bottom; much like the traditional rendering of offsetof as a
6998 macro. Returns the folded and properly cast result. */
7001 fold_offsetof_1 (tree expr
, tree stop_ref
)
7003 enum tree_code code
= PLUS_EXPR
;
7006 if (expr
== stop_ref
&& TREE_CODE (expr
) != ERROR_MARK
)
7007 return size_zero_node
;
7009 switch (TREE_CODE (expr
))
7015 error ("cannot apply %<offsetof%> to static data member %qD", expr
);
7016 return error_mark_node
;
7019 error ("cannot apply %<offsetof%> when %<operator[]%> is overloaded");
7020 return error_mark_node
;
7023 gcc_assert (integer_zerop (expr
));
7024 return size_zero_node
;
7028 base
= fold_offsetof_1 (TREE_OPERAND (expr
, 0), stop_ref
);
7029 gcc_assert (base
== error_mark_node
|| base
== size_zero_node
);
7033 base
= fold_offsetof_1 (TREE_OPERAND (expr
, 0), stop_ref
);
7034 if (base
== error_mark_node
)
7037 t
= TREE_OPERAND (expr
, 1);
7038 if (DECL_C_BIT_FIELD (t
))
7040 error ("attempt to take address of bit-field structure "
7042 return error_mark_node
;
7044 off
= size_binop (PLUS_EXPR
, DECL_FIELD_OFFSET (t
),
7045 size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t
), 1)
7050 base
= fold_offsetof_1 (TREE_OPERAND (expr
, 0), stop_ref
);
7051 if (base
== error_mark_node
)
7054 t
= TREE_OPERAND (expr
, 1);
7055 if (TREE_CODE (t
) == INTEGER_CST
&& tree_int_cst_sgn (t
) < 0)
7058 t
= fold_build1 (NEGATE_EXPR
, TREE_TYPE (t
), t
);
7060 t
= convert (sizetype
, t
);
7061 off
= size_binop (MULT_EXPR
, TYPE_SIZE_UNIT (TREE_TYPE (expr
)), t
);
7065 /* Handle static members of volatile structs. */
7066 t
= TREE_OPERAND (expr
, 1);
7067 gcc_assert (TREE_CODE (t
) == VAR_DECL
);
7068 return fold_offsetof_1 (t
, stop_ref
);
7074 return size_binop (code
, base
, off
);
7078 fold_offsetof (tree expr
, tree stop_ref
)
7080 /* Convert back from the internal sizetype to size_t. */
7081 return convert (size_type_node
, fold_offsetof_1 (expr
, stop_ref
));
7084 /* Print an error message for an invalid lvalue. USE says
7085 how the lvalue is being used and so selects the error message. */
7088 lvalue_error (enum lvalue_use use
)
7093 error ("lvalue required as left operand of assignment");
7096 error ("lvalue required as increment operand");
7099 error ("lvalue required as decrement operand");
7102 error ("lvalue required as unary %<&%> operand");
7105 error ("lvalue required in asm statement");
7112 /* *PTYPE is an incomplete array. Complete it with a domain based on
7113 INITIAL_VALUE. If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
7114 is true. Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
7115 2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty. */
7118 complete_array_type (tree
*ptype
, tree initial_value
, bool do_default
)
7120 tree maxindex
, type
, main_type
, elt
, unqual_elt
;
7121 int failure
= 0, quals
;
7122 hashval_t hashcode
= 0;
7124 maxindex
= size_zero_node
;
7127 if (TREE_CODE (initial_value
) == STRING_CST
)
7130 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value
)));
7131 maxindex
= size_int (TREE_STRING_LENGTH (initial_value
)/eltsize
- 1);
7133 else if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
7135 VEC(constructor_elt
,gc
) *v
= CONSTRUCTOR_ELTS (initial_value
);
7137 if (VEC_empty (constructor_elt
, v
))
7141 maxindex
= integer_minus_one_node
;
7146 unsigned HOST_WIDE_INT cnt
;
7147 constructor_elt
*ce
;
7149 if (VEC_index (constructor_elt
, v
, 0)->index
)
7150 maxindex
= fold_convert (sizetype
,
7151 VEC_index (constructor_elt
,
7153 curindex
= maxindex
;
7156 VEC_iterate (constructor_elt
, v
, cnt
, ce
);
7160 curindex
= fold_convert (sizetype
, ce
->index
);
7162 curindex
= size_binop (PLUS_EXPR
, curindex
, size_one_node
);
7164 if (tree_int_cst_lt (maxindex
, curindex
))
7165 maxindex
= curindex
;
7171 /* Make an error message unless that happened already. */
7172 if (initial_value
!= error_mark_node
)
7184 elt
= TREE_TYPE (type
);
7185 quals
= TYPE_QUALS (strip_array_types (elt
));
7189 unqual_elt
= c_build_qualified_type (elt
, TYPE_UNQUALIFIED
);
7191 /* Using build_distinct_type_copy and modifying things afterward instead
7192 of using build_array_type to create a new type preserves all of the
7193 TYPE_LANG_FLAG_? bits that the front end may have set. */
7194 main_type
= build_distinct_type_copy (TYPE_MAIN_VARIANT (type
));
7195 TREE_TYPE (main_type
) = unqual_elt
;
7196 TYPE_DOMAIN (main_type
) = build_index_type (maxindex
);
7197 layout_type (main_type
);
7199 /* Make sure we have the canonical MAIN_TYPE. */
7200 hashcode
= iterative_hash_object (TYPE_HASH (unqual_elt
), hashcode
);
7201 hashcode
= iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (main_type
)),
7203 main_type
= type_hash_canon (hashcode
, main_type
);
7205 /* Fix the canonical type. */
7206 if (TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (main_type
))
7207 || TYPE_STRUCTURAL_EQUALITY_P (TYPE_DOMAIN (main_type
)))
7208 SET_TYPE_STRUCTURAL_EQUALITY (main_type
);
7209 else if (TYPE_CANONICAL (TREE_TYPE (main_type
)) != TREE_TYPE (main_type
)
7210 || (TYPE_CANONICAL (TYPE_DOMAIN (main_type
))
7211 != TYPE_DOMAIN (main_type
)))
7212 TYPE_CANONICAL (main_type
)
7213 = build_array_type (TYPE_CANONICAL (TREE_TYPE (main_type
)),
7214 TYPE_CANONICAL (TYPE_DOMAIN (main_type
)));
7216 TYPE_CANONICAL (main_type
) = main_type
;
7221 type
= c_build_qualified_type (main_type
, quals
);
7223 if (COMPLETE_TYPE_P (type
)
7224 && TREE_CODE (TYPE_SIZE_UNIT (type
)) == INTEGER_CST
7225 && TREE_OVERFLOW (TYPE_SIZE_UNIT (type
)))
7227 error ("size of array is too large");
7228 /* If we proceed with the array type as it is, we'll eventually
7229 crash in tree_low_cst(). */
7230 type
= error_mark_node
;
7238 /* Used to help initialize the builtin-types.def table. When a type of
7239 the correct size doesn't exist, use error_mark_node instead of NULL.
7240 The later results in segfaults even when a decl using the type doesn't
7244 builtin_type_for_size (int size
, bool unsignedp
)
7246 tree type
= lang_hooks
.types
.type_for_size (size
, unsignedp
);
7247 return type
? type
: error_mark_node
;
7250 /* A helper function for resolve_overloaded_builtin in resolving the
7251 overloaded __sync_ builtins. Returns a positive power of 2 if the
7252 first operand of PARAMS is a pointer to a supported data type.
7253 Returns 0 if an error is encountered. */
7256 sync_resolve_size (tree function
, tree params
)
7263 error ("too few arguments to function %qE", function
);
7267 type
= TREE_TYPE (TREE_VALUE (params
));
7268 if (TREE_CODE (type
) != POINTER_TYPE
)
7271 type
= TREE_TYPE (type
);
7272 if (!INTEGRAL_TYPE_P (type
) && !POINTER_TYPE_P (type
))
7275 size
= tree_low_cst (TYPE_SIZE_UNIT (type
), 1);
7276 if (size
== 1 || size
== 2 || size
== 4 || size
== 8 || size
== 16)
7280 error ("incompatible type for argument %d of %qE", 1, function
);
7284 /* A helper function for resolve_overloaded_builtin. Adds casts to
7285 PARAMS to make arguments match up with those of FUNCTION. Drops
7286 the variadic arguments at the end. Returns false if some error
7287 was encountered; true on success. */
7290 sync_resolve_params (tree orig_function
, tree function
, tree params
)
7292 tree arg_types
= TYPE_ARG_TYPES (TREE_TYPE (function
));
7296 /* We've declared the implementation functions to use "volatile void *"
7297 as the pointer parameter, so we shouldn't get any complaints from the
7298 call to check_function_arguments what ever type the user used. */
7299 arg_types
= TREE_CHAIN (arg_types
);
7300 ptype
= TREE_TYPE (TREE_TYPE (TREE_VALUE (params
)));
7303 /* For the rest of the values, we need to cast these to FTYPE, so that we
7304 don't get warnings for passing pointer types, etc. */
7305 while (arg_types
!= void_list_node
)
7309 params
= TREE_CHAIN (params
);
7312 error ("too few arguments to function %qE", orig_function
);
7316 /* ??? Ideally for the first conversion we'd use convert_for_assignment
7317 so that we get warnings for anything that doesn't match the pointer
7318 type. This isn't portable across the C and C++ front ends atm. */
7319 val
= TREE_VALUE (params
);
7320 val
= convert (ptype
, val
);
7321 val
= convert (TREE_VALUE (arg_types
), val
);
7322 TREE_VALUE (params
) = val
;
7324 arg_types
= TREE_CHAIN (arg_types
);
7328 /* The definition of these primitives is variadic, with the remaining
7329 being "an optional list of variables protected by the memory barrier".
7330 No clue what that's supposed to mean, precisely, but we consider all
7331 call-clobbered variables to be protected so we're safe. */
7332 TREE_CHAIN (params
) = NULL
;
7337 /* A helper function for resolve_overloaded_builtin. Adds a cast to
7338 RESULT to make it match the type of the first pointer argument in
7342 sync_resolve_return (tree params
, tree result
)
7344 tree ptype
= TREE_TYPE (TREE_TYPE (TREE_VALUE (params
)));
7345 ptype
= TYPE_MAIN_VARIANT (ptype
);
7346 return convert (ptype
, result
);
7349 /* Some builtin functions are placeholders for other expressions. This
7350 function should be called immediately after parsing the call expression
7351 before surrounding code has committed to the type of the expression.
7353 FUNCTION is the DECL that has been invoked; it is known to be a builtin.
7354 PARAMS is the argument list for the call. The return value is non-null
7355 when expansion is complete, and null if normal processing should
7359 resolve_overloaded_builtin (tree function
, tree params
)
7361 enum built_in_function orig_code
= DECL_FUNCTION_CODE (function
);
7362 switch (DECL_BUILT_IN_CLASS (function
))
7364 case BUILT_IN_NORMAL
:
7367 if (targetm
.resolve_overloaded_builtin
)
7368 return targetm
.resolve_overloaded_builtin (function
, params
);
7375 /* Handle BUILT_IN_NORMAL here. */
7378 case BUILT_IN_FETCH_AND_ADD_N
:
7379 case BUILT_IN_FETCH_AND_SUB_N
:
7380 case BUILT_IN_FETCH_AND_OR_N
:
7381 case BUILT_IN_FETCH_AND_AND_N
:
7382 case BUILT_IN_FETCH_AND_XOR_N
:
7383 case BUILT_IN_FETCH_AND_NAND_N
:
7384 case BUILT_IN_ADD_AND_FETCH_N
:
7385 case BUILT_IN_SUB_AND_FETCH_N
:
7386 case BUILT_IN_OR_AND_FETCH_N
:
7387 case BUILT_IN_AND_AND_FETCH_N
:
7388 case BUILT_IN_XOR_AND_FETCH_N
:
7389 case BUILT_IN_NAND_AND_FETCH_N
:
7390 case BUILT_IN_BOOL_COMPARE_AND_SWAP_N
:
7391 case BUILT_IN_VAL_COMPARE_AND_SWAP_N
:
7392 case BUILT_IN_LOCK_TEST_AND_SET_N
:
7393 case BUILT_IN_LOCK_RELEASE_N
:
7395 int n
= sync_resolve_size (function
, params
);
7396 tree new_function
, result
;
7399 return error_mark_node
;
7401 new_function
= built_in_decls
[orig_code
+ exact_log2 (n
) + 1];
7402 if (!sync_resolve_params (function
, new_function
, params
))
7403 return error_mark_node
;
7405 result
= build_function_call (new_function
, params
);
7406 if (orig_code
!= BUILT_IN_BOOL_COMPARE_AND_SWAP_N
7407 && orig_code
!= BUILT_IN_LOCK_RELEASE_N
)
7408 result
= sync_resolve_return (params
, result
);
7418 /* Ignoring their sign, return true if two scalar types are the same. */
7420 same_scalar_type_ignoring_signedness (tree t1
, tree t2
)
7422 enum tree_code c1
= TREE_CODE (t1
), c2
= TREE_CODE (t2
);
7424 gcc_assert ((c1
== INTEGER_TYPE
|| c1
== REAL_TYPE
|| c1
== FIXED_POINT_TYPE
)
7425 && (c2
== INTEGER_TYPE
|| c2
== REAL_TYPE
7426 || c2
== FIXED_POINT_TYPE
));
7428 /* Equality works here because c_common_signed_type uses
7429 TYPE_MAIN_VARIANT. */
7430 return c_common_signed_type (t1
)
7431 == c_common_signed_type (t2
);
7434 /* Check for missing format attributes on function pointers. LTYPE is
7435 the new type or left-hand side type. RTYPE is the old type or
7436 right-hand side type. Returns TRUE if LTYPE is missing the desired
7440 check_missing_format_attribute (tree ltype
, tree rtype
)
7442 tree
const ttr
= TREE_TYPE (rtype
), ttl
= TREE_TYPE (ltype
);
7445 for (ra
= TYPE_ATTRIBUTES (ttr
); ra
; ra
= TREE_CHAIN (ra
))
7446 if (is_attribute_p ("format", TREE_PURPOSE (ra
)))
7451 for (la
= TYPE_ATTRIBUTES (ttl
); la
; la
= TREE_CHAIN (la
))
7452 if (is_attribute_p ("format", TREE_PURPOSE (la
)))
7460 /* Subscripting with type char is likely to lose on a machine where
7461 chars are signed. So warn on any machine, but optionally. Don't
7462 warn for unsigned char since that type is safe. Don't warn for
7463 signed char because anyone who uses that must have done so
7464 deliberately. Furthermore, we reduce the false positive load by
7465 warning only for non-constant value of type char. */
7468 warn_array_subscript_with_type_char (tree index
)
7470 if (TYPE_MAIN_VARIANT (TREE_TYPE (index
)) == char_type_node
7471 && TREE_CODE (index
) != INTEGER_CST
)
7472 warning (OPT_Wchar_subscripts
, "array subscript has type %<char%>");
7475 /* Implement -Wparentheses for the unexpected C precedence rules, to
7476 cover cases like x + y << z which readers are likely to
7477 misinterpret. We have seen an expression in which CODE is a binary
7478 operator used to combine expressions headed by CODE_LEFT and
7479 CODE_RIGHT. CODE_LEFT and CODE_RIGHT may be ERROR_MARK, which
7480 means that that side of the expression was not formed using a
7481 binary operator, or it was enclosed in parentheses. */
7484 warn_about_parentheses (enum tree_code code
, enum tree_code code_left
,
7485 enum tree_code code_right
)
7487 if (!warn_parentheses
)
7490 if (code
== LSHIFT_EXPR
|| code
== RSHIFT_EXPR
)
7492 if (code_left
== PLUS_EXPR
|| code_left
== MINUS_EXPR
7493 || code_right
== PLUS_EXPR
|| code_right
== MINUS_EXPR
)
7494 warning (OPT_Wparentheses
,
7495 "suggest parentheses around + or - inside shift");
7498 if (code
== TRUTH_ORIF_EXPR
)
7500 if (code_left
== TRUTH_ANDIF_EXPR
7501 || code_right
== TRUTH_ANDIF_EXPR
)
7502 warning (OPT_Wparentheses
,
7503 "suggest parentheses around && within ||");
7506 if (code
== BIT_IOR_EXPR
)
7508 if (code_left
== BIT_AND_EXPR
|| code_left
== BIT_XOR_EXPR
7509 || code_left
== PLUS_EXPR
|| code_left
== MINUS_EXPR
7510 || code_right
== BIT_AND_EXPR
|| code_right
== BIT_XOR_EXPR
7511 || code_right
== PLUS_EXPR
|| code_right
== MINUS_EXPR
)
7512 warning (OPT_Wparentheses
,
7513 "suggest parentheses around arithmetic in operand of |");
7514 /* Check cases like x|y==z */
7515 if (TREE_CODE_CLASS (code_left
) == tcc_comparison
7516 || TREE_CODE_CLASS (code_right
) == tcc_comparison
)
7517 warning (OPT_Wparentheses
,
7518 "suggest parentheses around comparison in operand of |");
7521 if (code
== BIT_XOR_EXPR
)
7523 if (code_left
== BIT_AND_EXPR
7524 || code_left
== PLUS_EXPR
|| code_left
== MINUS_EXPR
7525 || code_right
== BIT_AND_EXPR
7526 || code_right
== PLUS_EXPR
|| code_right
== MINUS_EXPR
)
7527 warning (OPT_Wparentheses
,
7528 "suggest parentheses around arithmetic in operand of ^");
7529 /* Check cases like x^y==z */
7530 if (TREE_CODE_CLASS (code_left
) == tcc_comparison
7531 || TREE_CODE_CLASS (code_right
) == tcc_comparison
)
7532 warning (OPT_Wparentheses
,
7533 "suggest parentheses around comparison in operand of ^");
7536 if (code
== BIT_AND_EXPR
)
7538 if (code_left
== PLUS_EXPR
|| code_left
== MINUS_EXPR
7539 || code_right
== PLUS_EXPR
|| code_right
== MINUS_EXPR
)
7540 warning (OPT_Wparentheses
,
7541 "suggest parentheses around + or - in operand of &");
7542 /* Check cases like x&y==z */
7543 if (TREE_CODE_CLASS (code_left
) == tcc_comparison
7544 || TREE_CODE_CLASS (code_right
) == tcc_comparison
)
7545 warning (OPT_Wparentheses
,
7546 "suggest parentheses around comparison in operand of &");
7549 if (code
== EQ_EXPR
|| code
== NE_EXPR
)
7551 if (TREE_CODE_CLASS (code_left
) == tcc_comparison
7552 || TREE_CODE_CLASS (code_right
) == tcc_comparison
)
7553 warning (OPT_Wparentheses
,
7554 "suggest parentheses around comparison in operand of %s",
7555 code
== EQ_EXPR
? "==" : "!=");
7557 else if (TREE_CODE_CLASS (code
) == tcc_comparison
)
7559 if ((TREE_CODE_CLASS (code_left
) == tcc_comparison
7560 && code_left
!= NE_EXPR
&& code_left
!= EQ_EXPR
)
7561 || (TREE_CODE_CLASS (code_right
) == tcc_comparison
7562 && code_right
!= NE_EXPR
&& code_right
!= EQ_EXPR
))
7563 warning (OPT_Wparentheses
, "comparisons like X<=Y<=Z do not "
7564 "have their mathematical meaning");
7568 /* If LABEL (a LABEL_DECL) has not been used, issue a warning. */
7571 warn_for_unused_label (tree label
)
7573 if (!TREE_USED (label
))
7575 if (DECL_INITIAL (label
))
7576 warning (OPT_Wunused_label
, "label %q+D defined but not used", label
);
7578 warning (OPT_Wunused_label
, "label %q+D declared but not defined", label
);
7582 #ifndef TARGET_HAS_TARGETCM
7583 struct gcc_targetcm targetcm
= TARGETCM_INITIALIZER
;
7586 /* Warn for division by zero according to the value of DIVISOR. */
7589 warn_for_div_by_zero (tree divisor
)
7591 /* If DIVISOR is zero, and has integral or fixed-point type, issue a warning
7592 about division by zero. Do not issue a warning if DIVISOR has a
7593 floating-point type, since we consider 0.0/0.0 a valid way of
7594 generating a NaN. */
7595 if (skip_evaluation
== 0
7596 && (integer_zerop (divisor
) || fixed_zerop (divisor
)))
7597 warning (OPT_Wdiv_by_zero
, "division by zero");
7600 #include "gt-c-common.h"