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 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 2, 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 COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
24 #include "coretypes.h"
37 #include "diagnostic.h"
42 #include "langhooks.h"
43 #include "except.h" /* For USING_SJLJ_EXCEPTIONS. */
44 #include "tree-inline.h"
46 cpp_reader
*parse_in
; /* Declared in c-pragma.h. */
48 /* We let tm.h override the types used here, to handle trivial differences
49 such as the choice of unsigned int or long unsigned int for size_t.
50 When machines start needing nontrivial differences in the size type,
51 it would be best to do something here to figure out automatically
52 from other information what type to use. */
55 #define SIZE_TYPE "long unsigned int"
59 #define WCHAR_TYPE "int"
62 /* WCHAR_TYPE gets overridden by -fshort-wchar. */
63 #define MODIFIED_WCHAR_TYPE \
64 (flag_short_wchar ? "short unsigned int" : WCHAR_TYPE)
67 #define PTRDIFF_TYPE "long int"
71 #define WINT_TYPE "unsigned int"
75 #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
77 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
83 #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
85 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
86 ? "long unsigned int" \
87 : "long long unsigned int"))
90 #ifndef REGISTER_PREFIX
91 #define REGISTER_PREFIX ""
94 /* The variant of the C language being processed. */
96 enum c_language_kind c_language
;
98 /* The following symbols are subsumed in the c_global_trees array, and
99 listed here individually for documentation purposes.
101 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
103 tree short_integer_type_node;
104 tree long_integer_type_node;
105 tree long_long_integer_type_node;
107 tree short_unsigned_type_node;
108 tree long_unsigned_type_node;
109 tree long_long_unsigned_type_node;
111 tree boolean_type_node;
112 tree boolean_false_node;
113 tree boolean_true_node;
115 tree ptrdiff_type_node;
117 tree unsigned_char_type_node;
118 tree signed_char_type_node;
119 tree wchar_type_node;
120 tree signed_wchar_type_node;
121 tree unsigned_wchar_type_node;
123 tree float_type_node;
124 tree double_type_node;
125 tree long_double_type_node;
127 tree complex_integer_type_node;
128 tree complex_float_type_node;
129 tree complex_double_type_node;
130 tree complex_long_double_type_node;
132 tree intQI_type_node;
133 tree intHI_type_node;
134 tree intSI_type_node;
135 tree intDI_type_node;
136 tree intTI_type_node;
138 tree unsigned_intQI_type_node;
139 tree unsigned_intHI_type_node;
140 tree unsigned_intSI_type_node;
141 tree unsigned_intDI_type_node;
142 tree unsigned_intTI_type_node;
144 tree widest_integer_literal_type_node;
145 tree widest_unsigned_literal_type_node;
147 Nodes for types `void *' and `const void *'.
149 tree ptr_type_node, const_ptr_type_node;
151 Nodes for types `char *' and `const char *'.
153 tree string_type_node, const_string_type_node;
155 Type `char[SOMENUMBER]'.
156 Used when an array of char is needed and the size is irrelevant.
158 tree char_array_type_node;
160 Type `int[SOMENUMBER]' or something like it.
161 Used when an array of int needed and the size is irrelevant.
163 tree int_array_type_node;
165 Type `wchar_t[SOMENUMBER]' or something like it.
166 Used when a wide string literal is created.
168 tree wchar_array_type_node;
170 Type `int ()' -- used for implicit declaration of functions.
172 tree default_function_type;
174 A VOID_TYPE node, packaged in a TREE_LIST.
178 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
179 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
180 VAR_DECLS, but C++ does.)
182 tree function_name_decl_node;
183 tree pretty_function_name_decl_node;
184 tree c99_function_name_decl_node;
186 Stack of nested function name VAR_DECLs.
188 tree saved_function_name_decls;
192 tree c_global_trees
[CTI_MAX
];
194 /* Nonzero if we can read a PCH file now. */
198 /* Switches common to the C front ends. */
200 /* Nonzero if prepreprocessing only. */
201 int flag_preprocess_only
;
203 /* The file name to which we should write a precompiled header, or
204 NULL if no header will be written in this compile. */
206 const char *pch_file
;
208 /* Nonzero if an ISO standard was selected. It rejects macros in the
212 /* Nonzero whenever Objective-C functionality is being used. */
215 /* Nonzero if -undef was given. It suppresses target built-in macros
219 /* Nonzero means don't recognize the non-ANSI builtin functions. */
223 /* Nonzero means don't recognize the non-ANSI builtin functions.
226 int flag_no_nonansi_builtin
;
228 /* Nonzero means give `double' the same size as `float'. */
230 int flag_short_double
;
232 /* Nonzero means give `wchar_t' the same size as `short'. */
234 int flag_short_wchar
;
236 /* Nonzero means allow Microsoft extensions without warnings or errors. */
237 int flag_ms_extensions
;
239 /* Nonzero means don't recognize the keyword `asm'. */
243 /* Nonzero means give string constants the type `const char *', as mandated
246 int flag_const_strings
;
248 /* Nonzero means `$' can be in an identifier. */
250 #ifndef DOLLARS_IN_IDENTIFIERS
251 #define DOLLARS_IN_IDENTIFIERS 1
253 int dollars_in_ident
= DOLLARS_IN_IDENTIFIERS
;
255 /* Nonzero means to treat bitfields as signed unless they say `unsigned'. */
257 int flag_signed_bitfields
= 1;
258 int explicit_flag_signed_bitfields
;
260 /* Nonzero means warn about pointer casts that can drop a type qualifier
261 from the pointer target type. */
265 /* Warn about functions which might be candidates for format attributes. */
267 int warn_missing_format_attribute
;
269 /* Nonzero means warn about sizeof(function) or addition/subtraction
270 of function pointers. */
272 int warn_pointer_arith
;
274 /* Nonzero means warn for any global function def
275 without separate previous prototype decl. */
277 int warn_missing_prototypes
;
279 /* Warn if adding () is suggested. */
281 int warn_parentheses
;
283 /* Warn if initializer is not completely bracketed. */
285 int warn_missing_braces
;
287 /* Warn about comparison of signed and unsigned values.
288 If -1, neither -Wsign-compare nor -Wno-sign-compare has been specified. */
290 int warn_sign_compare
;
292 /* Nonzero means warn about usage of long long when `-pedantic'. */
294 int warn_long_long
= 1;
296 /* Nonzero means warn about deprecated conversion from string constant to
299 int warn_write_strings
;
301 /* Nonzero means warn about multiple (redundant) decls for the same single
302 variable or function. */
304 int warn_redundant_decls
;
306 /* Warn about testing equality of floating point numbers. */
308 int warn_float_equal
;
310 /* Warn about a subscript that has type char. */
312 int warn_char_subscripts
;
314 /* Warn if a type conversion is done that might have confusing results. */
318 /* Warn about #pragma directives that are not recognized. */
320 int warn_unknown_pragmas
; /* Tri state variable. */
322 /* Warn about format/argument anomalies in calls to formatted I/O functions
323 (*printf, *scanf, strftime, strfmon, etc.). */
327 /* Warn about Y2K problems with strftime formats. */
331 /* Warn about excess arguments to formats. */
333 int warn_format_extra_args
;
335 /* Warn about zero-length formats. */
337 int warn_format_zero_length
;
339 /* Warn about non-literal format arguments. */
341 int warn_format_nonliteral
;
343 /* Warn about possible security problems with calls to format functions. */
345 int warn_format_security
;
348 /* C/ObjC language option variables. */
351 /* Nonzero means message about use of implicit function declarations;
352 1 means warning; 2 means error. */
354 int mesg_implicit_function_declaration
= -1;
356 /* Nonzero means allow type mismatches in conditional expressions;
357 just make their values `void'. */
359 int flag_cond_mismatch
;
361 /* Nonzero means enable C89 Amendment 1 features. */
365 /* Nonzero means use the ISO C99 dialect of C. */
369 /* Nonzero means that we have builtin functions, and main is an int */
373 /* Nonzero means add default format_arg attributes for functions not
376 int flag_noniso_default_format_attributes
= 1;
378 /* Nonzero means warn when casting a function call to a type that does
379 not match the return type (e.g. (float)sqrt() or (anything*)malloc()
380 when there is no previous declaration of sqrt or malloc. */
382 int warn_bad_function_cast
;
384 /* Warn about traditional constructs whose meanings changed in ANSI C. */
386 int warn_traditional
;
388 /* Nonzero means warn for non-prototype function decls
389 or non-prototyped defs without previous prototype. */
391 int warn_strict_prototypes
;
393 /* Nonzero means warn for any global function def
394 without separate previous decl. */
396 int warn_missing_declarations
;
398 /* Nonzero means warn about declarations of objects not at
399 file-scope level and about *all* declarations of functions (whether
400 or static) not at file-scope level. Note that we exclude
401 implicit function declarations. To get warnings about those, use
404 int warn_nested_externs
;
406 /* Warn if main is suspicious. */
410 /* Nonzero means warn about possible violations of sequence point rules. */
412 int warn_sequence_point
;
414 /* Nonzero means to warn about compile-time division by zero. */
415 int warn_div_by_zero
= 1;
417 /* Nonzero means warn about use of implicit int. */
419 int warn_implicit_int
;
421 /* Warn about NULL being passed to argument slots marked as requiring
427 /* ObjC language option variables. */
430 /* Open and close the file for outputting class declarations, if
433 int flag_gen_declaration
;
435 /* Generate code for GNU or NeXT runtime environment. */
437 #ifdef NEXT_OBJC_RUNTIME
438 int flag_next_runtime
= 1;
440 int flag_next_runtime
= 0;
443 /* Tells the compiler that this is a special run. Do not perform any
444 compiling, instead we are to test some platform dependent features
445 and output a C header file with appropriate definitions. */
447 int print_struct_values
;
449 /* ???. Undocumented. */
451 const char *constant_string_class_name
;
453 /* Warn if multiple methods are seen for the same selector, but with
454 different argument types. Performs the check on the whole selector
455 table at the end of compilation. */
459 /* Warn if a @selector() is found, and no method with that selector
460 has been previously declared. The check is done on each
461 @selector() as soon as it is found - so it warns about forward
464 int warn_undeclared_selector
;
466 /* Warn if methods required by a protocol are not implemented in the
467 class adopting it. When turned off, methods inherited to that
468 class are also considered implemented. */
470 int warn_protocol
= 1;
473 /* C++ language option variables. */
476 /* Nonzero means don't recognize any extension keywords. */
478 int flag_no_gnu_keywords
;
480 /* Nonzero means do emit exported implementations of functions even if
481 they can be inlined. */
483 int flag_implement_inlines
= 1;
485 /* Nonzero means do emit exported implementations of templates, instead of
486 multiple static copies in each file that needs a definition. */
488 int flag_external_templates
;
490 /* Nonzero means that the decision to emit or not emit the implementation of a
491 template depends on where the template is instantiated, rather than where
494 int flag_alt_external_templates
;
496 /* Nonzero means that implicit instantiations will be emitted if needed. */
498 int flag_implicit_templates
= 1;
500 /* Nonzero means that implicit instantiations of inline templates will be
501 emitted if needed, even if instantiations of non-inline templates
504 int flag_implicit_inline_templates
= 1;
506 /* Nonzero means generate separate instantiation control files and
507 juggle them at link time. */
509 int flag_use_repository
;
511 /* Nonzero if we want to issue diagnostics that the standard says are not
514 int flag_optional_diags
= 1;
516 /* Nonzero means we should attempt to elide constructors when possible. */
518 int flag_elide_constructors
= 1;
520 /* Nonzero means that member functions defined in class scope are
521 inline by default. */
523 int flag_default_inline
= 1;
525 /* Controls whether compiler generates 'type descriptor' that give
526 run-time type information. */
530 /* Nonzero if we want to conserve space in the .o files. We do this
531 by putting uninitialized data and runtime initialized data into
532 .common instead of .data at the expense of not flagging multiple
535 int flag_conserve_space
;
537 /* Nonzero if we want to obey access control semantics. */
539 int flag_access_control
= 1;
541 /* Nonzero if we want to check the return value of new and avoid calling
542 constructors if it is a null pointer. */
546 /* Nonzero if we want the new ISO rules for pushing a new scope for `for'
547 initialization variables.
548 0: Old rules, set by -fno-for-scope.
549 2: New ISO rules, set by -ffor-scope.
550 1: Try to implement new ISO rules, but with backup compatibility
551 (and warnings). This is the default, for now. */
553 int flag_new_for_scope
= 1;
555 /* Nonzero if we want to emit defined symbols with common-like linkage as
556 weak symbols where possible, in order to conform to C++ semantics.
557 Otherwise, emit them as local symbols. */
561 /* Nonzero to use __cxa_atexit, rather than atexit, to register
562 destructors for local statics and global objects. */
564 int flag_use_cxa_atexit
= DEFAULT_USE_CXA_ATEXIT
;
566 /* Nonzero means output .vtable_{entry,inherit} for use in doing vtable gc. */
570 /* Nonzero means make the default pedwarns warnings instead of errors.
571 The value of this flag is ignored if -pedantic is specified. */
575 /* Nonzero means to implement standard semantics for exception
576 specifications, calling unexpected if an exception is thrown that
577 doesn't match the specification. Zero means to treat them as
578 assertions and optimize accordingly, but not check them. */
580 int flag_enforce_eh_specs
= 1;
582 /* The version of the C++ ABI in use. The following values are
585 0: The version of the ABI believed most conformant with the
586 C++ ABI specification. This ABI may change as bugs are
587 discovered and fixed. Therefore, 0 will not necessarily
588 indicate the same ABI in different versions of G++.
590 1: The version of the ABI first used in G++ 3.2.
592 Additional positive integers will be assigned as new versions of
593 the ABI become the default version of the ABI. */
595 int flag_abi_version
= 1;
597 /* Nonzero means warn about things that will change when compiling
598 with an ABI-compliant compiler. */
602 /* Nonzero means warn about implicit declarations. */
604 int warn_implicit
= 1;
606 /* Nonzero means warn when all ctors or dtors are private, and the class
609 int warn_ctor_dtor_privacy
= 1;
611 /* Nonzero means warn in function declared in derived class has the
612 same name as a virtual in the base class, but fails to match the
613 type signature of any virtual function in the base class. */
615 int warn_overloaded_virtual
;
617 /* Nonzero means warn when declaring a class that has a non virtual
618 destructor, when it really ought to have a virtual one. */
622 /* Nonzero means warn when the compiler will reorder code. */
626 /* Nonzero means warn when synthesis behavior differs from Cfront's. */
630 /* Nonzero means warn when we convert a pointer to member function
631 into a pointer to (void or function). */
633 int warn_pmf2ptr
= 1;
635 /* Nonzero means warn about violation of some Effective C++ style rules. */
639 /* Nonzero means warn where overload resolution chooses a promotion from
640 unsigned to signed over a conversion to an unsigned of the same size. */
644 /* Nonzero means warn when an old-style cast is used. */
646 int warn_old_style_cast
;
648 /* Nonzero means warn when non-templatized friend functions are
649 declared within a template */
651 int warn_nontemplate_friend
= 1;
653 /* Nonzero means complain about deprecated features. */
655 int warn_deprecated
= 1;
657 /* Maximum template instantiation depth. This limit is rather
658 arbitrary, but it exists to limit the time it takes to notice
659 infinite template instantiations. */
661 int max_tinst_depth
= 500;
665 /* The elements of `ridpointers' are identifier nodes for the reserved
666 type names and storage classes. It is indexed by a RID_... value. */
669 tree (*make_fname_decl
) PARAMS ((tree
, int));
671 /* If non-NULL, the address of a language-specific function that
672 returns 1 for language-specific statement codes. */
673 int (*lang_statement_code_p
) PARAMS ((enum tree_code
));
675 /* If non-NULL, the address of a language-specific function that takes
676 any action required right before expand_function_end is called. */
677 void (*lang_expand_function_end
) PARAMS ((void));
679 /* Nonzero means the expression being parsed will never be evaluated.
680 This is a count, since unevaluated expressions can nest. */
683 /* Information about how a function name is generated. */
686 tree
*const decl
; /* pointer to the VAR_DECL. */
687 const unsigned rid
; /* RID number for the identifier. */
688 const int pretty
; /* How pretty is it? */
691 /* The three ways of getting then name of the current function. */
693 const struct fname_var_t fname_vars
[] =
695 /* C99 compliant __func__, must be first. */
696 {&c99_function_name_decl_node
, RID_C99_FUNCTION_NAME
, 0},
697 /* GCC __FUNCTION__ compliant. */
698 {&function_name_decl_node
, RID_FUNCTION_NAME
, 0},
699 /* GCC __PRETTY_FUNCTION__ compliant. */
700 {&pretty_function_name_decl_node
, RID_PRETTY_FUNCTION_NAME
, 1},
704 static int constant_fits_type_p
PARAMS ((tree
, tree
));
706 /* Keep a stack of if statements. We record the number of compound
707 statements seen up to the if keyword, as well as the line number
708 and file of the if. If a potentially ambiguous else is seen, that
709 fact is recorded; the warning is issued when we can be sure that
710 the enclosing if statement does not have an else branch. */
720 static if_elt
*if_stack
;
722 /* Amount of space in the if statement stack. */
723 static int if_stack_space
= 0;
726 static int if_stack_pointer
= 0;
728 static tree handle_packed_attribute
PARAMS ((tree
*, tree
, tree
, int,
730 static tree handle_nocommon_attribute
PARAMS ((tree
*, tree
, tree
, int,
732 static tree handle_common_attribute
PARAMS ((tree
*, tree
, tree
, int,
734 static tree handle_noreturn_attribute
PARAMS ((tree
*, tree
, tree
, int,
736 static tree handle_noinline_attribute
PARAMS ((tree
*, tree
, tree
, int,
738 static tree handle_always_inline_attribute
PARAMS ((tree
*, tree
, tree
, int,
740 static tree handle_used_attribute
PARAMS ((tree
*, tree
, tree
, int,
742 static tree handle_unused_attribute
PARAMS ((tree
*, tree
, tree
, int,
744 static tree handle_const_attribute
PARAMS ((tree
*, tree
, tree
, int,
746 static tree handle_transparent_union_attribute
PARAMS ((tree
*, tree
, tree
,
748 static tree handle_constructor_attribute
PARAMS ((tree
*, tree
, tree
, int,
750 static tree handle_destructor_attribute
PARAMS ((tree
*, tree
, tree
, int,
752 static tree handle_mode_attribute
PARAMS ((tree
*, tree
, tree
, int,
754 static tree handle_section_attribute
PARAMS ((tree
*, tree
, tree
, int,
756 static tree handle_aligned_attribute
PARAMS ((tree
*, tree
, tree
, int,
758 static tree handle_weak_attribute
PARAMS ((tree
*, tree
, tree
, int,
760 static tree handle_alias_attribute
PARAMS ((tree
*, tree
, tree
, int,
762 static tree handle_visibility_attribute
PARAMS ((tree
*, tree
, tree
, int,
764 static tree handle_tls_model_attribute
PARAMS ((tree
*, tree
, tree
, int,
766 static tree handle_no_instrument_function_attribute
PARAMS ((tree
*, tree
,
769 static tree handle_malloc_attribute
PARAMS ((tree
*, tree
, tree
, int,
771 static tree handle_no_limit_stack_attribute
PARAMS ((tree
*, tree
, tree
, int,
773 static tree handle_pure_attribute
PARAMS ((tree
*, tree
, tree
, int,
775 static tree handle_deprecated_attribute
PARAMS ((tree
*, tree
, tree
, int,
777 static tree handle_vector_size_attribute
PARAMS ((tree
*, tree
, tree
, int,
779 static tree handle_nonnull_attribute
PARAMS ((tree
*, tree
, tree
, int,
781 static tree handle_nothrow_attribute
PARAMS ((tree
*, tree
, tree
, int,
783 static tree vector_size_helper
PARAMS ((tree
, tree
));
785 static void check_function_nonnull
PARAMS ((tree
, tree
));
786 static void check_nonnull_arg
PARAMS ((void *, tree
,
787 unsigned HOST_WIDE_INT
));
788 static bool nonnull_check_p
PARAMS ((tree
, unsigned HOST_WIDE_INT
));
789 static bool get_nonnull_operand
PARAMS ((tree
,
790 unsigned HOST_WIDE_INT
*));
791 void builtin_define_std
PARAMS ((const char *));
792 static void builtin_define_with_value
PARAMS ((const char *, const char *,
794 static void builtin_define_with_int_value
PARAMS ((const char *,
796 static void builtin_define_with_hex_fp_value
PARAMS ((const char *, tree
,
799 static void builtin_define_type_max
PARAMS ((const char *, tree
, int));
800 static void builtin_define_type_precision
PARAMS ((const char *, tree
));
801 static void builtin_define_float_constants
PARAMS ((const char *,
802 const char *, tree
));
804 /* Table of machine-independent attributes common to all C-like languages. */
805 const struct attribute_spec c_common_attribute_table
[] =
807 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
808 { "packed", 0, 0, false, false, false,
809 handle_packed_attribute
},
810 { "nocommon", 0, 0, true, false, false,
811 handle_nocommon_attribute
},
812 { "common", 0, 0, true, false, false,
813 handle_common_attribute
},
814 /* FIXME: logically, noreturn attributes should be listed as
815 "false, true, true" and apply to function types. But implementing this
816 would require all the places in the compiler that use TREE_THIS_VOLATILE
817 on a decl to identify non-returning functions to be located and fixed
818 to check the function type instead. */
819 { "noreturn", 0, 0, true, false, false,
820 handle_noreturn_attribute
},
821 { "volatile", 0, 0, true, false, false,
822 handle_noreturn_attribute
},
823 { "noinline", 0, 0, true, false, false,
824 handle_noinline_attribute
},
825 { "always_inline", 0, 0, true, false, false,
826 handle_always_inline_attribute
},
827 { "used", 0, 0, true, false, false,
828 handle_used_attribute
},
829 { "unused", 0, 0, false, false, false,
830 handle_unused_attribute
},
831 /* The same comments as for noreturn attributes apply to const ones. */
832 { "const", 0, 0, true, false, false,
833 handle_const_attribute
},
834 { "transparent_union", 0, 0, false, false, false,
835 handle_transparent_union_attribute
},
836 { "constructor", 0, 0, true, false, false,
837 handle_constructor_attribute
},
838 { "destructor", 0, 0, true, false, false,
839 handle_destructor_attribute
},
840 { "mode", 1, 1, false, true, false,
841 handle_mode_attribute
},
842 { "section", 1, 1, true, false, false,
843 handle_section_attribute
},
844 { "aligned", 0, 1, false, false, false,
845 handle_aligned_attribute
},
846 { "weak", 0, 0, true, false, false,
847 handle_weak_attribute
},
848 { "alias", 1, 1, true, false, false,
849 handle_alias_attribute
},
850 { "no_instrument_function", 0, 0, true, false, false,
851 handle_no_instrument_function_attribute
},
852 { "malloc", 0, 0, true, false, false,
853 handle_malloc_attribute
},
854 { "no_stack_limit", 0, 0, true, false, false,
855 handle_no_limit_stack_attribute
},
856 { "pure", 0, 0, true, false, false,
857 handle_pure_attribute
},
858 { "deprecated", 0, 0, false, false, false,
859 handle_deprecated_attribute
},
860 { "vector_size", 1, 1, false, true, false,
861 handle_vector_size_attribute
},
862 { "visibility", 1, 1, true, false, false,
863 handle_visibility_attribute
},
864 { "tls_model", 1, 1, true, false, false,
865 handle_tls_model_attribute
},
866 { "nonnull", 0, -1, false, true, true,
867 handle_nonnull_attribute
},
868 { "nothrow", 0, 0, true, false, false,
869 handle_nothrow_attribute
},
870 { "may_alias", 0, 0, false, true, false, NULL
},
871 { NULL
, 0, 0, false, false, false, NULL
}
874 /* Give the specifications for the format attributes, used by C and all
877 const struct attribute_spec c_common_format_attribute_table
[] =
879 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
880 { "format", 3, 3, false, true, true,
881 handle_format_attribute
},
882 { "format_arg", 1, 1, false, true, true,
883 handle_format_arg_attribute
},
884 { NULL
, 0, 0, false, false, false, NULL
}
887 /* Record the start of an if-then, and record the start of it
888 for ambiguous else detection.
890 COND is the condition for the if-then statement.
892 IF_STMT is the statement node that has already been created for
893 this if-then statement. It is created before parsing the
894 condition to keep line number information accurate. */
897 c_expand_start_cond (cond
, compstmt_count
, if_stmt
)
902 /* Make sure there is enough space on the stack. */
903 if (if_stack_space
== 0)
906 if_stack
= (if_elt
*) xmalloc (10 * sizeof (if_elt
));
908 else if (if_stack_space
== if_stack_pointer
)
910 if_stack_space
+= 10;
911 if_stack
= (if_elt
*) xrealloc (if_stack
, if_stack_space
* sizeof (if_elt
));
914 IF_COND (if_stmt
) = cond
;
917 /* Record this if statement. */
918 if_stack
[if_stack_pointer
].compstmt_count
= compstmt_count
;
919 if_stack
[if_stack_pointer
].file
= input_filename
;
920 if_stack
[if_stack_pointer
].line
= lineno
;
921 if_stack
[if_stack_pointer
].needs_warning
= 0;
922 if_stack
[if_stack_pointer
].if_stmt
= if_stmt
;
926 /* Called after the then-clause for an if-statement is processed. */
931 tree if_stmt
= if_stack
[if_stack_pointer
- 1].if_stmt
;
932 RECHAIN_STMTS (if_stmt
, THEN_CLAUSE (if_stmt
));
935 /* Record the end of an if-then. Optionally warn if a nested
936 if statement had an ambiguous else clause. */
942 if (if_stack
[if_stack_pointer
].needs_warning
)
943 warning_with_file_and_line (if_stack
[if_stack_pointer
].file
,
944 if_stack
[if_stack_pointer
].line
,
945 "suggest explicit braces to avoid ambiguous `else'");
946 last_expr_type
= NULL_TREE
;
949 /* Called between the then-clause and the else-clause
950 of an if-then-else. */
953 c_expand_start_else ()
955 /* An ambiguous else warning must be generated for the enclosing if
956 statement, unless we see an else branch for that one, too. */
958 && if_stack_pointer
> 1
959 && (if_stack
[if_stack_pointer
- 1].compstmt_count
960 == if_stack
[if_stack_pointer
- 2].compstmt_count
))
961 if_stack
[if_stack_pointer
- 2].needs_warning
= 1;
963 /* Even if a nested if statement had an else branch, it can't be
964 ambiguous if this one also has an else. So don't warn in that
965 case. Also don't warn for any if statements nested in this else. */
966 if_stack
[if_stack_pointer
- 1].needs_warning
= 0;
967 if_stack
[if_stack_pointer
- 1].compstmt_count
--;
970 /* Called after the else-clause for an if-statement is processed. */
975 tree if_stmt
= if_stack
[if_stack_pointer
- 1].if_stmt
;
976 RECHAIN_STMTS (if_stmt
, ELSE_CLAUSE (if_stmt
));
979 /* Begin an if-statement. Returns a newly created IF_STMT if
982 Unlike the C++ front-end, we do not call add_stmt here; it is
983 probably safe to do so, but I am not very familiar with this
984 code so I am being extra careful not to change its behavior
985 beyond what is strictly necessary for correctness. */
991 r
= build_stmt (IF_STMT
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
995 /* Begin a while statement. Returns a newly created WHILE_STMT if
998 Unlike the C++ front-end, we do not call add_stmt here; it is
999 probably safe to do so, but I am not very familiar with this
1000 code so I am being extra careful not to change its behavior
1001 beyond what is strictly necessary for correctness. */
1004 c_begin_while_stmt ()
1007 r
= build_stmt (WHILE_STMT
, NULL_TREE
, NULL_TREE
);
1012 c_finish_while_stmt_cond (cond
, while_stmt
)
1016 WHILE_COND (while_stmt
) = cond
;
1019 /* Push current bindings for the function name VAR_DECLS. */
1022 start_fname_decls ()
1025 tree saved
= NULL_TREE
;
1027 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
1029 tree decl
= *fname_vars
[ix
].decl
;
1033 saved
= tree_cons (decl
, build_int_2 (ix
, 0), saved
);
1034 *fname_vars
[ix
].decl
= NULL_TREE
;
1037 if (saved
|| saved_function_name_decls
)
1038 /* Normally they'll have been NULL, so only push if we've got a
1039 stack, or they are non-NULL. */
1040 saved_function_name_decls
= tree_cons (saved
, NULL_TREE
,
1041 saved_function_name_decls
);
1044 /* Finish up the current bindings, adding them into the
1045 current function's statement tree. This is done by wrapping the
1046 function's body in a COMPOUND_STMT containing these decls too. This
1047 must be done _before_ finish_stmt_tree is called. If there is no
1048 current function, we must be at file scope and no statements are
1049 involved. Pop the previous bindings. */
1052 finish_fname_decls ()
1055 tree body
= NULL_TREE
;
1056 tree stack
= saved_function_name_decls
;
1058 for (; stack
&& TREE_VALUE (stack
); stack
= TREE_CHAIN (stack
))
1059 body
= chainon (TREE_VALUE (stack
), body
);
1063 /* They were called into existence, so add to statement tree. Add
1064 the DECL_STMTs inside the outermost scope. */
1065 tree
*p
= &DECL_SAVED_TREE (current_function_decl
);
1066 /* Skip the dummy EXPR_STMT and any EH_SPEC_BLOCK. */
1067 while (TREE_CODE (*p
) != COMPOUND_STMT
)
1068 p
= &TREE_CHAIN (*p
);
1069 p
= &COMPOUND_BODY (*p
);
1070 if (TREE_CODE (*p
) == SCOPE_STMT
)
1071 p
= &TREE_CHAIN (*p
);
1073 body
= chainon (body
, *p
);
1077 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
1078 *fname_vars
[ix
].decl
= NULL_TREE
;
1082 /* We had saved values, restore them. */
1085 for (saved
= TREE_PURPOSE (stack
); saved
; saved
= TREE_CHAIN (saved
))
1087 tree decl
= TREE_PURPOSE (saved
);
1088 unsigned ix
= TREE_INT_CST_LOW (TREE_VALUE (saved
));
1090 *fname_vars
[ix
].decl
= decl
;
1092 stack
= TREE_CHAIN (stack
);
1094 saved_function_name_decls
= stack
;
1097 /* Return the text name of the current function, suitably prettified
1101 fname_as_string (pretty_p
)
1104 const char *name
= NULL
;
1107 name
= (current_function_decl
1108 ? (*lang_hooks
.decl_printable_name
) (current_function_decl
, 2)
1110 else if (current_function_decl
&& DECL_NAME (current_function_decl
))
1111 name
= IDENTIFIER_POINTER (DECL_NAME (current_function_decl
));
1117 /* Return the text name of the current function, formatted as
1118 required by the supplied RID value. */
1126 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
1127 if (fname_vars
[ix
].rid
== rid
)
1129 return fname_as_string (fname_vars
[ix
].pretty
);
1132 /* Return the VAR_DECL for a const char array naming the current
1133 function. If the VAR_DECL has not yet been created, create it
1134 now. RID indicates how it should be formatted and IDENTIFIER_NODE
1135 ID is its name (unfortunately C and C++ hold the RID values of
1136 keywords in different places, so we can't derive RID from ID in
1137 this language independent code. */
1140 fname_decl (rid
, id
)
1145 tree decl
= NULL_TREE
;
1147 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
1148 if (fname_vars
[ix
].rid
== rid
)
1151 decl
= *fname_vars
[ix
].decl
;
1154 tree saved_last_tree
= last_tree
;
1155 /* If a tree is built here, it would normally have the lineno of
1156 the current statement. Later this tree will be moved to the
1157 beginning of the function and this line number will be wrong.
1158 To avoid this problem set the lineno to 0 here; that prevents
1159 it from appearing in the RTL. */
1160 int saved_lineno
= lineno
;
1163 decl
= (*make_fname_decl
) (id
, fname_vars
[ix
].pretty
);
1164 if (last_tree
!= saved_last_tree
)
1166 /* We created some statement tree for the decl. This belongs
1167 at the start of the function, so remove it now and reinsert
1168 it after the function is complete. */
1169 tree stmts
= TREE_CHAIN (saved_last_tree
);
1171 TREE_CHAIN (saved_last_tree
) = NULL_TREE
;
1172 last_tree
= saved_last_tree
;
1173 saved_function_name_decls
= tree_cons (decl
, stmts
,
1174 saved_function_name_decls
);
1176 *fname_vars
[ix
].decl
= decl
;
1177 lineno
= saved_lineno
;
1179 if (!ix
&& !current_function_decl
)
1180 pedwarn_with_decl (decl
, "`%s' is not defined outside of function scope");
1185 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
1188 fix_string_type (value
)
1191 const int wchar_bytes
= TYPE_PRECISION (wchar_type_node
) / BITS_PER_UNIT
;
1192 const int wide_flag
= TREE_TYPE (value
) == wchar_array_type_node
;
1193 const int nchars_max
= flag_isoc99
? 4095 : 509;
1194 int length
= TREE_STRING_LENGTH (value
);
1197 /* Compute the number of elements, for the array type. */
1198 nchars
= wide_flag
? length
/ wchar_bytes
: length
;
1200 if (pedantic
&& nchars
- 1 > nchars_max
&& c_language
== clk_c
)
1201 pedwarn ("string length `%d' is greater than the length `%d' ISO C%d compilers are required to support",
1202 nchars
- 1, nchars_max
, flag_isoc99
? 99 : 89);
1204 /* Create the array type for the string constant.
1205 -Wwrite-strings says make the string constant an array of const char
1206 so that copying it to a non-const pointer will get a warning.
1207 For C++, this is the standard behavior. */
1208 if (flag_const_strings
&& ! flag_writable_strings
)
1211 = build_type_variant (wide_flag
? wchar_type_node
: char_type_node
,
1214 = build_array_type (elements
,
1215 build_index_type (build_int_2 (nchars
- 1, 0)));
1219 = build_array_type (wide_flag
? wchar_type_node
: char_type_node
,
1220 build_index_type (build_int_2 (nchars
- 1, 0)));
1222 TREE_CONSTANT (value
) = 1;
1223 TREE_READONLY (value
) = ! flag_writable_strings
;
1224 TREE_STATIC (value
) = 1;
1228 /* Given a VARRAY of STRING_CST nodes, concatenate them into one
1232 combine_strings (strings
)
1233 varray_type strings
;
1235 const int wchar_bytes
= TYPE_PRECISION (wchar_type_node
) / BITS_PER_UNIT
;
1236 const int nstrings
= VARRAY_ACTIVE_SIZE (strings
);
1239 int wide_length
= 0;
1244 /* Don't include the \0 at the end of each substring. Count wide
1245 strings and ordinary strings separately. */
1246 for (i
= 0; i
< nstrings
; ++i
)
1248 t
= VARRAY_TREE (strings
, i
);
1250 if (TREE_TYPE (t
) == wchar_array_type_node
)
1252 wide_length
+= TREE_STRING_LENGTH (t
) - wchar_bytes
;
1257 length
+= (TREE_STRING_LENGTH (t
) - 1);
1258 if (C_ARTIFICIAL_STRING_P (t
) && !in_system_header
)
1259 warning ("concatenation of string literals with __FUNCTION__ is deprecated");
1263 /* If anything is wide, the non-wides will be converted,
1264 which makes them take more space. */
1266 length
= length
* wchar_bytes
+ wide_length
;
1268 p
= xmalloc (length
);
1270 /* Copy the individual strings into the new combined string.
1271 If the combined string is wide, convert the chars to ints
1272 for any individual strings that are not wide. */
1275 for (i
= 0; i
< nstrings
; ++i
)
1279 t
= VARRAY_TREE (strings
, i
);
1280 this_wide
= TREE_TYPE (t
) == wchar_array_type_node
;
1281 len
= TREE_STRING_LENGTH (t
) - (this_wide
? wchar_bytes
: 1);
1282 if (this_wide
== wide_flag
)
1284 memcpy (q
, TREE_STRING_POINTER (t
), len
);
1289 const int nzeros
= (TYPE_PRECISION (wchar_type_node
)
1290 / BITS_PER_UNIT
) - 1;
1293 if (BYTES_BIG_ENDIAN
)
1295 for (k
= 0; k
< len
; k
++)
1297 for (j
= 0; j
< nzeros
; j
++)
1299 *q
++ = TREE_STRING_POINTER (t
)[k
];
1304 for (k
= 0; k
< len
; k
++)
1306 *q
++ = TREE_STRING_POINTER (t
)[k
];
1307 for (j
= 0; j
< nzeros
; j
++)
1314 /* Nul terminate the string. */
1317 for (i
= 0; i
< wchar_bytes
; i
++)
1323 value
= build_string (length
, p
);
1327 TREE_TYPE (value
) = wchar_array_type_node
;
1329 TREE_TYPE (value
) = char_array_type_node
;
1334 static int is_valid_printf_arglist
PARAMS ((tree
));
1335 static rtx c_expand_builtin
PARAMS ((tree
, rtx
, enum machine_mode
, enum expand_modifier
));
1336 static rtx c_expand_builtin_printf
PARAMS ((tree
, rtx
, enum machine_mode
,
1337 enum expand_modifier
, int, int));
1338 static rtx c_expand_builtin_fprintf
PARAMS ((tree
, rtx
, enum machine_mode
,
1339 enum expand_modifier
, int, int));
1341 /* Print a warning if a constant expression had overflow in folding.
1342 Invoke this function on every expression that the language
1343 requires to be a constant expression.
1344 Note the ANSI C standard says it is erroneous for a
1345 constant expression to overflow. */
1348 constant_expression_warning (value
)
1351 if ((TREE_CODE (value
) == INTEGER_CST
|| TREE_CODE (value
) == REAL_CST
1352 || TREE_CODE (value
) == VECTOR_CST
1353 || TREE_CODE (value
) == COMPLEX_CST
)
1354 && TREE_CONSTANT_OVERFLOW (value
) && pedantic
)
1355 pedwarn ("overflow in constant expression");
1358 /* Print a warning if an expression had overflow in folding.
1359 Invoke this function on every expression that
1360 (1) appears in the source code, and
1361 (2) might be a constant expression that overflowed, and
1362 (3) is not already checked by convert_and_check;
1363 however, do not invoke this function on operands of explicit casts. */
1366 overflow_warning (value
)
1369 if ((TREE_CODE (value
) == INTEGER_CST
1370 || (TREE_CODE (value
) == COMPLEX_CST
1371 && TREE_CODE (TREE_REALPART (value
)) == INTEGER_CST
))
1372 && TREE_OVERFLOW (value
))
1374 TREE_OVERFLOW (value
) = 0;
1375 if (skip_evaluation
== 0)
1376 warning ("integer overflow in expression");
1378 else if ((TREE_CODE (value
) == REAL_CST
1379 || (TREE_CODE (value
) == COMPLEX_CST
1380 && TREE_CODE (TREE_REALPART (value
)) == REAL_CST
))
1381 && TREE_OVERFLOW (value
))
1383 TREE_OVERFLOW (value
) = 0;
1384 if (skip_evaluation
== 0)
1385 warning ("floating point overflow in expression");
1387 else if (TREE_CODE (value
) == VECTOR_CST
&& TREE_OVERFLOW (value
))
1389 TREE_OVERFLOW (value
) = 0;
1390 if (skip_evaluation
== 0)
1391 warning ("vector overflow in expression");
1395 /* Print a warning if a large constant is truncated to unsigned,
1396 or if -Wconversion is used and a constant < 0 is converted to unsigned.
1397 Invoke this function on every expression that might be implicitly
1398 converted to an unsigned type. */
1401 unsigned_conversion_warning (result
, operand
)
1402 tree result
, operand
;
1404 tree type
= TREE_TYPE (result
);
1406 if (TREE_CODE (operand
) == INTEGER_CST
1407 && TREE_CODE (type
) == INTEGER_TYPE
1408 && TREE_UNSIGNED (type
)
1409 && skip_evaluation
== 0
1410 && !int_fits_type_p (operand
, type
))
1412 if (!int_fits_type_p (operand
, c_common_signed_type (type
)))
1413 /* This detects cases like converting -129 or 256 to unsigned char. */
1414 warning ("large integer implicitly truncated to unsigned type");
1415 else if (warn_conversion
)
1416 warning ("negative integer implicitly converted to unsigned type");
1420 /* Nonzero if constant C has a value that is permissible
1421 for type TYPE (an INTEGER_TYPE). */
1424 constant_fits_type_p (c
, type
)
1427 if (TREE_CODE (c
) == INTEGER_CST
)
1428 return int_fits_type_p (c
, type
);
1430 c
= convert (type
, c
);
1431 return !TREE_OVERFLOW (c
);
1434 /* Convert EXPR to TYPE, warning about conversion problems with constants.
1435 Invoke this function on every expression that is converted implicitly,
1436 i.e. because of language rules and not because of an explicit cast. */
1439 convert_and_check (type
, expr
)
1442 tree t
= convert (type
, expr
);
1443 if (TREE_CODE (t
) == INTEGER_CST
)
1445 if (TREE_OVERFLOW (t
))
1447 TREE_OVERFLOW (t
) = 0;
1449 /* Do not diagnose overflow in a constant expression merely
1450 because a conversion overflowed. */
1451 TREE_CONSTANT_OVERFLOW (t
) = TREE_CONSTANT_OVERFLOW (expr
);
1453 /* No warning for converting 0x80000000 to int. */
1454 if (!(TREE_UNSIGNED (type
) < TREE_UNSIGNED (TREE_TYPE (expr
))
1455 && TREE_CODE (TREE_TYPE (expr
)) == INTEGER_TYPE
1456 && TYPE_PRECISION (type
) == TYPE_PRECISION (TREE_TYPE (expr
))))
1457 /* If EXPR fits in the unsigned version of TYPE,
1458 don't warn unless pedantic. */
1460 || TREE_UNSIGNED (type
)
1461 || ! constant_fits_type_p (expr
,
1462 c_common_unsigned_type (type
)))
1463 && skip_evaluation
== 0)
1464 warning ("overflow in implicit constant conversion");
1467 unsigned_conversion_warning (t
, expr
);
1472 /* A node in a list that describes references to variables (EXPR), which are
1473 either read accesses if WRITER is zero, or write accesses, in which case
1474 WRITER is the parent of EXPR. */
1481 /* Used to implement a cache the results of a call to verify_tree. We only
1482 use this for SAVE_EXPRs. */
1485 struct tlist_cache
*next
;
1486 struct tlist
*cache_before_sp
;
1487 struct tlist
*cache_after_sp
;
1491 /* Obstack to use when allocating tlist structures, and corresponding
1493 static struct obstack tlist_obstack
;
1494 static char *tlist_firstobj
= 0;
1496 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
1498 static struct tlist
*warned_ids
;
1499 /* SAVE_EXPRs need special treatment. We process them only once and then
1500 cache the results. */
1501 static struct tlist_cache
*save_expr_cache
;
1503 static void add_tlist
PARAMS ((struct tlist
**, struct tlist
*, tree
, int));
1504 static void merge_tlist
PARAMS ((struct tlist
**, struct tlist
*, int));
1505 static void verify_tree
PARAMS ((tree
, struct tlist
**, struct tlist
**, tree
));
1506 static int warning_candidate_p
PARAMS ((tree
));
1507 static void warn_for_collisions
PARAMS ((struct tlist
*));
1508 static void warn_for_collisions_1
PARAMS ((tree
, tree
, struct tlist
*, int));
1509 static struct tlist
*new_tlist
PARAMS ((struct tlist
*, tree
, tree
));
1510 static void verify_sequence_points
PARAMS ((tree
));
1512 /* Create a new struct tlist and fill in its fields. */
1513 static struct tlist
*
1514 new_tlist (next
, t
, writer
)
1520 l
= (struct tlist
*) obstack_alloc (&tlist_obstack
, sizeof *l
);
1527 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
1528 is nonnull, we ignore any node we find which has a writer equal to it. */
1531 add_tlist (to
, add
, exclude_writer
, copy
)
1534 tree exclude_writer
;
1539 struct tlist
*next
= add
->next
;
1542 if (! exclude_writer
|| add
->writer
!= exclude_writer
)
1543 *to
= copy
? new_tlist (*to
, add
->expr
, add
->writer
) : add
;
1548 /* Merge the nodes of ADD into TO. This merging process is done so that for
1549 each variable that already exists in TO, no new node is added; however if
1550 there is a write access recorded in ADD, and an occurrence on TO is only
1551 a read access, then the occurrence in TO will be modified to record the
1555 merge_tlist (to
, add
, copy
)
1560 struct tlist
**end
= to
;
1563 end
= &(*end
)->next
;
1569 struct tlist
*next
= add
->next
;
1571 for (tmp2
= *to
; tmp2
; tmp2
= tmp2
->next
)
1572 if (tmp2
->expr
== add
->expr
)
1576 tmp2
->writer
= add
->writer
;
1580 *end
= copy
? add
: new_tlist (NULL
, add
->expr
, add
->writer
);
1581 end
= &(*end
)->next
;
1588 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
1589 references in list LIST conflict with it, excluding reads if ONLY writers
1593 warn_for_collisions_1 (written
, writer
, list
, only_writes
)
1594 tree written
, writer
;
1600 /* Avoid duplicate warnings. */
1601 for (tmp
= warned_ids
; tmp
; tmp
= tmp
->next
)
1602 if (tmp
->expr
== written
)
1607 if (list
->expr
== written
1608 && list
->writer
!= writer
1609 && (! only_writes
|| list
->writer
))
1611 warned_ids
= new_tlist (warned_ids
, written
, NULL_TREE
);
1612 warning ("operation on `%s' may be undefined",
1613 IDENTIFIER_POINTER (DECL_NAME (list
->expr
)));
1619 /* Given a list LIST of references to variables, find whether any of these
1620 can cause conflicts due to missing sequence points. */
1623 warn_for_collisions (list
)
1628 for (tmp
= list
; tmp
; tmp
= tmp
->next
)
1631 warn_for_collisions_1 (tmp
->expr
, tmp
->writer
, list
, 0);
1635 /* Return nonzero if X is a tree that can be verified by the sequence point
1638 warning_candidate_p (x
)
1641 return TREE_CODE (x
) == VAR_DECL
|| TREE_CODE (x
) == PARM_DECL
;
1644 /* Walk the tree X, and record accesses to variables. If X is written by the
1645 parent tree, WRITER is the parent.
1646 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
1647 expression or its only operand forces a sequence point, then everything up
1648 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
1650 Once we return, we will have emitted warnings if any subexpression before
1651 such a sequence point could be undefined. On a higher level, however, the
1652 sequence point may not be relevant, and we'll merge the two lists.
1654 Example: (b++, a) + b;
1655 The call that processes the COMPOUND_EXPR will store the increment of B
1656 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
1657 processes the PLUS_EXPR will need to merge the two lists so that
1658 eventually, all accesses end up on the same list (and we'll warn about the
1659 unordered subexpressions b++ and b.
1661 A note on merging. If we modify the former example so that our expression
1664 care must be taken not simply to add all three expressions into the final
1665 PNO_SP list. The function merge_tlist takes care of that by merging the
1666 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1667 way, so that no more than one access to B is recorded. */
1670 verify_tree (x
, pbefore_sp
, pno_sp
, writer
)
1672 struct tlist
**pbefore_sp
, **pno_sp
;
1675 struct tlist
*tmp_before
, *tmp_nosp
, *tmp_list2
, *tmp_list3
;
1676 enum tree_code code
;
1679 /* X may be NULL if it is the operand of an empty statement expression
1685 code
= TREE_CODE (x
);
1686 class = TREE_CODE_CLASS (code
);
1688 if (warning_candidate_p (x
))
1690 *pno_sp
= new_tlist (*pno_sp
, x
, writer
);
1700 case TRUTH_ANDIF_EXPR
:
1701 case TRUTH_ORIF_EXPR
:
1702 tmp_before
= tmp_nosp
= tmp_list3
= 0;
1703 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1704 warn_for_collisions (tmp_nosp
);
1705 merge_tlist (pbefore_sp
, tmp_before
, 0);
1706 merge_tlist (pbefore_sp
, tmp_nosp
, 0);
1707 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, pno_sp
, NULL_TREE
);
1708 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1712 tmp_before
= tmp_list2
= 0;
1713 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_list2
, NULL_TREE
);
1714 warn_for_collisions (tmp_list2
);
1715 merge_tlist (pbefore_sp
, tmp_before
, 0);
1716 merge_tlist (pbefore_sp
, tmp_list2
, 1);
1718 tmp_list3
= tmp_nosp
= 0;
1719 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, &tmp_nosp
, NULL_TREE
);
1720 warn_for_collisions (tmp_nosp
);
1721 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1723 tmp_list3
= tmp_list2
= 0;
1724 verify_tree (TREE_OPERAND (x
, 2), &tmp_list3
, &tmp_list2
, NULL_TREE
);
1725 warn_for_collisions (tmp_list2
);
1726 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1727 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1728 two first, to avoid warning for (a ? b++ : b++). */
1729 merge_tlist (&tmp_nosp
, tmp_list2
, 0);
1730 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1733 case PREDECREMENT_EXPR
:
1734 case PREINCREMENT_EXPR
:
1735 case POSTDECREMENT_EXPR
:
1736 case POSTINCREMENT_EXPR
:
1737 verify_tree (TREE_OPERAND (x
, 0), pno_sp
, pno_sp
, x
);
1741 tmp_before
= tmp_nosp
= tmp_list3
= 0;
1742 verify_tree (TREE_OPERAND (x
, 1), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1743 verify_tree (TREE_OPERAND (x
, 0), &tmp_list3
, &tmp_list3
, x
);
1744 /* Expressions inside the LHS are not ordered wrt. the sequence points
1745 in the RHS. Example:
1747 Despite the fact that the modification of "a" is in the before_sp
1748 list (tmp_before), it conflicts with the use of "a" in the LHS.
1749 We can handle this by adding the contents of tmp_list3
1750 to those of tmp_before, and redoing the collision warnings for that
1752 add_tlist (&tmp_before
, tmp_list3
, x
, 1);
1753 warn_for_collisions (tmp_before
);
1754 /* Exclude the LHS itself here; we first have to merge it into the
1755 tmp_nosp list. This is done to avoid warning for "a = a"; if we
1756 didn't exclude the LHS, we'd get it twice, once as a read and once
1758 add_tlist (pno_sp
, tmp_list3
, x
, 0);
1759 warn_for_collisions_1 (TREE_OPERAND (x
, 0), x
, tmp_nosp
, 1);
1761 merge_tlist (pbefore_sp
, tmp_before
, 0);
1762 if (warning_candidate_p (TREE_OPERAND (x
, 0)))
1763 merge_tlist (&tmp_nosp
, new_tlist (NULL
, TREE_OPERAND (x
, 0), x
), 0);
1764 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 1);
1768 /* We need to warn about conflicts among arguments and conflicts between
1769 args and the function address. Side effects of the function address,
1770 however, are not ordered by the sequence point of the call. */
1771 tmp_before
= tmp_nosp
= tmp_list2
= tmp_list3
= 0;
1772 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1773 if (TREE_OPERAND (x
, 1))
1774 verify_tree (TREE_OPERAND (x
, 1), &tmp_list2
, &tmp_list3
, NULL_TREE
);
1775 merge_tlist (&tmp_list3
, tmp_list2
, 0);
1776 add_tlist (&tmp_before
, tmp_list3
, NULL_TREE
, 0);
1777 add_tlist (&tmp_before
, tmp_nosp
, NULL_TREE
, 0);
1778 warn_for_collisions (tmp_before
);
1779 add_tlist (pbefore_sp
, tmp_before
, NULL_TREE
, 0);
1783 /* Scan all the list, e.g. indices of multi dimensional array. */
1786 tmp_before
= tmp_nosp
= 0;
1787 verify_tree (TREE_VALUE (x
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1788 merge_tlist (&tmp_nosp
, tmp_before
, 0);
1789 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1796 struct tlist_cache
*t
;
1797 for (t
= save_expr_cache
; t
; t
= t
->next
)
1803 t
= (struct tlist_cache
*) obstack_alloc (&tlist_obstack
,
1805 t
->next
= save_expr_cache
;
1807 save_expr_cache
= t
;
1809 tmp_before
= tmp_nosp
= 0;
1810 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1811 warn_for_collisions (tmp_nosp
);
1816 struct tlist
*t
= tmp_nosp
;
1818 merge_tlist (&tmp_list3
, t
, 0);
1820 t
->cache_before_sp
= tmp_before
;
1821 t
->cache_after_sp
= tmp_list3
;
1823 merge_tlist (pbefore_sp
, t
->cache_before_sp
, 1);
1824 add_tlist (pno_sp
, t
->cache_after_sp
, NULL_TREE
, 1);
1833 if (first_rtl_op (code
) == 0)
1835 x
= TREE_OPERAND (x
, 0);
1851 int max
= first_rtl_op (TREE_CODE (x
));
1852 for (lp
= 0; lp
< max
; lp
++)
1854 tmp_before
= tmp_nosp
= 0;
1855 verify_tree (TREE_OPERAND (x
, lp
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1856 merge_tlist (&tmp_nosp
, tmp_before
, 0);
1857 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1864 /* Try to warn for undefined behavior in EXPR due to missing sequence
1868 verify_sequence_points (expr
)
1871 struct tlist
*before_sp
= 0, *after_sp
= 0;
1874 save_expr_cache
= 0;
1875 if (tlist_firstobj
== 0)
1877 gcc_obstack_init (&tlist_obstack
);
1878 tlist_firstobj
= obstack_alloc (&tlist_obstack
, 0);
1881 verify_tree (expr
, &before_sp
, &after_sp
, 0);
1882 warn_for_collisions (after_sp
);
1883 obstack_free (&tlist_obstack
, tlist_firstobj
);
1887 c_expand_expr_stmt (expr
)
1890 /* Do default conversion if safe and possibly important,
1891 in case within ({...}). */
1892 if ((TREE_CODE (TREE_TYPE (expr
)) == ARRAY_TYPE
1893 && (flag_isoc99
|| lvalue_p (expr
)))
1894 || TREE_CODE (TREE_TYPE (expr
)) == FUNCTION_TYPE
)
1895 expr
= default_conversion (expr
);
1897 if (warn_sequence_point
)
1898 verify_sequence_points (expr
);
1900 if (TREE_TYPE (expr
) != error_mark_node
1901 && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr
))
1902 && TREE_CODE (TREE_TYPE (expr
)) != ARRAY_TYPE
)
1903 error ("expression statement has incomplete type");
1905 last_expr_type
= TREE_TYPE (expr
);
1906 return add_stmt (build_stmt (EXPR_STMT
, expr
));
1909 /* Validate the expression after `case' and apply default promotions. */
1912 check_case_value (value
)
1915 if (value
== NULL_TREE
)
1918 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
1919 STRIP_TYPE_NOPS (value
);
1920 /* In C++, the following is allowed:
1923 switch (...) { case i: ... }
1925 So, we try to reduce the VALUE to a constant that way. */
1926 if (c_language
== clk_cplusplus
)
1928 value
= decl_constant_value (value
);
1929 STRIP_TYPE_NOPS (value
);
1930 value
= fold (value
);
1933 if (TREE_CODE (value
) != INTEGER_CST
1934 && value
!= error_mark_node
)
1936 error ("case label does not reduce to an integer constant");
1937 value
= error_mark_node
;
1940 /* Promote char or short to int. */
1941 value
= default_conversion (value
);
1943 constant_expression_warning (value
);
1948 /* Return an integer type with BITS bits of precision,
1949 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1952 c_common_type_for_size (bits
, unsignedp
)
1956 if (bits
== TYPE_PRECISION (integer_type_node
))
1957 return unsignedp
? unsigned_type_node
: integer_type_node
;
1959 if (bits
== TYPE_PRECISION (signed_char_type_node
))
1960 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1962 if (bits
== TYPE_PRECISION (short_integer_type_node
))
1963 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1965 if (bits
== TYPE_PRECISION (long_integer_type_node
))
1966 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1968 if (bits
== TYPE_PRECISION (long_long_integer_type_node
))
1969 return (unsignedp
? long_long_unsigned_type_node
1970 : long_long_integer_type_node
);
1972 if (bits
== TYPE_PRECISION (widest_integer_literal_type_node
))
1973 return (unsignedp
? widest_unsigned_literal_type_node
1974 : widest_integer_literal_type_node
);
1976 if (bits
<= TYPE_PRECISION (intQI_type_node
))
1977 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
1979 if (bits
<= TYPE_PRECISION (intHI_type_node
))
1980 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
1982 if (bits
<= TYPE_PRECISION (intSI_type_node
))
1983 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
1985 if (bits
<= TYPE_PRECISION (intDI_type_node
))
1986 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
1991 /* Return a data type that has machine mode MODE.
1992 If the mode is an integer,
1993 then UNSIGNEDP selects between signed and unsigned types. */
1996 c_common_type_for_mode (mode
, unsignedp
)
1997 enum machine_mode mode
;
2000 if (mode
== TYPE_MODE (integer_type_node
))
2001 return unsignedp
? unsigned_type_node
: integer_type_node
;
2003 if (mode
== TYPE_MODE (signed_char_type_node
))
2004 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2006 if (mode
== TYPE_MODE (short_integer_type_node
))
2007 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2009 if (mode
== TYPE_MODE (long_integer_type_node
))
2010 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2012 if (mode
== TYPE_MODE (long_long_integer_type_node
))
2013 return unsignedp
? long_long_unsigned_type_node
: long_long_integer_type_node
;
2015 if (mode
== TYPE_MODE (widest_integer_literal_type_node
))
2016 return unsignedp
? widest_unsigned_literal_type_node
2017 : widest_integer_literal_type_node
;
2020 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2023 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2026 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2029 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2031 #if HOST_BITS_PER_WIDE_INT >= 64
2032 if (mode
== TYPE_MODE (intTI_type_node
))
2033 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2036 if (mode
== TYPE_MODE (float_type_node
))
2037 return float_type_node
;
2039 if (mode
== TYPE_MODE (double_type_node
))
2040 return double_type_node
;
2042 if (mode
== TYPE_MODE (long_double_type_node
))
2043 return long_double_type_node
;
2045 if (mode
== TYPE_MODE (build_pointer_type (char_type_node
)))
2046 return build_pointer_type (char_type_node
);
2048 if (mode
== TYPE_MODE (build_pointer_type (integer_type_node
)))
2049 return build_pointer_type (integer_type_node
);
2054 return unsignedp
? unsigned_V16QI_type_node
: V16QI_type_node
;
2056 return unsignedp
? unsigned_V8HI_type_node
: V8HI_type_node
;
2058 return unsignedp
? unsigned_V4SI_type_node
: V4SI_type_node
;
2060 return unsignedp
? unsigned_V2DI_type_node
: V2DI_type_node
;
2062 return unsignedp
? unsigned_V2SI_type_node
: V2SI_type_node
;
2064 return unsignedp
? unsigned_V2HI_type_node
: V2HI_type_node
;
2066 return unsignedp
? unsigned_V4HI_type_node
: V4HI_type_node
;
2068 return unsignedp
? unsigned_V8QI_type_node
: V8QI_type_node
;
2070 return unsignedp
? unsigned_V1DI_type_node
: V1DI_type_node
;
2072 return V16SF_type_node
;
2074 return V4SF_type_node
;
2076 return V2SF_type_node
;
2078 return V2DF_type_node
;
2086 /* Return an unsigned type the same as TYPE in other respects. */
2088 c_common_unsigned_type (type
)
2091 tree type1
= TYPE_MAIN_VARIANT (type
);
2092 if (type1
== signed_char_type_node
|| type1
== char_type_node
)
2093 return unsigned_char_type_node
;
2094 if (type1
== integer_type_node
)
2095 return unsigned_type_node
;
2096 if (type1
== short_integer_type_node
)
2097 return short_unsigned_type_node
;
2098 if (type1
== long_integer_type_node
)
2099 return long_unsigned_type_node
;
2100 if (type1
== long_long_integer_type_node
)
2101 return long_long_unsigned_type_node
;
2102 if (type1
== widest_integer_literal_type_node
)
2103 return widest_unsigned_literal_type_node
;
2104 #if HOST_BITS_PER_WIDE_INT >= 64
2105 if (type1
== intTI_type_node
)
2106 return unsigned_intTI_type_node
;
2108 if (type1
== intDI_type_node
)
2109 return unsigned_intDI_type_node
;
2110 if (type1
== intSI_type_node
)
2111 return unsigned_intSI_type_node
;
2112 if (type1
== intHI_type_node
)
2113 return unsigned_intHI_type_node
;
2114 if (type1
== intQI_type_node
)
2115 return unsigned_intQI_type_node
;
2117 return c_common_signed_or_unsigned_type (1, type
);
2120 /* Return a signed type the same as TYPE in other respects. */
2123 c_common_signed_type (type
)
2126 tree type1
= TYPE_MAIN_VARIANT (type
);
2127 if (type1
== unsigned_char_type_node
|| type1
== char_type_node
)
2128 return signed_char_type_node
;
2129 if (type1
== unsigned_type_node
)
2130 return integer_type_node
;
2131 if (type1
== short_unsigned_type_node
)
2132 return short_integer_type_node
;
2133 if (type1
== long_unsigned_type_node
)
2134 return long_integer_type_node
;
2135 if (type1
== long_long_unsigned_type_node
)
2136 return long_long_integer_type_node
;
2137 if (type1
== widest_unsigned_literal_type_node
)
2138 return widest_integer_literal_type_node
;
2139 #if HOST_BITS_PER_WIDE_INT >= 64
2140 if (type1
== unsigned_intTI_type_node
)
2141 return intTI_type_node
;
2143 if (type1
== unsigned_intDI_type_node
)
2144 return intDI_type_node
;
2145 if (type1
== unsigned_intSI_type_node
)
2146 return intSI_type_node
;
2147 if (type1
== unsigned_intHI_type_node
)
2148 return intHI_type_node
;
2149 if (type1
== unsigned_intQI_type_node
)
2150 return intQI_type_node
;
2152 return c_common_signed_or_unsigned_type (0, type
);
2155 /* Return a type the same as TYPE except unsigned or
2156 signed according to UNSIGNEDP. */
2159 c_common_signed_or_unsigned_type (unsignedp
, type
)
2163 if (! INTEGRAL_TYPE_P (type
)
2164 || TREE_UNSIGNED (type
) == unsignedp
)
2167 if (TYPE_PRECISION (type
) == TYPE_PRECISION (signed_char_type_node
))
2168 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2169 if (TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
))
2170 return unsignedp
? unsigned_type_node
: integer_type_node
;
2171 if (TYPE_PRECISION (type
) == TYPE_PRECISION (short_integer_type_node
))
2172 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2173 if (TYPE_PRECISION (type
) == TYPE_PRECISION (long_integer_type_node
))
2174 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2175 if (TYPE_PRECISION (type
) == TYPE_PRECISION (long_long_integer_type_node
))
2176 return (unsignedp
? long_long_unsigned_type_node
2177 : long_long_integer_type_node
);
2178 if (TYPE_PRECISION (type
) == TYPE_PRECISION (widest_integer_literal_type_node
))
2179 return (unsignedp
? widest_unsigned_literal_type_node
2180 : widest_integer_literal_type_node
);
2182 #if HOST_BITS_PER_WIDE_INT >= 64
2183 if (TYPE_PRECISION (type
) == TYPE_PRECISION (intTI_type_node
))
2184 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2186 if (TYPE_PRECISION (type
) == TYPE_PRECISION (intDI_type_node
))
2187 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2188 if (TYPE_PRECISION (type
) == TYPE_PRECISION (intSI_type_node
))
2189 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2190 if (TYPE_PRECISION (type
) == TYPE_PRECISION (intHI_type_node
))
2191 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2192 if (TYPE_PRECISION (type
) == TYPE_PRECISION (intQI_type_node
))
2193 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2198 /* Return the minimum number of bits needed to represent VALUE in a
2199 signed or unsigned type, UNSIGNEDP says which. */
2202 min_precision (value
, unsignedp
)
2208 /* If the value is negative, compute its negative minus 1. The latter
2209 adjustment is because the absolute value of the largest negative value
2210 is one larger than the largest positive value. This is equivalent to
2211 a bit-wise negation, so use that operation instead. */
2213 if (tree_int_cst_sgn (value
) < 0)
2214 value
= fold (build1 (BIT_NOT_EXPR
, TREE_TYPE (value
), value
));
2216 /* Return the number of bits needed, taking into account the fact
2217 that we need one more bit for a signed than unsigned type. */
2219 if (integer_zerop (value
))
2222 log
= tree_floor_log2 (value
);
2224 return log
+ 1 + ! unsignedp
;
2227 /* Print an error message for invalid operands to arith operation
2228 CODE. NOP_EXPR is used as a special case (see
2229 c_common_truthvalue_conversion). */
2232 binary_op_error (code
)
2233 enum tree_code code
;
2240 error ("invalid truth-value expression");
2244 opname
= "+"; break;
2246 opname
= "-"; break;
2248 opname
= "*"; break;
2250 opname
= "max"; break;
2252 opname
= "min"; break;
2254 opname
= "=="; break;
2256 opname
= "!="; break;
2258 opname
= "<="; break;
2260 opname
= ">="; break;
2262 opname
= "<"; break;
2264 opname
= ">"; break;
2266 opname
= "<<"; break;
2268 opname
= ">>"; break;
2269 case TRUNC_MOD_EXPR
:
2270 case FLOOR_MOD_EXPR
:
2271 opname
= "%"; break;
2272 case TRUNC_DIV_EXPR
:
2273 case FLOOR_DIV_EXPR
:
2274 opname
= "/"; break;
2276 opname
= "&"; break;
2278 opname
= "|"; break;
2279 case TRUTH_ANDIF_EXPR
:
2280 opname
= "&&"; break;
2281 case TRUTH_ORIF_EXPR
:
2282 opname
= "||"; break;
2284 opname
= "^"; break;
2287 opname
= "rotate"; break;
2289 opname
= "unknown"; break;
2291 error ("invalid operands to binary %s", opname
);
2294 /* Subroutine of build_binary_op, used for comparison operations.
2295 See if the operands have both been converted from subword integer types
2296 and, if so, perhaps change them both back to their original type.
2297 This function is also responsible for converting the two operands
2298 to the proper common type for comparison.
2300 The arguments of this function are all pointers to local variables
2301 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2302 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2304 If this function returns nonzero, it means that the comparison has
2305 a constant value. What this function returns is an expression for
2309 shorten_compare (op0_ptr
, op1_ptr
, restype_ptr
, rescode_ptr
)
2310 tree
*op0_ptr
, *op1_ptr
;
2312 enum tree_code
*rescode_ptr
;
2315 tree op0
= *op0_ptr
;
2316 tree op1
= *op1_ptr
;
2317 int unsignedp0
, unsignedp1
;
2319 tree primop0
, primop1
;
2320 enum tree_code code
= *rescode_ptr
;
2322 /* Throw away any conversions to wider types
2323 already present in the operands. */
2325 primop0
= get_narrower (op0
, &unsignedp0
);
2326 primop1
= get_narrower (op1
, &unsignedp1
);
2328 /* Handle the case that OP0 does not *contain* a conversion
2329 but it *requires* conversion to FINAL_TYPE. */
2331 if (op0
== primop0
&& TREE_TYPE (op0
) != *restype_ptr
)
2332 unsignedp0
= TREE_UNSIGNED (TREE_TYPE (op0
));
2333 if (op1
== primop1
&& TREE_TYPE (op1
) != *restype_ptr
)
2334 unsignedp1
= TREE_UNSIGNED (TREE_TYPE (op1
));
2336 /* If one of the operands must be floated, we cannot optimize. */
2337 real1
= TREE_CODE (TREE_TYPE (primop0
)) == REAL_TYPE
;
2338 real2
= TREE_CODE (TREE_TYPE (primop1
)) == REAL_TYPE
;
2340 /* If first arg is constant, swap the args (changing operation
2341 so value is preserved), for canonicalization. Don't do this if
2342 the second arg is 0. */
2344 if (TREE_CONSTANT (primop0
)
2345 && ! integer_zerop (primop1
) && ! real_zerop (primop1
))
2348 int temi
= unsignedp0
;
2356 unsignedp0
= unsignedp1
;
2379 *rescode_ptr
= code
;
2382 /* If comparing an integer against a constant more bits wide,
2383 maybe we can deduce a value of 1 or 0 independent of the data.
2384 Or else truncate the constant now
2385 rather than extend the variable at run time.
2387 This is only interesting if the constant is the wider arg.
2388 Also, it is not safe if the constant is unsigned and the
2389 variable arg is signed, since in this case the variable
2390 would be sign-extended and then regarded as unsigned.
2391 Our technique fails in this case because the lowest/highest
2392 possible unsigned results don't follow naturally from the
2393 lowest/highest possible values of the variable operand.
2394 For just EQ_EXPR and NE_EXPR there is another technique that
2395 could be used: see if the constant can be faithfully represented
2396 in the other operand's type, by truncating it and reextending it
2397 and see if that preserves the constant's value. */
2399 if (!real1
&& !real2
2400 && TREE_CODE (primop1
) == INTEGER_CST
2401 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
))
2403 int min_gt
, max_gt
, min_lt
, max_lt
;
2404 tree maxval
, minval
;
2405 /* 1 if comparison is nominally unsigned. */
2406 int unsignedp
= TREE_UNSIGNED (*restype_ptr
);
2409 type
= c_common_signed_or_unsigned_type (unsignedp0
,
2410 TREE_TYPE (primop0
));
2412 /* If TYPE is an enumeration, then we need to get its min/max
2413 values from it's underlying integral type, not the enumerated
2415 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
2416 type
= c_common_type_for_size (TYPE_PRECISION (type
), unsignedp0
);
2418 maxval
= TYPE_MAX_VALUE (type
);
2419 minval
= TYPE_MIN_VALUE (type
);
2421 if (unsignedp
&& !unsignedp0
)
2422 *restype_ptr
= c_common_signed_type (*restype_ptr
);
2424 if (TREE_TYPE (primop1
) != *restype_ptr
)
2425 primop1
= convert (*restype_ptr
, primop1
);
2426 if (type
!= *restype_ptr
)
2428 minval
= convert (*restype_ptr
, minval
);
2429 maxval
= convert (*restype_ptr
, maxval
);
2432 if (unsignedp
&& unsignedp0
)
2434 min_gt
= INT_CST_LT_UNSIGNED (primop1
, minval
);
2435 max_gt
= INT_CST_LT_UNSIGNED (primop1
, maxval
);
2436 min_lt
= INT_CST_LT_UNSIGNED (minval
, primop1
);
2437 max_lt
= INT_CST_LT_UNSIGNED (maxval
, primop1
);
2441 min_gt
= INT_CST_LT (primop1
, minval
);
2442 max_gt
= INT_CST_LT (primop1
, maxval
);
2443 min_lt
= INT_CST_LT (minval
, primop1
);
2444 max_lt
= INT_CST_LT (maxval
, primop1
);
2448 /* This used to be a switch, but Genix compiler can't handle that. */
2449 if (code
== NE_EXPR
)
2451 if (max_lt
|| min_gt
)
2452 val
= boolean_true_node
;
2454 else if (code
== EQ_EXPR
)
2456 if (max_lt
|| min_gt
)
2457 val
= boolean_false_node
;
2459 else if (code
== LT_EXPR
)
2462 val
= boolean_true_node
;
2464 val
= boolean_false_node
;
2466 else if (code
== GT_EXPR
)
2469 val
= boolean_true_node
;
2471 val
= boolean_false_node
;
2473 else if (code
== LE_EXPR
)
2476 val
= boolean_true_node
;
2478 val
= boolean_false_node
;
2480 else if (code
== GE_EXPR
)
2483 val
= boolean_true_node
;
2485 val
= boolean_false_node
;
2488 /* If primop0 was sign-extended and unsigned comparison specd,
2489 we did a signed comparison above using the signed type bounds.
2490 But the comparison we output must be unsigned.
2492 Also, for inequalities, VAL is no good; but if the signed
2493 comparison had *any* fixed result, it follows that the
2494 unsigned comparison just tests the sign in reverse
2495 (positive values are LE, negative ones GE).
2496 So we can generate an unsigned comparison
2497 against an extreme value of the signed type. */
2499 if (unsignedp
&& !unsignedp0
)
2506 primop1
= TYPE_MIN_VALUE (type
);
2512 primop1
= TYPE_MAX_VALUE (type
);
2519 type
= c_common_unsigned_type (type
);
2522 if (TREE_CODE (primop0
) != INTEGER_CST
)
2524 if (val
== boolean_false_node
)
2525 warning ("comparison is always false due to limited range of data type");
2526 if (val
== boolean_true_node
)
2527 warning ("comparison is always true due to limited range of data type");
2532 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2533 if (TREE_SIDE_EFFECTS (primop0
))
2534 return build (COMPOUND_EXPR
, TREE_TYPE (val
), primop0
, val
);
2538 /* Value is not predetermined, but do the comparison
2539 in the type of the operand that is not constant.
2540 TYPE is already properly set. */
2542 else if (real1
&& real2
2543 && (TYPE_PRECISION (TREE_TYPE (primop0
))
2544 == TYPE_PRECISION (TREE_TYPE (primop1
))))
2545 type
= TREE_TYPE (primop0
);
2547 /* If args' natural types are both narrower than nominal type
2548 and both extend in the same manner, compare them
2549 in the type of the wider arg.
2550 Otherwise must actually extend both to the nominal
2551 common type lest different ways of extending
2553 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
2555 else if (unsignedp0
== unsignedp1
&& real1
== real2
2556 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
)
2557 && TYPE_PRECISION (TREE_TYPE (primop1
)) < TYPE_PRECISION (*restype_ptr
))
2559 type
= common_type (TREE_TYPE (primop0
), TREE_TYPE (primop1
));
2560 type
= c_common_signed_or_unsigned_type (unsignedp0
2561 || TREE_UNSIGNED (*restype_ptr
),
2563 /* Make sure shorter operand is extended the right way
2564 to match the longer operand. */
2566 = convert (c_common_signed_or_unsigned_type (unsignedp0
,
2567 TREE_TYPE (primop0
)),
2570 = convert (c_common_signed_or_unsigned_type (unsignedp1
,
2571 TREE_TYPE (primop1
)),
2576 /* Here we must do the comparison on the nominal type
2577 using the args exactly as we received them. */
2578 type
= *restype_ptr
;
2582 if (!real1
&& !real2
&& integer_zerop (primop1
)
2583 && TREE_UNSIGNED (*restype_ptr
))
2589 /* All unsigned values are >= 0, so we warn if extra warnings
2590 are requested. However, if OP0 is a constant that is
2591 >= 0, the signedness of the comparison isn't an issue,
2592 so suppress the warning. */
2593 if (extra_warnings
&& !in_system_header
2594 && ! (TREE_CODE (primop0
) == INTEGER_CST
2595 && ! TREE_OVERFLOW (convert (c_common_signed_type (type
),
2597 warning ("comparison of unsigned expression >= 0 is always true");
2598 value
= boolean_true_node
;
2602 if (extra_warnings
&& !in_system_header
2603 && ! (TREE_CODE (primop0
) == INTEGER_CST
2604 && ! TREE_OVERFLOW (convert (c_common_signed_type (type
),
2606 warning ("comparison of unsigned expression < 0 is always false");
2607 value
= boolean_false_node
;
2616 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2617 if (TREE_SIDE_EFFECTS (primop0
))
2618 return build (COMPOUND_EXPR
, TREE_TYPE (value
),
2625 *op0_ptr
= convert (type
, primop0
);
2626 *op1_ptr
= convert (type
, primop1
);
2628 *restype_ptr
= boolean_type_node
;
2633 /* Return a tree for the sum or difference (RESULTCODE says which)
2634 of pointer PTROP and integer INTOP. */
2637 pointer_int_sum (resultcode
, ptrop
, intop
)
2638 enum tree_code resultcode
;
2646 /* The result is a pointer of the same type that is being added. */
2648 tree result_type
= TREE_TYPE (ptrop
);
2650 if (TREE_CODE (TREE_TYPE (result_type
)) == VOID_TYPE
)
2652 if (pedantic
|| warn_pointer_arith
)
2653 pedwarn ("pointer of type `void *' used in arithmetic");
2654 size_exp
= integer_one_node
;
2656 else if (TREE_CODE (TREE_TYPE (result_type
)) == FUNCTION_TYPE
)
2658 if (pedantic
|| warn_pointer_arith
)
2659 pedwarn ("pointer to a function used in arithmetic");
2660 size_exp
= integer_one_node
;
2662 else if (TREE_CODE (TREE_TYPE (result_type
)) == METHOD_TYPE
)
2664 if (pedantic
|| warn_pointer_arith
)
2665 pedwarn ("pointer to member function used in arithmetic");
2666 size_exp
= integer_one_node
;
2668 else if (TREE_CODE (TREE_TYPE (result_type
)) == OFFSET_TYPE
)
2670 if (pedantic
|| warn_pointer_arith
)
2671 pedwarn ("pointer to a member used in arithmetic");
2672 size_exp
= integer_one_node
;
2675 size_exp
= size_in_bytes (TREE_TYPE (result_type
));
2677 /* If what we are about to multiply by the size of the elements
2678 contains a constant term, apply distributive law
2679 and multiply that constant term separately.
2680 This helps produce common subexpressions. */
2682 if ((TREE_CODE (intop
) == PLUS_EXPR
|| TREE_CODE (intop
) == MINUS_EXPR
)
2683 && ! TREE_CONSTANT (intop
)
2684 && TREE_CONSTANT (TREE_OPERAND (intop
, 1))
2685 && TREE_CONSTANT (size_exp
)
2686 /* If the constant comes from pointer subtraction,
2687 skip this optimization--it would cause an error. */
2688 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop
, 0))) == INTEGER_TYPE
2689 /* If the constant is unsigned, and smaller than the pointer size,
2690 then we must skip this optimization. This is because it could cause
2691 an overflow error if the constant is negative but INTOP is not. */
2692 && (! TREE_UNSIGNED (TREE_TYPE (intop
))
2693 || (TYPE_PRECISION (TREE_TYPE (intop
))
2694 == TYPE_PRECISION (TREE_TYPE (ptrop
)))))
2696 enum tree_code subcode
= resultcode
;
2697 tree int_type
= TREE_TYPE (intop
);
2698 if (TREE_CODE (intop
) == MINUS_EXPR
)
2699 subcode
= (subcode
== PLUS_EXPR
? MINUS_EXPR
: PLUS_EXPR
);
2700 /* Convert both subexpression types to the type of intop,
2701 because weird cases involving pointer arithmetic
2702 can result in a sum or difference with different type args. */
2703 ptrop
= build_binary_op (subcode
, ptrop
,
2704 convert (int_type
, TREE_OPERAND (intop
, 1)), 1);
2705 intop
= convert (int_type
, TREE_OPERAND (intop
, 0));
2708 /* Convert the integer argument to a type the same size as sizetype
2709 so the multiply won't overflow spuriously. */
2711 if (TYPE_PRECISION (TREE_TYPE (intop
)) != TYPE_PRECISION (sizetype
)
2712 || TREE_UNSIGNED (TREE_TYPE (intop
)) != TREE_UNSIGNED (sizetype
))
2713 intop
= convert (c_common_type_for_size (TYPE_PRECISION (sizetype
),
2714 TREE_UNSIGNED (sizetype
)), intop
);
2716 /* Replace the integer argument with a suitable product by the object size.
2717 Do this multiplication as signed, then convert to the appropriate
2718 pointer type (actually unsigned integral). */
2720 intop
= convert (result_type
,
2721 build_binary_op (MULT_EXPR
, intop
,
2722 convert (TREE_TYPE (intop
), size_exp
), 1));
2724 /* Create the sum or difference. */
2726 result
= build (resultcode
, result_type
, ptrop
, intop
);
2728 folded
= fold (result
);
2729 if (folded
== result
)
2730 TREE_CONSTANT (folded
) = TREE_CONSTANT (ptrop
) & TREE_CONSTANT (intop
);
2734 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2735 or validate its data type for an `if' or `while' statement or ?..: exp.
2737 This preparation consists of taking the ordinary
2738 representation of an expression expr and producing a valid tree
2739 boolean expression describing whether expr is nonzero. We could
2740 simply always do build_binary_op (NE_EXPR, expr, boolean_false_node, 1),
2741 but we optimize comparisons, &&, ||, and !.
2743 The resulting type should always be `boolean_type_node'. */
2746 c_common_truthvalue_conversion (expr
)
2749 if (TREE_CODE (expr
) == ERROR_MARK
)
2752 #if 0 /* This appears to be wrong for C++. */
2753 /* These really should return error_mark_node after 2.4 is stable.
2754 But not all callers handle ERROR_MARK properly. */
2755 switch (TREE_CODE (TREE_TYPE (expr
)))
2758 error ("struct type value used where scalar is required");
2759 return boolean_false_node
;
2762 error ("union type value used where scalar is required");
2763 return boolean_false_node
;
2766 error ("array type value used where scalar is required");
2767 return boolean_false_node
;
2774 switch (TREE_CODE (expr
))
2777 case NE_EXPR
: case LE_EXPR
: case GE_EXPR
: case LT_EXPR
: case GT_EXPR
:
2778 case TRUTH_ANDIF_EXPR
:
2779 case TRUTH_ORIF_EXPR
:
2780 case TRUTH_AND_EXPR
:
2782 case TRUTH_XOR_EXPR
:
2783 case TRUTH_NOT_EXPR
:
2784 TREE_TYPE (expr
) = boolean_type_node
;
2791 return integer_zerop (expr
) ? boolean_false_node
: boolean_true_node
;
2794 return real_zerop (expr
) ? boolean_false_node
: boolean_true_node
;
2797 /* If we are taking the address of an external decl, it might be zero
2798 if it is weak, so we cannot optimize. */
2799 if (DECL_P (TREE_OPERAND (expr
, 0))
2800 && DECL_EXTERNAL (TREE_OPERAND (expr
, 0)))
2803 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 0)))
2804 return build (COMPOUND_EXPR
, boolean_type_node
,
2805 TREE_OPERAND (expr
, 0), boolean_true_node
);
2807 return boolean_true_node
;
2810 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1))
2811 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
2812 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0)),
2813 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 1)),
2821 /* These don't change whether an object is nonzero or zero. */
2822 return c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0));
2826 /* These don't change whether an object is zero or nonzero, but
2827 we can't ignore them if their second arg has side-effects. */
2828 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1)))
2829 return build (COMPOUND_EXPR
, boolean_type_node
, TREE_OPERAND (expr
, 1),
2830 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0)));
2832 return c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0));
2835 /* Distribute the conversion into the arms of a COND_EXPR. */
2836 return fold (build (COND_EXPR
, boolean_type_node
, TREE_OPERAND (expr
, 0),
2837 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 1)),
2838 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 2))));
2841 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2842 since that affects how `default_conversion' will behave. */
2843 if (TREE_CODE (TREE_TYPE (expr
)) == REFERENCE_TYPE
2844 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == REFERENCE_TYPE
)
2846 /* fall through... */
2848 /* If this is widening the argument, we can ignore it. */
2849 if (TYPE_PRECISION (TREE_TYPE (expr
))
2850 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr
, 0))))
2851 return c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0));
2855 /* Perhaps reduce (x - y) != 0 to (x != y). The expressions
2856 aren't guaranteed to the be same for modes that can represent
2857 infinity, since if x and y are both +infinity, or both
2858 -infinity, then x - y is not a number.
2860 Note that this transformation is safe when x or y is NaN.
2861 (x - y) is then NaN, and both (x - y) != 0 and x != y will
2863 if (HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr
, 0)))))
2865 /* fall through... */
2867 /* This and MINUS_EXPR can be changed into a comparison of the
2869 if (TREE_TYPE (TREE_OPERAND (expr
, 0))
2870 == TREE_TYPE (TREE_OPERAND (expr
, 1)))
2871 return build_binary_op (NE_EXPR
, TREE_OPERAND (expr
, 0),
2872 TREE_OPERAND (expr
, 1), 1);
2873 return build_binary_op (NE_EXPR
, TREE_OPERAND (expr
, 0),
2874 fold (build1 (NOP_EXPR
,
2875 TREE_TYPE (TREE_OPERAND (expr
, 0)),
2876 TREE_OPERAND (expr
, 1))), 1);
2879 if (integer_onep (TREE_OPERAND (expr
, 1))
2880 && TREE_TYPE (expr
) != boolean_type_node
)
2881 /* Using convert here would cause infinite recursion. */
2882 return build1 (NOP_EXPR
, boolean_type_node
, expr
);
2886 if (warn_parentheses
&& C_EXP_ORIGINAL_CODE (expr
) == MODIFY_EXPR
)
2887 warning ("suggest parentheses around assignment used as truth value");
2894 if (TREE_CODE (TREE_TYPE (expr
)) == COMPLEX_TYPE
)
2896 tree t
= save_expr (expr
);
2897 return (build_binary_op
2898 ((TREE_SIDE_EFFECTS (expr
)
2899 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
2900 c_common_truthvalue_conversion (build_unary_op (REALPART_EXPR
, t
, 0)),
2901 c_common_truthvalue_conversion (build_unary_op (IMAGPART_EXPR
, t
, 0)),
2905 return build_binary_op (NE_EXPR
, expr
, integer_zero_node
, 1);
2908 static tree builtin_function_2
PARAMS ((const char *, const char *, tree
, tree
,
2909 int, enum built_in_class
, int, int,
2912 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2913 down to the element type of an array. */
2916 c_build_qualified_type (type
, type_quals
)
2920 /* A restrict-qualified pointer type must be a pointer to object or
2921 incomplete type. Note that the use of POINTER_TYPE_P also allows
2922 REFERENCE_TYPEs, which is appropriate for C++. Unfortunately,
2923 the C++ front-end also use POINTER_TYPE for pointer-to-member
2924 values, so even though it should be illegal to use `restrict'
2925 with such an entity we don't flag that here. Thus, special case
2926 code for that case is required in the C++ front-end. */
2927 if ((type_quals
& TYPE_QUAL_RESTRICT
)
2928 && (!POINTER_TYPE_P (type
)
2929 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type
))))
2931 error ("invalid use of `restrict'");
2932 type_quals
&= ~TYPE_QUAL_RESTRICT
;
2935 if (TREE_CODE (type
) == ARRAY_TYPE
)
2936 return build_array_type (c_build_qualified_type (TREE_TYPE (type
),
2938 TYPE_DOMAIN (type
));
2939 return build_qualified_type (type
, type_quals
);
2942 /* Apply the TYPE_QUALS to the new DECL. */
2945 c_apply_type_quals_to_decl (type_quals
, decl
)
2949 if ((type_quals
& TYPE_QUAL_CONST
)
2950 || (TREE_TYPE (decl
)
2951 && TREE_CODE (TREE_TYPE (decl
)) == REFERENCE_TYPE
))
2952 TREE_READONLY (decl
) = 1;
2953 if (type_quals
& TYPE_QUAL_VOLATILE
)
2955 TREE_SIDE_EFFECTS (decl
) = 1;
2956 TREE_THIS_VOLATILE (decl
) = 1;
2958 if (type_quals
& TYPE_QUAL_RESTRICT
)
2960 if (!TREE_TYPE (decl
)
2961 || !POINTER_TYPE_P (TREE_TYPE (decl
))
2962 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (TREE_TYPE (decl
))))
2963 error ("invalid use of `restrict'");
2964 else if (flag_strict_aliasing
)
2965 /* Indicate we need to make a unique alias set for this pointer.
2966 We can't do it here because it might be pointing to an
2968 DECL_POINTER_ALIAS_SET (decl
) = -2;
2972 /* Return the typed-based alias set for T, which may be an expression
2973 or a type. Return -1 if we don't do anything special. */
2976 c_common_get_alias_set (t
)
2981 /* Permit type-punning when accessing a union, provided the access
2982 is directly through the union. For example, this code does not
2983 permit taking the address of a union member and then storing
2984 through it. Even the type-punning allowed here is a GCC
2985 extension, albeit a common and useful one; the C standard says
2986 that such accesses have implementation-defined behavior. */
2988 TREE_CODE (u
) == COMPONENT_REF
|| TREE_CODE (u
) == ARRAY_REF
;
2989 u
= TREE_OPERAND (u
, 0))
2990 if (TREE_CODE (u
) == COMPONENT_REF
2991 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u
, 0))) == UNION_TYPE
)
2994 /* That's all the expressions we handle specially. */
2998 /* The C standard guarantees that any object may be accessed via an
2999 lvalue that has character type. */
3000 if (t
== char_type_node
3001 || t
== signed_char_type_node
3002 || t
== unsigned_char_type_node
)
3005 /* If it has the may_alias attribute, it can alias anything. */
3006 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (t
)))
3009 /* The C standard specifically allows aliasing between signed and
3010 unsigned variants of the same type. We treat the signed
3011 variant as canonical. */
3012 if (TREE_CODE (t
) == INTEGER_TYPE
&& TREE_UNSIGNED (t
))
3014 tree t1
= c_common_signed_type (t
);
3016 /* t1 == t can happen for boolean nodes which are always unsigned. */
3018 return get_alias_set (t1
);
3020 else if (POINTER_TYPE_P (t
))
3024 /* Unfortunately, there is no canonical form of a pointer type.
3025 In particular, if we have `typedef int I', then `int *', and
3026 `I *' are different types. So, we have to pick a canonical
3027 representative. We do this below.
3029 Technically, this approach is actually more conservative that
3030 it needs to be. In particular, `const int *' and `int *'
3031 should be in different alias sets, according to the C and C++
3032 standard, since their types are not the same, and so,
3033 technically, an `int **' and `const int **' cannot point at
3036 But, the standard is wrong. In particular, this code is
3041 const int* const* cipp = &ipp;
3043 And, it doesn't make sense for that to be legal unless you
3044 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
3045 the pointed-to types. This issue has been reported to the
3047 t1
= build_type_no_quals (t
);
3049 return get_alias_set (t1
);
3055 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
3056 second parameter indicates which OPERATOR is being applied. The COMPLAIN
3057 flag controls whether we should diagnose possibly ill-formed
3058 constructs or not. */
3060 c_sizeof_or_alignof_type (type
, op
, complain
)
3065 const char *op_name
;
3067 enum tree_code type_code
= TREE_CODE (type
);
3069 my_friendly_assert (op
== SIZEOF_EXPR
|| op
== ALIGNOF_EXPR
, 20020720);
3070 op_name
= op
== SIZEOF_EXPR
? "sizeof" : "__alignof__";
3072 if (type_code
== FUNCTION_TYPE
)
3074 if (op
== SIZEOF_EXPR
)
3076 if (complain
&& (pedantic
|| warn_pointer_arith
))
3077 pedwarn ("invalid application of `sizeof' to a function type");
3078 value
= size_one_node
;
3081 value
= size_int (FUNCTION_BOUNDARY
/ BITS_PER_UNIT
);
3083 else if (type_code
== VOID_TYPE
|| type_code
== ERROR_MARK
)
3085 if (type_code
== VOID_TYPE
3086 && complain
&& (pedantic
|| warn_pointer_arith
))
3087 pedwarn ("invalid application of `%s' to a void type", op_name
);
3088 value
= size_one_node
;
3090 else if (!COMPLETE_TYPE_P (type
))
3093 error ("invalid application of `%s' to an incomplete type", op_name
);
3094 value
= size_zero_node
;
3098 if (op
== SIZEOF_EXPR
)
3099 /* Convert in case a char is more than one unit. */
3100 value
= size_binop (CEIL_DIV_EXPR
, TYPE_SIZE_UNIT (type
),
3101 size_int (TYPE_PRECISION (char_type_node
)
3104 value
= size_int (TYPE_ALIGN (type
) / BITS_PER_UNIT
);
3107 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
3108 TYPE_IS_SIZETYPE means that certain things (like overflow) will
3109 never happen. However, this node should really have type
3110 `size_t', which is just a typedef for an ordinary integer type. */
3111 value
= fold (build1 (NOP_EXPR
, size_type_node
, value
));
3112 my_friendly_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value
)), 20001021);
3117 /* Implement the __alignof keyword: Return the minimum required
3118 alignment of EXPR, measured in bytes. For VAR_DECL's and
3119 FIELD_DECL's return DECL_ALIGN (which can be set from an
3120 "aligned" __attribute__ specification). */
3123 c_alignof_expr (expr
)
3128 if (TREE_CODE (expr
) == VAR_DECL
)
3129 t
= size_int (DECL_ALIGN (expr
) / BITS_PER_UNIT
);
3131 else if (TREE_CODE (expr
) == COMPONENT_REF
3132 && DECL_C_BIT_FIELD (TREE_OPERAND (expr
, 1)))
3134 error ("`__alignof' applied to a bit-field");
3137 else if (TREE_CODE (expr
) == COMPONENT_REF
3138 && TREE_CODE (TREE_OPERAND (expr
, 1)) == FIELD_DECL
)
3139 t
= size_int (DECL_ALIGN (TREE_OPERAND (expr
, 1)) / BITS_PER_UNIT
);
3141 else if (TREE_CODE (expr
) == INDIRECT_REF
)
3143 tree t
= TREE_OPERAND (expr
, 0);
3145 int bestalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
3147 while (TREE_CODE (t
) == NOP_EXPR
3148 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0))) == POINTER_TYPE
)
3152 t
= TREE_OPERAND (t
, 0);
3153 thisalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
3154 if (thisalign
> bestalign
)
3155 best
= t
, bestalign
= thisalign
;
3157 return c_alignof (TREE_TYPE (TREE_TYPE (best
)));
3160 return c_alignof (TREE_TYPE (expr
));
3162 return fold (build1 (NOP_EXPR
, size_type_node
, t
));
3165 /* Handle C and C++ default attributes. */
3167 enum built_in_attribute
3169 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
3170 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
3171 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
3172 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
3173 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No entry needed in enum. */
3174 #include "builtin-attrs.def"
3175 #undef DEF_ATTR_NULL_TREE
3177 #undef DEF_ATTR_IDENT
3178 #undef DEF_ATTR_TREE_LIST
3183 static GTY(()) tree built_in_attributes
[(int) ATTR_LAST
];
3185 static bool c_attrs_initialized
= false;
3187 static void c_init_attributes
PARAMS ((void));
3189 /* Build tree nodes and builtin functions common to both C and C++ language
3193 c_common_nodes_and_builtins ()
3197 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
3198 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
3199 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
3200 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
3201 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3202 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3203 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
3204 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
3205 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
3206 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3207 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
3208 #include "builtin-types.def"
3209 #undef DEF_PRIMITIVE_TYPE
3210 #undef DEF_FUNCTION_TYPE_0
3211 #undef DEF_FUNCTION_TYPE_1
3212 #undef DEF_FUNCTION_TYPE_2
3213 #undef DEF_FUNCTION_TYPE_3
3214 #undef DEF_FUNCTION_TYPE_4
3215 #undef DEF_FUNCTION_TYPE_VAR_0
3216 #undef DEF_FUNCTION_TYPE_VAR_1
3217 #undef DEF_FUNCTION_TYPE_VAR_2
3218 #undef DEF_FUNCTION_TYPE_VAR_3
3219 #undef DEF_POINTER_TYPE
3223 typedef enum builtin_type builtin_type
;
3225 tree builtin_types
[(int) BT_LAST
];
3226 int wchar_type_size
;
3227 tree array_domain_type
;
3228 tree va_list_ref_type_node
;
3229 tree va_list_arg_type_node
;
3231 /* Define `int' and `char' first so that dbx will output them first. */
3232 record_builtin_type (RID_INT
, NULL
, integer_type_node
);
3233 record_builtin_type (RID_CHAR
, "char", char_type_node
);
3235 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
3236 "unsigned long", "long long unsigned" and "unsigned short" were in C++
3237 but not C. Are the conditionals here needed? */
3238 if (c_language
== clk_cplusplus
)
3239 record_builtin_type (RID_SIGNED
, NULL
, integer_type_node
);
3240 record_builtin_type (RID_LONG
, "long int", long_integer_type_node
);
3241 record_builtin_type (RID_UNSIGNED
, "unsigned int", unsigned_type_node
);
3242 record_builtin_type (RID_MAX
, "long unsigned int",
3243 long_unsigned_type_node
);
3244 if (c_language
== clk_cplusplus
)
3245 record_builtin_type (RID_MAX
, "unsigned long", long_unsigned_type_node
);
3246 record_builtin_type (RID_MAX
, "long long int",
3247 long_long_integer_type_node
);
3248 record_builtin_type (RID_MAX
, "long long unsigned int",
3249 long_long_unsigned_type_node
);
3250 if (c_language
== clk_cplusplus
)
3251 record_builtin_type (RID_MAX
, "long long unsigned",
3252 long_long_unsigned_type_node
);
3253 record_builtin_type (RID_SHORT
, "short int", short_integer_type_node
);
3254 record_builtin_type (RID_MAX
, "short unsigned int",
3255 short_unsigned_type_node
);
3256 if (c_language
== clk_cplusplus
)
3257 record_builtin_type (RID_MAX
, "unsigned short",
3258 short_unsigned_type_node
);
3260 /* Define both `signed char' and `unsigned char'. */
3261 record_builtin_type (RID_MAX
, "signed char", signed_char_type_node
);
3262 record_builtin_type (RID_MAX
, "unsigned char", unsigned_char_type_node
);
3264 /* These are types that c_common_type_for_size and
3265 c_common_type_for_mode use. */
3266 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
3268 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
3270 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
3272 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
3274 #if HOST_BITS_PER_WIDE_INT >= 64
3275 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
,
3276 get_identifier ("__int128_t"),
3279 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
3280 unsigned_intQI_type_node
));
3281 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
3282 unsigned_intHI_type_node
));
3283 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
3284 unsigned_intSI_type_node
));
3285 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
3286 unsigned_intDI_type_node
));
3287 #if HOST_BITS_PER_WIDE_INT >= 64
3288 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
,
3289 get_identifier ("__uint128_t"),
3290 unsigned_intTI_type_node
));
3293 /* Create the widest literal types. */
3294 widest_integer_literal_type_node
3295 = make_signed_type (HOST_BITS_PER_WIDE_INT
* 2);
3296 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
3297 widest_integer_literal_type_node
));
3299 widest_unsigned_literal_type_node
3300 = make_unsigned_type (HOST_BITS_PER_WIDE_INT
* 2);
3301 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
3302 widest_unsigned_literal_type_node
));
3304 /* `unsigned long' is the standard type for sizeof.
3305 Note that stddef.h uses `unsigned long',
3306 and this must agree, even if long and int are the same size. */
3308 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE
)));
3309 signed_size_type_node
= c_common_signed_type (size_type_node
);
3310 set_sizetype (size_type_node
);
3312 build_common_tree_nodes_2 (flag_short_double
);
3314 record_builtin_type (RID_FLOAT
, NULL
, float_type_node
);
3315 record_builtin_type (RID_DOUBLE
, NULL
, double_type_node
);
3316 record_builtin_type (RID_MAX
, "long double", long_double_type_node
);
3318 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
,
3319 get_identifier ("complex int"),
3320 complex_integer_type_node
));
3321 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
,
3322 get_identifier ("complex float"),
3323 complex_float_type_node
));
3324 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
,
3325 get_identifier ("complex double"),
3326 complex_double_type_node
));
3327 (*lang_hooks
.decls
.pushdecl
)
3328 (build_decl (TYPE_DECL
, get_identifier ("complex long double"),
3329 complex_long_double_type_node
));
3331 /* Types which are common to the fortran compiler and libf2c. When
3332 changing these, you also need to be concerned with f/com.h. */
3334 if (TYPE_PRECISION (float_type_node
)
3335 == TYPE_PRECISION (long_integer_type_node
))
3337 g77_integer_type_node
= long_integer_type_node
;
3338 g77_uinteger_type_node
= long_unsigned_type_node
;
3340 else if (TYPE_PRECISION (float_type_node
)
3341 == TYPE_PRECISION (integer_type_node
))
3343 g77_integer_type_node
= integer_type_node
;
3344 g77_uinteger_type_node
= unsigned_type_node
;
3347 g77_integer_type_node
= g77_uinteger_type_node
= NULL_TREE
;
3349 if (g77_integer_type_node
!= NULL_TREE
)
3351 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
,
3352 get_identifier ("__g77_integer"),
3353 g77_integer_type_node
));
3354 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
,
3355 get_identifier ("__g77_uinteger"),
3356 g77_uinteger_type_node
));
3359 if (TYPE_PRECISION (float_type_node
) * 2
3360 == TYPE_PRECISION (long_integer_type_node
))
3362 g77_longint_type_node
= long_integer_type_node
;
3363 g77_ulongint_type_node
= long_unsigned_type_node
;
3365 else if (TYPE_PRECISION (float_type_node
) * 2
3366 == TYPE_PRECISION (long_long_integer_type_node
))
3368 g77_longint_type_node
= long_long_integer_type_node
;
3369 g77_ulongint_type_node
= long_long_unsigned_type_node
;
3372 g77_longint_type_node
= g77_ulongint_type_node
= NULL_TREE
;
3374 if (g77_longint_type_node
!= NULL_TREE
)
3376 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
,
3377 get_identifier ("__g77_longint"),
3378 g77_longint_type_node
));
3379 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
,
3380 get_identifier ("__g77_ulongint"),
3381 g77_ulongint_type_node
));
3384 record_builtin_type (RID_VOID
, NULL
, void_type_node
);
3386 void_zero_node
= build_int_2 (0, 0);
3387 TREE_TYPE (void_zero_node
) = void_type_node
;
3389 void_list_node
= build_void_list_node ();
3391 /* Make a type to be the domain of a few array types
3392 whose domains don't really matter.
3393 200 is small enough that it always fits in size_t
3394 and large enough that it can hold most function names for the
3395 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
3396 array_domain_type
= build_index_type (size_int (200));
3398 /* Make a type for arrays of characters.
3399 With luck nothing will ever really depend on the length of this
3401 char_array_type_node
3402 = build_array_type (char_type_node
, array_domain_type
);
3404 /* Likewise for arrays of ints. */
3406 = build_array_type (integer_type_node
, array_domain_type
);
3408 string_type_node
= build_pointer_type (char_type_node
);
3409 const_string_type_node
3410 = build_pointer_type (build_qualified_type
3411 (char_type_node
, TYPE_QUAL_CONST
));
3413 (*targetm
.init_builtins
) ();
3415 /* This is special for C++ so functions can be overloaded. */
3416 wchar_type_node
= get_identifier (MODIFIED_WCHAR_TYPE
);
3417 wchar_type_node
= TREE_TYPE (identifier_global_value (wchar_type_node
));
3418 wchar_type_size
= TYPE_PRECISION (wchar_type_node
);
3419 if (c_language
== clk_cplusplus
)
3421 if (TREE_UNSIGNED (wchar_type_node
))
3422 wchar_type_node
= make_unsigned_type (wchar_type_size
);
3424 wchar_type_node
= make_signed_type (wchar_type_size
);
3425 record_builtin_type (RID_WCHAR
, "wchar_t", wchar_type_node
);
3429 signed_wchar_type_node
= c_common_signed_type (wchar_type_node
);
3430 unsigned_wchar_type_node
= c_common_unsigned_type (wchar_type_node
);
3433 /* This is for wide string constants. */
3434 wchar_array_type_node
3435 = build_array_type (wchar_type_node
, array_domain_type
);
3438 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE
)));
3441 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE
)));
3443 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE
)));
3445 default_function_type
= build_function_type (integer_type_node
, NULL_TREE
);
3447 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE
)));
3448 unsigned_ptrdiff_type_node
= c_common_unsigned_type (ptrdiff_type_node
);
3450 (*lang_hooks
.decls
.pushdecl
)
3451 (build_decl (TYPE_DECL
, get_identifier ("__builtin_va_list"),
3452 va_list_type_node
));
3454 (*lang_hooks
.decls
.pushdecl
)
3455 (build_decl (TYPE_DECL
, get_identifier ("__builtin_ptrdiff_t"),
3456 ptrdiff_type_node
));
3458 (*lang_hooks
.decls
.pushdecl
)
3459 (build_decl (TYPE_DECL
, get_identifier ("__builtin_size_t"),
3462 if (TREE_CODE (va_list_type_node
) == ARRAY_TYPE
)
3464 va_list_arg_type_node
= va_list_ref_type_node
=
3465 build_pointer_type (TREE_TYPE (va_list_type_node
));
3469 va_list_arg_type_node
= va_list_type_node
;
3470 va_list_ref_type_node
= build_reference_type (va_list_type_node
);
3473 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3474 builtin_types[(int) ENUM] = VALUE;
3475 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
3476 builtin_types[(int) ENUM] \
3477 = build_function_type (builtin_types[(int) RETURN], \
3479 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
3480 builtin_types[(int) ENUM] \
3481 = build_function_type (builtin_types[(int) RETURN], \
3482 tree_cons (NULL_TREE, \
3483 builtin_types[(int) ARG1], \
3485 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
3486 builtin_types[(int) ENUM] \
3487 = build_function_type \
3488 (builtin_types[(int) RETURN], \
3489 tree_cons (NULL_TREE, \
3490 builtin_types[(int) ARG1], \
3491 tree_cons (NULL_TREE, \
3492 builtin_types[(int) ARG2], \
3494 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3495 builtin_types[(int) ENUM] \
3496 = build_function_type \
3497 (builtin_types[(int) RETURN], \
3498 tree_cons (NULL_TREE, \
3499 builtin_types[(int) ARG1], \
3500 tree_cons (NULL_TREE, \
3501 builtin_types[(int) ARG2], \
3502 tree_cons (NULL_TREE, \
3503 builtin_types[(int) ARG3], \
3505 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3506 builtin_types[(int) ENUM] \
3507 = build_function_type \
3508 (builtin_types[(int) RETURN], \
3509 tree_cons (NULL_TREE, \
3510 builtin_types[(int) ARG1], \
3511 tree_cons (NULL_TREE, \
3512 builtin_types[(int) ARG2], \
3515 builtin_types[(int) ARG3], \
3516 tree_cons (NULL_TREE, \
3517 builtin_types[(int) ARG4], \
3518 void_list_node)))));
3519 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
3520 builtin_types[(int) ENUM] \
3521 = build_function_type (builtin_types[(int) RETURN], NULL_TREE);
3522 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
3523 builtin_types[(int) ENUM] \
3524 = build_function_type (builtin_types[(int) RETURN], \
3525 tree_cons (NULL_TREE, \
3526 builtin_types[(int) ARG1], \
3529 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
3530 builtin_types[(int) ENUM] \
3531 = build_function_type \
3532 (builtin_types[(int) RETURN], \
3533 tree_cons (NULL_TREE, \
3534 builtin_types[(int) ARG1], \
3535 tree_cons (NULL_TREE, \
3536 builtin_types[(int) ARG2], \
3539 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3540 builtin_types[(int) ENUM] \
3541 = build_function_type \
3542 (builtin_types[(int) RETURN], \
3543 tree_cons (NULL_TREE, \
3544 builtin_types[(int) ARG1], \
3545 tree_cons (NULL_TREE, \
3546 builtin_types[(int) ARG2], \
3547 tree_cons (NULL_TREE, \
3548 builtin_types[(int) ARG3], \
3551 #define DEF_POINTER_TYPE(ENUM, TYPE) \
3552 builtin_types[(int) ENUM] \
3553 = build_pointer_type (builtin_types[(int) TYPE]);
3554 #include "builtin-types.def"
3555 #undef DEF_PRIMITIVE_TYPE
3556 #undef DEF_FUNCTION_TYPE_1
3557 #undef DEF_FUNCTION_TYPE_2
3558 #undef DEF_FUNCTION_TYPE_3
3559 #undef DEF_FUNCTION_TYPE_4
3560 #undef DEF_FUNCTION_TYPE_VAR_0
3561 #undef DEF_FUNCTION_TYPE_VAR_1
3562 #undef DEF_FUNCTION_TYPE_VAR_2
3563 #undef DEF_FUNCTION_TYPE_VAR_3
3564 #undef DEF_POINTER_TYPE
3566 if (!c_attrs_initialized
)
3567 c_init_attributes ();
3569 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, \
3570 BOTH_P, FALLBACK_P, NONANSI_P, ATTRS, IMPLICIT) \
3575 if (strncmp (NAME, "__builtin_", strlen ("__builtin_")) != 0) \
3579 decl = builtin_function (NAME, builtin_types[TYPE], ENUM, \
3582 ? (NAME + strlen ("__builtin_")) \
3584 built_in_attributes[(int) ATTRS]); \
3586 decl = builtin_function_2 (NAME, \
3587 NAME + strlen ("__builtin_"), \
3588 builtin_types[TYPE], \
3589 builtin_types[LIBTYPE], \
3594 built_in_attributes[(int) ATTRS]); \
3596 built_in_decls[(int) ENUM] = decl; \
3598 implicit_built_in_decls[(int) ENUM] = decl; \
3600 #include "builtins.def"
3603 main_identifier_node
= get_identifier ("main");
3607 build_va_arg (expr
, type
)
3610 return build1 (VA_ARG_EXPR
, type
, expr
);
3614 /* Linked list of disabled built-in functions. */
3616 typedef struct disabled_builtin
3619 struct disabled_builtin
*next
;
3621 static disabled_builtin
*disabled_builtins
= NULL
;
3623 static bool builtin_function_disabled_p
PARAMS ((const char *));
3625 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
3626 begins with "__builtin_", give an error. */
3629 disable_builtin_function (name
)
3632 if (strncmp (name
, "__builtin_", strlen ("__builtin_")) == 0)
3633 error ("cannot disable built-in function `%s'", name
);
3636 disabled_builtin
*new = xmalloc (sizeof (disabled_builtin
));
3638 new->next
= disabled_builtins
;
3639 disabled_builtins
= new;
3644 /* Return true if the built-in function NAME has been disabled, false
3648 builtin_function_disabled_p (name
)
3651 disabled_builtin
*p
;
3652 for (p
= disabled_builtins
; p
!= NULL
; p
= p
->next
)
3654 if (strcmp (name
, p
->name
) == 0)
3661 /* Possibly define a builtin function with one or two names. BUILTIN_NAME
3662 is an __builtin_-prefixed name; NAME is the ordinary name; one or both
3663 of these may be NULL (though both being NULL is useless).
3664 BUILTIN_TYPE is the type of the __builtin_-prefixed function;
3665 TYPE is the type of the function with the ordinary name. These
3666 may differ if the ordinary name is declared with a looser type to avoid
3667 conflicts with headers. FUNCTION_CODE and CLASS are as for
3668 builtin_function. If LIBRARY_NAME_P is nonzero, NAME is passed as
3669 the LIBRARY_NAME parameter to builtin_function when declaring BUILTIN_NAME.
3670 If NONANSI_P is nonzero, the name NAME is treated as a non-ANSI name;
3671 ATTRS is the tree list representing the builtin's function attributes.
3672 Returns the declaration of BUILTIN_NAME, if any, otherwise
3673 the declaration of NAME. Does not declare NAME if flag_no_builtin,
3674 or if NONANSI_P and flag_no_nonansi_builtin. */
3677 builtin_function_2 (builtin_name
, name
, builtin_type
, type
, function_code
,
3678 class, library_name_p
, nonansi_p
, attrs
)
3679 const char *builtin_name
;
3684 enum built_in_class
class;
3689 tree bdecl
= NULL_TREE
;
3690 tree decl
= NULL_TREE
;
3691 if (builtin_name
!= 0)
3693 bdecl
= builtin_function (builtin_name
, builtin_type
, function_code
,
3694 class, library_name_p
? name
: NULL
,
3697 if (name
!= 0 && !flag_no_builtin
&& !builtin_function_disabled_p (name
)
3698 && !(nonansi_p
&& flag_no_nonansi_builtin
))
3700 decl
= builtin_function (name
, type
, function_code
, class, NULL
,
3703 DECL_BUILT_IN_NONANSI (decl
) = 1;
3705 return (bdecl
!= 0 ? bdecl
: decl
);
3708 /* Nonzero if the type T promotes to int. This is (nearly) the
3709 integral promotions defined in ISO C99 6.3.1.1/2. */
3712 c_promoting_integer_type_p (t
)
3715 switch (TREE_CODE (t
))
3718 return (TYPE_MAIN_VARIANT (t
) == char_type_node
3719 || TYPE_MAIN_VARIANT (t
) == signed_char_type_node
3720 || TYPE_MAIN_VARIANT (t
) == unsigned_char_type_node
3721 || TYPE_MAIN_VARIANT (t
) == short_integer_type_node
3722 || TYPE_MAIN_VARIANT (t
) == short_unsigned_type_node
3723 || TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
));
3726 /* ??? Technically all enumerations not larger than an int
3727 promote to an int. But this is used along code paths
3728 that only want to notice a size change. */
3729 return TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
);
3739 /* Return 1 if PARMS specifies a fixed number of parameters
3740 and none of their types is affected by default promotions. */
3743 self_promoting_args_p (parms
)
3747 for (t
= parms
; t
; t
= TREE_CHAIN (t
))
3749 tree type
= TREE_VALUE (t
);
3751 if (TREE_CHAIN (t
) == 0 && type
!= void_type_node
)
3757 if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
3760 if (c_promoting_integer_type_p (type
))
3766 /* Recursively examines the array elements of TYPE, until a non-array
3767 element type is found. */
3770 strip_array_types (type
)
3773 while (TREE_CODE (type
) == ARRAY_TYPE
)
3774 type
= TREE_TYPE (type
);
3779 static tree expand_unordered_cmp
PARAMS ((tree
, tree
, enum tree_code
,
3782 /* Expand a call to an unordered comparison function such as
3783 __builtin_isgreater(). FUNCTION is the function's declaration and
3784 PARAMS a list of the values passed. For __builtin_isunordered(),
3785 UNORDERED_CODE is UNORDERED_EXPR and ORDERED_CODE is NOP_EXPR. In
3786 other cases, UNORDERED_CODE and ORDERED_CODE are comparison codes
3787 that give the opposite of the desired result. UNORDERED_CODE is
3788 used for modes that can hold NaNs and ORDERED_CODE is used for the
3792 expand_unordered_cmp (function
, params
, unordered_code
, ordered_code
)
3793 tree function
, params
;
3794 enum tree_code unordered_code
, ordered_code
;
3796 tree arg0
, arg1
, type
;
3797 enum tree_code code0
, code1
;
3799 /* Check that we have exactly two arguments. */
3800 if (params
== 0 || TREE_CHAIN (params
) == 0)
3802 error ("too few arguments to function `%s'",
3803 IDENTIFIER_POINTER (DECL_NAME (function
)));
3804 return error_mark_node
;
3806 else if (TREE_CHAIN (TREE_CHAIN (params
)) != 0)
3808 error ("too many arguments to function `%s'",
3809 IDENTIFIER_POINTER (DECL_NAME (function
)));
3810 return error_mark_node
;
3813 arg0
= TREE_VALUE (params
);
3814 arg1
= TREE_VALUE (TREE_CHAIN (params
));
3816 code0
= TREE_CODE (TREE_TYPE (arg0
));
3817 code1
= TREE_CODE (TREE_TYPE (arg1
));
3819 /* Make sure that the arguments have a common type of REAL. */
3821 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
)
3822 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
))
3823 type
= common_type (TREE_TYPE (arg0
), TREE_TYPE (arg1
));
3825 if (type
== 0 || TREE_CODE (type
) != REAL_TYPE
)
3827 error ("non-floating-point argument to function `%s'",
3828 IDENTIFIER_POINTER (DECL_NAME (function
)));
3829 return error_mark_node
;
3832 if (unordered_code
== UNORDERED_EXPR
)
3834 if (MODE_HAS_NANS (TYPE_MODE (type
)))
3835 return build_binary_op (unordered_code
,
3836 convert (type
, arg0
),
3837 convert (type
, arg1
),
3840 return integer_zero_node
;
3843 return build_unary_op (TRUTH_NOT_EXPR
,
3844 build_binary_op (MODE_HAS_NANS (TYPE_MODE (type
))
3847 convert (type
, arg0
),
3848 convert (type
, arg1
),
3854 /* Recognize certain built-in functions so we can make tree-codes
3855 other than CALL_EXPR. We do this when it enables fold-const.c
3856 to do something useful. */
3857 /* ??? By rights this should go in builtins.c, but only C and C++
3858 implement build_{binary,unary}_op. Not exactly sure what bits
3859 of functionality are actually needed from those functions, or
3860 where the similar functionality exists in the other front ends. */
3863 expand_tree_builtin (function
, params
, coerced_params
)
3864 tree function
, params
, coerced_params
;
3866 if (DECL_BUILT_IN_CLASS (function
) != BUILT_IN_NORMAL
)
3869 switch (DECL_FUNCTION_CODE (function
))
3873 case BUILT_IN_LLABS
:
3874 case BUILT_IN_IMAXABS
:
3876 case BUILT_IN_FABSL
:
3877 case BUILT_IN_FABSF
:
3878 if (coerced_params
== 0)
3879 return integer_zero_node
;
3880 return build_unary_op (ABS_EXPR
, TREE_VALUE (coerced_params
), 0);
3883 case BUILT_IN_CONJF
:
3884 case BUILT_IN_CONJL
:
3885 if (coerced_params
== 0)
3886 return integer_zero_node
;
3887 return build_unary_op (CONJ_EXPR
, TREE_VALUE (coerced_params
), 0);
3889 case BUILT_IN_CREAL
:
3890 case BUILT_IN_CREALF
:
3891 case BUILT_IN_CREALL
:
3892 if (coerced_params
== 0)
3893 return integer_zero_node
;
3894 return build_unary_op (REALPART_EXPR
, TREE_VALUE (coerced_params
), 0);
3896 case BUILT_IN_CIMAG
:
3897 case BUILT_IN_CIMAGF
:
3898 case BUILT_IN_CIMAGL
:
3899 if (coerced_params
== 0)
3900 return integer_zero_node
;
3901 return build_unary_op (IMAGPART_EXPR
, TREE_VALUE (coerced_params
), 0);
3903 case BUILT_IN_ISGREATER
:
3904 return expand_unordered_cmp (function
, params
, UNLE_EXPR
, LE_EXPR
);
3906 case BUILT_IN_ISGREATEREQUAL
:
3907 return expand_unordered_cmp (function
, params
, UNLT_EXPR
, LT_EXPR
);
3909 case BUILT_IN_ISLESS
:
3910 return expand_unordered_cmp (function
, params
, UNGE_EXPR
, GE_EXPR
);
3912 case BUILT_IN_ISLESSEQUAL
:
3913 return expand_unordered_cmp (function
, params
, UNGT_EXPR
, GT_EXPR
);
3915 case BUILT_IN_ISLESSGREATER
:
3916 return expand_unordered_cmp (function
, params
, UNEQ_EXPR
, EQ_EXPR
);
3918 case BUILT_IN_ISUNORDERED
:
3919 return expand_unordered_cmp (function
, params
, UNORDERED_EXPR
, NOP_EXPR
);
3928 /* Returns nonzero if CODE is the code for a statement. */
3931 statement_code_p (code
)
3932 enum tree_code code
;
3957 if (lang_statement_code_p
)
3958 return (*lang_statement_code_p
) (code
);
3963 /* Walk the statement tree, rooted at *tp. Apply FUNC to all the
3964 sub-trees of *TP in a pre-order traversal. FUNC is called with the
3965 DATA and the address of each sub-tree. If FUNC returns a non-NULL
3966 value, the traversal is aborted, and the value returned by FUNC is
3967 returned. If FUNC sets WALK_SUBTREES to zero, then the subtrees of
3968 the node being visited are not walked.
3970 We don't need a without_duplicates variant of this one because the
3971 statement tree is a tree, not a graph. */
3974 walk_stmt_tree (tp
, func
, data
)
3979 enum tree_code code
;
3984 #define WALK_SUBTREE(NODE) \
3987 result = walk_stmt_tree (&(NODE), func, data); \
3993 /* Skip empty subtrees. */
3997 /* Skip subtrees below non-statement nodes. */
3998 if (!statement_code_p (TREE_CODE (*tp
)))
4001 /* Call the function. */
4003 result
= (*func
) (tp
, &walk_subtrees
, data
);
4005 /* If we found something, return it. */
4009 /* FUNC may have modified the tree, recheck that we're looking at a
4011 code
= TREE_CODE (*tp
);
4012 if (!statement_code_p (code
))
4015 /* Visit the subtrees unless FUNC decided that there was nothing
4016 interesting below this point in the tree. */
4019 /* Walk over all the sub-trees of this operand. Statement nodes
4020 never contain RTL, and we needn't worry about TARGET_EXPRs. */
4021 len
= TREE_CODE_LENGTH (code
);
4023 /* Go through the subtrees. We need to do this in forward order so
4024 that the scope of a FOR_EXPR is handled properly. */
4025 for (i
= 0; i
< len
; ++i
)
4026 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
4029 /* Finally visit the chain. This can be tail-recursion optimized if
4030 we write it this way. */
4031 return walk_stmt_tree (&TREE_CHAIN (*tp
), func
, data
);
4036 /* Used to compare case labels. K1 and K2 are actually tree nodes
4037 representing case labels, or NULL_TREE for a `default' label.
4038 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
4039 K2, and 0 if K1 and K2 are equal. */
4042 case_compare (k1
, k2
)
4046 /* Consider a NULL key (such as arises with a `default' label) to be
4047 smaller than anything else. */
4053 return tree_int_cst_compare ((tree
) k1
, (tree
) k2
);
4056 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
4057 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
4058 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
4059 case label was declared using the usual C/C++ syntax, rather than
4060 the GNU case range extension. CASES is a tree containing all the
4061 case ranges processed so far; COND is the condition for the
4062 switch-statement itself. Returns the CASE_LABEL created, or
4063 ERROR_MARK_NODE if no CASE_LABEL is created. */
4066 c_add_case_label (cases
, cond
, low_value
, high_value
)
4075 splay_tree_node node
;
4077 /* Create the LABEL_DECL itself. */
4078 label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
4079 DECL_CONTEXT (label
) = current_function_decl
;
4081 /* If there was an error processing the switch condition, bail now
4082 before we get more confused. */
4083 if (!cond
|| cond
== error_mark_node
)
4085 /* Add a label anyhow so that the back-end doesn't think that
4086 the beginning of the switch is unreachable. */
4088 add_stmt (build_case_label (NULL_TREE
, NULL_TREE
, label
));
4089 return error_mark_node
;
4092 if ((low_value
&& TREE_TYPE (low_value
)
4093 && POINTER_TYPE_P (TREE_TYPE (low_value
)))
4094 || (high_value
&& TREE_TYPE (high_value
)
4095 && POINTER_TYPE_P (TREE_TYPE (high_value
))))
4096 error ("pointers are not permitted as case values");
4098 /* Case ranges are a GNU extension. */
4099 if (high_value
&& pedantic
)
4101 if (c_language
== clk_cplusplus
)
4102 pedwarn ("ISO C++ forbids range expressions in switch statements");
4104 pedwarn ("ISO C forbids range expressions in switch statements");
4107 type
= TREE_TYPE (cond
);
4110 low_value
= check_case_value (low_value
);
4111 low_value
= convert_and_check (type
, low_value
);
4115 high_value
= check_case_value (high_value
);
4116 high_value
= convert_and_check (type
, high_value
);
4119 /* If an error has occurred, bail out now. */
4120 if (low_value
== error_mark_node
|| high_value
== error_mark_node
)
4123 add_stmt (build_case_label (NULL_TREE
, NULL_TREE
, label
));
4124 return error_mark_node
;
4127 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
4128 really a case range, even though it was written that way. Remove
4129 the HIGH_VALUE to simplify later processing. */
4130 if (tree_int_cst_equal (low_value
, high_value
))
4131 high_value
= NULL_TREE
;
4132 if (low_value
&& high_value
4133 && !tree_int_cst_lt (low_value
, high_value
))
4134 warning ("empty range specified");
4136 /* Look up the LOW_VALUE in the table of case labels we already
4138 node
= splay_tree_lookup (cases
, (splay_tree_key
) low_value
);
4139 /* If there was not an exact match, check for overlapping ranges.
4140 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
4141 that's a `default' label and the only overlap is an exact match. */
4142 if (!node
&& (low_value
|| high_value
))
4144 splay_tree_node low_bound
;
4145 splay_tree_node high_bound
;
4147 /* Even though there wasn't an exact match, there might be an
4148 overlap between this case range and another case range.
4149 Since we've (inductively) not allowed any overlapping case
4150 ranges, we simply need to find the greatest low case label
4151 that is smaller that LOW_VALUE, and the smallest low case
4152 label that is greater than LOW_VALUE. If there is an overlap
4153 it will occur in one of these two ranges. */
4154 low_bound
= splay_tree_predecessor (cases
,
4155 (splay_tree_key
) low_value
);
4156 high_bound
= splay_tree_successor (cases
,
4157 (splay_tree_key
) low_value
);
4159 /* Check to see if the LOW_BOUND overlaps. It is smaller than
4160 the LOW_VALUE, so there is no need to check unless the
4161 LOW_BOUND is in fact itself a case range. */
4163 && CASE_HIGH ((tree
) low_bound
->value
)
4164 && tree_int_cst_compare (CASE_HIGH ((tree
) low_bound
->value
),
4167 /* Check to see if the HIGH_BOUND overlaps. The low end of that
4168 range is bigger than the low end of the current range, so we
4169 are only interested if the current range is a real range, and
4170 not an ordinary case label. */
4173 && (tree_int_cst_compare ((tree
) high_bound
->key
,
4178 /* If there was an overlap, issue an error. */
4181 tree duplicate
= CASE_LABEL_DECL ((tree
) node
->value
);
4185 error ("duplicate (or overlapping) case value");
4186 error_with_decl (duplicate
,
4187 "this is the first entry overlapping that value");
4191 error ("duplicate case value") ;
4192 error_with_decl (duplicate
, "previously used here");
4196 error ("multiple default labels in one switch");
4197 error_with_decl (duplicate
, "this is the first default label");
4200 add_stmt (build_case_label (NULL_TREE
, NULL_TREE
, label
));
4203 /* Add a CASE_LABEL to the statement-tree. */
4204 case_label
= add_stmt (build_case_label (low_value
, high_value
, label
));
4205 /* Register this case label in the splay tree. */
4206 splay_tree_insert (cases
,
4207 (splay_tree_key
) low_value
,
4208 (splay_tree_value
) case_label
);
4213 /* Finish an expression taking the address of LABEL. Returns an
4214 expression for the address. */
4217 finish_label_address_expr (label
)
4224 if (c_language
== clk_cplusplus
)
4225 pedwarn ("ISO C++ forbids taking the address of a label");
4227 pedwarn ("ISO C forbids taking the address of a label");
4230 label
= lookup_label (label
);
4231 if (label
== NULL_TREE
)
4232 result
= null_pointer_node
;
4235 TREE_USED (label
) = 1;
4236 result
= build1 (ADDR_EXPR
, ptr_type_node
, label
);
4237 TREE_CONSTANT (result
) = 1;
4238 /* The current function in not necessarily uninlinable.
4239 Computed gotos are incompatible with inlining, but the value
4240 here could be used only in a diagnostic, for example. */
4246 /* Hook used by expand_expr to expand language-specific tree codes. */
4249 c_expand_expr (exp
, target
, tmode
, modifier
)
4252 enum machine_mode tmode
;
4253 int modifier
; /* Actually enum_modifier. */
4255 switch (TREE_CODE (exp
))
4261 bool preserve_result
= false;
4262 bool return_target
= false;
4264 /* Since expand_expr_stmt calls free_temp_slots after every
4265 expression statement, we must call push_temp_slots here.
4266 Otherwise, any temporaries in use now would be considered
4267 out-of-scope after the first EXPR_STMT from within the
4270 rtl_expr
= expand_start_stmt_expr (!STMT_EXPR_NO_SCOPE (exp
));
4272 /* If we want the result of this expression, find the last
4273 EXPR_STMT in the COMPOUND_STMT and mark it as addressable. */
4274 if (target
!= const0_rtx
4275 && TREE_CODE (STMT_EXPR_STMT (exp
)) == COMPOUND_STMT
4276 && TREE_CODE (COMPOUND_BODY (STMT_EXPR_STMT (exp
))) == SCOPE_STMT
)
4278 tree expr
= COMPOUND_BODY (STMT_EXPR_STMT (exp
));
4279 tree last
= TREE_CHAIN (expr
);
4281 while (TREE_CHAIN (last
))
4284 last
= TREE_CHAIN (last
);
4287 if (TREE_CODE (last
) == SCOPE_STMT
4288 && TREE_CODE (expr
) == EXPR_STMT
)
4290 if (target
&& TREE_CODE (EXPR_STMT_EXPR (expr
)) == VAR_DECL
4291 && DECL_RTL_IF_SET (EXPR_STMT_EXPR (expr
)) == target
)
4292 /* If the last expression is a variable whose RTL is the
4293 same as our target, just return the target; if it
4294 isn't valid expanding the decl would produce different
4295 RTL, and store_expr would try to do a copy. */
4296 return_target
= true;
4299 /* Otherwise, note that we want the value from the last
4301 TREE_ADDRESSABLE (expr
) = 1;
4302 preserve_result
= true;
4307 expand_stmt (STMT_EXPR_STMT (exp
));
4308 expand_end_stmt_expr (rtl_expr
);
4310 result
= expand_expr (rtl_expr
, target
, tmode
, modifier
);
4313 else if (preserve_result
&& GET_CODE (result
) == MEM
)
4315 if (GET_MODE (result
) != BLKmode
)
4316 result
= copy_to_reg (result
);
4318 preserve_temp_slots (result
);
4321 /* If the statment-expression does not have a scope, then the
4322 new temporaries we created within it must live beyond the
4323 statement-expression. */
4324 if (STMT_EXPR_NO_SCOPE (exp
))
4325 preserve_temp_slots (NULL_RTX
);
4334 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == ADDR_EXPR
4335 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
4337 && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
4338 && (DECL_BUILT_IN_CLASS (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
4339 == BUILT_IN_FRONTEND
))
4340 return c_expand_builtin (exp
, target
, tmode
, modifier
);
4346 case COMPOUND_LITERAL_EXPR
:
4348 /* Initialize the anonymous variable declared in the compound
4349 literal, then return the variable. */
4350 tree decl
= COMPOUND_LITERAL_EXPR_DECL (exp
);
4351 emit_local_var (decl
);
4352 return expand_expr (decl
, target
, tmode
, modifier
);
4363 /* Hook used by safe_from_p to handle language-specific tree codes. */
4366 c_safe_from_p (target
, exp
)
4370 /* We can see statements here when processing the body of a
4371 statement-expression. For a declaration statement declaring a
4372 variable, look at the variable's initializer. */
4373 if (TREE_CODE (exp
) == DECL_STMT
)
4375 tree decl
= DECL_STMT_DECL (exp
);
4377 if (TREE_CODE (decl
) == VAR_DECL
4378 && DECL_INITIAL (decl
)
4379 && !safe_from_p (target
, DECL_INITIAL (decl
), /*top_p=*/0))
4383 /* For any statement, we must follow the statement-chain. */
4384 if (statement_code_p (TREE_CODE (exp
)) && TREE_CHAIN (exp
))
4385 return safe_from_p (target
, TREE_CHAIN (exp
), /*top_p=*/0);
4387 /* Assume everything else is safe. */
4391 /* Hook used by unsafe_for_reeval to handle language-specific tree codes. */
4394 c_common_unsafe_for_reeval (exp
)
4397 /* Statement expressions may not be reevaluated, likewise compound
4399 if (TREE_CODE (exp
) == STMT_EXPR
4400 || TREE_CODE (exp
) == COMPOUND_LITERAL_EXPR
)
4403 /* Walk all other expressions. */
4407 /* Hook used by staticp to handle language-specific tree codes. */
4413 if (TREE_CODE (exp
) == COMPOUND_LITERAL_EXPR
4414 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp
)))
4419 #define CALLED_AS_BUILT_IN(NODE) \
4420 (!strncmp (IDENTIFIER_POINTER (DECL_NAME (NODE)), "__builtin_", 10))
4423 c_expand_builtin (exp
, target
, tmode
, modifier
)
4426 enum machine_mode tmode
;
4427 enum expand_modifier modifier
;
4429 tree type
= TREE_TYPE (exp
);
4430 tree fndecl
= TREE_OPERAND (TREE_OPERAND (exp
, 0), 0);
4431 tree arglist
= TREE_OPERAND (exp
, 1);
4432 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
4433 enum tree_code code
= TREE_CODE (exp
);
4434 const int ignore
= (target
== const0_rtx
4435 || ((code
== NON_LVALUE_EXPR
|| code
== NOP_EXPR
4436 || code
== CONVERT_EXPR
|| code
== REFERENCE_EXPR
4437 || code
== COND_EXPR
)
4438 && TREE_CODE (type
) == VOID_TYPE
));
4440 if (! optimize
&& ! CALLED_AS_BUILT_IN (fndecl
))
4441 return expand_call (exp
, target
, ignore
);
4445 case BUILT_IN_PRINTF
:
4446 target
= c_expand_builtin_printf (arglist
, target
, tmode
,
4447 modifier
, ignore
, /*unlocked=*/ 0);
4452 case BUILT_IN_PRINTF_UNLOCKED
:
4453 target
= c_expand_builtin_printf (arglist
, target
, tmode
,
4454 modifier
, ignore
, /*unlocked=*/ 1);
4459 case BUILT_IN_FPRINTF
:
4460 target
= c_expand_builtin_fprintf (arglist
, target
, tmode
,
4461 modifier
, ignore
, /*unlocked=*/ 0);
4466 case BUILT_IN_FPRINTF_UNLOCKED
:
4467 target
= c_expand_builtin_fprintf (arglist
, target
, tmode
,
4468 modifier
, ignore
, /*unlocked=*/ 1);
4473 default: /* just do library call, if unknown builtin */
4474 error ("built-in function `%s' not currently supported",
4475 IDENTIFIER_POINTER (DECL_NAME (fndecl
)));
4478 /* The switch statement above can drop through to cause the function
4479 to be called normally. */
4480 return expand_call (exp
, target
, ignore
);
4483 /* Check an arglist to *printf for problems. The arglist should start
4484 at the format specifier, with the remaining arguments immediately
4487 is_valid_printf_arglist (arglist
)
4490 /* Save this value so we can restore it later. */
4491 const int SAVE_pedantic
= pedantic
;
4492 int diagnostic_occurred
= 0;
4495 /* Set this to a known value so the user setting won't affect code
4498 /* Check to make sure there are no format specifier errors. */
4499 attrs
= tree_cons (get_identifier ("format"),
4500 tree_cons (NULL_TREE
,
4501 get_identifier ("printf"),
4502 tree_cons (NULL_TREE
,
4504 tree_cons (NULL_TREE
,
4508 check_function_format (&diagnostic_occurred
, attrs
, arglist
);
4510 /* Restore the value of `pedantic'. */
4511 pedantic
= SAVE_pedantic
;
4513 /* If calling `check_function_format_ptr' produces a warning, we
4514 return false, otherwise we return true. */
4515 return ! diagnostic_occurred
;
4518 /* If the arguments passed to printf are suitable for optimizations,
4519 we attempt to transform the call. */
4521 c_expand_builtin_printf (arglist
, target
, tmode
, modifier
, ignore
, unlocked
)
4524 enum machine_mode tmode
;
4525 enum expand_modifier modifier
;
4529 tree fn_putchar
= unlocked
?
4530 implicit_built_in_decls
[BUILT_IN_PUTCHAR_UNLOCKED
] : implicit_built_in_decls
[BUILT_IN_PUTCHAR
];
4531 tree fn_puts
= unlocked
?
4532 implicit_built_in_decls
[BUILT_IN_PUTS_UNLOCKED
] : implicit_built_in_decls
[BUILT_IN_PUTS
];
4533 tree fn
, format_arg
, stripped_string
;
4535 /* If the return value is used, or the replacement _DECL isn't
4536 initialized, don't do the transformation. */
4537 if (!ignore
|| !fn_putchar
|| !fn_puts
)
4540 /* Verify the required arguments in the original call. */
4542 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != POINTER_TYPE
))
4545 /* Check the specifier vs. the parameters. */
4546 if (!is_valid_printf_arglist (arglist
))
4549 format_arg
= TREE_VALUE (arglist
);
4550 stripped_string
= format_arg
;
4551 STRIP_NOPS (stripped_string
);
4552 if (stripped_string
&& TREE_CODE (stripped_string
) == ADDR_EXPR
)
4553 stripped_string
= TREE_OPERAND (stripped_string
, 0);
4555 /* If the format specifier isn't a STRING_CST, punt. */
4556 if (TREE_CODE (stripped_string
) != STRING_CST
)
4559 /* OK! We can attempt optimization. */
4561 /* If the format specifier was "%s\n", call __builtin_puts(arg2). */
4562 if (strcmp (TREE_STRING_POINTER (stripped_string
), "%s\n") == 0)
4564 arglist
= TREE_CHAIN (arglist
);
4567 /* If the format specifier was "%c", call __builtin_putchar (arg2). */
4568 else if (strcmp (TREE_STRING_POINTER (stripped_string
), "%c") == 0)
4570 arglist
= TREE_CHAIN (arglist
);
4575 /* We can't handle anything else with % args or %% ... yet. */
4576 if (strchr (TREE_STRING_POINTER (stripped_string
), '%'))
4579 /* If the resulting constant string has a length of 1, call
4580 putchar. Note, TREE_STRING_LENGTH includes the terminating
4581 NULL in its count. */
4582 if (TREE_STRING_LENGTH (stripped_string
) == 2)
4584 /* Given printf("c"), (where c is any one character,)
4585 convert "c"[0] to an int and pass that to the replacement
4587 arglist
= build_int_2 (TREE_STRING_POINTER (stripped_string
)[0], 0);
4588 arglist
= build_tree_list (NULL_TREE
, arglist
);
4592 /* If the resulting constant was "string\n", call
4593 __builtin_puts("string"). Ensure "string" has at least one
4594 character besides the trailing \n. Note, TREE_STRING_LENGTH
4595 includes the terminating NULL in its count. */
4596 else if (TREE_STRING_LENGTH (stripped_string
) > 2
4597 && TREE_STRING_POINTER (stripped_string
)
4598 [TREE_STRING_LENGTH (stripped_string
) - 2] == '\n')
4600 /* Create a NULL-terminated string that's one char shorter
4601 than the original, stripping off the trailing '\n'. */
4602 const int newlen
= TREE_STRING_LENGTH (stripped_string
) - 1;
4603 char *newstr
= (char *) alloca (newlen
);
4604 memcpy (newstr
, TREE_STRING_POINTER (stripped_string
), newlen
- 1);
4605 newstr
[newlen
- 1] = 0;
4607 arglist
= fix_string_type (build_string (newlen
, newstr
));
4608 arglist
= build_tree_list (NULL_TREE
, arglist
);
4612 /* We'd like to arrange to call fputs(string) here, but we
4613 need stdout and don't have a way to get it ... yet. */
4617 return expand_expr (build_function_call (fn
, arglist
),
4618 (ignore
? const0_rtx
: target
),
4622 /* If the arguments passed to fprintf are suitable for optimizations,
4623 we attempt to transform the call. */
4625 c_expand_builtin_fprintf (arglist
, target
, tmode
, modifier
, ignore
, unlocked
)
4628 enum machine_mode tmode
;
4629 enum expand_modifier modifier
;
4633 tree fn_fputc
= unlocked
?
4634 implicit_built_in_decls
[BUILT_IN_FPUTC_UNLOCKED
] : implicit_built_in_decls
[BUILT_IN_FPUTC
];
4635 tree fn_fputs
= unlocked
?
4636 implicit_built_in_decls
[BUILT_IN_FPUTS_UNLOCKED
] : implicit_built_in_decls
[BUILT_IN_FPUTS
];
4637 tree fn
, format_arg
, stripped_string
;
4639 /* If the return value is used, or the replacement _DECL isn't
4640 initialized, don't do the transformation. */
4641 if (!ignore
|| !fn_fputc
|| !fn_fputs
)
4644 /* Verify the required arguments in the original call. */
4646 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != POINTER_TYPE
)
4647 || (TREE_CHAIN (arglist
) == 0)
4648 || (TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist
)))) !=
4652 /* Check the specifier vs. the parameters. */
4653 if (!is_valid_printf_arglist (TREE_CHAIN (arglist
)))
4656 format_arg
= TREE_VALUE (TREE_CHAIN (arglist
));
4657 stripped_string
= format_arg
;
4658 STRIP_NOPS (stripped_string
);
4659 if (stripped_string
&& TREE_CODE (stripped_string
) == ADDR_EXPR
)
4660 stripped_string
= TREE_OPERAND (stripped_string
, 0);
4662 /* If the format specifier isn't a STRING_CST, punt. */
4663 if (TREE_CODE (stripped_string
) != STRING_CST
)
4666 /* OK! We can attempt optimization. */
4668 /* If the format specifier was "%s", call __builtin_fputs(arg3, arg1). */
4669 if (strcmp (TREE_STRING_POINTER (stripped_string
), "%s") == 0)
4671 tree newarglist
= build_tree_list (NULL_TREE
, TREE_VALUE (arglist
));
4672 arglist
= tree_cons (NULL_TREE
,
4673 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
))),
4677 /* If the format specifier was "%c", call __builtin_fputc (arg3, arg1). */
4678 else if (strcmp (TREE_STRING_POINTER (stripped_string
), "%c") == 0)
4680 tree newarglist
= build_tree_list (NULL_TREE
, TREE_VALUE (arglist
));
4681 arglist
= tree_cons (NULL_TREE
,
4682 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
))),
4688 /* We can't handle anything else with % args or %% ... yet. */
4689 if (strchr (TREE_STRING_POINTER (stripped_string
), '%'))
4692 /* When "string" doesn't contain %, replace all cases of
4693 fprintf(stream,string) with fputs(string,stream). The fputs
4694 builtin will take take of special cases like length==1. */
4695 arglist
= tree_cons (NULL_TREE
, TREE_VALUE (TREE_CHAIN (arglist
)),
4696 build_tree_list (NULL_TREE
, TREE_VALUE (arglist
)));
4700 return expand_expr (build_function_call (fn
, arglist
),
4701 (ignore
? const0_rtx
: target
),
4706 /* Given a boolean expression ARG, return a tree representing an increment
4707 or decrement (as indicated by CODE) of ARG. The front end must check for
4708 invalid cases (e.g., decrement in C++). */
4710 boolean_increment (code
, arg
)
4711 enum tree_code code
;
4715 tree true_res
= (c_language
== clk_cplusplus
4717 : c_bool_true_node
);
4718 arg
= stabilize_reference (arg
);
4721 case PREINCREMENT_EXPR
:
4722 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
4724 case POSTINCREMENT_EXPR
:
4725 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
4726 arg
= save_expr (arg
);
4727 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
4728 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
4730 case PREDECREMENT_EXPR
:
4731 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, invert_truthvalue (arg
));
4733 case POSTDECREMENT_EXPR
:
4734 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, invert_truthvalue (arg
));
4735 arg
= save_expr (arg
);
4736 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
4737 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
4742 TREE_SIDE_EFFECTS (val
) = 1;
4746 /* Define NAME with value TYPE precision. */
4748 builtin_define_type_precision (name
, type
)
4752 builtin_define_with_int_value (name
, TYPE_PRECISION (type
));
4755 /* Define the float.h constants for TYPE using NAME_PREFIX and FP_SUFFIX. */
4757 builtin_define_float_constants (name_prefix
, fp_suffix
, type
)
4758 const char *name_prefix
;
4759 const char *fp_suffix
;
4762 /* Used to convert radix-based values to base 10 values in several cases.
4764 In the max_exp -> max_10_exp conversion for 128-bit IEEE, we need at
4765 least 6 significant digits for correct results. Using the fraction
4766 formed by (log(2)*1e6)/(log(10)*1e6) overflows a 32-bit integer as an
4767 intermediate; perhaps someone can find a better approximation, in the
4768 mean time, I suspect using doubles won't harm the bootstrap here. */
4770 const double log10_2
= .30102999566398119521;
4772 const struct real_format
*fmt
;
4774 char name
[64], buf
[128];
4775 int dig
, min_10_exp
, max_10_exp
;
4778 fmt
= real_format_for_mode
[TYPE_MODE (type
) - QFmode
];
4780 /* The radix of the exponent representation. */
4781 if (type
== float_type_node
)
4782 builtin_define_with_int_value ("__FLT_RADIX__", fmt
->b
);
4783 log10_b
= log10_2
* fmt
->log2_b
;
4785 /* The number of radix digits, p, in the floating-point significand. */
4786 sprintf (name
, "__%s_MANT_DIG__", name_prefix
);
4787 builtin_define_with_int_value (name
, fmt
->p
);
4789 /* The number of decimal digits, q, such that any floating-point number
4790 with q decimal digits can be rounded into a floating-point number with
4791 p radix b digits and back again without change to the q decimal digits,
4793 p log10 b if b is a power of 10
4794 floor((p - 1) log10 b) otherwise
4796 dig
= (fmt
->p
- 1) * log10_b
;
4797 sprintf (name
, "__%s_DIG__", name_prefix
);
4798 builtin_define_with_int_value (name
, dig
);
4800 /* The minimum negative int x such that b**(x-1) is a normalized float. */
4801 sprintf (name
, "__%s_MIN_EXP__", name_prefix
);
4802 sprintf (buf
, "(%d)", fmt
->emin
);
4803 builtin_define_with_value (name
, buf
, 0);
4805 /* The minimum negative int x such that 10**x is a normalized float,
4807 ceil (log10 (b ** (emin - 1)))
4808 = ceil (log10 (b) * (emin - 1))
4810 Recall that emin is negative, so the integer truncation calculates
4811 the ceiling, not the floor, in this case. */
4812 min_10_exp
= (fmt
->emin
- 1) * log10_b
;
4813 sprintf (name
, "__%s_MIN_10_EXP__", name_prefix
);
4814 sprintf (buf
, "(%d)", min_10_exp
);
4815 builtin_define_with_value (name
, buf
, 0);
4817 /* The maximum int x such that b**(x-1) is a representable float. */
4818 sprintf (name
, "__%s_MAX_EXP__", name_prefix
);
4819 builtin_define_with_int_value (name
, fmt
->emax
);
4821 /* The maximum int x such that 10**x is in the range of representable
4822 finite floating-point numbers,
4824 floor (log10((1 - b**-p) * b**emax))
4825 = floor (log10(1 - b**-p) + log10(b**emax))
4826 = floor (log10(1 - b**-p) + log10(b)*emax)
4828 The safest thing to do here is to just compute this number. But since
4829 we don't link cc1 with libm, we cannot. We could implement log10 here
4830 a series expansion, but that seems too much effort because:
4832 Note that the first term, for all extant p, is a number exceedingly close
4833 to zero, but slightly negative. Note that the second term is an integer
4834 scaling an irrational number, and that because of the floor we are only
4835 interested in its integral portion.
4837 In order for the first term to have any effect on the integral portion
4838 of the second term, the second term has to be exceedingly close to an
4839 integer itself (e.g. 123.000000000001 or something). Getting a result
4840 that close to an integer requires that the irrational multiplicand have
4841 a long series of zeros in its expansion, which doesn't occur in the
4842 first 20 digits or so of log10(b).
4844 Hand-waving aside, crunching all of the sets of constants above by hand
4845 does not yield a case for which the first term is significant, which
4846 in the end is all that matters. */
4847 max_10_exp
= fmt
->emax
* log10_b
;
4848 sprintf (name
, "__%s_MAX_10_EXP__", name_prefix
);
4849 builtin_define_with_int_value (name
, max_10_exp
);
4851 /* The number of decimal digits, n, such that any floating-point number
4852 can be rounded to n decimal digits and back again without change to
4855 p * log10(b) if b is a power of 10
4856 ceil(1 + p * log10(b)) otherwise
4858 The only macro we care about is this number for the widest supported
4859 floating type, but we want this value for rendering constants below. */
4861 double d_decimal_dig
= 1 + fmt
->p
* log10_b
;
4862 decimal_dig
= d_decimal_dig
;
4863 if (decimal_dig
< d_decimal_dig
)
4866 if (type
== long_double_type_node
)
4867 builtin_define_with_int_value ("__DECIMAL_DIG__", decimal_dig
);
4869 /* Since, for the supported formats, B is always a power of 2, we
4870 construct the following numbers directly as a hexadecimal
4873 /* The maximum representable finite floating-point number,
4874 (1 - b**-p) * b**emax */
4879 strcpy (buf
, "0x0.");
4880 n
= fmt
->p
* fmt
->log2_b
;
4881 for (i
= 0, p
= buf
+ 4; i
+ 3 < n
; i
+= 4)
4884 *p
++ = "08ce"[n
- i
];
4885 sprintf (p
, "p%d", fmt
->emax
* fmt
->log2_b
);
4887 sprintf (name
, "__%s_MAX__", name_prefix
);
4888 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
, buf
, fp_suffix
);
4890 /* The minimum normalized positive floating-point number,
4892 sprintf (name
, "__%s_MIN__", name_prefix
);
4893 sprintf (buf
, "0x1p%d", (fmt
->emin
- 1) * fmt
->log2_b
);
4894 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
, buf
, fp_suffix
);
4896 /* The difference between 1 and the least value greater than 1 that is
4897 representable in the given floating point type, b**(1-p). */
4898 sprintf (name
, "__%s_EPSILON__", name_prefix
);
4899 sprintf (buf
, "0x1p%d", (1 - fmt
->p
) * fmt
->log2_b
);
4900 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
, buf
, fp_suffix
);
4902 /* For C++ std::numeric_limits<T>::denorm_min. The minimum denormalized
4903 positive floating-point number, b**(emin-p). Zero for formats that
4904 don't support denormals. */
4905 sprintf (name
, "__%s_DENORM_MIN__", name_prefix
);
4906 if (fmt
->has_denorm
)
4908 sprintf (buf
, "0x1p%d", (fmt
->emin
- fmt
->p
) * fmt
->log2_b
);
4909 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
,
4914 sprintf (buf
, "0.0%s", fp_suffix
);
4915 builtin_define_with_value (name
, buf
, 0);
4918 /* For C++ std::numeric_limits<T>::has_infinity. */
4919 sprintf (name
, "__%s_HAS_INFINITY__", name_prefix
);
4920 builtin_define_with_int_value (name
,
4921 MODE_HAS_INFINITIES (TYPE_MODE (type
)));
4922 /* For C++ std::numeric_limits<T>::has_quiet_NaN. We do not have a
4923 predicate to distinguish a target that has both quiet and
4924 signalling NaNs from a target that has only quiet NaNs or only
4925 signalling NaNs, so we assume that a target that has any kind of
4926 NaN has quiet NaNs. */
4927 sprintf (name
, "__%s_HAS_QUIET_NAN__", name_prefix
);
4928 builtin_define_with_int_value (name
, MODE_HAS_NANS (TYPE_MODE (type
)));
4931 /* Hook that registers front end and target-specific built-ins. */
4933 cb_register_builtins (pfile
)
4936 /* -undef turns off target-specific built-ins. */
4940 if (c_language
== clk_cplusplus
)
4942 if (SUPPORTS_ONE_ONLY
)
4943 cpp_define (pfile
, "__GXX_WEAK__=1");
4945 cpp_define (pfile
, "__GXX_WEAK__=0");
4946 if (flag_exceptions
)
4947 cpp_define (pfile
, "__EXCEPTIONS");
4948 if (warn_deprecated
)
4949 cpp_define (pfile
, "__DEPRECATED");
4952 /* represents the C++ ABI version, always defined so it can be used while
4953 preprocessing C and assembler. */
4954 cpp_define (pfile
, "__GXX_ABI_VERSION=102");
4956 /* libgcc needs to know this. */
4957 if (USING_SJLJ_EXCEPTIONS
)
4958 cpp_define (pfile
, "__USING_SJLJ_EXCEPTIONS__");
4960 /* stddef.h needs to know these. */
4961 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE
, 0);
4962 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE
, 0);
4963 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE
, 0);
4964 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE
, 0);
4966 /* limits.h needs to know these. */
4967 builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node
, 0);
4968 builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node
, 0);
4969 builtin_define_type_max ("__INT_MAX__", integer_type_node
, 0);
4970 builtin_define_type_max ("__LONG_MAX__", long_integer_type_node
, 1);
4971 builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node
, 2);
4972 builtin_define_type_max ("__WCHAR_MAX__", wchar_type_node
, 0);
4974 builtin_define_type_precision ("__CHAR_BIT__", char_type_node
);
4976 /* float.h needs to know these. */
4978 builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
4979 TARGET_FLT_EVAL_METHOD
);
4981 builtin_define_float_constants ("FLT", "F", float_type_node
);
4982 builtin_define_float_constants ("DBL", "", double_type_node
);
4983 builtin_define_float_constants ("LDBL", "L", long_double_type_node
);
4985 /* For use in assembly language. */
4986 builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX
, 0);
4987 builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix
, 0);
4990 builtin_define_with_value ("__VERSION__", version_string
, 1);
4992 /* Other target-independent built-ins determined by command-line
4995 cpp_define (pfile
, "__OPTIMIZE_SIZE__");
4997 cpp_define (pfile
, "__OPTIMIZE__");
5000 cpp_define (pfile
, "__STDC_HOSTED__=1");
5002 cpp_define (pfile
, "__STDC_HOSTED__=0");
5004 if (fast_math_flags_set_p ())
5005 cpp_define (pfile
, "__FAST_MATH__");
5006 if (flag_really_no_inline
)
5007 cpp_define (pfile
, "__NO_INLINE__");
5008 if (flag_signaling_nans
)
5009 cpp_define (pfile
, "__SUPPORT_SNAN__");
5010 if (flag_finite_math_only
)
5011 cpp_define (pfile
, "__FINITE_MATH_ONLY__=1");
5013 cpp_define (pfile
, "__FINITE_MATH_ONLY__=0");
5016 cpp_define (pfile
, "__STRICT_ANSI__");
5018 if (!flag_signed_char
)
5019 cpp_define (pfile
, "__CHAR_UNSIGNED__");
5021 if (c_language
== clk_cplusplus
&& TREE_UNSIGNED (wchar_type_node
))
5022 cpp_define (pfile
, "__WCHAR_UNSIGNED__");
5024 /* Make the choice of ObjC runtime visible to source code. */
5025 if (flag_objc
&& flag_next_runtime
)
5026 cpp_define (pfile
, "__NEXT_RUNTIME__");
5028 /* A straightforward target hook doesn't work, because of problems
5029 linking that hook's body when part of non-C front ends. */
5030 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
5031 # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
5032 # define builtin_define(TXT) cpp_define (pfile, TXT)
5033 # define builtin_assert(TXT) cpp_assert (pfile, TXT)
5034 TARGET_CPU_CPP_BUILTINS ();
5035 TARGET_OS_CPP_BUILTINS ();
5038 /* Pass an object-like macro. If it doesn't lie in the user's
5039 namespace, defines it unconditionally. Otherwise define a version
5040 with two leading underscores, and another version with two leading
5041 and trailing underscores, and define the original only if an ISO
5042 standard was not nominated.
5044 e.g. passing "unix" defines "__unix", "__unix__" and possibly
5045 "unix". Passing "_mips" defines "__mips", "__mips__" and possibly
5048 builtin_define_std (macro
)
5051 size_t len
= strlen (macro
);
5052 char *buff
= alloca (len
+ 5);
5056 /* prepend __ (or maybe just _) if in user's namespace. */
5057 memcpy (p
, macro
, len
+ 1);
5058 if (!( *p
== '_' && (p
[1] == '_' || ISUPPER (p
[1]))))
5065 cpp_define (parse_in
, p
);
5067 /* If it was in user's namespace... */
5070 /* Define the macro with leading and following __. */
5076 cpp_define (parse_in
, p
);
5078 /* Finally, define the original macro if permitted. */
5080 cpp_define (parse_in
, macro
);
5084 /* Pass an object-like macro and a value to define it to. The third
5085 parameter says whether or not to turn the value into a string
5088 builtin_define_with_value (macro
, expansion
, is_str
)
5090 const char *expansion
;
5094 size_t mlen
= strlen (macro
);
5095 size_t elen
= strlen (expansion
);
5096 size_t extra
= 2; /* space for an = and a NUL */
5099 extra
+= 2; /* space for two quote marks */
5101 buf
= alloca (mlen
+ elen
+ extra
);
5103 sprintf (buf
, "%s=\"%s\"", macro
, expansion
);
5105 sprintf (buf
, "%s=%s", macro
, expansion
);
5107 cpp_define (parse_in
, buf
);
5110 /* Pass an object-like macro and an integer value to define it to. */
5112 builtin_define_with_int_value (macro
, value
)
5114 HOST_WIDE_INT value
;
5117 size_t mlen
= strlen (macro
);
5119 size_t extra
= 2; /* space for = and NUL. */
5121 buf
= alloca (mlen
+ vlen
+ extra
);
5122 memcpy (buf
, macro
, mlen
);
5124 sprintf (buf
+ mlen
+ 1, HOST_WIDE_INT_PRINT_DEC
, value
);
5126 cpp_define (parse_in
, buf
);
5129 /* Pass an object-like macro a hexadecimal floating-point value. */
5131 builtin_define_with_hex_fp_value (macro
, type
, digits
, hex_str
, fp_suffix
)
5133 tree type ATTRIBUTE_UNUSED
;
5135 const char *hex_str
;
5136 const char *fp_suffix
;
5138 REAL_VALUE_TYPE real
;
5139 char dec_str
[64], buf
[256];
5141 /* Hex values are really cool and convenient, except that they're
5142 not supported in strict ISO C90 mode. First, the "p-" sequence
5143 is not valid as part of a preprocessor number. Second, we get a
5144 pedwarn from the preprocessor, which has no context, so we can't
5145 suppress the warning with __extension__.
5147 So instead what we do is construct the number in hex (because
5148 it's easy to get the exact correct value), parse it as a real,
5149 then print it back out as decimal. */
5151 real_from_string (&real
, hex_str
);
5152 real_to_decimal (dec_str
, &real
, sizeof (dec_str
), digits
, 0);
5154 sprintf (buf
, "%s=%s%s", macro
, dec_str
, fp_suffix
);
5155 cpp_define (parse_in
, buf
);
5158 /* Define MAX for TYPE based on the precision of the type. IS_LONG is
5159 1 for type "long" and 2 for "long long". We have to handle
5160 unsigned types, since wchar_t might be unsigned. */
5163 builtin_define_type_max (macro
, type
, is_long
)
5168 static const char *const values
[]
5171 "2147483647", "4294967295",
5172 "9223372036854775807", "18446744073709551615",
5173 "170141183460469231731687303715884105727",
5174 "340282366920938463463374607431768211455" };
5175 static const char *const suffixes
[] = { "", "U", "L", "UL", "LL", "ULL" };
5177 const char *value
, *suffix
;
5181 /* Pre-rendering the values mean we don't have to futz with printing a
5182 multi-word decimal value. There are also a very limited number of
5183 precisions that we support, so it's really a waste of time. */
5184 switch (TYPE_PRECISION (type
))
5186 case 8: idx
= 0; break;
5187 case 16: idx
= 2; break;
5188 case 32: idx
= 4; break;
5189 case 64: idx
= 6; break;
5190 case 128: idx
= 8; break;
5194 value
= values
[idx
+ TREE_UNSIGNED (type
)];
5195 suffix
= suffixes
[is_long
* 2 + TREE_UNSIGNED (type
)];
5197 buf
= alloca (strlen (macro
) + 1 + strlen (value
) + strlen (suffix
) + 1);
5198 sprintf (buf
, "%s=%s%s", macro
, value
, suffix
);
5200 cpp_define (parse_in
, buf
);
5204 c_init_attributes ()
5206 /* Fill in the built_in_attributes array. */
5207 #define DEF_ATTR_NULL_TREE(ENUM) \
5208 built_in_attributes[(int) ENUM] = NULL_TREE;
5209 #define DEF_ATTR_INT(ENUM, VALUE) \
5210 built_in_attributes[(int) ENUM] = build_int_2 (VALUE, VALUE < 0 ? -1 : 0);
5211 #define DEF_ATTR_IDENT(ENUM, STRING) \
5212 built_in_attributes[(int) ENUM] = get_identifier (STRING);
5213 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
5214 built_in_attributes[(int) ENUM] \
5215 = tree_cons (built_in_attributes[(int) PURPOSE], \
5216 built_in_attributes[(int) VALUE], \
5217 built_in_attributes[(int) CHAIN]);
5218 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No initialization needed. */
5219 #include "builtin-attrs.def"
5220 #undef DEF_ATTR_NULL_TREE
5222 #undef DEF_ATTR_IDENT
5223 #undef DEF_ATTR_TREE_LIST
5225 c_attrs_initialized
= true;
5228 /* Depending on the name of DECL, apply default attributes to it. */
5231 c_common_insert_default_attributes (decl
)
5234 tree name
= DECL_NAME (decl
);
5236 if (!c_attrs_initialized
)
5237 c_init_attributes ();
5239 #define DEF_ATTR_NULL_TREE(ENUM) /* Nothing needed after initialization. */
5240 #define DEF_ATTR_INT(ENUM, VALUE)
5241 #define DEF_ATTR_IDENT(ENUM, STRING)
5242 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN)
5243 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) \
5244 if ((PREDICATE) && name == built_in_attributes[(int) NAME]) \
5245 decl_attributes (&decl, built_in_attributes[(int) ATTRS], \
5246 ATTR_FLAG_BUILT_IN);
5247 #include "builtin-attrs.def"
5248 #undef DEF_ATTR_NULL_TREE
5250 #undef DEF_ATTR_IDENT
5251 #undef DEF_ATTR_TREE_LIST
5255 /* Output a -Wshadow warning MSGID about NAME, an IDENTIFIER_NODE, and
5256 additionally give the location of the previous declaration DECL. */
5258 shadow_warning (msgid
, name
, decl
)
5262 warning ("declaration of `%s' shadows %s", IDENTIFIER_POINTER (name
), msgid
);
5263 warning_with_file_and_line (DECL_SOURCE_FILE (decl
),
5264 DECL_SOURCE_LINE (decl
),
5265 "shadowed declaration is here");
5268 /* Attribute handlers common to C front ends. */
5270 /* Handle a "packed" attribute; arguments as in
5271 struct attribute_spec.handler. */
5274 handle_packed_attribute (node
, name
, args
, flags
, no_add_attrs
)
5277 tree args ATTRIBUTE_UNUSED
;
5284 if (TREE_CODE (*node
) == TYPE_DECL
)
5285 type
= &TREE_TYPE (*node
);
5292 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
5293 *type
= build_type_copy (*type
);
5294 TYPE_PACKED (*type
) = 1;
5296 else if (TREE_CODE (*node
) == FIELD_DECL
)
5297 DECL_PACKED (*node
) = 1;
5298 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
5299 used for DECL_REGISTER. It wouldn't mean anything anyway. */
5302 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5303 *no_add_attrs
= true;
5309 /* Handle a "nocommon" attribute; arguments as in
5310 struct attribute_spec.handler. */
5313 handle_nocommon_attribute (node
, name
, args
, flags
, no_add_attrs
)
5316 tree args ATTRIBUTE_UNUSED
;
5317 int flags ATTRIBUTE_UNUSED
;
5320 if (TREE_CODE (*node
) == VAR_DECL
)
5321 DECL_COMMON (*node
) = 0;
5324 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5325 *no_add_attrs
= true;
5331 /* Handle a "common" attribute; arguments as in
5332 struct attribute_spec.handler. */
5335 handle_common_attribute (node
, name
, args
, flags
, no_add_attrs
)
5338 tree args ATTRIBUTE_UNUSED
;
5339 int flags ATTRIBUTE_UNUSED
;
5342 if (TREE_CODE (*node
) == VAR_DECL
)
5343 DECL_COMMON (*node
) = 1;
5346 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5347 *no_add_attrs
= true;
5353 /* Handle a "noreturn" attribute; arguments as in
5354 struct attribute_spec.handler. */
5357 handle_noreturn_attribute (node
, name
, args
, flags
, no_add_attrs
)
5360 tree args ATTRIBUTE_UNUSED
;
5361 int flags ATTRIBUTE_UNUSED
;
5364 tree type
= TREE_TYPE (*node
);
5366 /* See FIXME comment in c_common_attribute_table. */
5367 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5368 TREE_THIS_VOLATILE (*node
) = 1;
5369 else if (TREE_CODE (type
) == POINTER_TYPE
5370 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
5372 = build_pointer_type
5373 (build_type_variant (TREE_TYPE (type
),
5374 TREE_READONLY (TREE_TYPE (type
)), 1));
5377 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5378 *no_add_attrs
= true;
5384 /* Handle a "noinline" attribute; arguments as in
5385 struct attribute_spec.handler. */
5388 handle_noinline_attribute (node
, name
, args
, flags
, no_add_attrs
)
5391 tree args ATTRIBUTE_UNUSED
;
5392 int flags ATTRIBUTE_UNUSED
;
5395 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5396 DECL_UNINLINABLE (*node
) = 1;
5399 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5400 *no_add_attrs
= true;
5406 /* Handle a "always_inline" attribute; arguments as in
5407 struct attribute_spec.handler. */
5410 handle_always_inline_attribute (node
, name
, args
, flags
, no_add_attrs
)
5413 tree args ATTRIBUTE_UNUSED
;
5414 int flags ATTRIBUTE_UNUSED
;
5417 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5419 /* Do nothing else, just set the attribute. We'll get at
5420 it later with lookup_attribute. */
5424 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5425 *no_add_attrs
= true;
5431 /* Handle a "used" attribute; arguments as in
5432 struct attribute_spec.handler. */
5435 handle_used_attribute (pnode
, name
, args
, flags
, no_add_attrs
)
5438 tree args ATTRIBUTE_UNUSED
;
5439 int flags ATTRIBUTE_UNUSED
;
5444 if (TREE_CODE (node
) == FUNCTION_DECL
5445 || (TREE_CODE (node
) == VAR_DECL
&& TREE_STATIC (node
)))
5446 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (node
))
5447 = TREE_USED (node
) = 1;
5450 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5451 *no_add_attrs
= true;
5457 /* Handle a "unused" attribute; arguments as in
5458 struct attribute_spec.handler. */
5461 handle_unused_attribute (node
, name
, args
, flags
, no_add_attrs
)
5464 tree args ATTRIBUTE_UNUSED
;
5472 if (TREE_CODE (decl
) == PARM_DECL
5473 || TREE_CODE (decl
) == VAR_DECL
5474 || TREE_CODE (decl
) == FUNCTION_DECL
5475 || TREE_CODE (decl
) == LABEL_DECL
5476 || TREE_CODE (decl
) == TYPE_DECL
)
5477 TREE_USED (decl
) = 1;
5480 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5481 *no_add_attrs
= true;
5486 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
5487 *node
= build_type_copy (*node
);
5488 TREE_USED (*node
) = 1;
5494 /* Handle a "const" attribute; arguments as in
5495 struct attribute_spec.handler. */
5498 handle_const_attribute (node
, name
, args
, flags
, no_add_attrs
)
5501 tree args ATTRIBUTE_UNUSED
;
5502 int flags ATTRIBUTE_UNUSED
;
5505 tree type
= TREE_TYPE (*node
);
5507 /* See FIXME comment on noreturn in c_common_attribute_table. */
5508 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5509 TREE_READONLY (*node
) = 1;
5510 else if (TREE_CODE (type
) == POINTER_TYPE
5511 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
5513 = build_pointer_type
5514 (build_type_variant (TREE_TYPE (type
), 1,
5515 TREE_THIS_VOLATILE (TREE_TYPE (type
))));
5518 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5519 *no_add_attrs
= true;
5525 /* Handle a "transparent_union" attribute; arguments as in
5526 struct attribute_spec.handler. */
5529 handle_transparent_union_attribute (node
, name
, args
, flags
, no_add_attrs
)
5532 tree args ATTRIBUTE_UNUSED
;
5536 tree decl
= NULL_TREE
;
5543 type
= &TREE_TYPE (decl
);
5544 is_type
= TREE_CODE (*node
) == TYPE_DECL
;
5546 else if (TYPE_P (*node
))
5547 type
= node
, is_type
= 1;
5550 && TREE_CODE (*type
) == UNION_TYPE
5552 || (TYPE_FIELDS (*type
) != 0
5553 && TYPE_MODE (*type
) == DECL_MODE (TYPE_FIELDS (*type
)))))
5555 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
5556 *type
= build_type_copy (*type
);
5557 TYPE_TRANSPARENT_UNION (*type
) = 1;
5559 else if (decl
!= 0 && TREE_CODE (decl
) == PARM_DECL
5560 && TREE_CODE (*type
) == UNION_TYPE
5561 && TYPE_MODE (*type
) == DECL_MODE (TYPE_FIELDS (*type
)))
5562 DECL_TRANSPARENT_UNION (decl
) = 1;
5565 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5566 *no_add_attrs
= true;
5572 /* Handle a "constructor" attribute; arguments as in
5573 struct attribute_spec.handler. */
5576 handle_constructor_attribute (node
, name
, args
, flags
, no_add_attrs
)
5579 tree args ATTRIBUTE_UNUSED
;
5580 int flags ATTRIBUTE_UNUSED
;
5584 tree type
= TREE_TYPE (decl
);
5586 if (TREE_CODE (decl
) == FUNCTION_DECL
5587 && TREE_CODE (type
) == FUNCTION_TYPE
5588 && decl_function_context (decl
) == 0)
5590 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
5591 TREE_USED (decl
) = 1;
5595 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5596 *no_add_attrs
= true;
5602 /* Handle a "destructor" attribute; arguments as in
5603 struct attribute_spec.handler. */
5606 handle_destructor_attribute (node
, name
, args
, flags
, no_add_attrs
)
5609 tree args ATTRIBUTE_UNUSED
;
5610 int flags ATTRIBUTE_UNUSED
;
5614 tree type
= TREE_TYPE (decl
);
5616 if (TREE_CODE (decl
) == FUNCTION_DECL
5617 && TREE_CODE (type
) == FUNCTION_TYPE
5618 && decl_function_context (decl
) == 0)
5620 DECL_STATIC_DESTRUCTOR (decl
) = 1;
5621 TREE_USED (decl
) = 1;
5625 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5626 *no_add_attrs
= true;
5632 /* Handle a "mode" attribute; arguments as in
5633 struct attribute_spec.handler. */
5636 handle_mode_attribute (node
, name
, args
, flags
, no_add_attrs
)
5640 int flags ATTRIBUTE_UNUSED
;
5645 *no_add_attrs
= true;
5647 if (TREE_CODE (TREE_VALUE (args
)) != IDENTIFIER_NODE
)
5648 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5652 const char *p
= IDENTIFIER_POINTER (TREE_VALUE (args
));
5653 int len
= strlen (p
);
5654 enum machine_mode mode
= VOIDmode
;
5658 if (len
> 4 && p
[0] == '_' && p
[1] == '_'
5659 && p
[len
- 1] == '_' && p
[len
- 2] == '_')
5661 char *newp
= (char *) alloca (len
- 1);
5663 strcpy (newp
, &p
[2]);
5664 newp
[len
- 4] = '\0';
5668 /* Change this type to have a type with the specified mode.
5669 First check for the special modes. */
5670 if (! strcmp (p
, "byte"))
5672 else if (!strcmp (p
, "word"))
5674 else if (! strcmp (p
, "pointer"))
5677 for (j
= 0; j
< NUM_MACHINE_MODES
; j
++)
5678 if (!strcmp (p
, GET_MODE_NAME (j
)))
5679 mode
= (enum machine_mode
) j
;
5681 if (mode
== VOIDmode
)
5682 error ("unknown machine mode `%s'", p
);
5683 else if (0 == (typefm
= (*lang_hooks
.types
.type_for_mode
)
5684 (mode
, TREE_UNSIGNED (type
))))
5685 error ("no data type for mode `%s'", p
);
5686 else if ((TREE_CODE (type
) == POINTER_TYPE
5687 || TREE_CODE (type
) == REFERENCE_TYPE
)
5688 && !(*targetm
.valid_pointer_mode
) (mode
))
5689 error ("invalid pointer mode `%s'", p
);
5692 /* If this is a vector, make sure we either have hardware
5693 support, or we can emulate it. */
5694 if ((GET_MODE_CLASS (mode
) == MODE_VECTOR_INT
5695 || GET_MODE_CLASS (mode
) == MODE_VECTOR_FLOAT
)
5696 && !vector_mode_valid_p (mode
))
5698 error ("unable to emulate '%s'", GET_MODE_NAME (mode
));
5702 if (TREE_CODE (type
) == POINTER_TYPE
)
5704 ptr_type
= build_pointer_type_for_mode (TREE_TYPE (type
),
5708 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
5710 ptr_type
= build_reference_type_for_mode (TREE_TYPE (type
),
5716 /* No need to layout the type here. The caller should do this. */
5723 /* Handle a "section" attribute; arguments as in
5724 struct attribute_spec.handler. */
5727 handle_section_attribute (node
, name
, args
, flags
, no_add_attrs
)
5729 tree name ATTRIBUTE_UNUSED
;
5731 int flags ATTRIBUTE_UNUSED
;
5736 if (targetm
.have_named_sections
)
5738 if ((TREE_CODE (decl
) == FUNCTION_DECL
5739 || TREE_CODE (decl
) == VAR_DECL
)
5740 && TREE_CODE (TREE_VALUE (args
)) == STRING_CST
)
5742 if (TREE_CODE (decl
) == VAR_DECL
5743 && current_function_decl
!= NULL_TREE
5744 && ! TREE_STATIC (decl
))
5746 error_with_decl (decl
,
5747 "section attribute cannot be specified for local variables");
5748 *no_add_attrs
= true;
5751 /* The decl may have already been given a section attribute
5752 from a previous declaration. Ensure they match. */
5753 else if (DECL_SECTION_NAME (decl
) != NULL_TREE
5754 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl
)),
5755 TREE_STRING_POINTER (TREE_VALUE (args
))) != 0)
5757 error_with_decl (*node
,
5758 "section of `%s' conflicts with previous declaration");
5759 *no_add_attrs
= true;
5762 DECL_SECTION_NAME (decl
) = TREE_VALUE (args
);
5766 error_with_decl (*node
,
5767 "section attribute not allowed for `%s'");
5768 *no_add_attrs
= true;
5773 error_with_decl (*node
,
5774 "section attributes are not supported for this target");
5775 *no_add_attrs
= true;
5781 /* Handle a "aligned" attribute; arguments as in
5782 struct attribute_spec.handler. */
5785 handle_aligned_attribute (node
, name
, args
, flags
, no_add_attrs
)
5787 tree name ATTRIBUTE_UNUSED
;
5792 tree decl
= NULL_TREE
;
5795 tree align_expr
= (args
? TREE_VALUE (args
)
5796 : size_int (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
));
5802 type
= &TREE_TYPE (decl
);
5803 is_type
= TREE_CODE (*node
) == TYPE_DECL
;
5805 else if (TYPE_P (*node
))
5806 type
= node
, is_type
= 1;
5808 /* Strip any NOPs of any kind. */
5809 while (TREE_CODE (align_expr
) == NOP_EXPR
5810 || TREE_CODE (align_expr
) == CONVERT_EXPR
5811 || TREE_CODE (align_expr
) == NON_LVALUE_EXPR
)
5812 align_expr
= TREE_OPERAND (align_expr
, 0);
5814 if (TREE_CODE (align_expr
) != INTEGER_CST
)
5816 error ("requested alignment is not a constant");
5817 *no_add_attrs
= true;
5819 else if ((i
= tree_log2 (align_expr
)) == -1)
5821 error ("requested alignment is not a power of 2");
5822 *no_add_attrs
= true;
5824 else if (i
> HOST_BITS_PER_INT
- 2)
5826 error ("requested alignment is too large");
5827 *no_add_attrs
= true;
5831 /* If we have a TYPE_DECL, then copy the type, so that we
5832 don't accidentally modify a builtin type. See pushdecl. */
5833 if (decl
&& TREE_TYPE (decl
) != error_mark_node
5834 && DECL_ORIGINAL_TYPE (decl
) == NULL_TREE
)
5836 tree tt
= TREE_TYPE (decl
);
5837 *type
= build_type_copy (*type
);
5838 DECL_ORIGINAL_TYPE (decl
) = tt
;
5839 TYPE_NAME (*type
) = decl
;
5840 TREE_USED (*type
) = TREE_USED (decl
);
5841 TREE_TYPE (decl
) = *type
;
5843 else if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
5844 *type
= build_type_copy (*type
);
5846 TYPE_ALIGN (*type
) = (1 << i
) * BITS_PER_UNIT
;
5847 TYPE_USER_ALIGN (*type
) = 1;
5849 else if (TREE_CODE (decl
) != VAR_DECL
5850 && TREE_CODE (decl
) != FIELD_DECL
)
5852 error_with_decl (decl
,
5853 "alignment may not be specified for `%s'");
5854 *no_add_attrs
= true;
5858 DECL_ALIGN (decl
) = (1 << i
) * BITS_PER_UNIT
;
5859 DECL_USER_ALIGN (decl
) = 1;
5865 /* Handle a "weak" attribute; arguments as in
5866 struct attribute_spec.handler. */
5869 handle_weak_attribute (node
, name
, args
, flags
, no_add_attrs
)
5871 tree name ATTRIBUTE_UNUSED
;
5872 tree args ATTRIBUTE_UNUSED
;
5873 int flags ATTRIBUTE_UNUSED
;
5874 bool *no_add_attrs ATTRIBUTE_UNUSED
;
5876 declare_weak (*node
);
5881 /* Handle an "alias" attribute; arguments as in
5882 struct attribute_spec.handler. */
5885 handle_alias_attribute (node
, name
, args
, flags
, no_add_attrs
)
5889 int flags ATTRIBUTE_UNUSED
;
5894 if ((TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_INITIAL (decl
))
5895 || (TREE_CODE (decl
) != FUNCTION_DECL
&& ! DECL_EXTERNAL (decl
)))
5897 error_with_decl (decl
,
5898 "`%s' defined both normally and as an alias");
5899 *no_add_attrs
= true;
5901 else if (decl_function_context (decl
) == 0)
5905 id
= TREE_VALUE (args
);
5906 if (TREE_CODE (id
) != STRING_CST
)
5908 error ("alias arg not a string");
5909 *no_add_attrs
= true;
5912 id
= get_identifier (TREE_STRING_POINTER (id
));
5913 /* This counts as a use of the object pointed to. */
5916 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5917 DECL_INITIAL (decl
) = error_mark_node
;
5919 DECL_EXTERNAL (decl
) = 0;
5923 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5924 *no_add_attrs
= true;
5930 /* Handle an "visibility" attribute; arguments as in
5931 struct attribute_spec.handler. */
5934 handle_visibility_attribute (node
, name
, args
, flags
, no_add_attrs
)
5938 int flags ATTRIBUTE_UNUSED
;
5943 if (decl_function_context (decl
) != 0 || ! TREE_PUBLIC (decl
))
5945 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5946 *no_add_attrs
= true;
5952 id
= TREE_VALUE (args
);
5953 if (TREE_CODE (id
) != STRING_CST
)
5955 error ("visibility arg not a string");
5956 *no_add_attrs
= true;
5959 if (strcmp (TREE_STRING_POINTER (id
), "hidden")
5960 && strcmp (TREE_STRING_POINTER (id
), "protected")
5961 && strcmp (TREE_STRING_POINTER (id
), "internal")
5962 && strcmp (TREE_STRING_POINTER (id
), "default"))
5964 error ("visibility arg must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
5965 *no_add_attrs
= true;
5973 /* Handle an "tls_model" attribute; arguments as in
5974 struct attribute_spec.handler. */
5977 handle_tls_model_attribute (node
, name
, args
, flags
, no_add_attrs
)
5981 int flags ATTRIBUTE_UNUSED
;
5986 if (! DECL_THREAD_LOCAL (decl
))
5988 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5989 *no_add_attrs
= true;
5995 id
= TREE_VALUE (args
);
5996 if (TREE_CODE (id
) != STRING_CST
)
5998 error ("tls_model arg not a string");
5999 *no_add_attrs
= true;
6002 if (strcmp (TREE_STRING_POINTER (id
), "local-exec")
6003 && strcmp (TREE_STRING_POINTER (id
), "initial-exec")
6004 && strcmp (TREE_STRING_POINTER (id
), "local-dynamic")
6005 && strcmp (TREE_STRING_POINTER (id
), "global-dynamic"))
6007 error ("tls_model arg must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
6008 *no_add_attrs
= true;
6016 /* Handle a "no_instrument_function" attribute; arguments as in
6017 struct attribute_spec.handler. */
6020 handle_no_instrument_function_attribute (node
, name
, args
, flags
, no_add_attrs
)
6023 tree args ATTRIBUTE_UNUSED
;
6024 int flags ATTRIBUTE_UNUSED
;
6029 if (TREE_CODE (decl
) != FUNCTION_DECL
)
6031 error_with_decl (decl
,
6032 "`%s' attribute applies only to functions",
6033 IDENTIFIER_POINTER (name
));
6034 *no_add_attrs
= true;
6036 else if (DECL_INITIAL (decl
))
6038 error_with_decl (decl
,
6039 "can't set `%s' attribute after definition",
6040 IDENTIFIER_POINTER (name
));
6041 *no_add_attrs
= true;
6044 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl
) = 1;
6049 /* Handle a "malloc" attribute; arguments as in
6050 struct attribute_spec.handler. */
6053 handle_malloc_attribute (node
, name
, args
, flags
, no_add_attrs
)
6056 tree args ATTRIBUTE_UNUSED
;
6057 int flags ATTRIBUTE_UNUSED
;
6060 if (TREE_CODE (*node
) == FUNCTION_DECL
)
6061 DECL_IS_MALLOC (*node
) = 1;
6062 /* ??? TODO: Support types. */
6065 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
6066 *no_add_attrs
= true;
6072 /* Handle a "no_limit_stack" attribute; arguments as in
6073 struct attribute_spec.handler. */
6076 handle_no_limit_stack_attribute (node
, name
, args
, flags
, no_add_attrs
)
6079 tree args ATTRIBUTE_UNUSED
;
6080 int flags ATTRIBUTE_UNUSED
;
6085 if (TREE_CODE (decl
) != FUNCTION_DECL
)
6087 error_with_decl (decl
,
6088 "`%s' attribute applies only to functions",
6089 IDENTIFIER_POINTER (name
));
6090 *no_add_attrs
= true;
6092 else if (DECL_INITIAL (decl
))
6094 error_with_decl (decl
,
6095 "can't set `%s' attribute after definition",
6096 IDENTIFIER_POINTER (name
));
6097 *no_add_attrs
= true;
6100 DECL_NO_LIMIT_STACK (decl
) = 1;
6105 /* Handle a "pure" attribute; arguments as in
6106 struct attribute_spec.handler. */
6109 handle_pure_attribute (node
, name
, args
, flags
, no_add_attrs
)
6112 tree args ATTRIBUTE_UNUSED
;
6113 int flags ATTRIBUTE_UNUSED
;
6116 if (TREE_CODE (*node
) == FUNCTION_DECL
)
6117 DECL_IS_PURE (*node
) = 1;
6118 /* ??? TODO: Support types. */
6121 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
6122 *no_add_attrs
= true;
6128 /* Handle a "deprecated" attribute; arguments as in
6129 struct attribute_spec.handler. */
6132 handle_deprecated_attribute (node
, name
, args
, flags
, no_add_attrs
)
6135 tree args ATTRIBUTE_UNUSED
;
6139 tree type
= NULL_TREE
;
6141 const char *what
= NULL
;
6146 type
= TREE_TYPE (decl
);
6148 if (TREE_CODE (decl
) == TYPE_DECL
6149 || TREE_CODE (decl
) == PARM_DECL
6150 || TREE_CODE (decl
) == VAR_DECL
6151 || TREE_CODE (decl
) == FUNCTION_DECL
6152 || TREE_CODE (decl
) == FIELD_DECL
)
6153 TREE_DEPRECATED (decl
) = 1;
6157 else if (TYPE_P (*node
))
6159 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
6160 *node
= build_type_copy (*node
);
6161 TREE_DEPRECATED (*node
) = 1;
6169 *no_add_attrs
= true;
6170 if (type
&& TYPE_NAME (type
))
6172 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
6173 what
= IDENTIFIER_POINTER (TYPE_NAME (*node
));
6174 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
6175 && DECL_NAME (TYPE_NAME (type
)))
6176 what
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)));
6179 warning ("`%s' attribute ignored for `%s'",
6180 IDENTIFIER_POINTER (name
), what
);
6182 warning ("`%s' attribute ignored",
6183 IDENTIFIER_POINTER (name
));
6189 /* Keep a list of vector type nodes we created in handle_vector_size_attribute,
6190 to prevent us from duplicating type nodes unnecessarily.
6191 The normal mechanism to prevent duplicates is to use type_hash_canon, but
6192 since we want to distinguish types that are essentially identical (except
6193 for their debug representation), we use a local list here. */
6194 static GTY(()) tree vector_type_node_list
= 0;
6196 /* Handle a "vector_size" attribute; arguments as in
6197 struct attribute_spec.handler. */
6200 handle_vector_size_attribute (node
, name
, args
, flags
, no_add_attrs
)
6204 int flags ATTRIBUTE_UNUSED
;
6207 unsigned HOST_WIDE_INT vecsize
, nunits
;
6208 enum machine_mode mode
, orig_mode
, new_mode
;
6209 tree type
= *node
, new_type
= NULL_TREE
;
6210 tree type_list_node
;
6212 *no_add_attrs
= true;
6214 if (! host_integerp (TREE_VALUE (args
), 1))
6216 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
6220 /* Get the vector size (in bytes). */
6221 vecsize
= tree_low_cst (TREE_VALUE (args
), 1);
6223 /* We need to provide for vector pointers, vector arrays, and
6224 functions returning vectors. For example:
6226 __attribute__((vector_size(16))) short *foo;
6228 In this case, the mode is SI, but the type being modified is
6229 HI, so we need to look further. */
6231 while (POINTER_TYPE_P (type
)
6232 || TREE_CODE (type
) == FUNCTION_TYPE
6233 || TREE_CODE (type
) == ARRAY_TYPE
)
6234 type
= TREE_TYPE (type
);
6236 /* Get the mode of the type being modified. */
6237 orig_mode
= TYPE_MODE (type
);
6239 if (TREE_CODE (type
) == RECORD_TYPE
6240 || (GET_MODE_CLASS (orig_mode
) != MODE_FLOAT
6241 && GET_MODE_CLASS (orig_mode
) != MODE_INT
)
6242 || ! host_integerp (TYPE_SIZE_UNIT (type
), 1))
6244 error ("invalid vector type for attribute `%s'",
6245 IDENTIFIER_POINTER (name
));
6249 /* Calculate how many units fit in the vector. */
6250 nunits
= vecsize
/ tree_low_cst (TYPE_SIZE_UNIT (type
), 1);
6252 /* Find a suitably sized vector. */
6253 new_mode
= VOIDmode
;
6254 for (mode
= GET_CLASS_NARROWEST_MODE (GET_MODE_CLASS (orig_mode
) == MODE_INT
6256 : MODE_VECTOR_FLOAT
);
6258 mode
= GET_MODE_WIDER_MODE (mode
))
6259 if (vecsize
== GET_MODE_SIZE (mode
)
6260 && nunits
== (unsigned HOST_WIDE_INT
) GET_MODE_NUNITS (mode
))
6266 if (new_mode
== VOIDmode
)
6268 error ("no vector mode with the size and type specified could be found");
6272 for (type_list_node
= vector_type_node_list
; type_list_node
;
6273 type_list_node
= TREE_CHAIN (type_list_node
))
6275 tree other_type
= TREE_VALUE (type_list_node
);
6276 tree record
= TYPE_DEBUG_REPRESENTATION_TYPE (other_type
);
6277 tree fields
= TYPE_FIELDS (record
);
6278 tree field_type
= TREE_TYPE (fields
);
6279 tree array_type
= TREE_TYPE (field_type
);
6280 if (TREE_CODE (fields
) != FIELD_DECL
6281 || TREE_CODE (field_type
) != ARRAY_TYPE
)
6284 if (TYPE_MODE (other_type
) == mode
&& type
== array_type
)
6286 new_type
= other_type
;
6291 if (new_type
== NULL_TREE
)
6293 tree index
, array
, rt
, list_node
;
6295 new_type
= (*lang_hooks
.types
.type_for_mode
) (new_mode
,
6296 TREE_UNSIGNED (type
));
6300 error ("no vector mode with the size and type specified could be found");
6304 new_type
= build_type_copy (new_type
);
6306 /* If this is a vector, make sure we either have hardware
6307 support, or we can emulate it. */
6308 if ((GET_MODE_CLASS (mode
) == MODE_VECTOR_INT
6309 || GET_MODE_CLASS (mode
) == MODE_VECTOR_FLOAT
)
6310 && !vector_mode_valid_p (mode
))
6312 error ("unable to emulate '%s'", GET_MODE_NAME (mode
));
6316 /* Set the debug information here, because this is the only
6317 place where we know the underlying type for a vector made
6318 with vector_size. For debugging purposes we pretend a vector
6319 is an array within a structure. */
6320 index
= build_int_2 (TYPE_VECTOR_SUBPARTS (new_type
) - 1, 0);
6321 array
= build_array_type (type
, build_index_type (index
));
6322 rt
= make_node (RECORD_TYPE
);
6324 TYPE_FIELDS (rt
) = build_decl (FIELD_DECL
, get_identifier ("f"), array
);
6325 DECL_CONTEXT (TYPE_FIELDS (rt
)) = rt
;
6327 TYPE_DEBUG_REPRESENTATION_TYPE (new_type
) = rt
;
6329 list_node
= build_tree_list (NULL
, new_type
);
6330 TREE_CHAIN (list_node
) = vector_type_node_list
;
6331 vector_type_node_list
= list_node
;
6334 /* Build back pointers if needed. */
6335 *node
= vector_size_helper (*node
, new_type
);
6340 /* HACK. GROSS. This is absolutely disgusting. I wish there was a
6343 If we requested a pointer to a vector, build up the pointers that
6344 we stripped off while looking for the inner type. Similarly for
6345 return values from functions.
6347 The argument "type" is the top of the chain, and "bottom" is the
6348 new type which we will point to. */
6351 vector_size_helper (type
, bottom
)
6356 if (POINTER_TYPE_P (type
))
6358 inner
= vector_size_helper (TREE_TYPE (type
), bottom
);
6359 outer
= build_pointer_type (inner
);
6361 else if (TREE_CODE (type
) == ARRAY_TYPE
)
6363 inner
= vector_size_helper (TREE_TYPE (type
), bottom
);
6364 outer
= build_array_type (inner
, TYPE_VALUES (type
));
6366 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
6368 inner
= vector_size_helper (TREE_TYPE (type
), bottom
);
6369 outer
= build_function_type (inner
, TYPE_VALUES (type
));
6374 TREE_READONLY (outer
) = TREE_READONLY (type
);
6375 TREE_THIS_VOLATILE (outer
) = TREE_THIS_VOLATILE (type
);
6380 /* Handle the "nonnull" attribute. */
6382 handle_nonnull_attribute (node
, name
, args
, flags
, no_add_attrs
)
6384 tree name ATTRIBUTE_UNUSED
;
6386 int flags ATTRIBUTE_UNUSED
;
6390 unsigned HOST_WIDE_INT attr_arg_num
;
6392 /* If no arguments are specified, all pointer arguments should be
6393 non-null. Verify a full prototype is given so that the arguments
6394 will have the correct types when we actually check them later. */
6397 if (! TYPE_ARG_TYPES (type
))
6399 error ("nonnull attribute without arguments on a non-prototype");
6400 *no_add_attrs
= true;
6405 /* Argument list specified. Verify that each argument number references
6406 a pointer argument. */
6407 for (attr_arg_num
= 1; args
; args
= TREE_CHAIN (args
))
6410 unsigned HOST_WIDE_INT arg_num
, ck_num
;
6412 if (! get_nonnull_operand (TREE_VALUE (args
), &arg_num
))
6414 error ("nonnull argument has invalid operand number (arg %lu)",
6415 (unsigned long) attr_arg_num
);
6416 *no_add_attrs
= true;
6420 argument
= TYPE_ARG_TYPES (type
);
6423 for (ck_num
= 1; ; ck_num
++)
6425 if (! argument
|| ck_num
== arg_num
)
6427 argument
= TREE_CHAIN (argument
);
6431 || TREE_CODE (TREE_VALUE (argument
)) == VOID_TYPE
)
6433 error ("nonnull argument with out-of-range operand number (arg %lu, operand %lu)",
6434 (unsigned long) attr_arg_num
, (unsigned long) arg_num
);
6435 *no_add_attrs
= true;
6439 if (TREE_CODE (TREE_VALUE (argument
)) != POINTER_TYPE
)
6441 error ("nonnull argument references non-pointer operand (arg %lu, operand %lu)",
6442 (unsigned long) attr_arg_num
, (unsigned long) arg_num
);
6443 *no_add_attrs
= true;
6452 /* Check the argument list of a function call for null in argument slots
6453 that are marked as requiring a non-null pointer argument. */
6456 check_function_nonnull (attrs
, params
)
6460 tree a
, args
, param
;
6463 for (a
= attrs
; a
; a
= TREE_CHAIN (a
))
6465 if (is_attribute_p ("nonnull", TREE_PURPOSE (a
)))
6467 args
= TREE_VALUE (a
);
6469 /* Walk the argument list. If we encounter an argument number we
6470 should check for non-null, do it. If the attribute has no args,
6471 then every pointer argument is checked (in which case the check
6472 for pointer type is done in check_nonnull_arg). */
6473 for (param
= params
, param_num
= 1; ;
6474 param_num
++, param
= TREE_CHAIN (param
))
6478 if (! args
|| nonnull_check_p (args
, param_num
))
6479 check_function_arguments_recurse (check_nonnull_arg
, NULL
,
6487 /* Helper for check_function_nonnull; given a list of operands which
6488 must be non-null in ARGS, determine if operand PARAM_NUM should be
6492 nonnull_check_p (args
, param_num
)
6494 unsigned HOST_WIDE_INT param_num
;
6496 unsigned HOST_WIDE_INT arg_num
;
6498 for (; args
; args
= TREE_CHAIN (args
))
6500 if (! get_nonnull_operand (TREE_VALUE (args
), &arg_num
))
6503 if (arg_num
== param_num
)
6509 /* Check that the function argument PARAM (which is operand number
6510 PARAM_NUM) is non-null. This is called by check_function_nonnull
6511 via check_function_arguments_recurse. */
6514 check_nonnull_arg (ctx
, param
, param_num
)
6515 void *ctx ATTRIBUTE_UNUSED
;
6517 unsigned HOST_WIDE_INT param_num
;
6519 /* Just skip checking the argument if it's not a pointer. This can
6520 happen if the "nonnull" attribute was given without an operand
6521 list (which means to check every pointer argument). */
6523 if (TREE_CODE (TREE_TYPE (param
)) != POINTER_TYPE
)
6526 if (integer_zerop (param
))
6527 warning ("null argument where non-null required (arg %lu)",
6528 (unsigned long) param_num
);
6531 /* Helper for nonnull attribute handling; fetch the operand number
6532 from the attribute argument list. */
6535 get_nonnull_operand (arg_num_expr
, valp
)
6537 unsigned HOST_WIDE_INT
*valp
;
6539 /* Strip any conversions from the arg number and verify they
6541 while (TREE_CODE (arg_num_expr
) == NOP_EXPR
6542 || TREE_CODE (arg_num_expr
) == CONVERT_EXPR
6543 || TREE_CODE (arg_num_expr
) == NON_LVALUE_EXPR
)
6544 arg_num_expr
= TREE_OPERAND (arg_num_expr
, 0);
6546 if (TREE_CODE (arg_num_expr
) != INTEGER_CST
6547 || TREE_INT_CST_HIGH (arg_num_expr
) != 0)
6550 *valp
= TREE_INT_CST_LOW (arg_num_expr
);
6554 /* Handle a "nothrow" attribute; arguments as in
6555 struct attribute_spec.handler. */
6558 handle_nothrow_attribute (node
, name
, args
, flags
, no_add_attrs
)
6561 tree args ATTRIBUTE_UNUSED
;
6562 int flags ATTRIBUTE_UNUSED
;
6565 if (TREE_CODE (*node
) == FUNCTION_DECL
)
6566 TREE_NOTHROW (*node
) = 1;
6567 /* ??? TODO: Support types. */
6570 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
6571 *no_add_attrs
= true;
6577 /* Check for valid arguments being passed to a function. */
6579 check_function_arguments (attrs
, params
)
6583 /* Check for null being passed in a pointer argument that must be
6584 non-null. We also need to do this if format checking is enabled. */
6587 check_function_nonnull (attrs
, params
);
6589 /* Check for errors in format strings. */
6592 check_function_format (NULL
, attrs
, params
);
6595 /* Generic argument checking recursion routine. PARAM is the argument to
6596 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
6597 once the argument is resolved. CTX is context for the callback. */
6599 check_function_arguments_recurse (callback
, ctx
, param
, param_num
)
6600 void (*callback
) PARAMS ((void *, tree
, unsigned HOST_WIDE_INT
));
6603 unsigned HOST_WIDE_INT param_num
;
6605 if (TREE_CODE (param
) == NOP_EXPR
)
6607 /* Strip coercion. */
6608 check_function_arguments_recurse (callback
, ctx
,
6609 TREE_OPERAND (param
, 0), param_num
);
6613 if (TREE_CODE (param
) == CALL_EXPR
)
6615 tree type
= TREE_TYPE (TREE_TYPE (TREE_OPERAND (param
, 0)));
6617 bool found_format_arg
= false;
6619 /* See if this is a call to a known internationalization function
6620 that modifies a format arg. Such a function may have multiple
6621 format_arg attributes (for example, ngettext). */
6623 for (attrs
= TYPE_ATTRIBUTES (type
);
6625 attrs
= TREE_CHAIN (attrs
))
6626 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs
)))
6629 tree format_num_expr
;
6633 /* Extract the argument number, which was previously checked
6635 format_num_expr
= TREE_VALUE (TREE_VALUE (attrs
));
6636 while (TREE_CODE (format_num_expr
) == NOP_EXPR
6637 || TREE_CODE (format_num_expr
) == CONVERT_EXPR
6638 || TREE_CODE (format_num_expr
) == NON_LVALUE_EXPR
)
6639 format_num_expr
= TREE_OPERAND (format_num_expr
, 0);
6641 if (TREE_CODE (format_num_expr
) != INTEGER_CST
6642 || TREE_INT_CST_HIGH (format_num_expr
) != 0)
6645 format_num
= TREE_INT_CST_LOW (format_num_expr
);
6647 for (inner_args
= TREE_OPERAND (param
, 1), i
= 1;
6649 inner_args
= TREE_CHAIN (inner_args
), i
++)
6650 if (i
== format_num
)
6652 check_function_arguments_recurse (callback
, ctx
,
6653 TREE_VALUE (inner_args
),
6655 found_format_arg
= true;
6660 /* If we found a format_arg attribute and did a recursive check,
6661 we are done with checking this argument. Otherwise, we continue
6662 and this will be considered a non-literal. */
6663 if (found_format_arg
)
6667 if (TREE_CODE (param
) == COND_EXPR
)
6669 /* Check both halves of the conditional expression. */
6670 check_function_arguments_recurse (callback
, ctx
,
6671 TREE_OPERAND (param
, 1), param_num
);
6672 check_function_arguments_recurse (callback
, ctx
,
6673 TREE_OPERAND (param
, 2), param_num
);
6677 (*callback
) (ctx
, param
, param_num
);
6680 #include "gt-c-common.h"