1 /* Subroutines shared by all languages that are variants of C.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003 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"
36 #include "diagnostic.h"
41 #include "langhooks.h"
42 #include "tree-inline.h"
45 cpp_reader
*parse_in
; /* Declared in c-pragma.h. */
47 /* We let tm.h override the types used here, to handle trivial differences
48 such as the choice of unsigned int or long unsigned int for size_t.
49 When machines start needing nontrivial differences in the size type,
50 it would be best to do something here to figure out automatically
51 from other information what type to use. */
54 #define SIZE_TYPE "long unsigned int"
58 #define WCHAR_TYPE "int"
61 /* WCHAR_TYPE gets overridden by -fshort-wchar. */
62 #define MODIFIED_WCHAR_TYPE \
63 (flag_short_wchar ? "short unsigned int" : WCHAR_TYPE)
66 #define PTRDIFF_TYPE "long int"
70 #define WINT_TYPE "unsigned int"
74 #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
76 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
82 #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
84 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
85 ? "long unsigned int" \
86 : "long long unsigned int"))
89 /* The variant of the C language being processed. */
91 enum c_language_kind c_language
;
93 /* The following symbols are subsumed in the c_global_trees array, and
94 listed here individually for documentation purposes.
96 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
98 tree short_integer_type_node;
99 tree long_integer_type_node;
100 tree long_long_integer_type_node;
102 tree short_unsigned_type_node;
103 tree long_unsigned_type_node;
104 tree long_long_unsigned_type_node;
106 tree boolean_type_node;
107 tree boolean_false_node;
108 tree boolean_true_node;
110 tree ptrdiff_type_node;
112 tree unsigned_char_type_node;
113 tree signed_char_type_node;
114 tree wchar_type_node;
115 tree signed_wchar_type_node;
116 tree unsigned_wchar_type_node;
118 tree float_type_node;
119 tree double_type_node;
120 tree long_double_type_node;
122 tree complex_integer_type_node;
123 tree complex_float_type_node;
124 tree complex_double_type_node;
125 tree complex_long_double_type_node;
127 tree intQI_type_node;
128 tree intHI_type_node;
129 tree intSI_type_node;
130 tree intDI_type_node;
131 tree intTI_type_node;
133 tree unsigned_intQI_type_node;
134 tree unsigned_intHI_type_node;
135 tree unsigned_intSI_type_node;
136 tree unsigned_intDI_type_node;
137 tree unsigned_intTI_type_node;
139 tree widest_integer_literal_type_node;
140 tree widest_unsigned_literal_type_node;
142 Nodes for types `void *' and `const void *'.
144 tree ptr_type_node, const_ptr_type_node;
146 Nodes for types `char *' and `const char *'.
148 tree string_type_node, const_string_type_node;
150 Type `char[SOMENUMBER]'.
151 Used when an array of char is needed and the size is irrelevant.
153 tree char_array_type_node;
155 Type `int[SOMENUMBER]' or something like it.
156 Used when an array of int needed and the size is irrelevant.
158 tree int_array_type_node;
160 Type `wchar_t[SOMENUMBER]' or something like it.
161 Used when a wide string literal is created.
163 tree wchar_array_type_node;
165 Type `int ()' -- used for implicit declaration of functions.
167 tree default_function_type;
169 A VOID_TYPE node, packaged in a TREE_LIST.
173 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
174 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
175 VAR_DECLS, but C++ does.)
177 tree function_name_decl_node;
178 tree pretty_function_name_decl_node;
179 tree c99_function_name_decl_node;
181 Stack of nested function name VAR_DECLs.
183 tree saved_function_name_decls;
187 tree c_global_trees
[CTI_MAX
];
189 /* Nonzero if we can read a PCH file now. */
193 /* Switches common to the C front ends. */
195 /* Nonzero if prepreprocessing only. */
197 int flag_preprocess_only
;
199 /* Nonzero means don't output line number information. */
201 char flag_no_line_commands
;
203 /* Nonzero causes -E output not to be done, but directives such as
204 #define that have side effects are still obeyed. */
208 /* Nonzero means dump macros in some fashion. */
210 char flag_dump_macros
;
212 /* Nonzero means pass #include lines through to the output. */
214 char flag_dump_includes
;
216 /* The file name to which we should write a precompiled header, or
217 NULL if no header will be written in this compile. */
219 const char *pch_file
;
221 /* Nonzero if an ISO standard was selected. It rejects macros in the
225 /* Nonzero whenever Objective-C functionality is being used. */
228 /* Nonzero if -undef was given. It suppresses target built-in macros
232 /* Nonzero means don't recognize the non-ANSI builtin functions. */
236 /* Nonzero means don't recognize the non-ANSI builtin functions.
239 int flag_no_nonansi_builtin
;
241 /* Nonzero means give `double' the same size as `float'. */
243 int flag_short_double
;
245 /* Nonzero means give `wchar_t' the same size as `short'. */
247 int flag_short_wchar
;
249 /* Nonzero means allow Microsoft extensions without warnings or errors. */
250 int flag_ms_extensions
;
252 /* Nonzero means don't recognize the keyword `asm'. */
256 /* Nonzero means give string constants the type `const char *', as mandated
259 int flag_const_strings
;
261 /* Nonzero means `$' can be in an identifier. */
263 #ifndef DOLLARS_IN_IDENTIFIERS
264 #define DOLLARS_IN_IDENTIFIERS 1
266 int dollars_in_ident
= DOLLARS_IN_IDENTIFIERS
;
268 /* Nonzero means to treat bitfields as signed unless they say `unsigned'. */
270 int flag_signed_bitfields
= 1;
271 int explicit_flag_signed_bitfields
;
273 /* Nonzero means warn about pointer casts that can drop a type qualifier
274 from the pointer target type. */
278 /* Warn about functions which might be candidates for format attributes. */
280 int warn_missing_format_attribute
;
282 /* Nonzero means warn about sizeof(function) or addition/subtraction
283 of function pointers. */
285 int warn_pointer_arith
;
287 /* Nonzero means warn for any global function def
288 without separate previous prototype decl. */
290 int warn_missing_prototypes
;
292 /* Warn if adding () is suggested. */
294 int warn_parentheses
;
296 /* Warn if initializer is not completely bracketed. */
298 int warn_missing_braces
;
300 /* Warn about comparison of signed and unsigned values.
301 If -1, neither -Wsign-compare nor -Wno-sign-compare has been specified. */
303 int warn_sign_compare
;
305 /* Nonzero means warn about usage of long long when `-pedantic'. */
307 int warn_long_long
= 1;
309 /* Nonzero means warn about deprecated conversion from string constant to
312 int warn_write_strings
;
314 /* Nonzero means warn about multiple (redundant) decls for the same single
315 variable or function. */
317 int warn_redundant_decls
;
319 /* Warn about testing equality of floating point numbers. */
321 int warn_float_equal
;
323 /* Warn about a subscript that has type char. */
325 int warn_char_subscripts
;
327 /* Warn if a type conversion is done that might have confusing results. */
331 /* Warn about #pragma directives that are not recognized. */
333 int warn_unknown_pragmas
; /* Tri state variable. */
335 /* Warn about format/argument anomalies in calls to formatted I/O functions
336 (*printf, *scanf, strftime, strfmon, etc.). */
340 /* Warn about Y2K problems with strftime formats. */
344 /* Warn about excess arguments to formats. */
346 int warn_format_extra_args
;
348 /* Warn about zero-length formats. */
350 int warn_format_zero_length
;
352 /* Warn about non-literal format arguments. */
354 int warn_format_nonliteral
;
356 /* Warn about possible security problems with calls to format functions. */
358 int warn_format_security
;
361 /* C/ObjC language option variables. */
364 /* Nonzero means message about use of implicit function declarations;
365 1 means warning; 2 means error. */
367 int mesg_implicit_function_declaration
= -1;
369 /* Nonzero means allow type mismatches in conditional expressions;
370 just make their values `void'. */
372 int flag_cond_mismatch
;
374 /* Nonzero means enable C89 Amendment 1 features. */
378 /* Nonzero means use the ISO C99 dialect of C. */
382 /* Nonzero means that we have builtin functions, and main is an int */
386 /* Nonzero means add default format_arg attributes for functions not
389 int flag_noniso_default_format_attributes
= 1;
391 /* Nonzero means warn when casting a function call to a type that does
392 not match the return type (e.g. (float)sqrt() or (anything*)malloc()
393 when there is no previous declaration of sqrt or malloc. */
395 int warn_bad_function_cast
;
397 /* Warn about traditional constructs whose meanings changed in ANSI C. */
399 int warn_traditional
;
401 /* Nonzero means warn for non-prototype function decls
402 or non-prototyped defs without previous prototype. */
404 int warn_strict_prototypes
;
406 /* Nonzero means warn for any global function def
407 without separate previous decl. */
409 int warn_missing_declarations
;
411 /* Nonzero means warn about declarations of objects not at
412 file-scope level and about *all* declarations of functions (whether
413 or static) not at file-scope level. Note that we exclude
414 implicit function declarations. To get warnings about those, use
417 int warn_nested_externs
;
419 /* Warn if main is suspicious. */
423 /* Nonzero means warn about possible violations of sequence point rules. */
425 int warn_sequence_point
;
427 /* Nonzero means to warn about compile-time division by zero. */
428 int warn_div_by_zero
= 1;
430 /* Nonzero means warn about use of implicit int. */
432 int warn_implicit_int
;
434 /* Warn about NULL being passed to argument slots marked as requiring
440 /* ObjC language option variables. */
443 /* Open and close the file for outputting class declarations, if
446 int flag_gen_declaration
;
448 /* Generate code for GNU or NeXT runtime environment. */
450 #ifdef NEXT_OBJC_RUNTIME
451 int flag_next_runtime
= 1;
453 int flag_next_runtime
= 0;
456 /* Tells the compiler that this is a special run. Do not perform any
457 compiling, instead we are to test some platform dependent features
458 and output a C header file with appropriate definitions. */
460 int print_struct_values
;
462 /* ???. Undocumented. */
464 const char *constant_string_class_name
;
466 /* Warn if multiple methods are seen for the same selector, but with
467 different argument types. Performs the check on the whole selector
468 table at the end of compilation. */
472 /* Warn if a @selector() is found, and no method with that selector
473 has been previously declared. The check is done on each
474 @selector() as soon as it is found - so it warns about forward
477 int warn_undeclared_selector
;
479 /* Warn if methods required by a protocol are not implemented in the
480 class adopting it. When turned off, methods inherited to that
481 class are also considered implemented. */
483 int warn_protocol
= 1;
486 /* C++ language option variables. */
489 /* Nonzero means don't recognize any extension keywords. */
491 int flag_no_gnu_keywords
;
493 /* Nonzero means do emit exported implementations of functions even if
494 they can be inlined. */
496 int flag_implement_inlines
= 1;
498 /* Nonzero means do emit exported implementations of templates, instead of
499 multiple static copies in each file that needs a definition. */
501 int flag_external_templates
;
503 /* Nonzero means that the decision to emit or not emit the implementation of a
504 template depends on where the template is instantiated, rather than where
507 int flag_alt_external_templates
;
509 /* Nonzero means that implicit instantiations will be emitted if needed. */
511 int flag_implicit_templates
= 1;
513 /* Nonzero means that implicit instantiations of inline templates will be
514 emitted if needed, even if instantiations of non-inline templates
517 int flag_implicit_inline_templates
= 1;
519 /* Nonzero means generate separate instantiation control files and
520 juggle them at link time. */
522 int flag_use_repository
;
524 /* Nonzero if we want to issue diagnostics that the standard says are not
527 int flag_optional_diags
= 1;
529 /* Nonzero means we should attempt to elide constructors when possible. */
531 int flag_elide_constructors
= 1;
533 /* Nonzero means that member functions defined in class scope are
534 inline by default. */
536 int flag_default_inline
= 1;
538 /* Controls whether compiler generates 'type descriptor' that give
539 run-time type information. */
543 /* Nonzero if we want to conserve space in the .o files. We do this
544 by putting uninitialized data and runtime initialized data into
545 .common instead of .data at the expense of not flagging multiple
548 int flag_conserve_space
;
550 /* Nonzero if we want to obey access control semantics. */
552 int flag_access_control
= 1;
554 /* Nonzero if we want to check the return value of new and avoid calling
555 constructors if it is a null pointer. */
559 /* Nonzero if we want the new ISO rules for pushing a new scope for `for'
560 initialization variables.
561 0: Old rules, set by -fno-for-scope.
562 2: New ISO rules, set by -ffor-scope.
563 1: Try to implement new ISO rules, but with backup compatibility
564 (and warnings). This is the default, for now. */
566 int flag_new_for_scope
= 1;
568 /* Nonzero if we want to emit defined symbols with common-like linkage as
569 weak symbols where possible, in order to conform to C++ semantics.
570 Otherwise, emit them as local symbols. */
574 /* Nonzero to use __cxa_atexit, rather than atexit, to register
575 destructors for local statics and global objects. */
577 int flag_use_cxa_atexit
= DEFAULT_USE_CXA_ATEXIT
;
579 /* Nonzero means output .vtable_{entry,inherit} for use in doing vtable gc. */
583 /* Nonzero means make the default pedwarns warnings instead of errors.
584 The value of this flag is ignored if -pedantic is specified. */
588 /* Nonzero means to implement standard semantics for exception
589 specifications, calling unexpected if an exception is thrown that
590 doesn't match the specification. Zero means to treat them as
591 assertions and optimize accordingly, but not check them. */
593 int flag_enforce_eh_specs
= 1;
595 /* The version of the C++ ABI in use. The following values are
598 0: The version of the ABI believed most conformant with the
599 C++ ABI specification. This ABI may change as bugs are
600 discovered and fixed. Therefore, 0 will not necessarily
601 indicate the same ABI in different versions of G++.
603 1: The version of the ABI first used in G++ 3.2.
605 Additional positive integers will be assigned as new versions of
606 the ABI become the default version of the ABI. */
608 int flag_abi_version
= 1;
610 /* Nonzero means warn about things that will change when compiling
611 with an ABI-compliant compiler. */
615 /* Nonzero means warn about implicit declarations. */
617 int warn_implicit
= 1;
619 /* Nonzero means warn when all ctors or dtors are private, and the class
622 int warn_ctor_dtor_privacy
= 1;
624 /* Nonzero means warn in function declared in derived class has the
625 same name as a virtual in the base class, but fails to match the
626 type signature of any virtual function in the base class. */
628 int warn_overloaded_virtual
;
630 /* Nonzero means warn when declaring a class that has a non virtual
631 destructor, when it really ought to have a virtual one. */
635 /* Nonzero means warn when the compiler will reorder code. */
639 /* Nonzero means warn when synthesis behavior differs from Cfront's. */
643 /* Nonzero means warn when we convert a pointer to member function
644 into a pointer to (void or function). */
646 int warn_pmf2ptr
= 1;
648 /* Nonzero means warn about violation of some Effective C++ style rules. */
652 /* Nonzero means warn where overload resolution chooses a promotion from
653 unsigned to signed over a conversion to an unsigned of the same size. */
657 /* Nonzero means warn when an old-style cast is used. */
659 int warn_old_style_cast
;
661 /* Nonzero means warn when non-templatized friend functions are
662 declared within a template */
664 int warn_nontemplate_friend
= 1;
666 /* Nonzero means complain about deprecated features. */
668 int warn_deprecated
= 1;
670 /* Maximum template instantiation depth. This limit is rather
671 arbitrary, but it exists to limit the time it takes to notice
672 infinite template instantiations. */
674 int max_tinst_depth
= 500;
678 /* The elements of `ridpointers' are identifier nodes for the reserved
679 type names and storage classes. It is indexed by a RID_... value. */
682 tree (*make_fname_decl
) PARAMS ((tree
, int));
684 /* If non-NULL, the address of a language-specific function that
685 returns 1 for language-specific statement codes. */
686 int (*lang_statement_code_p
) PARAMS ((enum tree_code
));
688 /* If non-NULL, the address of a language-specific function that takes
689 any action required right before expand_function_end is called. */
690 void (*lang_expand_function_end
) PARAMS ((void));
692 /* Nonzero means the expression being parsed will never be evaluated.
693 This is a count, since unevaluated expressions can nest. */
696 /* Information about how a function name is generated. */
699 tree
*const decl
; /* pointer to the VAR_DECL. */
700 const unsigned rid
; /* RID number for the identifier. */
701 const int pretty
; /* How pretty is it? */
704 /* The three ways of getting then name of the current function. */
706 const struct fname_var_t fname_vars
[] =
708 /* C99 compliant __func__, must be first. */
709 {&c99_function_name_decl_node
, RID_C99_FUNCTION_NAME
, 0},
710 /* GCC __FUNCTION__ compliant. */
711 {&function_name_decl_node
, RID_FUNCTION_NAME
, 0},
712 /* GCC __PRETTY_FUNCTION__ compliant. */
713 {&pretty_function_name_decl_node
, RID_PRETTY_FUNCTION_NAME
, 1},
717 static int constant_fits_type_p
PARAMS ((tree
, tree
));
719 /* Keep a stack of if statements. We record the number of compound
720 statements seen up to the if keyword, as well as the line number
721 and file of the if. If a potentially ambiguous else is seen, that
722 fact is recorded; the warning is issued when we can be sure that
723 the enclosing if statement does not have an else branch. */
733 static if_elt
*if_stack
;
735 /* Amount of space in the if statement stack. */
736 static int if_stack_space
= 0;
739 static int if_stack_pointer
= 0;
741 static tree handle_packed_attribute
PARAMS ((tree
*, tree
, tree
, int,
743 static tree handle_nocommon_attribute
PARAMS ((tree
*, tree
, tree
, int,
745 static tree handle_common_attribute
PARAMS ((tree
*, tree
, tree
, int,
747 static tree handle_noreturn_attribute
PARAMS ((tree
*, tree
, tree
, int,
749 static tree handle_noinline_attribute
PARAMS ((tree
*, tree
, tree
, int,
751 static tree handle_always_inline_attribute
PARAMS ((tree
*, tree
, tree
, int,
753 static tree handle_used_attribute
PARAMS ((tree
*, tree
, tree
, int,
755 static tree handle_unused_attribute
PARAMS ((tree
*, tree
, tree
, int,
757 static tree handle_const_attribute
PARAMS ((tree
*, tree
, tree
, int,
759 static tree handle_transparent_union_attribute
PARAMS ((tree
*, tree
, tree
,
761 static tree handle_constructor_attribute
PARAMS ((tree
*, tree
, tree
, int,
763 static tree handle_destructor_attribute
PARAMS ((tree
*, tree
, tree
, int,
765 static tree handle_mode_attribute
PARAMS ((tree
*, tree
, tree
, int,
767 static tree handle_section_attribute
PARAMS ((tree
*, tree
, tree
, int,
769 static tree handle_aligned_attribute
PARAMS ((tree
*, tree
, tree
, int,
771 static tree handle_weak_attribute
PARAMS ((tree
*, tree
, tree
, int,
773 static tree handle_alias_attribute
PARAMS ((tree
*, tree
, tree
, int,
775 static tree handle_visibility_attribute
PARAMS ((tree
*, tree
, tree
, int,
777 static tree handle_tls_model_attribute
PARAMS ((tree
*, tree
, tree
, int,
779 static tree handle_no_instrument_function_attribute
PARAMS ((tree
*, tree
,
782 static tree handle_malloc_attribute
PARAMS ((tree
*, tree
, tree
, int,
784 static tree handle_no_limit_stack_attribute
PARAMS ((tree
*, tree
, tree
, int,
786 static tree handle_pure_attribute
PARAMS ((tree
*, tree
, tree
, int,
788 static tree handle_deprecated_attribute
PARAMS ((tree
*, tree
, tree
, int,
790 static tree handle_vector_size_attribute
PARAMS ((tree
*, tree
, tree
, int,
792 static tree handle_nonnull_attribute
PARAMS ((tree
*, tree
, tree
, int,
794 static tree handle_nothrow_attribute
PARAMS ((tree
*, tree
, tree
, int,
796 static tree vector_size_helper
PARAMS ((tree
, tree
));
798 static void check_function_nonnull
PARAMS ((tree
, tree
));
799 static void check_nonnull_arg
PARAMS ((void *, tree
,
800 unsigned HOST_WIDE_INT
));
801 static bool nonnull_check_p
PARAMS ((tree
, unsigned HOST_WIDE_INT
));
802 static bool get_nonnull_operand
PARAMS ((tree
,
803 unsigned HOST_WIDE_INT
*));
805 /* Table of machine-independent attributes common to all C-like languages. */
806 const struct attribute_spec c_common_attribute_table
[] =
808 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
809 { "packed", 0, 0, false, false, false,
810 handle_packed_attribute
},
811 { "nocommon", 0, 0, true, false, false,
812 handle_nocommon_attribute
},
813 { "common", 0, 0, true, false, false,
814 handle_common_attribute
},
815 /* FIXME: logically, noreturn attributes should be listed as
816 "false, true, true" and apply to function types. But implementing this
817 would require all the places in the compiler that use TREE_THIS_VOLATILE
818 on a decl to identify non-returning functions to be located and fixed
819 to check the function type instead. */
820 { "noreturn", 0, 0, true, false, false,
821 handle_noreturn_attribute
},
822 { "volatile", 0, 0, true, false, false,
823 handle_noreturn_attribute
},
824 { "noinline", 0, 0, true, false, false,
825 handle_noinline_attribute
},
826 { "always_inline", 0, 0, true, false, false,
827 handle_always_inline_attribute
},
828 { "used", 0, 0, true, false, false,
829 handle_used_attribute
},
830 { "unused", 0, 0, false, false, false,
831 handle_unused_attribute
},
832 /* The same comments as for noreturn attributes apply to const ones. */
833 { "const", 0, 0, true, false, false,
834 handle_const_attribute
},
835 { "transparent_union", 0, 0, false, false, false,
836 handle_transparent_union_attribute
},
837 { "constructor", 0, 0, true, false, false,
838 handle_constructor_attribute
},
839 { "destructor", 0, 0, true, false, false,
840 handle_destructor_attribute
},
841 { "mode", 1, 1, false, true, false,
842 handle_mode_attribute
},
843 { "section", 1, 1, true, false, false,
844 handle_section_attribute
},
845 { "aligned", 0, 1, false, false, false,
846 handle_aligned_attribute
},
847 { "weak", 0, 0, true, false, false,
848 handle_weak_attribute
},
849 { "alias", 1, 1, true, false, false,
850 handle_alias_attribute
},
851 { "no_instrument_function", 0, 0, true, false, false,
852 handle_no_instrument_function_attribute
},
853 { "malloc", 0, 0, true, false, false,
854 handle_malloc_attribute
},
855 { "no_stack_limit", 0, 0, true, false, false,
856 handle_no_limit_stack_attribute
},
857 { "pure", 0, 0, true, false, false,
858 handle_pure_attribute
},
859 { "deprecated", 0, 0, false, false, false,
860 handle_deprecated_attribute
},
861 { "vector_size", 1, 1, false, true, false,
862 handle_vector_size_attribute
},
863 { "visibility", 1, 1, true, false, false,
864 handle_visibility_attribute
},
865 { "tls_model", 1, 1, true, false, false,
866 handle_tls_model_attribute
},
867 { "nonnull", 0, -1, false, true, true,
868 handle_nonnull_attribute
},
869 { "nothrow", 0, 0, true, false, false,
870 handle_nothrow_attribute
},
871 { "may_alias", 0, 0, false, true, false, NULL
},
872 { NULL
, 0, 0, false, false, false, NULL
}
875 /* Give the specifications for the format attributes, used by C and all
878 const struct attribute_spec c_common_format_attribute_table
[] =
880 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
881 { "format", 3, 3, false, true, true,
882 handle_format_attribute
},
883 { "format_arg", 1, 1, false, true, true,
884 handle_format_arg_attribute
},
885 { NULL
, 0, 0, false, false, false, NULL
}
888 /* Record the start of an if-then, and record the start of it
889 for ambiguous else detection.
891 COND is the condition for the if-then statement.
893 IF_STMT is the statement node that has already been created for
894 this if-then statement. It is created before parsing the
895 condition to keep line number information accurate. */
898 c_expand_start_cond (cond
, compstmt_count
, if_stmt
)
903 /* Make sure there is enough space on the stack. */
904 if (if_stack_space
== 0)
907 if_stack
= (if_elt
*) xmalloc (10 * sizeof (if_elt
));
909 else if (if_stack_space
== if_stack_pointer
)
911 if_stack_space
+= 10;
912 if_stack
= (if_elt
*) xrealloc (if_stack
, if_stack_space
* sizeof (if_elt
));
915 IF_COND (if_stmt
) = cond
;
918 /* Record this if statement. */
919 if_stack
[if_stack_pointer
].compstmt_count
= compstmt_count
;
920 if_stack
[if_stack_pointer
].file
= input_filename
;
921 if_stack
[if_stack_pointer
].line
= lineno
;
922 if_stack
[if_stack_pointer
].needs_warning
= 0;
923 if_stack
[if_stack_pointer
].if_stmt
= if_stmt
;
927 /* Called after the then-clause for an if-statement is processed. */
932 tree if_stmt
= if_stack
[if_stack_pointer
- 1].if_stmt
;
933 RECHAIN_STMTS (if_stmt
, THEN_CLAUSE (if_stmt
));
936 /* Record the end of an if-then. Optionally warn if a nested
937 if statement had an ambiguous else clause. */
943 if (if_stack
[if_stack_pointer
].needs_warning
)
944 warning_with_file_and_line (if_stack
[if_stack_pointer
].file
,
945 if_stack
[if_stack_pointer
].line
,
946 "suggest explicit braces to avoid ambiguous `else'");
947 last_expr_type
= NULL_TREE
;
950 /* Called between the then-clause and the else-clause
951 of an if-then-else. */
954 c_expand_start_else ()
956 /* An ambiguous else warning must be generated for the enclosing if
957 statement, unless we see an else branch for that one, too. */
959 && if_stack_pointer
> 1
960 && (if_stack
[if_stack_pointer
- 1].compstmt_count
961 == if_stack
[if_stack_pointer
- 2].compstmt_count
))
962 if_stack
[if_stack_pointer
- 2].needs_warning
= 1;
964 /* Even if a nested if statement had an else branch, it can't be
965 ambiguous if this one also has an else. So don't warn in that
966 case. Also don't warn for any if statements nested in this else. */
967 if_stack
[if_stack_pointer
- 1].needs_warning
= 0;
968 if_stack
[if_stack_pointer
- 1].compstmt_count
--;
971 /* Called after the else-clause for an if-statement is processed. */
976 tree if_stmt
= if_stack
[if_stack_pointer
- 1].if_stmt
;
977 RECHAIN_STMTS (if_stmt
, ELSE_CLAUSE (if_stmt
));
980 /* Begin an if-statement. Returns a newly created IF_STMT if
983 Unlike the C++ front-end, we do not call add_stmt here; it is
984 probably safe to do so, but I am not very familiar with this
985 code so I am being extra careful not to change its behavior
986 beyond what is strictly necessary for correctness. */
992 r
= build_stmt (IF_STMT
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
996 /* Begin a while statement. Returns a newly created WHILE_STMT if
999 Unlike the C++ front-end, we do not call add_stmt here; it is
1000 probably safe to do so, but I am not very familiar with this
1001 code so I am being extra careful not to change its behavior
1002 beyond what is strictly necessary for correctness. */
1005 c_begin_while_stmt ()
1008 r
= build_stmt (WHILE_STMT
, NULL_TREE
, NULL_TREE
);
1013 c_finish_while_stmt_cond (cond
, while_stmt
)
1017 WHILE_COND (while_stmt
) = cond
;
1020 /* Push current bindings for the function name VAR_DECLS. */
1023 start_fname_decls ()
1026 tree saved
= NULL_TREE
;
1028 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
1030 tree decl
= *fname_vars
[ix
].decl
;
1034 saved
= tree_cons (decl
, build_int_2 (ix
, 0), saved
);
1035 *fname_vars
[ix
].decl
= NULL_TREE
;
1038 if (saved
|| saved_function_name_decls
)
1039 /* Normally they'll have been NULL, so only push if we've got a
1040 stack, or they are non-NULL. */
1041 saved_function_name_decls
= tree_cons (saved
, NULL_TREE
,
1042 saved_function_name_decls
);
1045 /* Finish up the current bindings, adding them into the
1046 current function's statement tree. This is done by wrapping the
1047 function's body in a COMPOUND_STMT containing these decls too. This
1048 must be done _before_ finish_stmt_tree is called. If there is no
1049 current function, we must be at file scope and no statements are
1050 involved. Pop the previous bindings. */
1053 finish_fname_decls ()
1056 tree body
= NULL_TREE
;
1057 tree stack
= saved_function_name_decls
;
1059 for (; stack
&& TREE_VALUE (stack
); stack
= TREE_CHAIN (stack
))
1060 body
= chainon (TREE_VALUE (stack
), body
);
1064 /* They were called into existence, so add to statement tree. Add
1065 the DECL_STMTs inside the outermost scope. */
1066 tree
*p
= &DECL_SAVED_TREE (current_function_decl
);
1067 /* Skip the dummy EXPR_STMT and any EH_SPEC_BLOCK. */
1068 while (TREE_CODE (*p
) != COMPOUND_STMT
)
1069 p
= &TREE_CHAIN (*p
);
1070 p
= &COMPOUND_BODY (*p
);
1071 if (TREE_CODE (*p
) == SCOPE_STMT
)
1072 p
= &TREE_CHAIN (*p
);
1074 body
= chainon (body
, *p
);
1078 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
1079 *fname_vars
[ix
].decl
= NULL_TREE
;
1083 /* We had saved values, restore them. */
1086 for (saved
= TREE_PURPOSE (stack
); saved
; saved
= TREE_CHAIN (saved
))
1088 tree decl
= TREE_PURPOSE (saved
);
1089 unsigned ix
= TREE_INT_CST_LOW (TREE_VALUE (saved
));
1091 *fname_vars
[ix
].decl
= decl
;
1093 stack
= TREE_CHAIN (stack
);
1095 saved_function_name_decls
= stack
;
1098 /* Return the text name of the current function, suitably prettified
1102 fname_as_string (pretty_p
)
1105 const char *name
= NULL
;
1108 name
= (current_function_decl
1109 ? (*lang_hooks
.decl_printable_name
) (current_function_decl
, 2)
1111 else if (current_function_decl
&& DECL_NAME (current_function_decl
))
1112 name
= IDENTIFIER_POINTER (DECL_NAME (current_function_decl
));
1118 /* Return the text name of the current function, formatted as
1119 required by the supplied RID value. */
1127 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
1128 if (fname_vars
[ix
].rid
== rid
)
1130 return fname_as_string (fname_vars
[ix
].pretty
);
1133 /* Return the VAR_DECL for a const char array naming the current
1134 function. If the VAR_DECL has not yet been created, create it
1135 now. RID indicates how it should be formatted and IDENTIFIER_NODE
1136 ID is its name (unfortunately C and C++ hold the RID values of
1137 keywords in different places, so we can't derive RID from ID in
1138 this language independent code. */
1141 fname_decl (rid
, id
)
1146 tree decl
= NULL_TREE
;
1148 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
1149 if (fname_vars
[ix
].rid
== rid
)
1152 decl
= *fname_vars
[ix
].decl
;
1155 tree saved_last_tree
= last_tree
;
1156 /* If a tree is built here, it would normally have the lineno of
1157 the current statement. Later this tree will be moved to the
1158 beginning of the function and this line number will be wrong.
1159 To avoid this problem set the lineno to 0 here; that prevents
1160 it from appearing in the RTL. */
1161 int saved_lineno
= lineno
;
1164 decl
= (*make_fname_decl
) (id
, fname_vars
[ix
].pretty
);
1165 if (last_tree
!= saved_last_tree
)
1167 /* We created some statement tree for the decl. This belongs
1168 at the start of the function, so remove it now and reinsert
1169 it after the function is complete. */
1170 tree stmts
= TREE_CHAIN (saved_last_tree
);
1172 TREE_CHAIN (saved_last_tree
) = NULL_TREE
;
1173 last_tree
= saved_last_tree
;
1174 saved_function_name_decls
= tree_cons (decl
, stmts
,
1175 saved_function_name_decls
);
1177 *fname_vars
[ix
].decl
= decl
;
1178 lineno
= saved_lineno
;
1180 if (!ix
&& !current_function_decl
)
1181 pedwarn_with_decl (decl
, "`%s' is not defined outside of function scope");
1186 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
1189 fix_string_type (value
)
1192 const int wchar_bytes
= TYPE_PRECISION (wchar_type_node
) / BITS_PER_UNIT
;
1193 const int wide_flag
= TREE_TYPE (value
) == wchar_array_type_node
;
1194 const int nchars_max
= flag_isoc99
? 4095 : 509;
1195 int length
= TREE_STRING_LENGTH (value
);
1198 /* Compute the number of elements, for the array type. */
1199 nchars
= wide_flag
? length
/ wchar_bytes
: length
;
1201 if (pedantic
&& nchars
- 1 > nchars_max
&& c_language
== clk_c
)
1202 pedwarn ("string length `%d' is greater than the length `%d' ISO C%d compilers are required to support",
1203 nchars
- 1, nchars_max
, flag_isoc99
? 99 : 89);
1205 /* Create the array type for the string constant.
1206 -Wwrite-strings says make the string constant an array of const char
1207 so that copying it to a non-const pointer will get a warning.
1208 For C++, this is the standard behavior. */
1209 if (flag_const_strings
&& ! flag_writable_strings
)
1212 = build_type_variant (wide_flag
? wchar_type_node
: char_type_node
,
1215 = build_array_type (elements
,
1216 build_index_type (build_int_2 (nchars
- 1, 0)));
1220 = build_array_type (wide_flag
? wchar_type_node
: char_type_node
,
1221 build_index_type (build_int_2 (nchars
- 1, 0)));
1223 TREE_CONSTANT (value
) = 1;
1224 TREE_READONLY (value
) = ! flag_writable_strings
;
1225 TREE_STATIC (value
) = 1;
1229 /* Given a VARRAY of STRING_CST nodes, concatenate them into one
1233 combine_strings (strings
)
1234 varray_type strings
;
1236 const int wchar_bytes
= TYPE_PRECISION (wchar_type_node
) / BITS_PER_UNIT
;
1237 const int nstrings
= VARRAY_ACTIVE_SIZE (strings
);
1240 int wide_length
= 0;
1245 /* Don't include the \0 at the end of each substring. Count wide
1246 strings and ordinary strings separately. */
1247 for (i
= 0; i
< nstrings
; ++i
)
1249 t
= VARRAY_TREE (strings
, i
);
1251 if (TREE_TYPE (t
) == wchar_array_type_node
)
1253 wide_length
+= TREE_STRING_LENGTH (t
) - wchar_bytes
;
1258 length
+= (TREE_STRING_LENGTH (t
) - 1);
1259 if (C_ARTIFICIAL_STRING_P (t
) && !in_system_header
)
1260 warning ("concatenation of string literals with __FUNCTION__ is deprecated");
1264 /* If anything is wide, the non-wides will be converted,
1265 which makes them take more space. */
1267 length
= length
* wchar_bytes
+ wide_length
;
1269 p
= xmalloc (length
);
1271 /* Copy the individual strings into the new combined string.
1272 If the combined string is wide, convert the chars to ints
1273 for any individual strings that are not wide. */
1276 for (i
= 0; i
< nstrings
; ++i
)
1280 t
= VARRAY_TREE (strings
, i
);
1281 this_wide
= TREE_TYPE (t
) == wchar_array_type_node
;
1282 len
= TREE_STRING_LENGTH (t
) - (this_wide
? wchar_bytes
: 1);
1283 if (this_wide
== wide_flag
)
1285 memcpy (q
, TREE_STRING_POINTER (t
), len
);
1290 const int nzeros
= (TYPE_PRECISION (wchar_type_node
)
1291 / BITS_PER_UNIT
) - 1;
1294 if (BYTES_BIG_ENDIAN
)
1296 for (k
= 0; k
< len
; k
++)
1298 for (j
= 0; j
< nzeros
; j
++)
1300 *q
++ = TREE_STRING_POINTER (t
)[k
];
1305 for (k
= 0; k
< len
; k
++)
1307 *q
++ = TREE_STRING_POINTER (t
)[k
];
1308 for (j
= 0; j
< nzeros
; j
++)
1315 /* Nul terminate the string. */
1318 for (i
= 0; i
< wchar_bytes
; i
++)
1324 value
= build_string (length
, p
);
1328 TREE_TYPE (value
) = wchar_array_type_node
;
1330 TREE_TYPE (value
) = char_array_type_node
;
1335 static int is_valid_printf_arglist
PARAMS ((tree
));
1336 static rtx c_expand_builtin
PARAMS ((tree
, rtx
, enum machine_mode
, enum expand_modifier
));
1337 static rtx c_expand_builtin_printf
PARAMS ((tree
, rtx
, enum machine_mode
,
1338 enum expand_modifier
, int, int));
1339 static rtx c_expand_builtin_fprintf
PARAMS ((tree
, rtx
, enum machine_mode
,
1340 enum expand_modifier
, int, int));
1342 /* Print a warning if a constant expression had overflow in folding.
1343 Invoke this function on every expression that the language
1344 requires to be a constant expression.
1345 Note the ANSI C standard says it is erroneous for a
1346 constant expression to overflow. */
1349 constant_expression_warning (value
)
1352 if ((TREE_CODE (value
) == INTEGER_CST
|| TREE_CODE (value
) == REAL_CST
1353 || TREE_CODE (value
) == VECTOR_CST
1354 || TREE_CODE (value
) == COMPLEX_CST
)
1355 && TREE_CONSTANT_OVERFLOW (value
) && pedantic
)
1356 pedwarn ("overflow in constant expression");
1359 /* Print a warning if an expression had overflow in folding.
1360 Invoke this function on every expression that
1361 (1) appears in the source code, and
1362 (2) might be a constant expression that overflowed, and
1363 (3) is not already checked by convert_and_check;
1364 however, do not invoke this function on operands of explicit casts. */
1367 overflow_warning (value
)
1370 if ((TREE_CODE (value
) == INTEGER_CST
1371 || (TREE_CODE (value
) == COMPLEX_CST
1372 && TREE_CODE (TREE_REALPART (value
)) == INTEGER_CST
))
1373 && TREE_OVERFLOW (value
))
1375 TREE_OVERFLOW (value
) = 0;
1376 if (skip_evaluation
== 0)
1377 warning ("integer overflow in expression");
1379 else if ((TREE_CODE (value
) == REAL_CST
1380 || (TREE_CODE (value
) == COMPLEX_CST
1381 && TREE_CODE (TREE_REALPART (value
)) == REAL_CST
))
1382 && TREE_OVERFLOW (value
))
1384 TREE_OVERFLOW (value
) = 0;
1385 if (skip_evaluation
== 0)
1386 warning ("floating point overflow in expression");
1388 else if (TREE_CODE (value
) == VECTOR_CST
&& TREE_OVERFLOW (value
))
1390 TREE_OVERFLOW (value
) = 0;
1391 if (skip_evaluation
== 0)
1392 warning ("vector overflow in expression");
1396 /* Print a warning if a large constant is truncated to unsigned,
1397 or if -Wconversion is used and a constant < 0 is converted to unsigned.
1398 Invoke this function on every expression that might be implicitly
1399 converted to an unsigned type. */
1402 unsigned_conversion_warning (result
, operand
)
1403 tree result
, operand
;
1405 tree type
= TREE_TYPE (result
);
1407 if (TREE_CODE (operand
) == INTEGER_CST
1408 && TREE_CODE (type
) == INTEGER_TYPE
1409 && TREE_UNSIGNED (type
)
1410 && skip_evaluation
== 0
1411 && !int_fits_type_p (operand
, type
))
1413 if (!int_fits_type_p (operand
, c_common_signed_type (type
)))
1414 /* This detects cases like converting -129 or 256 to unsigned char. */
1415 warning ("large integer implicitly truncated to unsigned type");
1416 else if (warn_conversion
)
1417 warning ("negative integer implicitly converted to unsigned type");
1421 /* Nonzero if constant C has a value that is permissible
1422 for type TYPE (an INTEGER_TYPE). */
1425 constant_fits_type_p (c
, type
)
1428 if (TREE_CODE (c
) == INTEGER_CST
)
1429 return int_fits_type_p (c
, type
);
1431 c
= convert (type
, c
);
1432 return !TREE_OVERFLOW (c
);
1435 /* Convert EXPR to TYPE, warning about conversion problems with constants.
1436 Invoke this function on every expression that is converted implicitly,
1437 i.e. because of language rules and not because of an explicit cast. */
1440 convert_and_check (type
, expr
)
1443 tree t
= convert (type
, expr
);
1444 if (TREE_CODE (t
) == INTEGER_CST
)
1446 if (TREE_OVERFLOW (t
))
1448 TREE_OVERFLOW (t
) = 0;
1450 /* Do not diagnose overflow in a constant expression merely
1451 because a conversion overflowed. */
1452 TREE_CONSTANT_OVERFLOW (t
) = TREE_CONSTANT_OVERFLOW (expr
);
1454 /* No warning for converting 0x80000000 to int. */
1455 if (!(TREE_UNSIGNED (type
) < TREE_UNSIGNED (TREE_TYPE (expr
))
1456 && TREE_CODE (TREE_TYPE (expr
)) == INTEGER_TYPE
1457 && TYPE_PRECISION (type
) == TYPE_PRECISION (TREE_TYPE (expr
))))
1458 /* If EXPR fits in the unsigned version of TYPE,
1459 don't warn unless pedantic. */
1461 || TREE_UNSIGNED (type
)
1462 || ! constant_fits_type_p (expr
,
1463 c_common_unsigned_type (type
)))
1464 && skip_evaluation
== 0)
1465 warning ("overflow in implicit constant conversion");
1468 unsigned_conversion_warning (t
, expr
);
1473 /* A node in a list that describes references to variables (EXPR), which are
1474 either read accesses if WRITER is zero, or write accesses, in which case
1475 WRITER is the parent of EXPR. */
1482 /* Used to implement a cache the results of a call to verify_tree. We only
1483 use this for SAVE_EXPRs. */
1486 struct tlist_cache
*next
;
1487 struct tlist
*cache_before_sp
;
1488 struct tlist
*cache_after_sp
;
1492 /* Obstack to use when allocating tlist structures, and corresponding
1494 static struct obstack tlist_obstack
;
1495 static char *tlist_firstobj
= 0;
1497 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
1499 static struct tlist
*warned_ids
;
1500 /* SAVE_EXPRs need special treatment. We process them only once and then
1501 cache the results. */
1502 static struct tlist_cache
*save_expr_cache
;
1504 static void add_tlist
PARAMS ((struct tlist
**, struct tlist
*, tree
, int));
1505 static void merge_tlist
PARAMS ((struct tlist
**, struct tlist
*, int));
1506 static void verify_tree
PARAMS ((tree
, struct tlist
**, struct tlist
**, tree
));
1507 static int warning_candidate_p
PARAMS ((tree
));
1508 static void warn_for_collisions
PARAMS ((struct tlist
*));
1509 static void warn_for_collisions_1
PARAMS ((tree
, tree
, struct tlist
*, int));
1510 static struct tlist
*new_tlist
PARAMS ((struct tlist
*, tree
, tree
));
1511 static void verify_sequence_points
PARAMS ((tree
));
1513 /* Create a new struct tlist and fill in its fields. */
1514 static struct tlist
*
1515 new_tlist (next
, t
, writer
)
1521 l
= (struct tlist
*) obstack_alloc (&tlist_obstack
, sizeof *l
);
1528 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
1529 is nonnull, we ignore any node we find which has a writer equal to it. */
1532 add_tlist (to
, add
, exclude_writer
, copy
)
1535 tree exclude_writer
;
1540 struct tlist
*next
= add
->next
;
1543 if (! exclude_writer
|| add
->writer
!= exclude_writer
)
1544 *to
= copy
? new_tlist (*to
, add
->expr
, add
->writer
) : add
;
1549 /* Merge the nodes of ADD into TO. This merging process is done so that for
1550 each variable that already exists in TO, no new node is added; however if
1551 there is a write access recorded in ADD, and an occurrence on TO is only
1552 a read access, then the occurrence in TO will be modified to record the
1556 merge_tlist (to
, add
, copy
)
1561 struct tlist
**end
= to
;
1564 end
= &(*end
)->next
;
1570 struct tlist
*next
= add
->next
;
1572 for (tmp2
= *to
; tmp2
; tmp2
= tmp2
->next
)
1573 if (tmp2
->expr
== add
->expr
)
1577 tmp2
->writer
= add
->writer
;
1581 *end
= copy
? add
: new_tlist (NULL
, add
->expr
, add
->writer
);
1582 end
= &(*end
)->next
;
1589 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
1590 references in list LIST conflict with it, excluding reads if ONLY writers
1594 warn_for_collisions_1 (written
, writer
, list
, only_writes
)
1595 tree written
, writer
;
1601 /* Avoid duplicate warnings. */
1602 for (tmp
= warned_ids
; tmp
; tmp
= tmp
->next
)
1603 if (tmp
->expr
== written
)
1608 if (list
->expr
== written
1609 && list
->writer
!= writer
1610 && (! only_writes
|| list
->writer
))
1612 warned_ids
= new_tlist (warned_ids
, written
, NULL_TREE
);
1613 warning ("operation on `%s' may be undefined",
1614 IDENTIFIER_POINTER (DECL_NAME (list
->expr
)));
1620 /* Given a list LIST of references to variables, find whether any of these
1621 can cause conflicts due to missing sequence points. */
1624 warn_for_collisions (list
)
1629 for (tmp
= list
; tmp
; tmp
= tmp
->next
)
1632 warn_for_collisions_1 (tmp
->expr
, tmp
->writer
, list
, 0);
1636 /* Return nonzero if X is a tree that can be verified by the sequence point
1639 warning_candidate_p (x
)
1642 return TREE_CODE (x
) == VAR_DECL
|| TREE_CODE (x
) == PARM_DECL
;
1645 /* Walk the tree X, and record accesses to variables. If X is written by the
1646 parent tree, WRITER is the parent.
1647 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
1648 expression or its only operand forces a sequence point, then everything up
1649 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
1651 Once we return, we will have emitted warnings if any subexpression before
1652 such a sequence point could be undefined. On a higher level, however, the
1653 sequence point may not be relevant, and we'll merge the two lists.
1655 Example: (b++, a) + b;
1656 The call that processes the COMPOUND_EXPR will store the increment of B
1657 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
1658 processes the PLUS_EXPR will need to merge the two lists so that
1659 eventually, all accesses end up on the same list (and we'll warn about the
1660 unordered subexpressions b++ and b.
1662 A note on merging. If we modify the former example so that our expression
1665 care must be taken not simply to add all three expressions into the final
1666 PNO_SP list. The function merge_tlist takes care of that by merging the
1667 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1668 way, so that no more than one access to B is recorded. */
1671 verify_tree (x
, pbefore_sp
, pno_sp
, writer
)
1673 struct tlist
**pbefore_sp
, **pno_sp
;
1676 struct tlist
*tmp_before
, *tmp_nosp
, *tmp_list2
, *tmp_list3
;
1677 enum tree_code code
;
1680 /* X may be NULL if it is the operand of an empty statement expression
1686 code
= TREE_CODE (x
);
1687 class = TREE_CODE_CLASS (code
);
1689 if (warning_candidate_p (x
))
1691 *pno_sp
= new_tlist (*pno_sp
, x
, writer
);
1701 case TRUTH_ANDIF_EXPR
:
1702 case TRUTH_ORIF_EXPR
:
1703 tmp_before
= tmp_nosp
= tmp_list3
= 0;
1704 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1705 warn_for_collisions (tmp_nosp
);
1706 merge_tlist (pbefore_sp
, tmp_before
, 0);
1707 merge_tlist (pbefore_sp
, tmp_nosp
, 0);
1708 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, pno_sp
, NULL_TREE
);
1709 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1713 tmp_before
= tmp_list2
= 0;
1714 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_list2
, NULL_TREE
);
1715 warn_for_collisions (tmp_list2
);
1716 merge_tlist (pbefore_sp
, tmp_before
, 0);
1717 merge_tlist (pbefore_sp
, tmp_list2
, 1);
1719 tmp_list3
= tmp_nosp
= 0;
1720 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, &tmp_nosp
, NULL_TREE
);
1721 warn_for_collisions (tmp_nosp
);
1722 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1724 tmp_list3
= tmp_list2
= 0;
1725 verify_tree (TREE_OPERAND (x
, 2), &tmp_list3
, &tmp_list2
, NULL_TREE
);
1726 warn_for_collisions (tmp_list2
);
1727 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1728 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1729 two first, to avoid warning for (a ? b++ : b++). */
1730 merge_tlist (&tmp_nosp
, tmp_list2
, 0);
1731 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1734 case PREDECREMENT_EXPR
:
1735 case PREINCREMENT_EXPR
:
1736 case POSTDECREMENT_EXPR
:
1737 case POSTINCREMENT_EXPR
:
1738 verify_tree (TREE_OPERAND (x
, 0), pno_sp
, pno_sp
, x
);
1742 tmp_before
= tmp_nosp
= tmp_list3
= 0;
1743 verify_tree (TREE_OPERAND (x
, 1), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1744 verify_tree (TREE_OPERAND (x
, 0), &tmp_list3
, &tmp_list3
, x
);
1745 /* Expressions inside the LHS are not ordered wrt. the sequence points
1746 in the RHS. Example:
1748 Despite the fact that the modification of "a" is in the before_sp
1749 list (tmp_before), it conflicts with the use of "a" in the LHS.
1750 We can handle this by adding the contents of tmp_list3
1751 to those of tmp_before, and redoing the collision warnings for that
1753 add_tlist (&tmp_before
, tmp_list3
, x
, 1);
1754 warn_for_collisions (tmp_before
);
1755 /* Exclude the LHS itself here; we first have to merge it into the
1756 tmp_nosp list. This is done to avoid warning for "a = a"; if we
1757 didn't exclude the LHS, we'd get it twice, once as a read and once
1759 add_tlist (pno_sp
, tmp_list3
, x
, 0);
1760 warn_for_collisions_1 (TREE_OPERAND (x
, 0), x
, tmp_nosp
, 1);
1762 merge_tlist (pbefore_sp
, tmp_before
, 0);
1763 if (warning_candidate_p (TREE_OPERAND (x
, 0)))
1764 merge_tlist (&tmp_nosp
, new_tlist (NULL
, TREE_OPERAND (x
, 0), x
), 0);
1765 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 1);
1769 /* We need to warn about conflicts among arguments and conflicts between
1770 args and the function address. Side effects of the function address,
1771 however, are not ordered by the sequence point of the call. */
1772 tmp_before
= tmp_nosp
= tmp_list2
= tmp_list3
= 0;
1773 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1774 if (TREE_OPERAND (x
, 1))
1775 verify_tree (TREE_OPERAND (x
, 1), &tmp_list2
, &tmp_list3
, NULL_TREE
);
1776 merge_tlist (&tmp_list3
, tmp_list2
, 0);
1777 add_tlist (&tmp_before
, tmp_list3
, NULL_TREE
, 0);
1778 add_tlist (&tmp_before
, tmp_nosp
, NULL_TREE
, 0);
1779 warn_for_collisions (tmp_before
);
1780 add_tlist (pbefore_sp
, tmp_before
, NULL_TREE
, 0);
1784 /* Scan all the list, e.g. indices of multi dimensional array. */
1787 tmp_before
= tmp_nosp
= 0;
1788 verify_tree (TREE_VALUE (x
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1789 merge_tlist (&tmp_nosp
, tmp_before
, 0);
1790 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1797 struct tlist_cache
*t
;
1798 for (t
= save_expr_cache
; t
; t
= t
->next
)
1804 t
= (struct tlist_cache
*) obstack_alloc (&tlist_obstack
,
1806 t
->next
= save_expr_cache
;
1808 save_expr_cache
= t
;
1810 tmp_before
= tmp_nosp
= 0;
1811 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1812 warn_for_collisions (tmp_nosp
);
1817 struct tlist
*t
= tmp_nosp
;
1819 merge_tlist (&tmp_list3
, t
, 0);
1821 t
->cache_before_sp
= tmp_before
;
1822 t
->cache_after_sp
= tmp_list3
;
1824 merge_tlist (pbefore_sp
, t
->cache_before_sp
, 1);
1825 add_tlist (pno_sp
, t
->cache_after_sp
, NULL_TREE
, 1);
1834 if (first_rtl_op (code
) == 0)
1836 x
= TREE_OPERAND (x
, 0);
1852 int max
= first_rtl_op (TREE_CODE (x
));
1853 for (lp
= 0; lp
< max
; lp
++)
1855 tmp_before
= tmp_nosp
= 0;
1856 verify_tree (TREE_OPERAND (x
, lp
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1857 merge_tlist (&tmp_nosp
, tmp_before
, 0);
1858 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1865 /* Try to warn for undefined behavior in EXPR due to missing sequence
1869 verify_sequence_points (expr
)
1872 struct tlist
*before_sp
= 0, *after_sp
= 0;
1875 save_expr_cache
= 0;
1876 if (tlist_firstobj
== 0)
1878 gcc_obstack_init (&tlist_obstack
);
1879 tlist_firstobj
= obstack_alloc (&tlist_obstack
, 0);
1882 verify_tree (expr
, &before_sp
, &after_sp
, 0);
1883 warn_for_collisions (after_sp
);
1884 obstack_free (&tlist_obstack
, tlist_firstobj
);
1888 c_expand_expr_stmt (expr
)
1891 /* Do default conversion if safe and possibly important,
1892 in case within ({...}). */
1893 if ((TREE_CODE (TREE_TYPE (expr
)) == ARRAY_TYPE
1894 && (flag_isoc99
|| lvalue_p (expr
)))
1895 || TREE_CODE (TREE_TYPE (expr
)) == FUNCTION_TYPE
)
1896 expr
= default_conversion (expr
);
1898 if (warn_sequence_point
)
1899 verify_sequence_points (expr
);
1901 if (TREE_TYPE (expr
) != error_mark_node
1902 && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr
))
1903 && TREE_CODE (TREE_TYPE (expr
)) != ARRAY_TYPE
)
1904 error ("expression statement has incomplete type");
1906 last_expr_type
= TREE_TYPE (expr
);
1907 return add_stmt (build_stmt (EXPR_STMT
, expr
));
1910 /* Validate the expression after `case' and apply default promotions. */
1913 check_case_value (value
)
1916 if (value
== NULL_TREE
)
1919 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
1920 STRIP_TYPE_NOPS (value
);
1921 /* In C++, the following is allowed:
1924 switch (...) { case i: ... }
1926 So, we try to reduce the VALUE to a constant that way. */
1927 if (c_language
== clk_cplusplus
)
1929 value
= decl_constant_value (value
);
1930 STRIP_TYPE_NOPS (value
);
1931 value
= fold (value
);
1934 if (TREE_CODE (value
) != INTEGER_CST
1935 && value
!= error_mark_node
)
1937 error ("case label does not reduce to an integer constant");
1938 value
= error_mark_node
;
1941 /* Promote char or short to int. */
1942 value
= default_conversion (value
);
1944 constant_expression_warning (value
);
1949 /* Return an integer type with BITS bits of precision,
1950 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1953 c_common_type_for_size (bits
, unsignedp
)
1957 if (bits
== TYPE_PRECISION (integer_type_node
))
1958 return unsignedp
? unsigned_type_node
: integer_type_node
;
1960 if (bits
== TYPE_PRECISION (signed_char_type_node
))
1961 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1963 if (bits
== TYPE_PRECISION (short_integer_type_node
))
1964 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1966 if (bits
== TYPE_PRECISION (long_integer_type_node
))
1967 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1969 if (bits
== TYPE_PRECISION (long_long_integer_type_node
))
1970 return (unsignedp
? long_long_unsigned_type_node
1971 : long_long_integer_type_node
);
1973 if (bits
== TYPE_PRECISION (widest_integer_literal_type_node
))
1974 return (unsignedp
? widest_unsigned_literal_type_node
1975 : widest_integer_literal_type_node
);
1977 if (bits
<= TYPE_PRECISION (intQI_type_node
))
1978 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
1980 if (bits
<= TYPE_PRECISION (intHI_type_node
))
1981 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
1983 if (bits
<= TYPE_PRECISION (intSI_type_node
))
1984 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
1986 if (bits
<= TYPE_PRECISION (intDI_type_node
))
1987 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
1992 /* Return a data type that has machine mode MODE.
1993 If the mode is an integer,
1994 then UNSIGNEDP selects between signed and unsigned types. */
1997 c_common_type_for_mode (mode
, unsignedp
)
1998 enum machine_mode mode
;
2001 if (mode
== TYPE_MODE (integer_type_node
))
2002 return unsignedp
? unsigned_type_node
: integer_type_node
;
2004 if (mode
== TYPE_MODE (signed_char_type_node
))
2005 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2007 if (mode
== TYPE_MODE (short_integer_type_node
))
2008 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2010 if (mode
== TYPE_MODE (long_integer_type_node
))
2011 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2013 if (mode
== TYPE_MODE (long_long_integer_type_node
))
2014 return unsignedp
? long_long_unsigned_type_node
: long_long_integer_type_node
;
2016 if (mode
== TYPE_MODE (widest_integer_literal_type_node
))
2017 return unsignedp
? widest_unsigned_literal_type_node
2018 : widest_integer_literal_type_node
;
2021 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2024 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2027 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2030 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2032 #if HOST_BITS_PER_WIDE_INT >= 64
2033 if (mode
== TYPE_MODE (intTI_type_node
))
2034 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2037 if (mode
== TYPE_MODE (float_type_node
))
2038 return float_type_node
;
2040 if (mode
== TYPE_MODE (double_type_node
))
2041 return double_type_node
;
2043 if (mode
== TYPE_MODE (long_double_type_node
))
2044 return long_double_type_node
;
2046 if (mode
== TYPE_MODE (build_pointer_type (char_type_node
)))
2047 return build_pointer_type (char_type_node
);
2049 if (mode
== TYPE_MODE (build_pointer_type (integer_type_node
)))
2050 return build_pointer_type (integer_type_node
);
2055 return unsignedp
? unsigned_V16QI_type_node
: V16QI_type_node
;
2057 return unsignedp
? unsigned_V8HI_type_node
: V8HI_type_node
;
2059 return unsignedp
? unsigned_V4SI_type_node
: V4SI_type_node
;
2061 return unsignedp
? unsigned_V2DI_type_node
: V2DI_type_node
;
2063 return unsignedp
? unsigned_V2SI_type_node
: V2SI_type_node
;
2065 return unsignedp
? unsigned_V2HI_type_node
: V2HI_type_node
;
2067 return unsignedp
? unsigned_V4HI_type_node
: V4HI_type_node
;
2069 return unsignedp
? unsigned_V8QI_type_node
: V8QI_type_node
;
2071 return unsignedp
? unsigned_V1DI_type_node
: V1DI_type_node
;
2073 return V16SF_type_node
;
2075 return V4SF_type_node
;
2077 return V2SF_type_node
;
2079 return V2DF_type_node
;
2087 /* Return an unsigned type the same as TYPE in other respects. */
2089 c_common_unsigned_type (type
)
2092 tree type1
= TYPE_MAIN_VARIANT (type
);
2093 if (type1
== signed_char_type_node
|| type1
== char_type_node
)
2094 return unsigned_char_type_node
;
2095 if (type1
== integer_type_node
)
2096 return unsigned_type_node
;
2097 if (type1
== short_integer_type_node
)
2098 return short_unsigned_type_node
;
2099 if (type1
== long_integer_type_node
)
2100 return long_unsigned_type_node
;
2101 if (type1
== long_long_integer_type_node
)
2102 return long_long_unsigned_type_node
;
2103 if (type1
== widest_integer_literal_type_node
)
2104 return widest_unsigned_literal_type_node
;
2105 #if HOST_BITS_PER_WIDE_INT >= 64
2106 if (type1
== intTI_type_node
)
2107 return unsigned_intTI_type_node
;
2109 if (type1
== intDI_type_node
)
2110 return unsigned_intDI_type_node
;
2111 if (type1
== intSI_type_node
)
2112 return unsigned_intSI_type_node
;
2113 if (type1
== intHI_type_node
)
2114 return unsigned_intHI_type_node
;
2115 if (type1
== intQI_type_node
)
2116 return unsigned_intQI_type_node
;
2118 return c_common_signed_or_unsigned_type (1, type
);
2121 /* Return a signed type the same as TYPE in other respects. */
2124 c_common_signed_type (type
)
2127 tree type1
= TYPE_MAIN_VARIANT (type
);
2128 if (type1
== unsigned_char_type_node
|| type1
== char_type_node
)
2129 return signed_char_type_node
;
2130 if (type1
== unsigned_type_node
)
2131 return integer_type_node
;
2132 if (type1
== short_unsigned_type_node
)
2133 return short_integer_type_node
;
2134 if (type1
== long_unsigned_type_node
)
2135 return long_integer_type_node
;
2136 if (type1
== long_long_unsigned_type_node
)
2137 return long_long_integer_type_node
;
2138 if (type1
== widest_unsigned_literal_type_node
)
2139 return widest_integer_literal_type_node
;
2140 #if HOST_BITS_PER_WIDE_INT >= 64
2141 if (type1
== unsigned_intTI_type_node
)
2142 return intTI_type_node
;
2144 if (type1
== unsigned_intDI_type_node
)
2145 return intDI_type_node
;
2146 if (type1
== unsigned_intSI_type_node
)
2147 return intSI_type_node
;
2148 if (type1
== unsigned_intHI_type_node
)
2149 return intHI_type_node
;
2150 if (type1
== unsigned_intQI_type_node
)
2151 return intQI_type_node
;
2153 return c_common_signed_or_unsigned_type (0, type
);
2156 /* Return a type the same as TYPE except unsigned or
2157 signed according to UNSIGNEDP. */
2160 c_common_signed_or_unsigned_type (unsignedp
, type
)
2164 if (! INTEGRAL_TYPE_P (type
)
2165 || TREE_UNSIGNED (type
) == unsignedp
)
2168 if (TYPE_PRECISION (type
) == TYPE_PRECISION (signed_char_type_node
))
2169 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2170 if (TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
))
2171 return unsignedp
? unsigned_type_node
: integer_type_node
;
2172 if (TYPE_PRECISION (type
) == TYPE_PRECISION (short_integer_type_node
))
2173 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2174 if (TYPE_PRECISION (type
) == TYPE_PRECISION (long_integer_type_node
))
2175 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2176 if (TYPE_PRECISION (type
) == TYPE_PRECISION (long_long_integer_type_node
))
2177 return (unsignedp
? long_long_unsigned_type_node
2178 : long_long_integer_type_node
);
2179 if (TYPE_PRECISION (type
) == TYPE_PRECISION (widest_integer_literal_type_node
))
2180 return (unsignedp
? widest_unsigned_literal_type_node
2181 : widest_integer_literal_type_node
);
2183 #if HOST_BITS_PER_WIDE_INT >= 64
2184 if (TYPE_PRECISION (type
) == TYPE_PRECISION (intTI_type_node
))
2185 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2187 if (TYPE_PRECISION (type
) == TYPE_PRECISION (intDI_type_node
))
2188 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2189 if (TYPE_PRECISION (type
) == TYPE_PRECISION (intSI_type_node
))
2190 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2191 if (TYPE_PRECISION (type
) == TYPE_PRECISION (intHI_type_node
))
2192 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2193 if (TYPE_PRECISION (type
) == TYPE_PRECISION (intQI_type_node
))
2194 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2199 /* Return the minimum number of bits needed to represent VALUE in a
2200 signed or unsigned type, UNSIGNEDP says which. */
2203 min_precision (value
, unsignedp
)
2209 /* If the value is negative, compute its negative minus 1. The latter
2210 adjustment is because the absolute value of the largest negative value
2211 is one larger than the largest positive value. This is equivalent to
2212 a bit-wise negation, so use that operation instead. */
2214 if (tree_int_cst_sgn (value
) < 0)
2215 value
= fold (build1 (BIT_NOT_EXPR
, TREE_TYPE (value
), value
));
2217 /* Return the number of bits needed, taking into account the fact
2218 that we need one more bit for a signed than unsigned type. */
2220 if (integer_zerop (value
))
2223 log
= tree_floor_log2 (value
);
2225 return log
+ 1 + ! unsignedp
;
2228 /* Print an error message for invalid operands to arith operation
2229 CODE. NOP_EXPR is used as a special case (see
2230 c_common_truthvalue_conversion). */
2233 binary_op_error (code
)
2234 enum tree_code code
;
2241 error ("invalid truth-value expression");
2245 opname
= "+"; break;
2247 opname
= "-"; break;
2249 opname
= "*"; break;
2251 opname
= "max"; break;
2253 opname
= "min"; break;
2255 opname
= "=="; break;
2257 opname
= "!="; break;
2259 opname
= "<="; break;
2261 opname
= ">="; break;
2263 opname
= "<"; break;
2265 opname
= ">"; break;
2267 opname
= "<<"; break;
2269 opname
= ">>"; break;
2270 case TRUNC_MOD_EXPR
:
2271 case FLOOR_MOD_EXPR
:
2272 opname
= "%"; break;
2273 case TRUNC_DIV_EXPR
:
2274 case FLOOR_DIV_EXPR
:
2275 opname
= "/"; break;
2277 opname
= "&"; break;
2279 opname
= "|"; break;
2280 case TRUTH_ANDIF_EXPR
:
2281 opname
= "&&"; break;
2282 case TRUTH_ORIF_EXPR
:
2283 opname
= "||"; break;
2285 opname
= "^"; break;
2288 opname
= "rotate"; break;
2290 opname
= "unknown"; break;
2292 error ("invalid operands to binary %s", opname
);
2295 /* Subroutine of build_binary_op, used for comparison operations.
2296 See if the operands have both been converted from subword integer types
2297 and, if so, perhaps change them both back to their original type.
2298 This function is also responsible for converting the two operands
2299 to the proper common type for comparison.
2301 The arguments of this function are all pointers to local variables
2302 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2303 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2305 If this function returns nonzero, it means that the comparison has
2306 a constant value. What this function returns is an expression for
2310 shorten_compare (op0_ptr
, op1_ptr
, restype_ptr
, rescode_ptr
)
2311 tree
*op0_ptr
, *op1_ptr
;
2313 enum tree_code
*rescode_ptr
;
2316 tree op0
= *op0_ptr
;
2317 tree op1
= *op1_ptr
;
2318 int unsignedp0
, unsignedp1
;
2320 tree primop0
, primop1
;
2321 enum tree_code code
= *rescode_ptr
;
2323 /* Throw away any conversions to wider types
2324 already present in the operands. */
2326 primop0
= get_narrower (op0
, &unsignedp0
);
2327 primop1
= get_narrower (op1
, &unsignedp1
);
2329 /* Handle the case that OP0 does not *contain* a conversion
2330 but it *requires* conversion to FINAL_TYPE. */
2332 if (op0
== primop0
&& TREE_TYPE (op0
) != *restype_ptr
)
2333 unsignedp0
= TREE_UNSIGNED (TREE_TYPE (op0
));
2334 if (op1
== primop1
&& TREE_TYPE (op1
) != *restype_ptr
)
2335 unsignedp1
= TREE_UNSIGNED (TREE_TYPE (op1
));
2337 /* If one of the operands must be floated, we cannot optimize. */
2338 real1
= TREE_CODE (TREE_TYPE (primop0
)) == REAL_TYPE
;
2339 real2
= TREE_CODE (TREE_TYPE (primop1
)) == REAL_TYPE
;
2341 /* If first arg is constant, swap the args (changing operation
2342 so value is preserved), for canonicalization. Don't do this if
2343 the second arg is 0. */
2345 if (TREE_CONSTANT (primop0
)
2346 && ! integer_zerop (primop1
) && ! real_zerop (primop1
))
2349 int temi
= unsignedp0
;
2357 unsignedp0
= unsignedp1
;
2380 *rescode_ptr
= code
;
2383 /* If comparing an integer against a constant more bits wide,
2384 maybe we can deduce a value of 1 or 0 independent of the data.
2385 Or else truncate the constant now
2386 rather than extend the variable at run time.
2388 This is only interesting if the constant is the wider arg.
2389 Also, it is not safe if the constant is unsigned and the
2390 variable arg is signed, since in this case the variable
2391 would be sign-extended and then regarded as unsigned.
2392 Our technique fails in this case because the lowest/highest
2393 possible unsigned results don't follow naturally from the
2394 lowest/highest possible values of the variable operand.
2395 For just EQ_EXPR and NE_EXPR there is another technique that
2396 could be used: see if the constant can be faithfully represented
2397 in the other operand's type, by truncating it and reextending it
2398 and see if that preserves the constant's value. */
2400 if (!real1
&& !real2
2401 && TREE_CODE (primop1
) == INTEGER_CST
2402 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
))
2404 int min_gt
, max_gt
, min_lt
, max_lt
;
2405 tree maxval
, minval
;
2406 /* 1 if comparison is nominally unsigned. */
2407 int unsignedp
= TREE_UNSIGNED (*restype_ptr
);
2410 type
= c_common_signed_or_unsigned_type (unsignedp0
,
2411 TREE_TYPE (primop0
));
2413 /* If TYPE is an enumeration, then we need to get its min/max
2414 values from it's underlying integral type, not the enumerated
2416 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
2417 type
= c_common_type_for_size (TYPE_PRECISION (type
), unsignedp0
);
2419 maxval
= TYPE_MAX_VALUE (type
);
2420 minval
= TYPE_MIN_VALUE (type
);
2422 if (unsignedp
&& !unsignedp0
)
2423 *restype_ptr
= c_common_signed_type (*restype_ptr
);
2425 if (TREE_TYPE (primop1
) != *restype_ptr
)
2426 primop1
= convert (*restype_ptr
, primop1
);
2427 if (type
!= *restype_ptr
)
2429 minval
= convert (*restype_ptr
, minval
);
2430 maxval
= convert (*restype_ptr
, maxval
);
2433 if (unsignedp
&& unsignedp0
)
2435 min_gt
= INT_CST_LT_UNSIGNED (primop1
, minval
);
2436 max_gt
= INT_CST_LT_UNSIGNED (primop1
, maxval
);
2437 min_lt
= INT_CST_LT_UNSIGNED (minval
, primop1
);
2438 max_lt
= INT_CST_LT_UNSIGNED (maxval
, primop1
);
2442 min_gt
= INT_CST_LT (primop1
, minval
);
2443 max_gt
= INT_CST_LT (primop1
, maxval
);
2444 min_lt
= INT_CST_LT (minval
, primop1
);
2445 max_lt
= INT_CST_LT (maxval
, primop1
);
2449 /* This used to be a switch, but Genix compiler can't handle that. */
2450 if (code
== NE_EXPR
)
2452 if (max_lt
|| min_gt
)
2453 val
= boolean_true_node
;
2455 else if (code
== EQ_EXPR
)
2457 if (max_lt
|| min_gt
)
2458 val
= boolean_false_node
;
2460 else if (code
== LT_EXPR
)
2463 val
= boolean_true_node
;
2465 val
= boolean_false_node
;
2467 else if (code
== GT_EXPR
)
2470 val
= boolean_true_node
;
2472 val
= boolean_false_node
;
2474 else if (code
== LE_EXPR
)
2477 val
= boolean_true_node
;
2479 val
= boolean_false_node
;
2481 else if (code
== GE_EXPR
)
2484 val
= boolean_true_node
;
2486 val
= boolean_false_node
;
2489 /* If primop0 was sign-extended and unsigned comparison specd,
2490 we did a signed comparison above using the signed type bounds.
2491 But the comparison we output must be unsigned.
2493 Also, for inequalities, VAL is no good; but if the signed
2494 comparison had *any* fixed result, it follows that the
2495 unsigned comparison just tests the sign in reverse
2496 (positive values are LE, negative ones GE).
2497 So we can generate an unsigned comparison
2498 against an extreme value of the signed type. */
2500 if (unsignedp
&& !unsignedp0
)
2507 primop1
= TYPE_MIN_VALUE (type
);
2513 primop1
= TYPE_MAX_VALUE (type
);
2520 type
= c_common_unsigned_type (type
);
2523 if (TREE_CODE (primop0
) != INTEGER_CST
)
2525 if (val
== boolean_false_node
)
2526 warning ("comparison is always false due to limited range of data type");
2527 if (val
== boolean_true_node
)
2528 warning ("comparison is always true due to limited range of data type");
2533 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2534 if (TREE_SIDE_EFFECTS (primop0
))
2535 return build (COMPOUND_EXPR
, TREE_TYPE (val
), primop0
, val
);
2539 /* Value is not predetermined, but do the comparison
2540 in the type of the operand that is not constant.
2541 TYPE is already properly set. */
2543 else if (real1
&& real2
2544 && (TYPE_PRECISION (TREE_TYPE (primop0
))
2545 == TYPE_PRECISION (TREE_TYPE (primop1
))))
2546 type
= TREE_TYPE (primop0
);
2548 /* If args' natural types are both narrower than nominal type
2549 and both extend in the same manner, compare them
2550 in the type of the wider arg.
2551 Otherwise must actually extend both to the nominal
2552 common type lest different ways of extending
2554 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
2556 else if (unsignedp0
== unsignedp1
&& real1
== real2
2557 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
)
2558 && TYPE_PRECISION (TREE_TYPE (primop1
)) < TYPE_PRECISION (*restype_ptr
))
2560 type
= common_type (TREE_TYPE (primop0
), TREE_TYPE (primop1
));
2561 type
= c_common_signed_or_unsigned_type (unsignedp0
2562 || TREE_UNSIGNED (*restype_ptr
),
2564 /* Make sure shorter operand is extended the right way
2565 to match the longer operand. */
2567 = convert (c_common_signed_or_unsigned_type (unsignedp0
,
2568 TREE_TYPE (primop0
)),
2571 = convert (c_common_signed_or_unsigned_type (unsignedp1
,
2572 TREE_TYPE (primop1
)),
2577 /* Here we must do the comparison on the nominal type
2578 using the args exactly as we received them. */
2579 type
= *restype_ptr
;
2583 if (!real1
&& !real2
&& integer_zerop (primop1
)
2584 && TREE_UNSIGNED (*restype_ptr
))
2590 /* All unsigned values are >= 0, so we warn if extra warnings
2591 are requested. However, if OP0 is a constant that is
2592 >= 0, the signedness of the comparison isn't an issue,
2593 so suppress the warning. */
2594 if (extra_warnings
&& !in_system_header
2595 && ! (TREE_CODE (primop0
) == INTEGER_CST
2596 && ! TREE_OVERFLOW (convert (c_common_signed_type (type
),
2598 warning ("comparison of unsigned expression >= 0 is always true");
2599 value
= boolean_true_node
;
2603 if (extra_warnings
&& !in_system_header
2604 && ! (TREE_CODE (primop0
) == INTEGER_CST
2605 && ! TREE_OVERFLOW (convert (c_common_signed_type (type
),
2607 warning ("comparison of unsigned expression < 0 is always false");
2608 value
= boolean_false_node
;
2617 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2618 if (TREE_SIDE_EFFECTS (primop0
))
2619 return build (COMPOUND_EXPR
, TREE_TYPE (value
),
2626 *op0_ptr
= convert (type
, primop0
);
2627 *op1_ptr
= convert (type
, primop1
);
2629 *restype_ptr
= boolean_type_node
;
2634 /* Return a tree for the sum or difference (RESULTCODE says which)
2635 of pointer PTROP and integer INTOP. */
2638 pointer_int_sum (resultcode
, ptrop
, intop
)
2639 enum tree_code resultcode
;
2647 /* The result is a pointer of the same type that is being added. */
2649 tree result_type
= TREE_TYPE (ptrop
);
2651 if (TREE_CODE (TREE_TYPE (result_type
)) == VOID_TYPE
)
2653 if (pedantic
|| warn_pointer_arith
)
2654 pedwarn ("pointer of type `void *' used in arithmetic");
2655 size_exp
= integer_one_node
;
2657 else if (TREE_CODE (TREE_TYPE (result_type
)) == FUNCTION_TYPE
)
2659 if (pedantic
|| warn_pointer_arith
)
2660 pedwarn ("pointer to a function used in arithmetic");
2661 size_exp
= integer_one_node
;
2663 else if (TREE_CODE (TREE_TYPE (result_type
)) == METHOD_TYPE
)
2665 if (pedantic
|| warn_pointer_arith
)
2666 pedwarn ("pointer to member function used in arithmetic");
2667 size_exp
= integer_one_node
;
2669 else if (TREE_CODE (TREE_TYPE (result_type
)) == OFFSET_TYPE
)
2671 if (pedantic
|| warn_pointer_arith
)
2672 pedwarn ("pointer to a member used in arithmetic");
2673 size_exp
= integer_one_node
;
2676 size_exp
= size_in_bytes (TREE_TYPE (result_type
));
2678 /* If what we are about to multiply by the size of the elements
2679 contains a constant term, apply distributive law
2680 and multiply that constant term separately.
2681 This helps produce common subexpressions. */
2683 if ((TREE_CODE (intop
) == PLUS_EXPR
|| TREE_CODE (intop
) == MINUS_EXPR
)
2684 && ! TREE_CONSTANT (intop
)
2685 && TREE_CONSTANT (TREE_OPERAND (intop
, 1))
2686 && TREE_CONSTANT (size_exp
)
2687 /* If the constant comes from pointer subtraction,
2688 skip this optimization--it would cause an error. */
2689 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop
, 0))) == INTEGER_TYPE
2690 /* If the constant is unsigned, and smaller than the pointer size,
2691 then we must skip this optimization. This is because it could cause
2692 an overflow error if the constant is negative but INTOP is not. */
2693 && (! TREE_UNSIGNED (TREE_TYPE (intop
))
2694 || (TYPE_PRECISION (TREE_TYPE (intop
))
2695 == TYPE_PRECISION (TREE_TYPE (ptrop
)))))
2697 enum tree_code subcode
= resultcode
;
2698 tree int_type
= TREE_TYPE (intop
);
2699 if (TREE_CODE (intop
) == MINUS_EXPR
)
2700 subcode
= (subcode
== PLUS_EXPR
? MINUS_EXPR
: PLUS_EXPR
);
2701 /* Convert both subexpression types to the type of intop,
2702 because weird cases involving pointer arithmetic
2703 can result in a sum or difference with different type args. */
2704 ptrop
= build_binary_op (subcode
, ptrop
,
2705 convert (int_type
, TREE_OPERAND (intop
, 1)), 1);
2706 intop
= convert (int_type
, TREE_OPERAND (intop
, 0));
2709 /* Convert the integer argument to a type the same size as sizetype
2710 so the multiply won't overflow spuriously. */
2712 if (TYPE_PRECISION (TREE_TYPE (intop
)) != TYPE_PRECISION (sizetype
)
2713 || TREE_UNSIGNED (TREE_TYPE (intop
)) != TREE_UNSIGNED (sizetype
))
2714 intop
= convert (c_common_type_for_size (TYPE_PRECISION (sizetype
),
2715 TREE_UNSIGNED (sizetype
)), intop
);
2717 /* Replace the integer argument with a suitable product by the object size.
2718 Do this multiplication as signed, then convert to the appropriate
2719 pointer type (actually unsigned integral). */
2721 intop
= convert (result_type
,
2722 build_binary_op (MULT_EXPR
, intop
,
2723 convert (TREE_TYPE (intop
), size_exp
), 1));
2725 /* Create the sum or difference. */
2727 result
= build (resultcode
, result_type
, ptrop
, intop
);
2729 folded
= fold (result
);
2730 if (folded
== result
)
2731 TREE_CONSTANT (folded
) = TREE_CONSTANT (ptrop
) & TREE_CONSTANT (intop
);
2735 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2736 or validate its data type for an `if' or `while' statement or ?..: exp.
2738 This preparation consists of taking the ordinary
2739 representation of an expression expr and producing a valid tree
2740 boolean expression describing whether expr is nonzero. We could
2741 simply always do build_binary_op (NE_EXPR, expr, boolean_false_node, 1),
2742 but we optimize comparisons, &&, ||, and !.
2744 The resulting type should always be `boolean_type_node'. */
2747 c_common_truthvalue_conversion (expr
)
2750 if (TREE_CODE (expr
) == ERROR_MARK
)
2753 #if 0 /* This appears to be wrong for C++. */
2754 /* These really should return error_mark_node after 2.4 is stable.
2755 But not all callers handle ERROR_MARK properly. */
2756 switch (TREE_CODE (TREE_TYPE (expr
)))
2759 error ("struct type value used where scalar is required");
2760 return boolean_false_node
;
2763 error ("union type value used where scalar is required");
2764 return boolean_false_node
;
2767 error ("array type value used where scalar is required");
2768 return boolean_false_node
;
2775 switch (TREE_CODE (expr
))
2778 case NE_EXPR
: case LE_EXPR
: case GE_EXPR
: case LT_EXPR
: case GT_EXPR
:
2779 case TRUTH_ANDIF_EXPR
:
2780 case TRUTH_ORIF_EXPR
:
2781 case TRUTH_AND_EXPR
:
2783 case TRUTH_XOR_EXPR
:
2784 case TRUTH_NOT_EXPR
:
2785 TREE_TYPE (expr
) = boolean_type_node
;
2792 return integer_zerop (expr
) ? boolean_false_node
: boolean_true_node
;
2795 return real_zerop (expr
) ? boolean_false_node
: boolean_true_node
;
2798 /* If we are taking the address of an external decl, it might be zero
2799 if it is weak, so we cannot optimize. */
2800 if (DECL_P (TREE_OPERAND (expr
, 0))
2801 && DECL_EXTERNAL (TREE_OPERAND (expr
, 0)))
2804 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 0)))
2805 return build (COMPOUND_EXPR
, boolean_type_node
,
2806 TREE_OPERAND (expr
, 0), boolean_true_node
);
2808 return boolean_true_node
;
2811 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1))
2812 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
2813 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0)),
2814 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 1)),
2822 /* These don't change whether an object is nonzero or zero. */
2823 return c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0));
2827 /* These don't change whether an object is zero or nonzero, but
2828 we can't ignore them if their second arg has side-effects. */
2829 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1)))
2830 return build (COMPOUND_EXPR
, boolean_type_node
, TREE_OPERAND (expr
, 1),
2831 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0)));
2833 return c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0));
2836 /* Distribute the conversion into the arms of a COND_EXPR. */
2837 return fold (build (COND_EXPR
, boolean_type_node
, TREE_OPERAND (expr
, 0),
2838 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 1)),
2839 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 2))));
2842 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2843 since that affects how `default_conversion' will behave. */
2844 if (TREE_CODE (TREE_TYPE (expr
)) == REFERENCE_TYPE
2845 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == REFERENCE_TYPE
)
2847 /* fall through... */
2849 /* If this is widening the argument, we can ignore it. */
2850 if (TYPE_PRECISION (TREE_TYPE (expr
))
2851 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr
, 0))))
2852 return c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0));
2856 /* Perhaps reduce (x - y) != 0 to (x != y). The expressions
2857 aren't guaranteed to the be same for modes that can represent
2858 infinity, since if x and y are both +infinity, or both
2859 -infinity, then x - y is not a number.
2861 Note that this transformation is safe when x or y is NaN.
2862 (x - y) is then NaN, and both (x - y) != 0 and x != y will
2864 if (HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr
, 0)))))
2866 /* fall through... */
2868 /* This and MINUS_EXPR can be changed into a comparison of the
2870 if (TREE_TYPE (TREE_OPERAND (expr
, 0))
2871 == TREE_TYPE (TREE_OPERAND (expr
, 1)))
2872 return build_binary_op (NE_EXPR
, TREE_OPERAND (expr
, 0),
2873 TREE_OPERAND (expr
, 1), 1);
2874 return build_binary_op (NE_EXPR
, TREE_OPERAND (expr
, 0),
2875 fold (build1 (NOP_EXPR
,
2876 TREE_TYPE (TREE_OPERAND (expr
, 0)),
2877 TREE_OPERAND (expr
, 1))), 1);
2880 if (integer_onep (TREE_OPERAND (expr
, 1))
2881 && TREE_TYPE (expr
) != boolean_type_node
)
2882 /* Using convert here would cause infinite recursion. */
2883 return build1 (NOP_EXPR
, boolean_type_node
, expr
);
2887 if (warn_parentheses
&& C_EXP_ORIGINAL_CODE (expr
) == MODIFY_EXPR
)
2888 warning ("suggest parentheses around assignment used as truth value");
2895 if (TREE_CODE (TREE_TYPE (expr
)) == COMPLEX_TYPE
)
2897 tree t
= save_expr (expr
);
2898 return (build_binary_op
2899 ((TREE_SIDE_EFFECTS (expr
)
2900 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
2901 c_common_truthvalue_conversion (build_unary_op (REALPART_EXPR
, t
, 0)),
2902 c_common_truthvalue_conversion (build_unary_op (IMAGPART_EXPR
, t
, 0)),
2906 return build_binary_op (NE_EXPR
, expr
, integer_zero_node
, 1);
2909 static tree builtin_function_2
PARAMS ((const char *, const char *, tree
, tree
,
2910 int, enum built_in_class
, int, int,
2913 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2914 down to the element type of an array. */
2917 c_build_qualified_type (type
, type_quals
)
2921 /* A restrict-qualified pointer type must be a pointer to object or
2922 incomplete type. Note that the use of POINTER_TYPE_P also allows
2923 REFERENCE_TYPEs, which is appropriate for C++. Unfortunately,
2924 the C++ front-end also use POINTER_TYPE for pointer-to-member
2925 values, so even though it should be illegal to use `restrict'
2926 with such an entity we don't flag that here. Thus, special case
2927 code for that case is required in the C++ front-end. */
2928 if ((type_quals
& TYPE_QUAL_RESTRICT
)
2929 && (!POINTER_TYPE_P (type
)
2930 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type
))))
2932 error ("invalid use of `restrict'");
2933 type_quals
&= ~TYPE_QUAL_RESTRICT
;
2936 if (TREE_CODE (type
) == ARRAY_TYPE
)
2937 return build_array_type (c_build_qualified_type (TREE_TYPE (type
),
2939 TYPE_DOMAIN (type
));
2940 return build_qualified_type (type
, type_quals
);
2943 /* Apply the TYPE_QUALS to the new DECL. */
2946 c_apply_type_quals_to_decl (type_quals
, decl
)
2950 if ((type_quals
& TYPE_QUAL_CONST
)
2951 || (TREE_TYPE (decl
)
2952 && TREE_CODE (TREE_TYPE (decl
)) == REFERENCE_TYPE
))
2953 TREE_READONLY (decl
) = 1;
2954 if (type_quals
& TYPE_QUAL_VOLATILE
)
2956 TREE_SIDE_EFFECTS (decl
) = 1;
2957 TREE_THIS_VOLATILE (decl
) = 1;
2959 if (type_quals
& TYPE_QUAL_RESTRICT
)
2961 if (!TREE_TYPE (decl
)
2962 || !POINTER_TYPE_P (TREE_TYPE (decl
))
2963 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (TREE_TYPE (decl
))))
2964 error ("invalid use of `restrict'");
2965 else if (flag_strict_aliasing
)
2966 /* Indicate we need to make a unique alias set for this pointer.
2967 We can't do it here because it might be pointing to an
2969 DECL_POINTER_ALIAS_SET (decl
) = -2;
2973 /* Return the typed-based alias set for T, which may be an expression
2974 or a type. Return -1 if we don't do anything special. */
2977 c_common_get_alias_set (t
)
2982 /* Permit type-punning when accessing a union, provided the access
2983 is directly through the union. For example, this code does not
2984 permit taking the address of a union member and then storing
2985 through it. Even the type-punning allowed here is a GCC
2986 extension, albeit a common and useful one; the C standard says
2987 that such accesses have implementation-defined behavior. */
2989 TREE_CODE (u
) == COMPONENT_REF
|| TREE_CODE (u
) == ARRAY_REF
;
2990 u
= TREE_OPERAND (u
, 0))
2991 if (TREE_CODE (u
) == COMPONENT_REF
2992 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u
, 0))) == UNION_TYPE
)
2995 /* That's all the expressions we handle specially. */
2999 /* The C standard guarantees that any object may be accessed via an
3000 lvalue that has character type. */
3001 if (t
== char_type_node
3002 || t
== signed_char_type_node
3003 || t
== unsigned_char_type_node
)
3006 /* If it has the may_alias attribute, it can alias anything. */
3007 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (t
)))
3010 /* The C standard specifically allows aliasing between signed and
3011 unsigned variants of the same type. We treat the signed
3012 variant as canonical. */
3013 if (TREE_CODE (t
) == INTEGER_TYPE
&& TREE_UNSIGNED (t
))
3015 tree t1
= c_common_signed_type (t
);
3017 /* t1 == t can happen for boolean nodes which are always unsigned. */
3019 return get_alias_set (t1
);
3021 else if (POINTER_TYPE_P (t
))
3025 /* Unfortunately, there is no canonical form of a pointer type.
3026 In particular, if we have `typedef int I', then `int *', and
3027 `I *' are different types. So, we have to pick a canonical
3028 representative. We do this below.
3030 Technically, this approach is actually more conservative that
3031 it needs to be. In particular, `const int *' and `int *'
3032 should be in different alias sets, according to the C and C++
3033 standard, since their types are not the same, and so,
3034 technically, an `int **' and `const int **' cannot point at
3037 But, the standard is wrong. In particular, this code is
3042 const int* const* cipp = &ipp;
3044 And, it doesn't make sense for that to be legal unless you
3045 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
3046 the pointed-to types. This issue has been reported to the
3048 t1
= build_type_no_quals (t
);
3050 return get_alias_set (t1
);
3056 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
3057 second parameter indicates which OPERATOR is being applied. The COMPLAIN
3058 flag controls whether we should diagnose possibly ill-formed
3059 constructs or not. */
3061 c_sizeof_or_alignof_type (type
, op
, complain
)
3066 const char *op_name
;
3068 enum tree_code type_code
= TREE_CODE (type
);
3070 my_friendly_assert (op
== SIZEOF_EXPR
|| op
== ALIGNOF_EXPR
, 20020720);
3071 op_name
= op
== SIZEOF_EXPR
? "sizeof" : "__alignof__";
3073 if (type_code
== FUNCTION_TYPE
)
3075 if (op
== SIZEOF_EXPR
)
3077 if (complain
&& (pedantic
|| warn_pointer_arith
))
3078 pedwarn ("invalid application of `sizeof' to a function type");
3079 value
= size_one_node
;
3082 value
= size_int (FUNCTION_BOUNDARY
/ BITS_PER_UNIT
);
3084 else if (type_code
== VOID_TYPE
|| type_code
== ERROR_MARK
)
3086 if (type_code
== VOID_TYPE
3087 && complain
&& (pedantic
|| warn_pointer_arith
))
3088 pedwarn ("invalid application of `%s' to a void type", op_name
);
3089 value
= size_one_node
;
3091 else if (!COMPLETE_TYPE_P (type
))
3094 error ("invalid application of `%s' to an incomplete type", op_name
);
3095 value
= size_zero_node
;
3099 if (op
== SIZEOF_EXPR
)
3100 /* Convert in case a char is more than one unit. */
3101 value
= size_binop (CEIL_DIV_EXPR
, TYPE_SIZE_UNIT (type
),
3102 size_int (TYPE_PRECISION (char_type_node
)
3105 value
= size_int (TYPE_ALIGN (type
) / BITS_PER_UNIT
);
3108 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
3109 TYPE_IS_SIZETYPE means that certain things (like overflow) will
3110 never happen. However, this node should really have type
3111 `size_t', which is just a typedef for an ordinary integer type. */
3112 value
= fold (build1 (NOP_EXPR
, size_type_node
, value
));
3113 my_friendly_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value
)), 20001021);
3118 /* Implement the __alignof keyword: Return the minimum required
3119 alignment of EXPR, measured in bytes. For VAR_DECL's and
3120 FIELD_DECL's return DECL_ALIGN (which can be set from an
3121 "aligned" __attribute__ specification). */
3124 c_alignof_expr (expr
)
3129 if (TREE_CODE (expr
) == VAR_DECL
)
3130 t
= size_int (DECL_ALIGN (expr
) / BITS_PER_UNIT
);
3132 else if (TREE_CODE (expr
) == COMPONENT_REF
3133 && DECL_C_BIT_FIELD (TREE_OPERAND (expr
, 1)))
3135 error ("`__alignof' applied to a bit-field");
3138 else if (TREE_CODE (expr
) == COMPONENT_REF
3139 && TREE_CODE (TREE_OPERAND (expr
, 1)) == FIELD_DECL
)
3140 t
= size_int (DECL_ALIGN (TREE_OPERAND (expr
, 1)) / BITS_PER_UNIT
);
3142 else if (TREE_CODE (expr
) == INDIRECT_REF
)
3144 tree t
= TREE_OPERAND (expr
, 0);
3146 int bestalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
3148 while (TREE_CODE (t
) == NOP_EXPR
3149 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0))) == POINTER_TYPE
)
3153 t
= TREE_OPERAND (t
, 0);
3154 thisalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
3155 if (thisalign
> bestalign
)
3156 best
= t
, bestalign
= thisalign
;
3158 return c_alignof (TREE_TYPE (TREE_TYPE (best
)));
3161 return c_alignof (TREE_TYPE (expr
));
3163 return fold (build1 (NOP_EXPR
, size_type_node
, t
));
3166 /* Handle C and C++ default attributes. */
3168 enum built_in_attribute
3170 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
3171 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
3172 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
3173 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
3174 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No entry needed in enum. */
3175 #include "builtin-attrs.def"
3176 #undef DEF_ATTR_NULL_TREE
3178 #undef DEF_ATTR_IDENT
3179 #undef DEF_ATTR_TREE_LIST
3184 static GTY(()) tree built_in_attributes
[(int) ATTR_LAST
];
3186 static bool c_attrs_initialized
= false;
3188 static void c_init_attributes
PARAMS ((void));
3190 /* Build tree nodes and builtin functions common to both C and C++ language
3194 c_common_nodes_and_builtins ()
3198 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
3199 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
3200 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
3201 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
3202 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3203 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3204 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
3205 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
3206 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
3207 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3208 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
3209 #include "builtin-types.def"
3210 #undef DEF_PRIMITIVE_TYPE
3211 #undef DEF_FUNCTION_TYPE_0
3212 #undef DEF_FUNCTION_TYPE_1
3213 #undef DEF_FUNCTION_TYPE_2
3214 #undef DEF_FUNCTION_TYPE_3
3215 #undef DEF_FUNCTION_TYPE_4
3216 #undef DEF_FUNCTION_TYPE_VAR_0
3217 #undef DEF_FUNCTION_TYPE_VAR_1
3218 #undef DEF_FUNCTION_TYPE_VAR_2
3219 #undef DEF_FUNCTION_TYPE_VAR_3
3220 #undef DEF_POINTER_TYPE
3224 typedef enum builtin_type builtin_type
;
3226 tree builtin_types
[(int) BT_LAST
];
3227 int wchar_type_size
;
3228 tree array_domain_type
;
3229 tree va_list_ref_type_node
;
3230 tree va_list_arg_type_node
;
3232 /* Define `int' and `char' first so that dbx will output them first. */
3233 record_builtin_type (RID_INT
, NULL
, integer_type_node
);
3234 record_builtin_type (RID_CHAR
, "char", char_type_node
);
3236 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
3237 "unsigned long", "long long unsigned" and "unsigned short" were in C++
3238 but not C. Are the conditionals here needed? */
3239 if (c_language
== clk_cplusplus
)
3240 record_builtin_type (RID_SIGNED
, NULL
, integer_type_node
);
3241 record_builtin_type (RID_LONG
, "long int", long_integer_type_node
);
3242 record_builtin_type (RID_UNSIGNED
, "unsigned int", unsigned_type_node
);
3243 record_builtin_type (RID_MAX
, "long unsigned int",
3244 long_unsigned_type_node
);
3245 if (c_language
== clk_cplusplus
)
3246 record_builtin_type (RID_MAX
, "unsigned long", long_unsigned_type_node
);
3247 record_builtin_type (RID_MAX
, "long long int",
3248 long_long_integer_type_node
);
3249 record_builtin_type (RID_MAX
, "long long unsigned int",
3250 long_long_unsigned_type_node
);
3251 if (c_language
== clk_cplusplus
)
3252 record_builtin_type (RID_MAX
, "long long unsigned",
3253 long_long_unsigned_type_node
);
3254 record_builtin_type (RID_SHORT
, "short int", short_integer_type_node
);
3255 record_builtin_type (RID_MAX
, "short unsigned int",
3256 short_unsigned_type_node
);
3257 if (c_language
== clk_cplusplus
)
3258 record_builtin_type (RID_MAX
, "unsigned short",
3259 short_unsigned_type_node
);
3261 /* Define both `signed char' and `unsigned char'. */
3262 record_builtin_type (RID_MAX
, "signed char", signed_char_type_node
);
3263 record_builtin_type (RID_MAX
, "unsigned char", unsigned_char_type_node
);
3265 /* These are types that c_common_type_for_size and
3266 c_common_type_for_mode use. */
3267 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
3269 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
3271 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
3273 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
3275 #if HOST_BITS_PER_WIDE_INT >= 64
3276 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
,
3277 get_identifier ("__int128_t"),
3280 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
3281 unsigned_intQI_type_node
));
3282 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
3283 unsigned_intHI_type_node
));
3284 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
3285 unsigned_intSI_type_node
));
3286 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
3287 unsigned_intDI_type_node
));
3288 #if HOST_BITS_PER_WIDE_INT >= 64
3289 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
,
3290 get_identifier ("__uint128_t"),
3291 unsigned_intTI_type_node
));
3294 /* Create the widest literal types. */
3295 widest_integer_literal_type_node
3296 = make_signed_type (HOST_BITS_PER_WIDE_INT
* 2);
3297 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
3298 widest_integer_literal_type_node
));
3300 widest_unsigned_literal_type_node
3301 = make_unsigned_type (HOST_BITS_PER_WIDE_INT
* 2);
3302 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
3303 widest_unsigned_literal_type_node
));
3305 /* `unsigned long' is the standard type for sizeof.
3306 Note that stddef.h uses `unsigned long',
3307 and this must agree, even if long and int are the same size. */
3309 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE
)));
3310 signed_size_type_node
= c_common_signed_type (size_type_node
);
3311 set_sizetype (size_type_node
);
3313 build_common_tree_nodes_2 (flag_short_double
);
3315 record_builtin_type (RID_FLOAT
, NULL
, float_type_node
);
3316 record_builtin_type (RID_DOUBLE
, NULL
, double_type_node
);
3317 record_builtin_type (RID_MAX
, "long double", long_double_type_node
);
3319 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
,
3320 get_identifier ("complex int"),
3321 complex_integer_type_node
));
3322 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
,
3323 get_identifier ("complex float"),
3324 complex_float_type_node
));
3325 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
,
3326 get_identifier ("complex double"),
3327 complex_double_type_node
));
3328 (*lang_hooks
.decls
.pushdecl
)
3329 (build_decl (TYPE_DECL
, get_identifier ("complex long double"),
3330 complex_long_double_type_node
));
3332 /* Types which are common to the fortran compiler and libf2c. When
3333 changing these, you also need to be concerned with f/com.h. */
3335 if (TYPE_PRECISION (float_type_node
)
3336 == TYPE_PRECISION (long_integer_type_node
))
3338 g77_integer_type_node
= long_integer_type_node
;
3339 g77_uinteger_type_node
= long_unsigned_type_node
;
3341 else if (TYPE_PRECISION (float_type_node
)
3342 == TYPE_PRECISION (integer_type_node
))
3344 g77_integer_type_node
= integer_type_node
;
3345 g77_uinteger_type_node
= unsigned_type_node
;
3348 g77_integer_type_node
= g77_uinteger_type_node
= NULL_TREE
;
3350 if (g77_integer_type_node
!= NULL_TREE
)
3352 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
,
3353 get_identifier ("__g77_integer"),
3354 g77_integer_type_node
));
3355 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
,
3356 get_identifier ("__g77_uinteger"),
3357 g77_uinteger_type_node
));
3360 if (TYPE_PRECISION (float_type_node
) * 2
3361 == TYPE_PRECISION (long_integer_type_node
))
3363 g77_longint_type_node
= long_integer_type_node
;
3364 g77_ulongint_type_node
= long_unsigned_type_node
;
3366 else if (TYPE_PRECISION (float_type_node
) * 2
3367 == TYPE_PRECISION (long_long_integer_type_node
))
3369 g77_longint_type_node
= long_long_integer_type_node
;
3370 g77_ulongint_type_node
= long_long_unsigned_type_node
;
3373 g77_longint_type_node
= g77_ulongint_type_node
= NULL_TREE
;
3375 if (g77_longint_type_node
!= NULL_TREE
)
3377 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
,
3378 get_identifier ("__g77_longint"),
3379 g77_longint_type_node
));
3380 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
,
3381 get_identifier ("__g77_ulongint"),
3382 g77_ulongint_type_node
));
3385 record_builtin_type (RID_VOID
, NULL
, void_type_node
);
3387 void_zero_node
= build_int_2 (0, 0);
3388 TREE_TYPE (void_zero_node
) = void_type_node
;
3390 void_list_node
= build_void_list_node ();
3392 /* Make a type to be the domain of a few array types
3393 whose domains don't really matter.
3394 200 is small enough that it always fits in size_t
3395 and large enough that it can hold most function names for the
3396 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
3397 array_domain_type
= build_index_type (size_int (200));
3399 /* Make a type for arrays of characters.
3400 With luck nothing will ever really depend on the length of this
3402 char_array_type_node
3403 = build_array_type (char_type_node
, array_domain_type
);
3405 /* Likewise for arrays of ints. */
3407 = build_array_type (integer_type_node
, array_domain_type
);
3409 string_type_node
= build_pointer_type (char_type_node
);
3410 const_string_type_node
3411 = build_pointer_type (build_qualified_type
3412 (char_type_node
, TYPE_QUAL_CONST
));
3414 /* This is special for C++ so functions can be overloaded. */
3415 wchar_type_node
= get_identifier (MODIFIED_WCHAR_TYPE
);
3416 wchar_type_node
= TREE_TYPE (identifier_global_value (wchar_type_node
));
3417 wchar_type_size
= TYPE_PRECISION (wchar_type_node
);
3418 if (c_language
== clk_cplusplus
)
3420 if (TREE_UNSIGNED (wchar_type_node
))
3421 wchar_type_node
= make_unsigned_type (wchar_type_size
);
3423 wchar_type_node
= make_signed_type (wchar_type_size
);
3424 record_builtin_type (RID_WCHAR
, "wchar_t", wchar_type_node
);
3428 signed_wchar_type_node
= c_common_signed_type (wchar_type_node
);
3429 unsigned_wchar_type_node
= c_common_unsigned_type (wchar_type_node
);
3432 /* This is for wide string constants. */
3433 wchar_array_type_node
3434 = build_array_type (wchar_type_node
, array_domain_type
);
3437 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE
)));
3440 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE
)));
3442 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE
)));
3444 default_function_type
= build_function_type (integer_type_node
, NULL_TREE
);
3446 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE
)));
3447 unsigned_ptrdiff_type_node
= c_common_unsigned_type (ptrdiff_type_node
);
3449 (*lang_hooks
.decls
.pushdecl
)
3450 (build_decl (TYPE_DECL
, get_identifier ("__builtin_va_list"),
3451 va_list_type_node
));
3453 (*lang_hooks
.decls
.pushdecl
)
3454 (build_decl (TYPE_DECL
, get_identifier ("__builtin_ptrdiff_t"),
3455 ptrdiff_type_node
));
3457 (*lang_hooks
.decls
.pushdecl
)
3458 (build_decl (TYPE_DECL
, get_identifier ("__builtin_size_t"),
3461 if (TREE_CODE (va_list_type_node
) == ARRAY_TYPE
)
3463 va_list_arg_type_node
= va_list_ref_type_node
=
3464 build_pointer_type (TREE_TYPE (va_list_type_node
));
3468 va_list_arg_type_node
= va_list_type_node
;
3469 va_list_ref_type_node
= build_reference_type (va_list_type_node
);
3472 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3473 builtin_types[(int) ENUM] = VALUE;
3474 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
3475 builtin_types[(int) ENUM] \
3476 = build_function_type (builtin_types[(int) RETURN], \
3478 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
3479 builtin_types[(int) ENUM] \
3480 = build_function_type (builtin_types[(int) RETURN], \
3481 tree_cons (NULL_TREE, \
3482 builtin_types[(int) ARG1], \
3484 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
3485 builtin_types[(int) ENUM] \
3486 = build_function_type \
3487 (builtin_types[(int) RETURN], \
3488 tree_cons (NULL_TREE, \
3489 builtin_types[(int) ARG1], \
3490 tree_cons (NULL_TREE, \
3491 builtin_types[(int) ARG2], \
3493 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3494 builtin_types[(int) ENUM] \
3495 = build_function_type \
3496 (builtin_types[(int) RETURN], \
3497 tree_cons (NULL_TREE, \
3498 builtin_types[(int) ARG1], \
3499 tree_cons (NULL_TREE, \
3500 builtin_types[(int) ARG2], \
3501 tree_cons (NULL_TREE, \
3502 builtin_types[(int) ARG3], \
3504 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3505 builtin_types[(int) ENUM] \
3506 = build_function_type \
3507 (builtin_types[(int) RETURN], \
3508 tree_cons (NULL_TREE, \
3509 builtin_types[(int) ARG1], \
3510 tree_cons (NULL_TREE, \
3511 builtin_types[(int) ARG2], \
3514 builtin_types[(int) ARG3], \
3515 tree_cons (NULL_TREE, \
3516 builtin_types[(int) ARG4], \
3517 void_list_node)))));
3518 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
3519 builtin_types[(int) ENUM] \
3520 = build_function_type (builtin_types[(int) RETURN], NULL_TREE);
3521 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
3522 builtin_types[(int) ENUM] \
3523 = build_function_type (builtin_types[(int) RETURN], \
3524 tree_cons (NULL_TREE, \
3525 builtin_types[(int) ARG1], \
3528 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
3529 builtin_types[(int) ENUM] \
3530 = build_function_type \
3531 (builtin_types[(int) RETURN], \
3532 tree_cons (NULL_TREE, \
3533 builtin_types[(int) ARG1], \
3534 tree_cons (NULL_TREE, \
3535 builtin_types[(int) ARG2], \
3538 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3539 builtin_types[(int) ENUM] \
3540 = build_function_type \
3541 (builtin_types[(int) RETURN], \
3542 tree_cons (NULL_TREE, \
3543 builtin_types[(int) ARG1], \
3544 tree_cons (NULL_TREE, \
3545 builtin_types[(int) ARG2], \
3546 tree_cons (NULL_TREE, \
3547 builtin_types[(int) ARG3], \
3550 #define DEF_POINTER_TYPE(ENUM, TYPE) \
3551 builtin_types[(int) ENUM] \
3552 = build_pointer_type (builtin_types[(int) TYPE]);
3553 #include "builtin-types.def"
3554 #undef DEF_PRIMITIVE_TYPE
3555 #undef DEF_FUNCTION_TYPE_1
3556 #undef DEF_FUNCTION_TYPE_2
3557 #undef DEF_FUNCTION_TYPE_3
3558 #undef DEF_FUNCTION_TYPE_4
3559 #undef DEF_FUNCTION_TYPE_VAR_0
3560 #undef DEF_FUNCTION_TYPE_VAR_1
3561 #undef DEF_FUNCTION_TYPE_VAR_2
3562 #undef DEF_FUNCTION_TYPE_VAR_3
3563 #undef DEF_POINTER_TYPE
3565 if (!c_attrs_initialized
)
3566 c_init_attributes ();
3568 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, \
3569 BOTH_P, FALLBACK_P, NONANSI_P, ATTRS, IMPLICIT) \
3574 if (strncmp (NAME, "__builtin_", strlen ("__builtin_")) != 0) \
3578 decl = builtin_function (NAME, builtin_types[TYPE], ENUM, \
3581 ? (NAME + strlen ("__builtin_")) \
3583 built_in_attributes[(int) ATTRS]); \
3585 decl = builtin_function_2 (NAME, \
3586 NAME + strlen ("__builtin_"), \
3587 builtin_types[TYPE], \
3588 builtin_types[LIBTYPE], \
3593 built_in_attributes[(int) ATTRS]); \
3595 built_in_decls[(int) ENUM] = decl; \
3597 implicit_built_in_decls[(int) ENUM] = decl; \
3599 #include "builtins.def"
3602 (*targetm
.init_builtins
) ();
3604 main_identifier_node
= get_identifier ("main");
3608 build_va_arg (expr
, type
)
3611 return build1 (VA_ARG_EXPR
, type
, expr
);
3615 /* Linked list of disabled built-in functions. */
3617 typedef struct disabled_builtin
3620 struct disabled_builtin
*next
;
3622 static disabled_builtin
*disabled_builtins
= NULL
;
3624 static bool builtin_function_disabled_p
PARAMS ((const char *));
3626 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
3627 begins with "__builtin_", give an error. */
3630 disable_builtin_function (name
)
3633 if (strncmp (name
, "__builtin_", strlen ("__builtin_")) == 0)
3634 error ("cannot disable built-in function `%s'", name
);
3637 disabled_builtin
*new = xmalloc (sizeof (disabled_builtin
));
3639 new->next
= disabled_builtins
;
3640 disabled_builtins
= new;
3645 /* Return true if the built-in function NAME has been disabled, false
3649 builtin_function_disabled_p (name
)
3652 disabled_builtin
*p
;
3653 for (p
= disabled_builtins
; p
!= NULL
; p
= p
->next
)
3655 if (strcmp (name
, p
->name
) == 0)
3662 /* Possibly define a builtin function with one or two names. BUILTIN_NAME
3663 is an __builtin_-prefixed name; NAME is the ordinary name; one or both
3664 of these may be NULL (though both being NULL is useless).
3665 BUILTIN_TYPE is the type of the __builtin_-prefixed function;
3666 TYPE is the type of the function with the ordinary name. These
3667 may differ if the ordinary name is declared with a looser type to avoid
3668 conflicts with headers. FUNCTION_CODE and CLASS are as for
3669 builtin_function. If LIBRARY_NAME_P is nonzero, NAME is passed as
3670 the LIBRARY_NAME parameter to builtin_function when declaring BUILTIN_NAME.
3671 If NONANSI_P is nonzero, the name NAME is treated as a non-ANSI name;
3672 ATTRS is the tree list representing the builtin's function attributes.
3673 Returns the declaration of BUILTIN_NAME, if any, otherwise
3674 the declaration of NAME. Does not declare NAME if flag_no_builtin,
3675 or if NONANSI_P and flag_no_nonansi_builtin. */
3678 builtin_function_2 (builtin_name
, name
, builtin_type
, type
, function_code
,
3679 class, library_name_p
, nonansi_p
, attrs
)
3680 const char *builtin_name
;
3685 enum built_in_class
class;
3690 tree bdecl
= NULL_TREE
;
3691 tree decl
= NULL_TREE
;
3692 if (builtin_name
!= 0)
3694 bdecl
= builtin_function (builtin_name
, builtin_type
, function_code
,
3695 class, library_name_p
? name
: NULL
,
3698 if (name
!= 0 && !flag_no_builtin
&& !builtin_function_disabled_p (name
)
3699 && !(nonansi_p
&& flag_no_nonansi_builtin
))
3701 decl
= builtin_function (name
, type
, function_code
, class, NULL
,
3704 DECL_BUILT_IN_NONANSI (decl
) = 1;
3706 return (bdecl
!= 0 ? bdecl
: decl
);
3709 /* Nonzero if the type T promotes to int. This is (nearly) the
3710 integral promotions defined in ISO C99 6.3.1.1/2. */
3713 c_promoting_integer_type_p (t
)
3716 switch (TREE_CODE (t
))
3719 return (TYPE_MAIN_VARIANT (t
) == char_type_node
3720 || TYPE_MAIN_VARIANT (t
) == signed_char_type_node
3721 || TYPE_MAIN_VARIANT (t
) == unsigned_char_type_node
3722 || TYPE_MAIN_VARIANT (t
) == short_integer_type_node
3723 || TYPE_MAIN_VARIANT (t
) == short_unsigned_type_node
3724 || TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
));
3727 /* ??? Technically all enumerations not larger than an int
3728 promote to an int. But this is used along code paths
3729 that only want to notice a size change. */
3730 return TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
);
3740 /* Return 1 if PARMS specifies a fixed number of parameters
3741 and none of their types is affected by default promotions. */
3744 self_promoting_args_p (parms
)
3748 for (t
= parms
; t
; t
= TREE_CHAIN (t
))
3750 tree type
= TREE_VALUE (t
);
3752 if (TREE_CHAIN (t
) == 0 && type
!= void_type_node
)
3758 if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
3761 if (c_promoting_integer_type_p (type
))
3767 /* Recursively examines the array elements of TYPE, until a non-array
3768 element type is found. */
3771 strip_array_types (type
)
3774 while (TREE_CODE (type
) == ARRAY_TYPE
)
3775 type
= TREE_TYPE (type
);
3780 static tree expand_unordered_cmp
PARAMS ((tree
, tree
, enum tree_code
,
3783 /* Expand a call to an unordered comparison function such as
3784 __builtin_isgreater(). FUNCTION is the function's declaration and
3785 PARAMS a list of the values passed. For __builtin_isunordered(),
3786 UNORDERED_CODE is UNORDERED_EXPR and ORDERED_CODE is NOP_EXPR. In
3787 other cases, UNORDERED_CODE and ORDERED_CODE are comparison codes
3788 that give the opposite of the desired result. UNORDERED_CODE is
3789 used for modes that can hold NaNs and ORDERED_CODE is used for the
3793 expand_unordered_cmp (function
, params
, unordered_code
, ordered_code
)
3794 tree function
, params
;
3795 enum tree_code unordered_code
, ordered_code
;
3797 tree arg0
, arg1
, type
;
3798 enum tree_code code0
, code1
;
3800 /* Check that we have exactly two arguments. */
3801 if (params
== 0 || TREE_CHAIN (params
) == 0)
3803 error ("too few arguments to function `%s'",
3804 IDENTIFIER_POINTER (DECL_NAME (function
)));
3805 return error_mark_node
;
3807 else if (TREE_CHAIN (TREE_CHAIN (params
)) != 0)
3809 error ("too many arguments to function `%s'",
3810 IDENTIFIER_POINTER (DECL_NAME (function
)));
3811 return error_mark_node
;
3814 arg0
= TREE_VALUE (params
);
3815 arg1
= TREE_VALUE (TREE_CHAIN (params
));
3817 code0
= TREE_CODE (TREE_TYPE (arg0
));
3818 code1
= TREE_CODE (TREE_TYPE (arg1
));
3820 /* Make sure that the arguments have a common type of REAL. */
3822 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
)
3823 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
))
3824 type
= common_type (TREE_TYPE (arg0
), TREE_TYPE (arg1
));
3826 if (type
== 0 || TREE_CODE (type
) != REAL_TYPE
)
3828 error ("non-floating-point argument to function `%s'",
3829 IDENTIFIER_POINTER (DECL_NAME (function
)));
3830 return error_mark_node
;
3833 if (unordered_code
== UNORDERED_EXPR
)
3835 if (MODE_HAS_NANS (TYPE_MODE (type
)))
3836 return build_binary_op (unordered_code
,
3837 convert (type
, arg0
),
3838 convert (type
, arg1
),
3841 return integer_zero_node
;
3844 return build_unary_op (TRUTH_NOT_EXPR
,
3845 build_binary_op (MODE_HAS_NANS (TYPE_MODE (type
))
3848 convert (type
, arg0
),
3849 convert (type
, arg1
),
3855 /* Recognize certain built-in functions so we can make tree-codes
3856 other than CALL_EXPR. We do this when it enables fold-const.c
3857 to do something useful. */
3858 /* ??? By rights this should go in builtins.c, but only C and C++
3859 implement build_{binary,unary}_op. Not exactly sure what bits
3860 of functionality are actually needed from those functions, or
3861 where the similar functionality exists in the other front ends. */
3864 expand_tree_builtin (function
, params
, coerced_params
)
3865 tree function
, params
, coerced_params
;
3867 if (DECL_BUILT_IN_CLASS (function
) != BUILT_IN_NORMAL
)
3870 switch (DECL_FUNCTION_CODE (function
))
3874 case BUILT_IN_LLABS
:
3875 case BUILT_IN_IMAXABS
:
3877 case BUILT_IN_FABSL
:
3878 case BUILT_IN_FABSF
:
3879 if (coerced_params
== 0)
3880 return integer_zero_node
;
3881 return build_unary_op (ABS_EXPR
, TREE_VALUE (coerced_params
), 0);
3884 case BUILT_IN_CONJF
:
3885 case BUILT_IN_CONJL
:
3886 if (coerced_params
== 0)
3887 return integer_zero_node
;
3888 return build_unary_op (CONJ_EXPR
, TREE_VALUE (coerced_params
), 0);
3890 case BUILT_IN_CREAL
:
3891 case BUILT_IN_CREALF
:
3892 case BUILT_IN_CREALL
:
3893 if (coerced_params
== 0)
3894 return integer_zero_node
;
3895 return build_unary_op (REALPART_EXPR
, TREE_VALUE (coerced_params
), 0);
3897 case BUILT_IN_CIMAG
:
3898 case BUILT_IN_CIMAGF
:
3899 case BUILT_IN_CIMAGL
:
3900 if (coerced_params
== 0)
3901 return integer_zero_node
;
3902 return build_unary_op (IMAGPART_EXPR
, TREE_VALUE (coerced_params
), 0);
3904 case BUILT_IN_ISGREATER
:
3905 return expand_unordered_cmp (function
, params
, UNLE_EXPR
, LE_EXPR
);
3907 case BUILT_IN_ISGREATEREQUAL
:
3908 return expand_unordered_cmp (function
, params
, UNLT_EXPR
, LT_EXPR
);
3910 case BUILT_IN_ISLESS
:
3911 return expand_unordered_cmp (function
, params
, UNGE_EXPR
, GE_EXPR
);
3913 case BUILT_IN_ISLESSEQUAL
:
3914 return expand_unordered_cmp (function
, params
, UNGT_EXPR
, GT_EXPR
);
3916 case BUILT_IN_ISLESSGREATER
:
3917 return expand_unordered_cmp (function
, params
, UNEQ_EXPR
, EQ_EXPR
);
3919 case BUILT_IN_ISUNORDERED
:
3920 return expand_unordered_cmp (function
, params
, UNORDERED_EXPR
, NOP_EXPR
);
3929 /* Returns nonzero if CODE is the code for a statement. */
3932 statement_code_p (code
)
3933 enum tree_code code
;
3958 if (lang_statement_code_p
)
3959 return (*lang_statement_code_p
) (code
);
3964 /* Walk the statement tree, rooted at *tp. Apply FUNC to all the
3965 sub-trees of *TP in a pre-order traversal. FUNC is called with the
3966 DATA and the address of each sub-tree. If FUNC returns a non-NULL
3967 value, the traversal is aborted, and the value returned by FUNC is
3968 returned. If FUNC sets WALK_SUBTREES to zero, then the subtrees of
3969 the node being visited are not walked.
3971 We don't need a without_duplicates variant of this one because the
3972 statement tree is a tree, not a graph. */
3975 walk_stmt_tree (tp
, func
, data
)
3980 enum tree_code code
;
3985 #define WALK_SUBTREE(NODE) \
3988 result = walk_stmt_tree (&(NODE), func, data); \
3994 /* Skip empty subtrees. */
3998 /* Skip subtrees below non-statement nodes. */
3999 if (!statement_code_p (TREE_CODE (*tp
)))
4002 /* Call the function. */
4004 result
= (*func
) (tp
, &walk_subtrees
, data
);
4006 /* If we found something, return it. */
4010 /* FUNC may have modified the tree, recheck that we're looking at a
4012 code
= TREE_CODE (*tp
);
4013 if (!statement_code_p (code
))
4016 /* Visit the subtrees unless FUNC decided that there was nothing
4017 interesting below this point in the tree. */
4020 /* Walk over all the sub-trees of this operand. Statement nodes
4021 never contain RTL, and we needn't worry about TARGET_EXPRs. */
4022 len
= TREE_CODE_LENGTH (code
);
4024 /* Go through the subtrees. We need to do this in forward order so
4025 that the scope of a FOR_EXPR is handled properly. */
4026 for (i
= 0; i
< len
; ++i
)
4027 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
4030 /* Finally visit the chain. This can be tail-recursion optimized if
4031 we write it this way. */
4032 return walk_stmt_tree (&TREE_CHAIN (*tp
), func
, data
);
4037 /* Used to compare case labels. K1 and K2 are actually tree nodes
4038 representing case labels, or NULL_TREE for a `default' label.
4039 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
4040 K2, and 0 if K1 and K2 are equal. */
4043 case_compare (k1
, k2
)
4047 /* Consider a NULL key (such as arises with a `default' label) to be
4048 smaller than anything else. */
4054 return tree_int_cst_compare ((tree
) k1
, (tree
) k2
);
4057 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
4058 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
4059 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
4060 case label was declared using the usual C/C++ syntax, rather than
4061 the GNU case range extension. CASES is a tree containing all the
4062 case ranges processed so far; COND is the condition for the
4063 switch-statement itself. Returns the CASE_LABEL created, or
4064 ERROR_MARK_NODE if no CASE_LABEL is created. */
4067 c_add_case_label (cases
, cond
, low_value
, high_value
)
4076 splay_tree_node node
;
4078 /* Create the LABEL_DECL itself. */
4079 label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
4080 DECL_CONTEXT (label
) = current_function_decl
;
4082 /* If there was an error processing the switch condition, bail now
4083 before we get more confused. */
4084 if (!cond
|| cond
== error_mark_node
)
4086 /* Add a label anyhow so that the back-end doesn't think that
4087 the beginning of the switch is unreachable. */
4089 add_stmt (build_case_label (NULL_TREE
, NULL_TREE
, label
));
4090 return error_mark_node
;
4093 if ((low_value
&& TREE_TYPE (low_value
)
4094 && POINTER_TYPE_P (TREE_TYPE (low_value
)))
4095 || (high_value
&& TREE_TYPE (high_value
)
4096 && POINTER_TYPE_P (TREE_TYPE (high_value
))))
4097 error ("pointers are not permitted as case values");
4099 /* Case ranges are a GNU extension. */
4100 if (high_value
&& pedantic
)
4102 if (c_language
== clk_cplusplus
)
4103 pedwarn ("ISO C++ forbids range expressions in switch statements");
4105 pedwarn ("ISO C forbids range expressions in switch statements");
4108 type
= TREE_TYPE (cond
);
4111 low_value
= check_case_value (low_value
);
4112 low_value
= convert_and_check (type
, low_value
);
4116 high_value
= check_case_value (high_value
);
4117 high_value
= convert_and_check (type
, high_value
);
4120 /* If an error has occurred, bail out now. */
4121 if (low_value
== error_mark_node
|| high_value
== error_mark_node
)
4124 add_stmt (build_case_label (NULL_TREE
, NULL_TREE
, label
));
4125 return error_mark_node
;
4128 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
4129 really a case range, even though it was written that way. Remove
4130 the HIGH_VALUE to simplify later processing. */
4131 if (tree_int_cst_equal (low_value
, high_value
))
4132 high_value
= NULL_TREE
;
4133 if (low_value
&& high_value
4134 && !tree_int_cst_lt (low_value
, high_value
))
4135 warning ("empty range specified");
4137 /* Look up the LOW_VALUE in the table of case labels we already
4139 node
= splay_tree_lookup (cases
, (splay_tree_key
) low_value
);
4140 /* If there was not an exact match, check for overlapping ranges.
4141 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
4142 that's a `default' label and the only overlap is an exact match. */
4143 if (!node
&& (low_value
|| high_value
))
4145 splay_tree_node low_bound
;
4146 splay_tree_node high_bound
;
4148 /* Even though there wasn't an exact match, there might be an
4149 overlap between this case range and another case range.
4150 Since we've (inductively) not allowed any overlapping case
4151 ranges, we simply need to find the greatest low case label
4152 that is smaller that LOW_VALUE, and the smallest low case
4153 label that is greater than LOW_VALUE. If there is an overlap
4154 it will occur in one of these two ranges. */
4155 low_bound
= splay_tree_predecessor (cases
,
4156 (splay_tree_key
) low_value
);
4157 high_bound
= splay_tree_successor (cases
,
4158 (splay_tree_key
) low_value
);
4160 /* Check to see if the LOW_BOUND overlaps. It is smaller than
4161 the LOW_VALUE, so there is no need to check unless the
4162 LOW_BOUND is in fact itself a case range. */
4164 && CASE_HIGH ((tree
) low_bound
->value
)
4165 && tree_int_cst_compare (CASE_HIGH ((tree
) low_bound
->value
),
4168 /* Check to see if the HIGH_BOUND overlaps. The low end of that
4169 range is bigger than the low end of the current range, so we
4170 are only interested if the current range is a real range, and
4171 not an ordinary case label. */
4174 && (tree_int_cst_compare ((tree
) high_bound
->key
,
4179 /* If there was an overlap, issue an error. */
4182 tree duplicate
= CASE_LABEL_DECL ((tree
) node
->value
);
4186 error ("duplicate (or overlapping) case value");
4187 error_with_decl (duplicate
,
4188 "this is the first entry overlapping that value");
4192 error ("duplicate case value") ;
4193 error_with_decl (duplicate
, "previously used here");
4197 error ("multiple default labels in one switch");
4198 error_with_decl (duplicate
, "this is the first default label");
4201 add_stmt (build_case_label (NULL_TREE
, NULL_TREE
, label
));
4204 /* Add a CASE_LABEL to the statement-tree. */
4205 case_label
= add_stmt (build_case_label (low_value
, high_value
, label
));
4206 /* Register this case label in the splay tree. */
4207 splay_tree_insert (cases
,
4208 (splay_tree_key
) low_value
,
4209 (splay_tree_value
) case_label
);
4214 /* Finish an expression taking the address of LABEL. Returns an
4215 expression for the address. */
4218 finish_label_address_expr (label
)
4225 if (c_language
== clk_cplusplus
)
4226 pedwarn ("ISO C++ forbids taking the address of a label");
4228 pedwarn ("ISO C forbids taking the address of a label");
4231 label
= lookup_label (label
);
4232 if (label
== NULL_TREE
)
4233 result
= null_pointer_node
;
4236 TREE_USED (label
) = 1;
4237 result
= build1 (ADDR_EXPR
, ptr_type_node
, label
);
4238 TREE_CONSTANT (result
) = 1;
4239 /* The current function in not necessarily uninlinable.
4240 Computed gotos are incompatible with inlining, but the value
4241 here could be used only in a diagnostic, for example. */
4247 /* Hook used by expand_expr to expand language-specific tree codes. */
4250 c_expand_expr (exp
, target
, tmode
, modifier
)
4253 enum machine_mode tmode
;
4254 int modifier
; /* Actually enum_modifier. */
4256 switch (TREE_CODE (exp
))
4262 bool preserve_result
= false;
4263 bool return_target
= false;
4265 /* Since expand_expr_stmt calls free_temp_slots after every
4266 expression statement, we must call push_temp_slots here.
4267 Otherwise, any temporaries in use now would be considered
4268 out-of-scope after the first EXPR_STMT from within the
4271 rtl_expr
= expand_start_stmt_expr (!STMT_EXPR_NO_SCOPE (exp
));
4273 /* If we want the result of this expression, find the last
4274 EXPR_STMT in the COMPOUND_STMT and mark it as addressable. */
4275 if (target
!= const0_rtx
4276 && TREE_CODE (STMT_EXPR_STMT (exp
)) == COMPOUND_STMT
4277 && TREE_CODE (COMPOUND_BODY (STMT_EXPR_STMT (exp
))) == SCOPE_STMT
)
4279 tree expr
= COMPOUND_BODY (STMT_EXPR_STMT (exp
));
4280 tree last
= TREE_CHAIN (expr
);
4282 while (TREE_CHAIN (last
))
4285 last
= TREE_CHAIN (last
);
4288 if (TREE_CODE (last
) == SCOPE_STMT
4289 && TREE_CODE (expr
) == EXPR_STMT
)
4291 if (target
&& TREE_CODE (EXPR_STMT_EXPR (expr
)) == VAR_DECL
4292 && DECL_RTL_IF_SET (EXPR_STMT_EXPR (expr
)) == target
)
4293 /* If the last expression is a variable whose RTL is the
4294 same as our target, just return the target; if it
4295 isn't valid expanding the decl would produce different
4296 RTL, and store_expr would try to do a copy. */
4297 return_target
= true;
4300 /* Otherwise, note that we want the value from the last
4302 TREE_ADDRESSABLE (expr
) = 1;
4303 preserve_result
= true;
4308 expand_stmt (STMT_EXPR_STMT (exp
));
4309 expand_end_stmt_expr (rtl_expr
);
4311 result
= expand_expr (rtl_expr
, target
, tmode
, modifier
);
4314 else if (preserve_result
&& GET_CODE (result
) == MEM
)
4316 if (GET_MODE (result
) != BLKmode
)
4317 result
= copy_to_reg (result
);
4319 preserve_temp_slots (result
);
4322 /* If the statment-expression does not have a scope, then the
4323 new temporaries we created within it must live beyond the
4324 statement-expression. */
4325 if (STMT_EXPR_NO_SCOPE (exp
))
4326 preserve_temp_slots (NULL_RTX
);
4335 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == ADDR_EXPR
4336 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
4338 && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
4339 && (DECL_BUILT_IN_CLASS (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
4340 == BUILT_IN_FRONTEND
))
4341 return c_expand_builtin (exp
, target
, tmode
, modifier
);
4347 case COMPOUND_LITERAL_EXPR
:
4349 /* Initialize the anonymous variable declared in the compound
4350 literal, then return the variable. */
4351 tree decl
= COMPOUND_LITERAL_EXPR_DECL (exp
);
4352 emit_local_var (decl
);
4353 return expand_expr (decl
, target
, tmode
, modifier
);
4364 /* Hook used by safe_from_p to handle language-specific tree codes. */
4367 c_safe_from_p (target
, exp
)
4371 /* We can see statements here when processing the body of a
4372 statement-expression. For a declaration statement declaring a
4373 variable, look at the variable's initializer. */
4374 if (TREE_CODE (exp
) == DECL_STMT
)
4376 tree decl
= DECL_STMT_DECL (exp
);
4378 if (TREE_CODE (decl
) == VAR_DECL
4379 && DECL_INITIAL (decl
)
4380 && !safe_from_p (target
, DECL_INITIAL (decl
), /*top_p=*/0))
4384 /* For any statement, we must follow the statement-chain. */
4385 if (statement_code_p (TREE_CODE (exp
)) && TREE_CHAIN (exp
))
4386 return safe_from_p (target
, TREE_CHAIN (exp
), /*top_p=*/0);
4388 /* Assume everything else is safe. */
4392 /* Hook used by unsafe_for_reeval to handle language-specific tree codes. */
4395 c_common_unsafe_for_reeval (exp
)
4398 /* Statement expressions may not be reevaluated, likewise compound
4400 if (TREE_CODE (exp
) == STMT_EXPR
4401 || TREE_CODE (exp
) == COMPOUND_LITERAL_EXPR
)
4404 /* Walk all other expressions. */
4408 /* Hook used by staticp to handle language-specific tree codes. */
4414 if (TREE_CODE (exp
) == COMPOUND_LITERAL_EXPR
4415 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp
)))
4420 #define CALLED_AS_BUILT_IN(NODE) \
4421 (!strncmp (IDENTIFIER_POINTER (DECL_NAME (NODE)), "__builtin_", 10))
4424 c_expand_builtin (exp
, target
, tmode
, modifier
)
4427 enum machine_mode tmode
;
4428 enum expand_modifier modifier
;
4430 tree type
= TREE_TYPE (exp
);
4431 tree fndecl
= TREE_OPERAND (TREE_OPERAND (exp
, 0), 0);
4432 tree arglist
= TREE_OPERAND (exp
, 1);
4433 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
4434 enum tree_code code
= TREE_CODE (exp
);
4435 const int ignore
= (target
== const0_rtx
4436 || ((code
== NON_LVALUE_EXPR
|| code
== NOP_EXPR
4437 || code
== CONVERT_EXPR
|| code
== REFERENCE_EXPR
4438 || code
== COND_EXPR
)
4439 && TREE_CODE (type
) == VOID_TYPE
));
4441 if (! optimize
&& ! CALLED_AS_BUILT_IN (fndecl
))
4442 return expand_call (exp
, target
, ignore
);
4446 case BUILT_IN_PRINTF
:
4447 target
= c_expand_builtin_printf (arglist
, target
, tmode
,
4448 modifier
, ignore
, /*unlocked=*/ 0);
4453 case BUILT_IN_PRINTF_UNLOCKED
:
4454 target
= c_expand_builtin_printf (arglist
, target
, tmode
,
4455 modifier
, ignore
, /*unlocked=*/ 1);
4460 case BUILT_IN_FPRINTF
:
4461 target
= c_expand_builtin_fprintf (arglist
, target
, tmode
,
4462 modifier
, ignore
, /*unlocked=*/ 0);
4467 case BUILT_IN_FPRINTF_UNLOCKED
:
4468 target
= c_expand_builtin_fprintf (arglist
, target
, tmode
,
4469 modifier
, ignore
, /*unlocked=*/ 1);
4474 default: /* just do library call, if unknown builtin */
4475 error ("built-in function `%s' not currently supported",
4476 IDENTIFIER_POINTER (DECL_NAME (fndecl
)));
4479 /* The switch statement above can drop through to cause the function
4480 to be called normally. */
4481 return expand_call (exp
, target
, ignore
);
4484 /* Check an arglist to *printf for problems. The arglist should start
4485 at the format specifier, with the remaining arguments immediately
4488 is_valid_printf_arglist (arglist
)
4491 /* Save this value so we can restore it later. */
4492 const int SAVE_pedantic
= pedantic
;
4493 int diagnostic_occurred
= 0;
4496 /* Set this to a known value so the user setting won't affect code
4499 /* Check to make sure there are no format specifier errors. */
4500 attrs
= tree_cons (get_identifier ("format"),
4501 tree_cons (NULL_TREE
,
4502 get_identifier ("printf"),
4503 tree_cons (NULL_TREE
,
4505 tree_cons (NULL_TREE
,
4509 check_function_format (&diagnostic_occurred
, attrs
, arglist
);
4511 /* Restore the value of `pedantic'. */
4512 pedantic
= SAVE_pedantic
;
4514 /* If calling `check_function_format_ptr' produces a warning, we
4515 return false, otherwise we return true. */
4516 return ! diagnostic_occurred
;
4519 /* If the arguments passed to printf are suitable for optimizations,
4520 we attempt to transform the call. */
4522 c_expand_builtin_printf (arglist
, target
, tmode
, modifier
, ignore
, unlocked
)
4525 enum machine_mode tmode
;
4526 enum expand_modifier modifier
;
4530 tree fn_putchar
= unlocked
?
4531 implicit_built_in_decls
[BUILT_IN_PUTCHAR_UNLOCKED
] : implicit_built_in_decls
[BUILT_IN_PUTCHAR
];
4532 tree fn_puts
= unlocked
?
4533 implicit_built_in_decls
[BUILT_IN_PUTS_UNLOCKED
] : implicit_built_in_decls
[BUILT_IN_PUTS
];
4534 tree fn
, format_arg
, stripped_string
;
4536 /* If the return value is used, or the replacement _DECL isn't
4537 initialized, don't do the transformation. */
4538 if (!ignore
|| !fn_putchar
|| !fn_puts
)
4541 /* Verify the required arguments in the original call. */
4543 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != POINTER_TYPE
))
4546 /* Check the specifier vs. the parameters. */
4547 if (!is_valid_printf_arglist (arglist
))
4550 format_arg
= TREE_VALUE (arglist
);
4551 stripped_string
= format_arg
;
4552 STRIP_NOPS (stripped_string
);
4553 if (stripped_string
&& TREE_CODE (stripped_string
) == ADDR_EXPR
)
4554 stripped_string
= TREE_OPERAND (stripped_string
, 0);
4556 /* If the format specifier isn't a STRING_CST, punt. */
4557 if (TREE_CODE (stripped_string
) != STRING_CST
)
4560 /* OK! We can attempt optimization. */
4562 /* If the format specifier was "%s\n", call __builtin_puts(arg2). */
4563 if (strcmp (TREE_STRING_POINTER (stripped_string
), "%s\n") == 0)
4565 arglist
= TREE_CHAIN (arglist
);
4568 /* If the format specifier was "%c", call __builtin_putchar (arg2). */
4569 else if (strcmp (TREE_STRING_POINTER (stripped_string
), "%c") == 0)
4571 arglist
= TREE_CHAIN (arglist
);
4576 /* We can't handle anything else with % args or %% ... yet. */
4577 if (strchr (TREE_STRING_POINTER (stripped_string
), '%'))
4580 /* If the resulting constant string has a length of 1, call
4581 putchar. Note, TREE_STRING_LENGTH includes the terminating
4582 NULL in its count. */
4583 if (TREE_STRING_LENGTH (stripped_string
) == 2)
4585 /* Given printf("c"), (where c is any one character,)
4586 convert "c"[0] to an int and pass that to the replacement
4588 arglist
= build_int_2 (TREE_STRING_POINTER (stripped_string
)[0], 0);
4589 arglist
= build_tree_list (NULL_TREE
, arglist
);
4593 /* If the resulting constant was "string\n", call
4594 __builtin_puts("string"). Ensure "string" has at least one
4595 character besides the trailing \n. Note, TREE_STRING_LENGTH
4596 includes the terminating NULL in its count. */
4597 else if (TREE_STRING_LENGTH (stripped_string
) > 2
4598 && TREE_STRING_POINTER (stripped_string
)
4599 [TREE_STRING_LENGTH (stripped_string
) - 2] == '\n')
4601 /* Create a NULL-terminated string that's one char shorter
4602 than the original, stripping off the trailing '\n'. */
4603 const int newlen
= TREE_STRING_LENGTH (stripped_string
) - 1;
4604 char *newstr
= (char *) alloca (newlen
);
4605 memcpy (newstr
, TREE_STRING_POINTER (stripped_string
), newlen
- 1);
4606 newstr
[newlen
- 1] = 0;
4608 arglist
= fix_string_type (build_string (newlen
, newstr
));
4609 arglist
= build_tree_list (NULL_TREE
, arglist
);
4613 /* We'd like to arrange to call fputs(string) here, but we
4614 need stdout and don't have a way to get it ... yet. */
4618 return expand_expr (build_function_call (fn
, arglist
),
4619 (ignore
? const0_rtx
: target
),
4623 /* If the arguments passed to fprintf are suitable for optimizations,
4624 we attempt to transform the call. */
4626 c_expand_builtin_fprintf (arglist
, target
, tmode
, modifier
, ignore
, unlocked
)
4629 enum machine_mode tmode
;
4630 enum expand_modifier modifier
;
4634 tree fn_fputc
= unlocked
?
4635 implicit_built_in_decls
[BUILT_IN_FPUTC_UNLOCKED
] : implicit_built_in_decls
[BUILT_IN_FPUTC
];
4636 tree fn_fputs
= unlocked
?
4637 implicit_built_in_decls
[BUILT_IN_FPUTS_UNLOCKED
] : implicit_built_in_decls
[BUILT_IN_FPUTS
];
4638 tree fn
, format_arg
, stripped_string
;
4640 /* If the return value is used, or the replacement _DECL isn't
4641 initialized, don't do the transformation. */
4642 if (!ignore
|| !fn_fputc
|| !fn_fputs
)
4645 /* Verify the required arguments in the original call. */
4647 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != POINTER_TYPE
)
4648 || (TREE_CHAIN (arglist
) == 0)
4649 || (TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist
)))) !=
4653 /* Check the specifier vs. the parameters. */
4654 if (!is_valid_printf_arglist (TREE_CHAIN (arglist
)))
4657 format_arg
= TREE_VALUE (TREE_CHAIN (arglist
));
4658 stripped_string
= format_arg
;
4659 STRIP_NOPS (stripped_string
);
4660 if (stripped_string
&& TREE_CODE (stripped_string
) == ADDR_EXPR
)
4661 stripped_string
= TREE_OPERAND (stripped_string
, 0);
4663 /* If the format specifier isn't a STRING_CST, punt. */
4664 if (TREE_CODE (stripped_string
) != STRING_CST
)
4667 /* OK! We can attempt optimization. */
4669 /* If the format specifier was "%s", call __builtin_fputs(arg3, arg1). */
4670 if (strcmp (TREE_STRING_POINTER (stripped_string
), "%s") == 0)
4672 tree newarglist
= build_tree_list (NULL_TREE
, TREE_VALUE (arglist
));
4673 arglist
= tree_cons (NULL_TREE
,
4674 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
))),
4678 /* If the format specifier was "%c", call __builtin_fputc (arg3, arg1). */
4679 else if (strcmp (TREE_STRING_POINTER (stripped_string
), "%c") == 0)
4681 tree newarglist
= build_tree_list (NULL_TREE
, TREE_VALUE (arglist
));
4682 arglist
= tree_cons (NULL_TREE
,
4683 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
))),
4689 /* We can't handle anything else with % args or %% ... yet. */
4690 if (strchr (TREE_STRING_POINTER (stripped_string
), '%'))
4693 /* When "string" doesn't contain %, replace all cases of
4694 fprintf(stream,string) with fputs(string,stream). The fputs
4695 builtin will take take of special cases like length==1. */
4696 arglist
= tree_cons (NULL_TREE
, TREE_VALUE (TREE_CHAIN (arglist
)),
4697 build_tree_list (NULL_TREE
, TREE_VALUE (arglist
)));
4701 return expand_expr (build_function_call (fn
, arglist
),
4702 (ignore
? const0_rtx
: target
),
4707 /* Given a boolean expression ARG, return a tree representing an increment
4708 or decrement (as indicated by CODE) of ARG. The front end must check for
4709 invalid cases (e.g., decrement in C++). */
4711 boolean_increment (code
, arg
)
4712 enum tree_code code
;
4716 tree true_res
= (c_language
== clk_cplusplus
4718 : c_bool_true_node
);
4719 arg
= stabilize_reference (arg
);
4722 case PREINCREMENT_EXPR
:
4723 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
4725 case POSTINCREMENT_EXPR
:
4726 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
4727 arg
= save_expr (arg
);
4728 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
4729 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
4731 case PREDECREMENT_EXPR
:
4732 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, invert_truthvalue (arg
));
4734 case POSTDECREMENT_EXPR
:
4735 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, invert_truthvalue (arg
));
4736 arg
= save_expr (arg
);
4737 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
4738 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
4743 TREE_SIDE_EFFECTS (val
) = 1;
4747 /* Built-in macros for stddef.h, that require macros defined in this
4750 c_stddef_cpp_builtins()
4752 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE
, 0);
4753 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE
, 0);
4754 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE
, 0);
4755 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE
, 0);
4759 c_init_attributes ()
4761 /* Fill in the built_in_attributes array. */
4762 #define DEF_ATTR_NULL_TREE(ENUM) \
4763 built_in_attributes[(int) ENUM] = NULL_TREE;
4764 #define DEF_ATTR_INT(ENUM, VALUE) \
4765 built_in_attributes[(int) ENUM] = build_int_2 (VALUE, VALUE < 0 ? -1 : 0);
4766 #define DEF_ATTR_IDENT(ENUM, STRING) \
4767 built_in_attributes[(int) ENUM] = get_identifier (STRING);
4768 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
4769 built_in_attributes[(int) ENUM] \
4770 = tree_cons (built_in_attributes[(int) PURPOSE], \
4771 built_in_attributes[(int) VALUE], \
4772 built_in_attributes[(int) CHAIN]);
4773 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No initialization needed. */
4774 #include "builtin-attrs.def"
4775 #undef DEF_ATTR_NULL_TREE
4777 #undef DEF_ATTR_IDENT
4778 #undef DEF_ATTR_TREE_LIST
4780 c_attrs_initialized
= true;
4783 /* Depending on the name of DECL, apply default attributes to it. */
4786 c_common_insert_default_attributes (decl
)
4789 tree name
= DECL_NAME (decl
);
4791 if (!c_attrs_initialized
)
4792 c_init_attributes ();
4794 #define DEF_ATTR_NULL_TREE(ENUM) /* Nothing needed after initialization. */
4795 #define DEF_ATTR_INT(ENUM, VALUE)
4796 #define DEF_ATTR_IDENT(ENUM, STRING)
4797 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN)
4798 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) \
4799 if ((PREDICATE) && name == built_in_attributes[(int) NAME]) \
4800 decl_attributes (&decl, built_in_attributes[(int) ATTRS], \
4801 ATTR_FLAG_BUILT_IN);
4802 #include "builtin-attrs.def"
4803 #undef DEF_ATTR_NULL_TREE
4805 #undef DEF_ATTR_IDENT
4806 #undef DEF_ATTR_TREE_LIST
4810 /* Output a -Wshadow warning MSGID about NAME, an IDENTIFIER_NODE, and
4811 additionally give the location of the previous declaration DECL. */
4813 shadow_warning (msgid
, name
, decl
)
4817 warning ("declaration of `%s' shadows %s", IDENTIFIER_POINTER (name
), msgid
);
4818 warning_with_file_and_line (DECL_SOURCE_FILE (decl
),
4819 DECL_SOURCE_LINE (decl
),
4820 "shadowed declaration is here");
4823 /* Attribute handlers common to C front ends. */
4825 /* Handle a "packed" attribute; arguments as in
4826 struct attribute_spec.handler. */
4829 handle_packed_attribute (node
, name
, args
, flags
, no_add_attrs
)
4832 tree args ATTRIBUTE_UNUSED
;
4839 if (TREE_CODE (*node
) == TYPE_DECL
)
4840 type
= &TREE_TYPE (*node
);
4847 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
4848 *type
= build_type_copy (*type
);
4849 TYPE_PACKED (*type
) = 1;
4851 else if (TREE_CODE (*node
) == FIELD_DECL
)
4852 DECL_PACKED (*node
) = 1;
4853 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
4854 used for DECL_REGISTER. It wouldn't mean anything anyway. */
4857 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4858 *no_add_attrs
= true;
4864 /* Handle a "nocommon" attribute; arguments as in
4865 struct attribute_spec.handler. */
4868 handle_nocommon_attribute (node
, name
, args
, flags
, no_add_attrs
)
4871 tree args ATTRIBUTE_UNUSED
;
4872 int flags ATTRIBUTE_UNUSED
;
4875 if (TREE_CODE (*node
) == VAR_DECL
)
4876 DECL_COMMON (*node
) = 0;
4879 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4880 *no_add_attrs
= true;
4886 /* Handle a "common" attribute; arguments as in
4887 struct attribute_spec.handler. */
4890 handle_common_attribute (node
, name
, args
, flags
, no_add_attrs
)
4893 tree args ATTRIBUTE_UNUSED
;
4894 int flags ATTRIBUTE_UNUSED
;
4897 if (TREE_CODE (*node
) == VAR_DECL
)
4898 DECL_COMMON (*node
) = 1;
4901 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4902 *no_add_attrs
= true;
4908 /* Handle a "noreturn" attribute; arguments as in
4909 struct attribute_spec.handler. */
4912 handle_noreturn_attribute (node
, name
, args
, flags
, no_add_attrs
)
4915 tree args ATTRIBUTE_UNUSED
;
4916 int flags ATTRIBUTE_UNUSED
;
4919 tree type
= TREE_TYPE (*node
);
4921 /* See FIXME comment in c_common_attribute_table. */
4922 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4923 TREE_THIS_VOLATILE (*node
) = 1;
4924 else if (TREE_CODE (type
) == POINTER_TYPE
4925 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
4927 = build_pointer_type
4928 (build_type_variant (TREE_TYPE (type
),
4929 TREE_READONLY (TREE_TYPE (type
)), 1));
4932 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4933 *no_add_attrs
= true;
4939 /* Handle a "noinline" attribute; arguments as in
4940 struct attribute_spec.handler. */
4943 handle_noinline_attribute (node
, name
, args
, flags
, no_add_attrs
)
4946 tree args ATTRIBUTE_UNUSED
;
4947 int flags ATTRIBUTE_UNUSED
;
4950 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4951 DECL_UNINLINABLE (*node
) = 1;
4954 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4955 *no_add_attrs
= true;
4961 /* Handle a "always_inline" attribute; arguments as in
4962 struct attribute_spec.handler. */
4965 handle_always_inline_attribute (node
, name
, args
, flags
, no_add_attrs
)
4968 tree args ATTRIBUTE_UNUSED
;
4969 int flags ATTRIBUTE_UNUSED
;
4972 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4974 /* Do nothing else, just set the attribute. We'll get at
4975 it later with lookup_attribute. */
4979 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4980 *no_add_attrs
= true;
4986 /* Handle a "used" attribute; arguments as in
4987 struct attribute_spec.handler. */
4990 handle_used_attribute (pnode
, name
, args
, flags
, no_add_attrs
)
4993 tree args ATTRIBUTE_UNUSED
;
4994 int flags ATTRIBUTE_UNUSED
;
4999 if (TREE_CODE (node
) == FUNCTION_DECL
5000 || (TREE_CODE (node
) == VAR_DECL
&& TREE_STATIC (node
)))
5001 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (node
))
5002 = TREE_USED (node
) = 1;
5005 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5006 *no_add_attrs
= true;
5012 /* Handle a "unused" attribute; arguments as in
5013 struct attribute_spec.handler. */
5016 handle_unused_attribute (node
, name
, args
, flags
, no_add_attrs
)
5019 tree args ATTRIBUTE_UNUSED
;
5027 if (TREE_CODE (decl
) == PARM_DECL
5028 || TREE_CODE (decl
) == VAR_DECL
5029 || TREE_CODE (decl
) == FUNCTION_DECL
5030 || TREE_CODE (decl
) == LABEL_DECL
5031 || TREE_CODE (decl
) == TYPE_DECL
)
5032 TREE_USED (decl
) = 1;
5035 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5036 *no_add_attrs
= true;
5041 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
5042 *node
= build_type_copy (*node
);
5043 TREE_USED (*node
) = 1;
5049 /* Handle a "const" attribute; arguments as in
5050 struct attribute_spec.handler. */
5053 handle_const_attribute (node
, name
, args
, flags
, no_add_attrs
)
5056 tree args ATTRIBUTE_UNUSED
;
5057 int flags ATTRIBUTE_UNUSED
;
5060 tree type
= TREE_TYPE (*node
);
5062 /* See FIXME comment on noreturn in c_common_attribute_table. */
5063 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5064 TREE_READONLY (*node
) = 1;
5065 else if (TREE_CODE (type
) == POINTER_TYPE
5066 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
5068 = build_pointer_type
5069 (build_type_variant (TREE_TYPE (type
), 1,
5070 TREE_THIS_VOLATILE (TREE_TYPE (type
))));
5073 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5074 *no_add_attrs
= true;
5080 /* Handle a "transparent_union" attribute; arguments as in
5081 struct attribute_spec.handler. */
5084 handle_transparent_union_attribute (node
, name
, args
, flags
, no_add_attrs
)
5087 tree args ATTRIBUTE_UNUSED
;
5091 tree decl
= NULL_TREE
;
5098 type
= &TREE_TYPE (decl
);
5099 is_type
= TREE_CODE (*node
) == TYPE_DECL
;
5101 else if (TYPE_P (*node
))
5102 type
= node
, is_type
= 1;
5105 && TREE_CODE (*type
) == UNION_TYPE
5107 || (TYPE_FIELDS (*type
) != 0
5108 && TYPE_MODE (*type
) == DECL_MODE (TYPE_FIELDS (*type
)))))
5110 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
5111 *type
= build_type_copy (*type
);
5112 TYPE_TRANSPARENT_UNION (*type
) = 1;
5114 else if (decl
!= 0 && TREE_CODE (decl
) == PARM_DECL
5115 && TREE_CODE (*type
) == UNION_TYPE
5116 && TYPE_MODE (*type
) == DECL_MODE (TYPE_FIELDS (*type
)))
5117 DECL_TRANSPARENT_UNION (decl
) = 1;
5120 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5121 *no_add_attrs
= true;
5127 /* Handle a "constructor" attribute; arguments as in
5128 struct attribute_spec.handler. */
5131 handle_constructor_attribute (node
, name
, args
, flags
, no_add_attrs
)
5134 tree args ATTRIBUTE_UNUSED
;
5135 int flags ATTRIBUTE_UNUSED
;
5139 tree type
= TREE_TYPE (decl
);
5141 if (TREE_CODE (decl
) == FUNCTION_DECL
5142 && TREE_CODE (type
) == FUNCTION_TYPE
5143 && decl_function_context (decl
) == 0)
5145 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
5146 TREE_USED (decl
) = 1;
5150 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5151 *no_add_attrs
= true;
5157 /* Handle a "destructor" attribute; arguments as in
5158 struct attribute_spec.handler. */
5161 handle_destructor_attribute (node
, name
, args
, flags
, no_add_attrs
)
5164 tree args ATTRIBUTE_UNUSED
;
5165 int flags ATTRIBUTE_UNUSED
;
5169 tree type
= TREE_TYPE (decl
);
5171 if (TREE_CODE (decl
) == FUNCTION_DECL
5172 && TREE_CODE (type
) == FUNCTION_TYPE
5173 && decl_function_context (decl
) == 0)
5175 DECL_STATIC_DESTRUCTOR (decl
) = 1;
5176 TREE_USED (decl
) = 1;
5180 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5181 *no_add_attrs
= true;
5187 /* Handle a "mode" attribute; arguments as in
5188 struct attribute_spec.handler. */
5191 handle_mode_attribute (node
, name
, args
, flags
, no_add_attrs
)
5195 int flags ATTRIBUTE_UNUSED
;
5200 *no_add_attrs
= true;
5202 if (TREE_CODE (TREE_VALUE (args
)) != IDENTIFIER_NODE
)
5203 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5207 const char *p
= IDENTIFIER_POINTER (TREE_VALUE (args
));
5208 int len
= strlen (p
);
5209 enum machine_mode mode
= VOIDmode
;
5213 if (len
> 4 && p
[0] == '_' && p
[1] == '_'
5214 && p
[len
- 1] == '_' && p
[len
- 2] == '_')
5216 char *newp
= (char *) alloca (len
- 1);
5218 strcpy (newp
, &p
[2]);
5219 newp
[len
- 4] = '\0';
5223 /* Change this type to have a type with the specified mode.
5224 First check for the special modes. */
5225 if (! strcmp (p
, "byte"))
5227 else if (!strcmp (p
, "word"))
5229 else if (! strcmp (p
, "pointer"))
5232 for (j
= 0; j
< NUM_MACHINE_MODES
; j
++)
5233 if (!strcmp (p
, GET_MODE_NAME (j
)))
5234 mode
= (enum machine_mode
) j
;
5236 if (mode
== VOIDmode
)
5237 error ("unknown machine mode `%s'", p
);
5238 else if (0 == (typefm
= (*lang_hooks
.types
.type_for_mode
)
5239 (mode
, TREE_UNSIGNED (type
))))
5240 error ("no data type for mode `%s'", p
);
5241 else if ((TREE_CODE (type
) == POINTER_TYPE
5242 || TREE_CODE (type
) == REFERENCE_TYPE
)
5243 && !(*targetm
.valid_pointer_mode
) (mode
))
5244 error ("invalid pointer mode `%s'", p
);
5247 /* If this is a vector, make sure we either have hardware
5248 support, or we can emulate it. */
5249 if ((GET_MODE_CLASS (mode
) == MODE_VECTOR_INT
5250 || GET_MODE_CLASS (mode
) == MODE_VECTOR_FLOAT
)
5251 && !vector_mode_valid_p (mode
))
5253 error ("unable to emulate '%s'", GET_MODE_NAME (mode
));
5257 if (TREE_CODE (type
) == POINTER_TYPE
)
5259 ptr_type
= build_pointer_type_for_mode (TREE_TYPE (type
),
5263 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
5265 ptr_type
= build_reference_type_for_mode (TREE_TYPE (type
),
5271 /* No need to layout the type here. The caller should do this. */
5278 /* Handle a "section" attribute; arguments as in
5279 struct attribute_spec.handler. */
5282 handle_section_attribute (node
, name
, args
, flags
, no_add_attrs
)
5284 tree name ATTRIBUTE_UNUSED
;
5286 int flags ATTRIBUTE_UNUSED
;
5291 if (targetm
.have_named_sections
)
5293 if ((TREE_CODE (decl
) == FUNCTION_DECL
5294 || TREE_CODE (decl
) == VAR_DECL
)
5295 && TREE_CODE (TREE_VALUE (args
)) == STRING_CST
)
5297 if (TREE_CODE (decl
) == VAR_DECL
5298 && current_function_decl
!= NULL_TREE
5299 && ! TREE_STATIC (decl
))
5301 error_with_decl (decl
,
5302 "section attribute cannot be specified for local variables");
5303 *no_add_attrs
= true;
5306 /* The decl may have already been given a section attribute
5307 from a previous declaration. Ensure they match. */
5308 else if (DECL_SECTION_NAME (decl
) != NULL_TREE
5309 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl
)),
5310 TREE_STRING_POINTER (TREE_VALUE (args
))) != 0)
5312 error_with_decl (*node
,
5313 "section of `%s' conflicts with previous declaration");
5314 *no_add_attrs
= true;
5317 DECL_SECTION_NAME (decl
) = TREE_VALUE (args
);
5321 error_with_decl (*node
,
5322 "section attribute not allowed for `%s'");
5323 *no_add_attrs
= true;
5328 error_with_decl (*node
,
5329 "section attributes are not supported for this target");
5330 *no_add_attrs
= true;
5336 /* Handle a "aligned" attribute; arguments as in
5337 struct attribute_spec.handler. */
5340 handle_aligned_attribute (node
, name
, args
, flags
, no_add_attrs
)
5342 tree name ATTRIBUTE_UNUSED
;
5347 tree decl
= NULL_TREE
;
5350 tree align_expr
= (args
? TREE_VALUE (args
)
5351 : size_int (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
));
5357 type
= &TREE_TYPE (decl
);
5358 is_type
= TREE_CODE (*node
) == TYPE_DECL
;
5360 else if (TYPE_P (*node
))
5361 type
= node
, is_type
= 1;
5363 /* Strip any NOPs of any kind. */
5364 while (TREE_CODE (align_expr
) == NOP_EXPR
5365 || TREE_CODE (align_expr
) == CONVERT_EXPR
5366 || TREE_CODE (align_expr
) == NON_LVALUE_EXPR
)
5367 align_expr
= TREE_OPERAND (align_expr
, 0);
5369 if (TREE_CODE (align_expr
) != INTEGER_CST
)
5371 error ("requested alignment is not a constant");
5372 *no_add_attrs
= true;
5374 else if ((i
= tree_log2 (align_expr
)) == -1)
5376 error ("requested alignment is not a power of 2");
5377 *no_add_attrs
= true;
5379 else if (i
> HOST_BITS_PER_INT
- 2)
5381 error ("requested alignment is too large");
5382 *no_add_attrs
= true;
5386 /* If we have a TYPE_DECL, then copy the type, so that we
5387 don't accidentally modify a builtin type. See pushdecl. */
5388 if (decl
&& TREE_TYPE (decl
) != error_mark_node
5389 && DECL_ORIGINAL_TYPE (decl
) == NULL_TREE
)
5391 tree tt
= TREE_TYPE (decl
);
5392 *type
= build_type_copy (*type
);
5393 DECL_ORIGINAL_TYPE (decl
) = tt
;
5394 TYPE_NAME (*type
) = decl
;
5395 TREE_USED (*type
) = TREE_USED (decl
);
5396 TREE_TYPE (decl
) = *type
;
5398 else if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
5399 *type
= build_type_copy (*type
);
5401 TYPE_ALIGN (*type
) = (1 << i
) * BITS_PER_UNIT
;
5402 TYPE_USER_ALIGN (*type
) = 1;
5404 else if (TREE_CODE (decl
) != VAR_DECL
5405 && TREE_CODE (decl
) != FIELD_DECL
)
5407 error_with_decl (decl
,
5408 "alignment may not be specified for `%s'");
5409 *no_add_attrs
= true;
5413 DECL_ALIGN (decl
) = (1 << i
) * BITS_PER_UNIT
;
5414 DECL_USER_ALIGN (decl
) = 1;
5420 /* Handle a "weak" attribute; arguments as in
5421 struct attribute_spec.handler. */
5424 handle_weak_attribute (node
, name
, args
, flags
, no_add_attrs
)
5426 tree name ATTRIBUTE_UNUSED
;
5427 tree args ATTRIBUTE_UNUSED
;
5428 int flags ATTRIBUTE_UNUSED
;
5429 bool *no_add_attrs ATTRIBUTE_UNUSED
;
5431 declare_weak (*node
);
5436 /* Handle an "alias" attribute; arguments as in
5437 struct attribute_spec.handler. */
5440 handle_alias_attribute (node
, name
, args
, flags
, no_add_attrs
)
5444 int flags ATTRIBUTE_UNUSED
;
5449 if ((TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_INITIAL (decl
))
5450 || (TREE_CODE (decl
) != FUNCTION_DECL
&& ! DECL_EXTERNAL (decl
)))
5452 error_with_decl (decl
,
5453 "`%s' defined both normally and as an alias");
5454 *no_add_attrs
= true;
5456 else if (decl_function_context (decl
) == 0)
5460 id
= TREE_VALUE (args
);
5461 if (TREE_CODE (id
) != STRING_CST
)
5463 error ("alias arg not a string");
5464 *no_add_attrs
= true;
5467 id
= get_identifier (TREE_STRING_POINTER (id
));
5468 /* This counts as a use of the object pointed to. */
5471 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5472 DECL_INITIAL (decl
) = error_mark_node
;
5474 DECL_EXTERNAL (decl
) = 0;
5478 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5479 *no_add_attrs
= true;
5485 /* Handle an "visibility" attribute; arguments as in
5486 struct attribute_spec.handler. */
5489 handle_visibility_attribute (node
, name
, args
, flags
, no_add_attrs
)
5493 int flags ATTRIBUTE_UNUSED
;
5498 if (decl_function_context (decl
) != 0 || ! TREE_PUBLIC (decl
))
5500 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5501 *no_add_attrs
= true;
5507 id
= TREE_VALUE (args
);
5508 if (TREE_CODE (id
) != STRING_CST
)
5510 error ("visibility arg not a string");
5511 *no_add_attrs
= true;
5514 if (strcmp (TREE_STRING_POINTER (id
), "hidden")
5515 && strcmp (TREE_STRING_POINTER (id
), "protected")
5516 && strcmp (TREE_STRING_POINTER (id
), "internal")
5517 && strcmp (TREE_STRING_POINTER (id
), "default"))
5519 error ("visibility arg must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
5520 *no_add_attrs
= true;
5528 /* Handle an "tls_model" attribute; arguments as in
5529 struct attribute_spec.handler. */
5532 handle_tls_model_attribute (node
, name
, args
, flags
, no_add_attrs
)
5536 int flags ATTRIBUTE_UNUSED
;
5541 if (! DECL_THREAD_LOCAL (decl
))
5543 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5544 *no_add_attrs
= true;
5550 id
= TREE_VALUE (args
);
5551 if (TREE_CODE (id
) != STRING_CST
)
5553 error ("tls_model arg not a string");
5554 *no_add_attrs
= true;
5557 if (strcmp (TREE_STRING_POINTER (id
), "local-exec")
5558 && strcmp (TREE_STRING_POINTER (id
), "initial-exec")
5559 && strcmp (TREE_STRING_POINTER (id
), "local-dynamic")
5560 && strcmp (TREE_STRING_POINTER (id
), "global-dynamic"))
5562 error ("tls_model arg must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
5563 *no_add_attrs
= true;
5571 /* Handle a "no_instrument_function" attribute; arguments as in
5572 struct attribute_spec.handler. */
5575 handle_no_instrument_function_attribute (node
, name
, args
, flags
, no_add_attrs
)
5578 tree args ATTRIBUTE_UNUSED
;
5579 int flags ATTRIBUTE_UNUSED
;
5584 if (TREE_CODE (decl
) != FUNCTION_DECL
)
5586 error_with_decl (decl
,
5587 "`%s' attribute applies only to functions",
5588 IDENTIFIER_POINTER (name
));
5589 *no_add_attrs
= true;
5591 else if (DECL_INITIAL (decl
))
5593 error_with_decl (decl
,
5594 "can't set `%s' attribute after definition",
5595 IDENTIFIER_POINTER (name
));
5596 *no_add_attrs
= true;
5599 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl
) = 1;
5604 /* Handle a "malloc" attribute; arguments as in
5605 struct attribute_spec.handler. */
5608 handle_malloc_attribute (node
, name
, args
, flags
, no_add_attrs
)
5611 tree args ATTRIBUTE_UNUSED
;
5612 int flags ATTRIBUTE_UNUSED
;
5615 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5616 DECL_IS_MALLOC (*node
) = 1;
5617 /* ??? TODO: Support types. */
5620 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5621 *no_add_attrs
= true;
5627 /* Handle a "no_limit_stack" attribute; arguments as in
5628 struct attribute_spec.handler. */
5631 handle_no_limit_stack_attribute (node
, name
, args
, flags
, no_add_attrs
)
5634 tree args ATTRIBUTE_UNUSED
;
5635 int flags ATTRIBUTE_UNUSED
;
5640 if (TREE_CODE (decl
) != FUNCTION_DECL
)
5642 error_with_decl (decl
,
5643 "`%s' attribute applies only to functions",
5644 IDENTIFIER_POINTER (name
));
5645 *no_add_attrs
= true;
5647 else if (DECL_INITIAL (decl
))
5649 error_with_decl (decl
,
5650 "can't set `%s' attribute after definition",
5651 IDENTIFIER_POINTER (name
));
5652 *no_add_attrs
= true;
5655 DECL_NO_LIMIT_STACK (decl
) = 1;
5660 /* Handle a "pure" attribute; arguments as in
5661 struct attribute_spec.handler. */
5664 handle_pure_attribute (node
, name
, args
, flags
, no_add_attrs
)
5667 tree args ATTRIBUTE_UNUSED
;
5668 int flags ATTRIBUTE_UNUSED
;
5671 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5672 DECL_IS_PURE (*node
) = 1;
5673 /* ??? TODO: Support types. */
5676 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5677 *no_add_attrs
= true;
5683 /* Handle a "deprecated" attribute; arguments as in
5684 struct attribute_spec.handler. */
5687 handle_deprecated_attribute (node
, name
, args
, flags
, no_add_attrs
)
5690 tree args ATTRIBUTE_UNUSED
;
5694 tree type
= NULL_TREE
;
5696 const char *what
= NULL
;
5701 type
= TREE_TYPE (decl
);
5703 if (TREE_CODE (decl
) == TYPE_DECL
5704 || TREE_CODE (decl
) == PARM_DECL
5705 || TREE_CODE (decl
) == VAR_DECL
5706 || TREE_CODE (decl
) == FUNCTION_DECL
5707 || TREE_CODE (decl
) == FIELD_DECL
)
5708 TREE_DEPRECATED (decl
) = 1;
5712 else if (TYPE_P (*node
))
5714 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
5715 *node
= build_type_copy (*node
);
5716 TREE_DEPRECATED (*node
) = 1;
5724 *no_add_attrs
= true;
5725 if (type
&& TYPE_NAME (type
))
5727 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
5728 what
= IDENTIFIER_POINTER (TYPE_NAME (*node
));
5729 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
5730 && DECL_NAME (TYPE_NAME (type
)))
5731 what
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)));
5734 warning ("`%s' attribute ignored for `%s'",
5735 IDENTIFIER_POINTER (name
), what
);
5737 warning ("`%s' attribute ignored",
5738 IDENTIFIER_POINTER (name
));
5744 /* Keep a list of vector type nodes we created in handle_vector_size_attribute,
5745 to prevent us from duplicating type nodes unnecessarily.
5746 The normal mechanism to prevent duplicates is to use type_hash_canon, but
5747 since we want to distinguish types that are essentially identical (except
5748 for their debug representation), we use a local list here. */
5749 static GTY(()) tree vector_type_node_list
= 0;
5751 /* Handle a "vector_size" attribute; arguments as in
5752 struct attribute_spec.handler. */
5755 handle_vector_size_attribute (node
, name
, args
, flags
, no_add_attrs
)
5759 int flags ATTRIBUTE_UNUSED
;
5762 unsigned HOST_WIDE_INT vecsize
, nunits
;
5763 enum machine_mode mode
, orig_mode
, new_mode
;
5764 tree type
= *node
, new_type
= NULL_TREE
;
5765 tree type_list_node
;
5767 *no_add_attrs
= true;
5769 if (! host_integerp (TREE_VALUE (args
), 1))
5771 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5775 /* Get the vector size (in bytes). */
5776 vecsize
= tree_low_cst (TREE_VALUE (args
), 1);
5778 /* We need to provide for vector pointers, vector arrays, and
5779 functions returning vectors. For example:
5781 __attribute__((vector_size(16))) short *foo;
5783 In this case, the mode is SI, but the type being modified is
5784 HI, so we need to look further. */
5786 while (POINTER_TYPE_P (type
)
5787 || TREE_CODE (type
) == FUNCTION_TYPE
5788 || TREE_CODE (type
) == ARRAY_TYPE
)
5789 type
= TREE_TYPE (type
);
5791 /* Get the mode of the type being modified. */
5792 orig_mode
= TYPE_MODE (type
);
5794 if (TREE_CODE (type
) == RECORD_TYPE
5795 || (GET_MODE_CLASS (orig_mode
) != MODE_FLOAT
5796 && GET_MODE_CLASS (orig_mode
) != MODE_INT
)
5797 || ! host_integerp (TYPE_SIZE_UNIT (type
), 1))
5799 error ("invalid vector type for attribute `%s'",
5800 IDENTIFIER_POINTER (name
));
5804 /* Calculate how many units fit in the vector. */
5805 nunits
= vecsize
/ tree_low_cst (TYPE_SIZE_UNIT (type
), 1);
5807 /* Find a suitably sized vector. */
5808 new_mode
= VOIDmode
;
5809 for (mode
= GET_CLASS_NARROWEST_MODE (GET_MODE_CLASS (orig_mode
) == MODE_INT
5811 : MODE_VECTOR_FLOAT
);
5813 mode
= GET_MODE_WIDER_MODE (mode
))
5814 if (vecsize
== GET_MODE_SIZE (mode
)
5815 && nunits
== (unsigned HOST_WIDE_INT
) GET_MODE_NUNITS (mode
))
5821 if (new_mode
== VOIDmode
)
5823 error ("no vector mode with the size and type specified could be found");
5827 for (type_list_node
= vector_type_node_list
; type_list_node
;
5828 type_list_node
= TREE_CHAIN (type_list_node
))
5830 tree other_type
= TREE_VALUE (type_list_node
);
5831 tree record
= TYPE_DEBUG_REPRESENTATION_TYPE (other_type
);
5832 tree fields
= TYPE_FIELDS (record
);
5833 tree field_type
= TREE_TYPE (fields
);
5834 tree array_type
= TREE_TYPE (field_type
);
5835 if (TREE_CODE (fields
) != FIELD_DECL
5836 || TREE_CODE (field_type
) != ARRAY_TYPE
)
5839 if (TYPE_MODE (other_type
) == mode
&& type
== array_type
)
5841 new_type
= other_type
;
5846 if (new_type
== NULL_TREE
)
5848 tree index
, array
, rt
, list_node
;
5850 new_type
= (*lang_hooks
.types
.type_for_mode
) (new_mode
,
5851 TREE_UNSIGNED (type
));
5855 error ("no vector mode with the size and type specified could be found");
5859 new_type
= build_type_copy (new_type
);
5861 /* If this is a vector, make sure we either have hardware
5862 support, or we can emulate it. */
5863 if ((GET_MODE_CLASS (mode
) == MODE_VECTOR_INT
5864 || GET_MODE_CLASS (mode
) == MODE_VECTOR_FLOAT
)
5865 && !vector_mode_valid_p (mode
))
5867 error ("unable to emulate '%s'", GET_MODE_NAME (mode
));
5871 /* Set the debug information here, because this is the only
5872 place where we know the underlying type for a vector made
5873 with vector_size. For debugging purposes we pretend a vector
5874 is an array within a structure. */
5875 index
= build_int_2 (TYPE_VECTOR_SUBPARTS (new_type
) - 1, 0);
5876 array
= build_array_type (type
, build_index_type (index
));
5877 rt
= make_node (RECORD_TYPE
);
5879 TYPE_FIELDS (rt
) = build_decl (FIELD_DECL
, get_identifier ("f"), array
);
5880 DECL_CONTEXT (TYPE_FIELDS (rt
)) = rt
;
5882 TYPE_DEBUG_REPRESENTATION_TYPE (new_type
) = rt
;
5884 list_node
= build_tree_list (NULL
, new_type
);
5885 TREE_CHAIN (list_node
) = vector_type_node_list
;
5886 vector_type_node_list
= list_node
;
5889 /* Build back pointers if needed. */
5890 *node
= vector_size_helper (*node
, new_type
);
5895 /* HACK. GROSS. This is absolutely disgusting. I wish there was a
5898 If we requested a pointer to a vector, build up the pointers that
5899 we stripped off while looking for the inner type. Similarly for
5900 return values from functions.
5902 The argument "type" is the top of the chain, and "bottom" is the
5903 new type which we will point to. */
5906 vector_size_helper (type
, bottom
)
5911 if (POINTER_TYPE_P (type
))
5913 inner
= vector_size_helper (TREE_TYPE (type
), bottom
);
5914 outer
= build_pointer_type (inner
);
5916 else if (TREE_CODE (type
) == ARRAY_TYPE
)
5918 inner
= vector_size_helper (TREE_TYPE (type
), bottom
);
5919 outer
= build_array_type (inner
, TYPE_VALUES (type
));
5921 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
5923 inner
= vector_size_helper (TREE_TYPE (type
), bottom
);
5924 outer
= build_function_type (inner
, TYPE_VALUES (type
));
5929 TREE_READONLY (outer
) = TREE_READONLY (type
);
5930 TREE_THIS_VOLATILE (outer
) = TREE_THIS_VOLATILE (type
);
5935 /* Handle the "nonnull" attribute. */
5937 handle_nonnull_attribute (node
, name
, args
, flags
, no_add_attrs
)
5939 tree name ATTRIBUTE_UNUSED
;
5941 int flags ATTRIBUTE_UNUSED
;
5945 unsigned HOST_WIDE_INT attr_arg_num
;
5947 /* If no arguments are specified, all pointer arguments should be
5948 non-null. Verify a full prototype is given so that the arguments
5949 will have the correct types when we actually check them later. */
5952 if (! TYPE_ARG_TYPES (type
))
5954 error ("nonnull attribute without arguments on a non-prototype");
5955 *no_add_attrs
= true;
5960 /* Argument list specified. Verify that each argument number references
5961 a pointer argument. */
5962 for (attr_arg_num
= 1; args
; args
= TREE_CHAIN (args
))
5965 unsigned HOST_WIDE_INT arg_num
, ck_num
;
5967 if (! get_nonnull_operand (TREE_VALUE (args
), &arg_num
))
5969 error ("nonnull argument has invalid operand number (arg %lu)",
5970 (unsigned long) attr_arg_num
);
5971 *no_add_attrs
= true;
5975 argument
= TYPE_ARG_TYPES (type
);
5978 for (ck_num
= 1; ; ck_num
++)
5980 if (! argument
|| ck_num
== arg_num
)
5982 argument
= TREE_CHAIN (argument
);
5986 || TREE_CODE (TREE_VALUE (argument
)) == VOID_TYPE
)
5988 error ("nonnull argument with out-of-range operand number (arg %lu, operand %lu)",
5989 (unsigned long) attr_arg_num
, (unsigned long) arg_num
);
5990 *no_add_attrs
= true;
5994 if (TREE_CODE (TREE_VALUE (argument
)) != POINTER_TYPE
)
5996 error ("nonnull argument references non-pointer operand (arg %lu, operand %lu)",
5997 (unsigned long) attr_arg_num
, (unsigned long) arg_num
);
5998 *no_add_attrs
= true;
6007 /* Check the argument list of a function call for null in argument slots
6008 that are marked as requiring a non-null pointer argument. */
6011 check_function_nonnull (attrs
, params
)
6015 tree a
, args
, param
;
6018 for (a
= attrs
; a
; a
= TREE_CHAIN (a
))
6020 if (is_attribute_p ("nonnull", TREE_PURPOSE (a
)))
6022 args
= TREE_VALUE (a
);
6024 /* Walk the argument list. If we encounter an argument number we
6025 should check for non-null, do it. If the attribute has no args,
6026 then every pointer argument is checked (in which case the check
6027 for pointer type is done in check_nonnull_arg). */
6028 for (param
= params
, param_num
= 1; ;
6029 param_num
++, param
= TREE_CHAIN (param
))
6033 if (! args
|| nonnull_check_p (args
, param_num
))
6034 check_function_arguments_recurse (check_nonnull_arg
, NULL
,
6042 /* Helper for check_function_nonnull; given a list of operands which
6043 must be non-null in ARGS, determine if operand PARAM_NUM should be
6047 nonnull_check_p (args
, param_num
)
6049 unsigned HOST_WIDE_INT param_num
;
6051 unsigned HOST_WIDE_INT arg_num
;
6053 for (; args
; args
= TREE_CHAIN (args
))
6055 if (! get_nonnull_operand (TREE_VALUE (args
), &arg_num
))
6058 if (arg_num
== param_num
)
6064 /* Check that the function argument PARAM (which is operand number
6065 PARAM_NUM) is non-null. This is called by check_function_nonnull
6066 via check_function_arguments_recurse. */
6069 check_nonnull_arg (ctx
, param
, param_num
)
6070 void *ctx ATTRIBUTE_UNUSED
;
6072 unsigned HOST_WIDE_INT param_num
;
6074 /* Just skip checking the argument if it's not a pointer. This can
6075 happen if the "nonnull" attribute was given without an operand
6076 list (which means to check every pointer argument). */
6078 if (TREE_CODE (TREE_TYPE (param
)) != POINTER_TYPE
)
6081 if (integer_zerop (param
))
6082 warning ("null argument where non-null required (arg %lu)",
6083 (unsigned long) param_num
);
6086 /* Helper for nonnull attribute handling; fetch the operand number
6087 from the attribute argument list. */
6090 get_nonnull_operand (arg_num_expr
, valp
)
6092 unsigned HOST_WIDE_INT
*valp
;
6094 /* Strip any conversions from the arg number and verify they
6096 while (TREE_CODE (arg_num_expr
) == NOP_EXPR
6097 || TREE_CODE (arg_num_expr
) == CONVERT_EXPR
6098 || TREE_CODE (arg_num_expr
) == NON_LVALUE_EXPR
)
6099 arg_num_expr
= TREE_OPERAND (arg_num_expr
, 0);
6101 if (TREE_CODE (arg_num_expr
) != INTEGER_CST
6102 || TREE_INT_CST_HIGH (arg_num_expr
) != 0)
6105 *valp
= TREE_INT_CST_LOW (arg_num_expr
);
6109 /* Handle a "nothrow" attribute; arguments as in
6110 struct attribute_spec.handler. */
6113 handle_nothrow_attribute (node
, name
, args
, flags
, no_add_attrs
)
6116 tree args ATTRIBUTE_UNUSED
;
6117 int flags ATTRIBUTE_UNUSED
;
6120 if (TREE_CODE (*node
) == FUNCTION_DECL
)
6121 TREE_NOTHROW (*node
) = 1;
6122 /* ??? TODO: Support types. */
6125 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
6126 *no_add_attrs
= true;
6132 /* Check for valid arguments being passed to a function. */
6134 check_function_arguments (attrs
, params
)
6138 /* Check for null being passed in a pointer argument that must be
6139 non-null. We also need to do this if format checking is enabled. */
6142 check_function_nonnull (attrs
, params
);
6144 /* Check for errors in format strings. */
6147 check_function_format (NULL
, attrs
, params
);
6150 /* Generic argument checking recursion routine. PARAM is the argument to
6151 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
6152 once the argument is resolved. CTX is context for the callback. */
6154 check_function_arguments_recurse (callback
, ctx
, param
, param_num
)
6155 void (*callback
) PARAMS ((void *, tree
, unsigned HOST_WIDE_INT
));
6158 unsigned HOST_WIDE_INT param_num
;
6160 if (TREE_CODE (param
) == NOP_EXPR
)
6162 /* Strip coercion. */
6163 check_function_arguments_recurse (callback
, ctx
,
6164 TREE_OPERAND (param
, 0), param_num
);
6168 if (TREE_CODE (param
) == CALL_EXPR
)
6170 tree type
= TREE_TYPE (TREE_TYPE (TREE_OPERAND (param
, 0)));
6172 bool found_format_arg
= false;
6174 /* See if this is a call to a known internationalization function
6175 that modifies a format arg. Such a function may have multiple
6176 format_arg attributes (for example, ngettext). */
6178 for (attrs
= TYPE_ATTRIBUTES (type
);
6180 attrs
= TREE_CHAIN (attrs
))
6181 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs
)))
6184 tree format_num_expr
;
6188 /* Extract the argument number, which was previously checked
6190 format_num_expr
= TREE_VALUE (TREE_VALUE (attrs
));
6191 while (TREE_CODE (format_num_expr
) == NOP_EXPR
6192 || TREE_CODE (format_num_expr
) == CONVERT_EXPR
6193 || TREE_CODE (format_num_expr
) == NON_LVALUE_EXPR
)
6194 format_num_expr
= TREE_OPERAND (format_num_expr
, 0);
6196 if (TREE_CODE (format_num_expr
) != INTEGER_CST
6197 || TREE_INT_CST_HIGH (format_num_expr
) != 0)
6200 format_num
= TREE_INT_CST_LOW (format_num_expr
);
6202 for (inner_args
= TREE_OPERAND (param
, 1), i
= 1;
6204 inner_args
= TREE_CHAIN (inner_args
), i
++)
6205 if (i
== format_num
)
6207 check_function_arguments_recurse (callback
, ctx
,
6208 TREE_VALUE (inner_args
),
6210 found_format_arg
= true;
6215 /* If we found a format_arg attribute and did a recursive check,
6216 we are done with checking this argument. Otherwise, we continue
6217 and this will be considered a non-literal. */
6218 if (found_format_arg
)
6222 if (TREE_CODE (param
) == COND_EXPR
)
6224 /* Check both halves of the conditional expression. */
6225 check_function_arguments_recurse (callback
, ctx
,
6226 TREE_OPERAND (param
, 1), param_num
);
6227 check_function_arguments_recurse (callback
, ctx
,
6228 TREE_OPERAND (param
, 2), param_num
);
6232 (*callback
) (ctx
, param
, param_num
);
6235 #include "gt-c-common.h"