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"
37 #include "diagnostic.h"
42 #include "langhooks.h"
43 #include "tree-inline.h"
46 cpp_reader
*parse_in
; /* Declared in c-pragma.h. */
48 /* We let tm.h override the types used here, to handle trivial differences
49 such as the choice of unsigned int or long unsigned int for size_t.
50 When machines start needing nontrivial differences in the size type,
51 it would be best to do something here to figure out automatically
52 from other information what type to use. */
55 #define SIZE_TYPE "long unsigned int"
59 #define WCHAR_TYPE "int"
62 /* WCHAR_TYPE gets overridden by -fshort-wchar. */
63 #define MODIFIED_WCHAR_TYPE \
64 (flag_short_wchar ? "short unsigned int" : WCHAR_TYPE)
67 #define PTRDIFF_TYPE "long int"
71 #define WINT_TYPE "unsigned int"
75 #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
77 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
83 #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
85 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
86 ? "long unsigned int" \
87 : "long long unsigned int"))
90 /* The variant of the C language being processed. */
92 enum c_language_kind c_language
;
94 /* The following symbols are subsumed in the c_global_trees array, and
95 listed here individually for documentation purposes.
97 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
99 tree short_integer_type_node;
100 tree long_integer_type_node;
101 tree long_long_integer_type_node;
103 tree short_unsigned_type_node;
104 tree long_unsigned_type_node;
105 tree long_long_unsigned_type_node;
107 tree boolean_type_node;
108 tree boolean_false_node;
109 tree boolean_true_node;
111 tree ptrdiff_type_node;
113 tree unsigned_char_type_node;
114 tree signed_char_type_node;
115 tree wchar_type_node;
116 tree signed_wchar_type_node;
117 tree unsigned_wchar_type_node;
119 tree float_type_node;
120 tree double_type_node;
121 tree long_double_type_node;
123 tree complex_integer_type_node;
124 tree complex_float_type_node;
125 tree complex_double_type_node;
126 tree complex_long_double_type_node;
128 tree intQI_type_node;
129 tree intHI_type_node;
130 tree intSI_type_node;
131 tree intDI_type_node;
132 tree intTI_type_node;
134 tree unsigned_intQI_type_node;
135 tree unsigned_intHI_type_node;
136 tree unsigned_intSI_type_node;
137 tree unsigned_intDI_type_node;
138 tree unsigned_intTI_type_node;
140 tree widest_integer_literal_type_node;
141 tree widest_unsigned_literal_type_node;
143 Nodes for types `void *' and `const void *'.
145 tree ptr_type_node, const_ptr_type_node;
147 Nodes for types `char *' and `const char *'.
149 tree string_type_node, const_string_type_node;
151 Type `char[SOMENUMBER]'.
152 Used when an array of char is needed and the size is irrelevant.
154 tree char_array_type_node;
156 Type `int[SOMENUMBER]' or something like it.
157 Used when an array of int needed and the size is irrelevant.
159 tree int_array_type_node;
161 Type `wchar_t[SOMENUMBER]' or something like it.
162 Used when a wide string literal is created.
164 tree wchar_array_type_node;
166 Type `int ()' -- used for implicit declaration of functions.
168 tree default_function_type;
170 A VOID_TYPE node, packaged in a TREE_LIST.
174 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
175 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
176 VAR_DECLS, but C++ does.)
178 tree function_name_decl_node;
179 tree pretty_function_name_decl_node;
180 tree c99_function_name_decl_node;
182 Stack of nested function name VAR_DECLs.
184 tree saved_function_name_decls;
188 tree c_global_trees
[CTI_MAX
];
190 /* Nonzero if we can read a PCH file now. */
194 /* Switches common to the C front ends. */
196 /* Nonzero if prepreprocessing only. */
198 int flag_preprocess_only
;
200 /* Nonzero means don't output line number information. */
202 char flag_no_line_commands
;
204 /* Nonzero causes -E output not to be done, but directives such as
205 #define that have side effects are still obeyed. */
209 /* Nonzero means dump macros in some fashion. */
211 char flag_dump_macros
;
213 /* Nonzero means pass #include lines through to the output. */
215 char flag_dump_includes
;
217 /* The file name to which we should write a precompiled header, or
218 NULL if no header will be written in this compile. */
220 const char *pch_file
;
222 /* Nonzero if an ISO standard was selected. It rejects macros in the
226 /* Nonzero whenever Objective-C functionality is being used. */
229 /* Nonzero if -undef was given. It suppresses target built-in macros
233 /* Nonzero means don't recognize the non-ANSI builtin functions. */
237 /* Nonzero means don't recognize the non-ANSI builtin functions.
240 int flag_no_nonansi_builtin
;
242 /* Nonzero means give `double' the same size as `float'. */
244 int flag_short_double
;
246 /* Nonzero means give `wchar_t' the same size as `short'. */
248 int flag_short_wchar
;
250 /* Nonzero means allow Microsoft extensions without warnings or errors. */
251 int flag_ms_extensions
;
253 /* Nonzero means don't recognize the keyword `asm'. */
257 /* Nonzero means give string constants the type `const char *', as mandated
260 int flag_const_strings
;
262 /* Nonzero means `$' can be in an identifier. */
264 #ifndef DOLLARS_IN_IDENTIFIERS
265 #define DOLLARS_IN_IDENTIFIERS 1
267 int dollars_in_ident
= DOLLARS_IN_IDENTIFIERS
;
269 /* Nonzero means to treat bitfields as signed unless they say `unsigned'. */
271 int flag_signed_bitfields
= 1;
272 int explicit_flag_signed_bitfields
;
274 /* Nonzero means warn about pointer casts that can drop a type qualifier
275 from the pointer target type. */
279 /* Warn about functions which might be candidates for format attributes. */
281 int warn_missing_format_attribute
;
283 /* Nonzero means warn about sizeof(function) or addition/subtraction
284 of function pointers. */
286 int warn_pointer_arith
;
288 /* Nonzero means warn for any global function def
289 without separate previous prototype decl. */
291 int warn_missing_prototypes
;
293 /* Warn if adding () is suggested. */
295 int warn_parentheses
;
297 /* Warn if initializer is not completely bracketed. */
299 int warn_missing_braces
;
301 /* Warn about comparison of signed and unsigned values.
302 If -1, neither -Wsign-compare nor -Wno-sign-compare has been specified. */
304 int warn_sign_compare
;
306 /* Nonzero means warn about usage of long long when `-pedantic'. */
308 int warn_long_long
= 1;
310 /* Nonzero means warn about deprecated conversion from string constant to
313 int warn_write_strings
;
315 /* Nonzero means warn about multiple (redundant) decls for the same single
316 variable or function. */
318 int warn_redundant_decls
;
320 /* Warn about testing equality of floating point numbers. */
322 int warn_float_equal
;
324 /* Warn about a subscript that has type char. */
326 int warn_char_subscripts
;
328 /* Warn if a type conversion is done that might have confusing results. */
332 /* Warn about #pragma directives that are not recognized. */
334 int warn_unknown_pragmas
; /* Tri state variable. */
336 /* Warn about format/argument anomalies in calls to formatted I/O functions
337 (*printf, *scanf, strftime, strfmon, etc.). */
341 /* Warn about Y2K problems with strftime formats. */
345 /* Warn about excess arguments to formats. */
347 int warn_format_extra_args
;
349 /* Warn about zero-length formats. */
351 int warn_format_zero_length
;
353 /* Warn about non-literal format arguments. */
355 int warn_format_nonliteral
;
357 /* Warn about possible security problems with calls to format functions. */
359 int warn_format_security
;
362 /* C/ObjC language option variables. */
365 /* Nonzero means message about use of implicit function declarations;
366 1 means warning; 2 means error. */
368 int mesg_implicit_function_declaration
= -1;
370 /* Nonzero means allow type mismatches in conditional expressions;
371 just make their values `void'. */
373 int flag_cond_mismatch
;
375 /* Nonzero means enable C89 Amendment 1 features. */
379 /* Nonzero means use the ISO C99 dialect of C. */
383 /* Nonzero means that we have builtin functions, and main is an int */
387 /* Nonzero means add default format_arg attributes for functions not
390 int flag_noniso_default_format_attributes
= 1;
392 /* Nonzero means warn when casting a function call to a type that does
393 not match the return type (e.g. (float)sqrt() or (anything*)malloc()
394 when there is no previous declaration of sqrt or malloc. */
396 int warn_bad_function_cast
;
398 /* Warn about traditional constructs whose meanings changed in ANSI C. */
400 int warn_traditional
;
402 /* Nonzero means warn for non-prototype function decls
403 or non-prototyped defs without previous prototype. */
405 int warn_strict_prototypes
;
407 /* Nonzero means warn for any global function def
408 without separate previous decl. */
410 int warn_missing_declarations
;
412 /* Nonzero means warn about declarations of objects not at
413 file-scope level and about *all* declarations of functions (whether
414 or static) not at file-scope level. Note that we exclude
415 implicit function declarations. To get warnings about those, use
418 int warn_nested_externs
;
420 /* Warn if main is suspicious. */
424 /* Nonzero means warn about possible violations of sequence point rules. */
426 int warn_sequence_point
;
428 /* Nonzero means to warn about compile-time division by zero. */
429 int warn_div_by_zero
= 1;
431 /* Nonzero means warn about use of implicit int. */
433 int warn_implicit_int
;
435 /* Warn about NULL being passed to argument slots marked as requiring
441 /* ObjC language option variables. */
444 /* Open and close the file for outputting class declarations, if
447 int flag_gen_declaration
;
449 /* Generate code for GNU or NeXT runtime environment. */
451 #ifdef NEXT_OBJC_RUNTIME
452 int flag_next_runtime
= 1;
454 int flag_next_runtime
= 0;
457 /* Tells the compiler that this is a special run. Do not perform any
458 compiling, instead we are to test some platform dependent features
459 and output a C header file with appropriate definitions. */
461 int print_struct_values
;
463 /* ???. Undocumented. */
465 const char *constant_string_class_name
;
467 /* Warn if multiple methods are seen for the same selector, but with
468 different argument types. Performs the check on the whole selector
469 table at the end of compilation. */
473 /* Warn if a @selector() is found, and no method with that selector
474 has been previously declared. The check is done on each
475 @selector() as soon as it is found - so it warns about forward
478 int warn_undeclared_selector
;
480 /* Warn if methods required by a protocol are not implemented in the
481 class adopting it. When turned off, methods inherited to that
482 class are also considered implemented. */
484 int warn_protocol
= 1;
487 /* C++ language option variables. */
490 /* Nonzero means don't recognize any extension keywords. */
492 int flag_no_gnu_keywords
;
494 /* Nonzero means do emit exported implementations of functions even if
495 they can be inlined. */
497 int flag_implement_inlines
= 1;
499 /* Nonzero means do emit exported implementations of templates, instead of
500 multiple static copies in each file that needs a definition. */
502 int flag_external_templates
;
504 /* Nonzero means that the decision to emit or not emit the implementation of a
505 template depends on where the template is instantiated, rather than where
508 int flag_alt_external_templates
;
510 /* Nonzero means that implicit instantiations will be emitted if needed. */
512 int flag_implicit_templates
= 1;
514 /* Nonzero means that implicit instantiations of inline templates will be
515 emitted if needed, even if instantiations of non-inline templates
518 int flag_implicit_inline_templates
= 1;
520 /* Nonzero means generate separate instantiation control files and
521 juggle them at link time. */
523 int flag_use_repository
;
525 /* Nonzero if we want to issue diagnostics that the standard says are not
528 int flag_optional_diags
= 1;
530 /* Nonzero means we should attempt to elide constructors when possible. */
532 int flag_elide_constructors
= 1;
534 /* Nonzero means that member functions defined in class scope are
535 inline by default. */
537 int flag_default_inline
= 1;
539 /* Controls whether compiler generates 'type descriptor' that give
540 run-time type information. */
544 /* Nonzero if we want to conserve space in the .o files. We do this
545 by putting uninitialized data and runtime initialized data into
546 .common instead of .data at the expense of not flagging multiple
549 int flag_conserve_space
;
551 /* Nonzero if we want to obey access control semantics. */
553 int flag_access_control
= 1;
555 /* Nonzero if we want to check the return value of new and avoid calling
556 constructors if it is a null pointer. */
560 /* Nonzero if we want the new ISO rules for pushing a new scope for `for'
561 initialization variables.
562 0: Old rules, set by -fno-for-scope.
563 2: New ISO rules, set by -ffor-scope.
564 1: Try to implement new ISO rules, but with backup compatibility
565 (and warnings). This is the default, for now. */
567 int flag_new_for_scope
= 1;
569 /* Nonzero if we want to emit defined symbols with common-like linkage as
570 weak symbols where possible, in order to conform to C++ semantics.
571 Otherwise, emit them as local symbols. */
575 /* Nonzero to use __cxa_atexit, rather than atexit, to register
576 destructors for local statics and global objects. */
578 int flag_use_cxa_atexit
= DEFAULT_USE_CXA_ATEXIT
;
580 /* Nonzero means output .vtable_{entry,inherit} for use in doing vtable gc. */
584 /* Nonzero means make the default pedwarns warnings instead of errors.
585 The value of this flag is ignored if -pedantic is specified. */
589 /* Nonzero means to implement standard semantics for exception
590 specifications, calling unexpected if an exception is thrown that
591 doesn't match the specification. Zero means to treat them as
592 assertions and optimize accordingly, but not check them. */
594 int flag_enforce_eh_specs
= 1;
596 /* The version of the C++ ABI in use. The following values are
599 0: The version of the ABI believed most conformant with the
600 C++ ABI specification. This ABI may change as bugs are
601 discovered and fixed. Therefore, 0 will not necessarily
602 indicate the same ABI in different versions of G++.
604 1: The version of the ABI first used in G++ 3.2.
606 Additional positive integers will be assigned as new versions of
607 the ABI become the default version of the ABI. */
609 int flag_abi_version
= 1;
611 /* Nonzero means warn about things that will change when compiling
612 with an ABI-compliant compiler. */
616 /* Nonzero means warn about implicit declarations. */
618 int warn_implicit
= 1;
620 /* Nonzero means warn when all ctors or dtors are private, and the class
623 int warn_ctor_dtor_privacy
= 1;
625 /* Nonzero means warn in function declared in derived class has the
626 same name as a virtual in the base class, but fails to match the
627 type signature of any virtual function in the base class. */
629 int warn_overloaded_virtual
;
631 /* Nonzero means warn when declaring a class that has a non virtual
632 destructor, when it really ought to have a virtual one. */
636 /* Nonzero means warn when the compiler will reorder code. */
640 /* Nonzero means warn when synthesis behavior differs from Cfront's. */
644 /* Nonzero means warn when we convert a pointer to member function
645 into a pointer to (void or function). */
647 int warn_pmf2ptr
= 1;
649 /* Nonzero means warn about violation of some Effective C++ style rules. */
653 /* Nonzero means warn where overload resolution chooses a promotion from
654 unsigned to signed over a conversion to an unsigned of the same size. */
658 /* Nonzero means warn when an old-style cast is used. */
660 int warn_old_style_cast
;
662 /* Nonzero means warn when non-templatized friend functions are
663 declared within a template */
665 int warn_nontemplate_friend
= 1;
667 /* Nonzero means complain about deprecated features. */
669 int warn_deprecated
= 1;
671 /* Maximum template instantiation depth. This limit is rather
672 arbitrary, but it exists to limit the time it takes to notice
673 infinite template instantiations. */
675 int max_tinst_depth
= 500;
679 /* The elements of `ridpointers' are identifier nodes for the reserved
680 type names and storage classes. It is indexed by a RID_... value. */
683 tree (*make_fname_decl
) PARAMS ((tree
, int));
685 /* If non-NULL, the address of a language-specific function that
686 returns 1 for language-specific statement codes. */
687 int (*lang_statement_code_p
) PARAMS ((enum tree_code
));
689 /* If non-NULL, the address of a language-specific function that takes
690 any action required right before expand_function_end is called. */
691 void (*lang_expand_function_end
) PARAMS ((void));
693 /* Nonzero means the expression being parsed will never be evaluated.
694 This is a count, since unevaluated expressions can nest. */
697 /* Information about how a function name is generated. */
700 tree
*const decl
; /* pointer to the VAR_DECL. */
701 const unsigned rid
; /* RID number for the identifier. */
702 const int pretty
; /* How pretty is it? */
705 /* The three ways of getting then name of the current function. */
707 const struct fname_var_t fname_vars
[] =
709 /* C99 compliant __func__, must be first. */
710 {&c99_function_name_decl_node
, RID_C99_FUNCTION_NAME
, 0},
711 /* GCC __FUNCTION__ compliant. */
712 {&function_name_decl_node
, RID_FUNCTION_NAME
, 0},
713 /* GCC __PRETTY_FUNCTION__ compliant. */
714 {&pretty_function_name_decl_node
, RID_PRETTY_FUNCTION_NAME
, 1},
718 static int constant_fits_type_p
PARAMS ((tree
, tree
));
720 /* Keep a stack of if statements. We record the number of compound
721 statements seen up to the if keyword, as well as the line number
722 and file of the if. If a potentially ambiguous else is seen, that
723 fact is recorded; the warning is issued when we can be sure that
724 the enclosing if statement does not have an else branch. */
734 static if_elt
*if_stack
;
736 /* Amount of space in the if statement stack. */
737 static int if_stack_space
= 0;
740 static int if_stack_pointer
= 0;
742 static tree handle_packed_attribute
PARAMS ((tree
*, tree
, tree
, int,
744 static tree handle_nocommon_attribute
PARAMS ((tree
*, tree
, tree
, int,
746 static tree handle_common_attribute
PARAMS ((tree
*, tree
, tree
, int,
748 static tree handle_noreturn_attribute
PARAMS ((tree
*, tree
, tree
, int,
750 static tree handle_noinline_attribute
PARAMS ((tree
*, tree
, tree
, int,
752 static tree handle_always_inline_attribute
PARAMS ((tree
*, tree
, tree
, int,
754 static tree handle_used_attribute
PARAMS ((tree
*, tree
, tree
, int,
756 static tree handle_unused_attribute
PARAMS ((tree
*, tree
, tree
, int,
758 static tree handle_const_attribute
PARAMS ((tree
*, tree
, tree
, int,
760 static tree handle_transparent_union_attribute
PARAMS ((tree
*, tree
, tree
,
762 static tree handle_constructor_attribute
PARAMS ((tree
*, tree
, tree
, int,
764 static tree handle_destructor_attribute
PARAMS ((tree
*, tree
, tree
, int,
766 static tree handle_mode_attribute
PARAMS ((tree
*, tree
, tree
, int,
768 static tree handle_section_attribute
PARAMS ((tree
*, tree
, tree
, int,
770 static tree handle_aligned_attribute
PARAMS ((tree
*, tree
, tree
, int,
772 static tree handle_weak_attribute
PARAMS ((tree
*, tree
, tree
, int,
774 static tree handle_alias_attribute
PARAMS ((tree
*, tree
, tree
, int,
776 static tree handle_visibility_attribute
PARAMS ((tree
*, tree
, tree
, int,
778 static tree handle_tls_model_attribute
PARAMS ((tree
*, tree
, tree
, int,
780 static tree handle_no_instrument_function_attribute
PARAMS ((tree
*, tree
,
783 static tree handle_malloc_attribute
PARAMS ((tree
*, tree
, tree
, int,
785 static tree handle_no_limit_stack_attribute
PARAMS ((tree
*, tree
, tree
, int,
787 static tree handle_pure_attribute
PARAMS ((tree
*, tree
, tree
, int,
789 static tree handle_deprecated_attribute
PARAMS ((tree
*, tree
, tree
, int,
791 static tree handle_vector_size_attribute
PARAMS ((tree
*, tree
, tree
, int,
793 static tree handle_nonnull_attribute
PARAMS ((tree
*, tree
, tree
, int,
795 static tree handle_nothrow_attribute
PARAMS ((tree
*, tree
, tree
, int,
797 static tree vector_size_helper
PARAMS ((tree
, tree
));
799 static void check_function_nonnull
PARAMS ((tree
, tree
));
800 static void check_nonnull_arg
PARAMS ((void *, tree
,
801 unsigned HOST_WIDE_INT
));
802 static bool nonnull_check_p
PARAMS ((tree
, unsigned HOST_WIDE_INT
));
803 static bool get_nonnull_operand
PARAMS ((tree
,
804 unsigned HOST_WIDE_INT
*));
806 /* Table of machine-independent attributes common to all C-like languages. */
807 const struct attribute_spec c_common_attribute_table
[] =
809 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
810 { "packed", 0, 0, false, false, false,
811 handle_packed_attribute
},
812 { "nocommon", 0, 0, true, false, false,
813 handle_nocommon_attribute
},
814 { "common", 0, 0, true, false, false,
815 handle_common_attribute
},
816 /* FIXME: logically, noreturn attributes should be listed as
817 "false, true, true" and apply to function types. But implementing this
818 would require all the places in the compiler that use TREE_THIS_VOLATILE
819 on a decl to identify non-returning functions to be located and fixed
820 to check the function type instead. */
821 { "noreturn", 0, 0, true, false, false,
822 handle_noreturn_attribute
},
823 { "volatile", 0, 0, true, false, false,
824 handle_noreturn_attribute
},
825 { "noinline", 0, 0, true, false, false,
826 handle_noinline_attribute
},
827 { "always_inline", 0, 0, true, false, false,
828 handle_always_inline_attribute
},
829 { "used", 0, 0, true, false, false,
830 handle_used_attribute
},
831 { "unused", 0, 0, false, false, false,
832 handle_unused_attribute
},
833 /* The same comments as for noreturn attributes apply to const ones. */
834 { "const", 0, 0, true, false, false,
835 handle_const_attribute
},
836 { "transparent_union", 0, 0, false, false, false,
837 handle_transparent_union_attribute
},
838 { "constructor", 0, 0, true, false, false,
839 handle_constructor_attribute
},
840 { "destructor", 0, 0, true, false, false,
841 handle_destructor_attribute
},
842 { "mode", 1, 1, false, true, false,
843 handle_mode_attribute
},
844 { "section", 1, 1, true, false, false,
845 handle_section_attribute
},
846 { "aligned", 0, 1, false, false, false,
847 handle_aligned_attribute
},
848 { "weak", 0, 0, true, false, false,
849 handle_weak_attribute
},
850 { "alias", 1, 1, true, false, false,
851 handle_alias_attribute
},
852 { "no_instrument_function", 0, 0, true, false, false,
853 handle_no_instrument_function_attribute
},
854 { "malloc", 0, 0, true, false, false,
855 handle_malloc_attribute
},
856 { "no_stack_limit", 0, 0, true, false, false,
857 handle_no_limit_stack_attribute
},
858 { "pure", 0, 0, true, false, false,
859 handle_pure_attribute
},
860 { "deprecated", 0, 0, false, false, false,
861 handle_deprecated_attribute
},
862 { "vector_size", 1, 1, false, true, false,
863 handle_vector_size_attribute
},
864 { "visibility", 1, 1, true, false, false,
865 handle_visibility_attribute
},
866 { "tls_model", 1, 1, true, false, false,
867 handle_tls_model_attribute
},
868 { "nonnull", 0, -1, false, true, true,
869 handle_nonnull_attribute
},
870 { "nothrow", 0, 0, true, false, false,
871 handle_nothrow_attribute
},
872 { "may_alias", 0, 0, false, true, false, NULL
},
873 { NULL
, 0, 0, false, false, false, NULL
}
876 /* Give the specifications for the format attributes, used by C and all
879 const struct attribute_spec c_common_format_attribute_table
[] =
881 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
882 { "format", 3, 3, false, true, true,
883 handle_format_attribute
},
884 { "format_arg", 1, 1, false, true, true,
885 handle_format_arg_attribute
},
886 { NULL
, 0, 0, false, false, false, NULL
}
889 /* Record the start of an if-then, and record the start of it
890 for ambiguous else detection.
892 COND is the condition for the if-then statement.
894 IF_STMT is the statement node that has already been created for
895 this if-then statement. It is created before parsing the
896 condition to keep line number information accurate. */
899 c_expand_start_cond (cond
, compstmt_count
, if_stmt
)
904 /* Make sure there is enough space on the stack. */
905 if (if_stack_space
== 0)
908 if_stack
= (if_elt
*) xmalloc (10 * sizeof (if_elt
));
910 else if (if_stack_space
== if_stack_pointer
)
912 if_stack_space
+= 10;
913 if_stack
= (if_elt
*) xrealloc (if_stack
, if_stack_space
* sizeof (if_elt
));
916 IF_COND (if_stmt
) = cond
;
919 /* Record this if statement. */
920 if_stack
[if_stack_pointer
].compstmt_count
= compstmt_count
;
921 if_stack
[if_stack_pointer
].file
= input_filename
;
922 if_stack
[if_stack_pointer
].line
= lineno
;
923 if_stack
[if_stack_pointer
].needs_warning
= 0;
924 if_stack
[if_stack_pointer
].if_stmt
= if_stmt
;
928 /* Called after the then-clause for an if-statement is processed. */
933 tree if_stmt
= if_stack
[if_stack_pointer
- 1].if_stmt
;
934 RECHAIN_STMTS (if_stmt
, THEN_CLAUSE (if_stmt
));
937 /* Record the end of an if-then. Optionally warn if a nested
938 if statement had an ambiguous else clause. */
944 if (if_stack
[if_stack_pointer
].needs_warning
)
945 warning_with_file_and_line (if_stack
[if_stack_pointer
].file
,
946 if_stack
[if_stack_pointer
].line
,
947 "suggest explicit braces to avoid ambiguous `else'");
948 last_expr_type
= NULL_TREE
;
951 /* Called between the then-clause and the else-clause
952 of an if-then-else. */
955 c_expand_start_else ()
957 /* An ambiguous else warning must be generated for the enclosing if
958 statement, unless we see an else branch for that one, too. */
960 && if_stack_pointer
> 1
961 && (if_stack
[if_stack_pointer
- 1].compstmt_count
962 == if_stack
[if_stack_pointer
- 2].compstmt_count
))
963 if_stack
[if_stack_pointer
- 2].needs_warning
= 1;
965 /* Even if a nested if statement had an else branch, it can't be
966 ambiguous if this one also has an else. So don't warn in that
967 case. Also don't warn for any if statements nested in this else. */
968 if_stack
[if_stack_pointer
- 1].needs_warning
= 0;
969 if_stack
[if_stack_pointer
- 1].compstmt_count
--;
972 /* Called after the else-clause for an if-statement is processed. */
977 tree if_stmt
= if_stack
[if_stack_pointer
- 1].if_stmt
;
978 RECHAIN_STMTS (if_stmt
, ELSE_CLAUSE (if_stmt
));
981 /* Begin an if-statement. Returns a newly created IF_STMT if
984 Unlike the C++ front-end, we do not call add_stmt here; it is
985 probably safe to do so, but I am not very familiar with this
986 code so I am being extra careful not to change its behavior
987 beyond what is strictly necessary for correctness. */
993 r
= build_stmt (IF_STMT
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
997 /* Begin a while statement. Returns a newly created WHILE_STMT if
1000 Unlike the C++ front-end, we do not call add_stmt here; it is
1001 probably safe to do so, but I am not very familiar with this
1002 code so I am being extra careful not to change its behavior
1003 beyond what is strictly necessary for correctness. */
1006 c_begin_while_stmt ()
1009 r
= build_stmt (WHILE_STMT
, NULL_TREE
, NULL_TREE
);
1014 c_finish_while_stmt_cond (cond
, while_stmt
)
1018 WHILE_COND (while_stmt
) = cond
;
1021 /* Push current bindings for the function name VAR_DECLS. */
1024 start_fname_decls ()
1027 tree saved
= NULL_TREE
;
1029 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
1031 tree decl
= *fname_vars
[ix
].decl
;
1035 saved
= tree_cons (decl
, build_int_2 (ix
, 0), saved
);
1036 *fname_vars
[ix
].decl
= NULL_TREE
;
1039 if (saved
|| saved_function_name_decls
)
1040 /* Normally they'll have been NULL, so only push if we've got a
1041 stack, or they are non-NULL. */
1042 saved_function_name_decls
= tree_cons (saved
, NULL_TREE
,
1043 saved_function_name_decls
);
1046 /* Finish up the current bindings, adding them into the
1047 current function's statement tree. This is done by wrapping the
1048 function's body in a COMPOUND_STMT containing these decls too. This
1049 must be done _before_ finish_stmt_tree is called. If there is no
1050 current function, we must be at file scope and no statements are
1051 involved. Pop the previous bindings. */
1054 finish_fname_decls ()
1057 tree body
= NULL_TREE
;
1058 tree stack
= saved_function_name_decls
;
1060 for (; stack
&& TREE_VALUE (stack
); stack
= TREE_CHAIN (stack
))
1061 body
= chainon (TREE_VALUE (stack
), body
);
1065 /* They were called into existence, so add to statement tree. Add
1066 the DECL_STMTs inside the outermost scope. */
1067 tree
*p
= &DECL_SAVED_TREE (current_function_decl
);
1068 /* Skip the dummy EXPR_STMT and any EH_SPEC_BLOCK. */
1069 while (TREE_CODE (*p
) != COMPOUND_STMT
)
1070 p
= &TREE_CHAIN (*p
);
1071 p
= &COMPOUND_BODY (*p
);
1072 if (TREE_CODE (*p
) == SCOPE_STMT
)
1073 p
= &TREE_CHAIN (*p
);
1075 body
= chainon (body
, *p
);
1079 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
1080 *fname_vars
[ix
].decl
= NULL_TREE
;
1084 /* We had saved values, restore them. */
1087 for (saved
= TREE_PURPOSE (stack
); saved
; saved
= TREE_CHAIN (saved
))
1089 tree decl
= TREE_PURPOSE (saved
);
1090 unsigned ix
= TREE_INT_CST_LOW (TREE_VALUE (saved
));
1092 *fname_vars
[ix
].decl
= decl
;
1094 stack
= TREE_CHAIN (stack
);
1096 saved_function_name_decls
= stack
;
1099 /* Return the text name of the current function, suitably prettified
1103 fname_as_string (pretty_p
)
1106 const char *name
= NULL
;
1109 name
= (current_function_decl
1110 ? (*lang_hooks
.decl_printable_name
) (current_function_decl
, 2)
1112 else if (current_function_decl
&& DECL_NAME (current_function_decl
))
1113 name
= IDENTIFIER_POINTER (DECL_NAME (current_function_decl
));
1119 /* Return the text name of the current function, formatted as
1120 required by the supplied RID value. */
1128 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
1129 if (fname_vars
[ix
].rid
== rid
)
1131 return fname_as_string (fname_vars
[ix
].pretty
);
1134 /* Return the VAR_DECL for a const char array naming the current
1135 function. If the VAR_DECL has not yet been created, create it
1136 now. RID indicates how it should be formatted and IDENTIFIER_NODE
1137 ID is its name (unfortunately C and C++ hold the RID values of
1138 keywords in different places, so we can't derive RID from ID in
1139 this language independent code. */
1142 fname_decl (rid
, id
)
1147 tree decl
= NULL_TREE
;
1149 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
1150 if (fname_vars
[ix
].rid
== rid
)
1153 decl
= *fname_vars
[ix
].decl
;
1156 tree saved_last_tree
= last_tree
;
1157 /* If a tree is built here, it would normally have the lineno of
1158 the current statement. Later this tree will be moved to the
1159 beginning of the function and this line number will be wrong.
1160 To avoid this problem set the lineno to 0 here; that prevents
1161 it from appearing in the RTL. */
1162 int saved_lineno
= lineno
;
1165 decl
= (*make_fname_decl
) (id
, fname_vars
[ix
].pretty
);
1166 if (last_tree
!= saved_last_tree
)
1168 /* We created some statement tree for the decl. This belongs
1169 at the start of the function, so remove it now and reinsert
1170 it after the function is complete. */
1171 tree stmts
= TREE_CHAIN (saved_last_tree
);
1173 TREE_CHAIN (saved_last_tree
) = NULL_TREE
;
1174 last_tree
= saved_last_tree
;
1175 saved_function_name_decls
= tree_cons (decl
, stmts
,
1176 saved_function_name_decls
);
1178 *fname_vars
[ix
].decl
= decl
;
1179 lineno
= saved_lineno
;
1181 if (!ix
&& !current_function_decl
)
1182 pedwarn_with_decl (decl
, "`%s' is not defined outside of function scope");
1187 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
1190 fix_string_type (value
)
1193 const int wchar_bytes
= TYPE_PRECISION (wchar_type_node
) / BITS_PER_UNIT
;
1194 const int wide_flag
= TREE_TYPE (value
) == wchar_array_type_node
;
1195 const int nchars_max
= flag_isoc99
? 4095 : 509;
1196 int length
= TREE_STRING_LENGTH (value
);
1199 /* Compute the number of elements, for the array type. */
1200 nchars
= wide_flag
? length
/ wchar_bytes
: length
;
1202 if (pedantic
&& nchars
- 1 > nchars_max
&& c_language
== clk_c
)
1203 pedwarn ("string length `%d' is greater than the length `%d' ISO C%d compilers are required to support",
1204 nchars
- 1, nchars_max
, flag_isoc99
? 99 : 89);
1206 /* Create the array type for the string constant.
1207 -Wwrite-strings says make the string constant an array of const char
1208 so that copying it to a non-const pointer will get a warning.
1209 For C++, this is the standard behavior. */
1210 if (flag_const_strings
&& ! flag_writable_strings
)
1213 = build_type_variant (wide_flag
? wchar_type_node
: char_type_node
,
1216 = build_array_type (elements
,
1217 build_index_type (build_int_2 (nchars
- 1, 0)));
1221 = build_array_type (wide_flag
? wchar_type_node
: char_type_node
,
1222 build_index_type (build_int_2 (nchars
- 1, 0)));
1224 TREE_CONSTANT (value
) = 1;
1225 TREE_READONLY (value
) = ! flag_writable_strings
;
1226 TREE_STATIC (value
) = 1;
1230 /* Given a VARRAY of STRING_CST nodes, concatenate them into one
1234 combine_strings (strings
)
1235 varray_type strings
;
1237 const int wchar_bytes
= TYPE_PRECISION (wchar_type_node
) / BITS_PER_UNIT
;
1238 const int nstrings
= VARRAY_ACTIVE_SIZE (strings
);
1241 int wide_length
= 0;
1246 /* Don't include the \0 at the end of each substring. Count wide
1247 strings and ordinary strings separately. */
1248 for (i
= 0; i
< nstrings
; ++i
)
1250 t
= VARRAY_TREE (strings
, i
);
1252 if (TREE_TYPE (t
) == wchar_array_type_node
)
1254 wide_length
+= TREE_STRING_LENGTH (t
) - wchar_bytes
;
1259 length
+= (TREE_STRING_LENGTH (t
) - 1);
1260 if (C_ARTIFICIAL_STRING_P (t
) && !in_system_header
)
1261 warning ("concatenation of string literals with __FUNCTION__ is deprecated");
1265 /* If anything is wide, the non-wides will be converted,
1266 which makes them take more space. */
1268 length
= length
* wchar_bytes
+ wide_length
;
1270 p
= xmalloc (length
);
1272 /* Copy the individual strings into the new combined string.
1273 If the combined string is wide, convert the chars to ints
1274 for any individual strings that are not wide. */
1277 for (i
= 0; i
< nstrings
; ++i
)
1281 t
= VARRAY_TREE (strings
, i
);
1282 this_wide
= TREE_TYPE (t
) == wchar_array_type_node
;
1283 len
= TREE_STRING_LENGTH (t
) - (this_wide
? wchar_bytes
: 1);
1284 if (this_wide
== wide_flag
)
1286 memcpy (q
, TREE_STRING_POINTER (t
), len
);
1291 const int nzeros
= (TYPE_PRECISION (wchar_type_node
)
1292 / BITS_PER_UNIT
) - 1;
1295 if (BYTES_BIG_ENDIAN
)
1297 for (k
= 0; k
< len
; k
++)
1299 for (j
= 0; j
< nzeros
; j
++)
1301 *q
++ = TREE_STRING_POINTER (t
)[k
];
1306 for (k
= 0; k
< len
; k
++)
1308 *q
++ = TREE_STRING_POINTER (t
)[k
];
1309 for (j
= 0; j
< nzeros
; j
++)
1316 /* Nul terminate the string. */
1319 for (i
= 0; i
< wchar_bytes
; i
++)
1325 value
= build_string (length
, p
);
1329 TREE_TYPE (value
) = wchar_array_type_node
;
1331 TREE_TYPE (value
) = char_array_type_node
;
1336 static int is_valid_printf_arglist
PARAMS ((tree
));
1337 static rtx c_expand_builtin
PARAMS ((tree
, rtx
, enum machine_mode
, enum expand_modifier
));
1338 static rtx c_expand_builtin_printf
PARAMS ((tree
, rtx
, enum machine_mode
,
1339 enum expand_modifier
, int, int));
1340 static rtx c_expand_builtin_fprintf
PARAMS ((tree
, rtx
, enum machine_mode
,
1341 enum expand_modifier
, int, int));
1343 /* Print a warning if a constant expression had overflow in folding.
1344 Invoke this function on every expression that the language
1345 requires to be a constant expression.
1346 Note the ANSI C standard says it is erroneous for a
1347 constant expression to overflow. */
1350 constant_expression_warning (value
)
1353 if ((TREE_CODE (value
) == INTEGER_CST
|| TREE_CODE (value
) == REAL_CST
1354 || TREE_CODE (value
) == VECTOR_CST
1355 || TREE_CODE (value
) == COMPLEX_CST
)
1356 && TREE_CONSTANT_OVERFLOW (value
) && pedantic
)
1357 pedwarn ("overflow in constant expression");
1360 /* Print a warning if an expression had overflow in folding.
1361 Invoke this function on every expression that
1362 (1) appears in the source code, and
1363 (2) might be a constant expression that overflowed, and
1364 (3) is not already checked by convert_and_check;
1365 however, do not invoke this function on operands of explicit casts. */
1368 overflow_warning (value
)
1371 if ((TREE_CODE (value
) == INTEGER_CST
1372 || (TREE_CODE (value
) == COMPLEX_CST
1373 && TREE_CODE (TREE_REALPART (value
)) == INTEGER_CST
))
1374 && TREE_OVERFLOW (value
))
1376 TREE_OVERFLOW (value
) = 0;
1377 if (skip_evaluation
== 0)
1378 warning ("integer overflow in expression");
1380 else if ((TREE_CODE (value
) == REAL_CST
1381 || (TREE_CODE (value
) == COMPLEX_CST
1382 && TREE_CODE (TREE_REALPART (value
)) == REAL_CST
))
1383 && TREE_OVERFLOW (value
))
1385 TREE_OVERFLOW (value
) = 0;
1386 if (skip_evaluation
== 0)
1387 warning ("floating point overflow in expression");
1389 else if (TREE_CODE (value
) == VECTOR_CST
&& TREE_OVERFLOW (value
))
1391 TREE_OVERFLOW (value
) = 0;
1392 if (skip_evaluation
== 0)
1393 warning ("vector overflow in expression");
1397 /* Print a warning if a large constant is truncated to unsigned,
1398 or if -Wconversion is used and a constant < 0 is converted to unsigned.
1399 Invoke this function on every expression that might be implicitly
1400 converted to an unsigned type. */
1403 unsigned_conversion_warning (result
, operand
)
1404 tree result
, operand
;
1406 tree type
= TREE_TYPE (result
);
1408 if (TREE_CODE (operand
) == INTEGER_CST
1409 && TREE_CODE (type
) == INTEGER_TYPE
1410 && TREE_UNSIGNED (type
)
1411 && skip_evaluation
== 0
1412 && !int_fits_type_p (operand
, type
))
1414 if (!int_fits_type_p (operand
, c_common_signed_type (type
)))
1415 /* This detects cases like converting -129 or 256 to unsigned char. */
1416 warning ("large integer implicitly truncated to unsigned type");
1417 else if (warn_conversion
)
1418 warning ("negative integer implicitly converted to unsigned type");
1422 /* Nonzero if constant C has a value that is permissible
1423 for type TYPE (an INTEGER_TYPE). */
1426 constant_fits_type_p (c
, type
)
1429 if (TREE_CODE (c
) == INTEGER_CST
)
1430 return int_fits_type_p (c
, type
);
1432 c
= convert (type
, c
);
1433 return !TREE_OVERFLOW (c
);
1436 /* Convert EXPR to TYPE, warning about conversion problems with constants.
1437 Invoke this function on every expression that is converted implicitly,
1438 i.e. because of language rules and not because of an explicit cast. */
1441 convert_and_check (type
, expr
)
1444 tree t
= convert (type
, expr
);
1445 if (TREE_CODE (t
) == INTEGER_CST
)
1447 if (TREE_OVERFLOW (t
))
1449 TREE_OVERFLOW (t
) = 0;
1451 /* Do not diagnose overflow in a constant expression merely
1452 because a conversion overflowed. */
1453 TREE_CONSTANT_OVERFLOW (t
) = TREE_CONSTANT_OVERFLOW (expr
);
1455 /* No warning for converting 0x80000000 to int. */
1456 if (!(TREE_UNSIGNED (type
) < TREE_UNSIGNED (TREE_TYPE (expr
))
1457 && TREE_CODE (TREE_TYPE (expr
)) == INTEGER_TYPE
1458 && TYPE_PRECISION (type
) == TYPE_PRECISION (TREE_TYPE (expr
))))
1459 /* If EXPR fits in the unsigned version of TYPE,
1460 don't warn unless pedantic. */
1462 || TREE_UNSIGNED (type
)
1463 || ! constant_fits_type_p (expr
,
1464 c_common_unsigned_type (type
)))
1465 && skip_evaluation
== 0)
1466 warning ("overflow in implicit constant conversion");
1469 unsigned_conversion_warning (t
, expr
);
1474 /* A node in a list that describes references to variables (EXPR), which are
1475 either read accesses if WRITER is zero, or write accesses, in which case
1476 WRITER is the parent of EXPR. */
1483 /* Used to implement a cache the results of a call to verify_tree. We only
1484 use this for SAVE_EXPRs. */
1487 struct tlist_cache
*next
;
1488 struct tlist
*cache_before_sp
;
1489 struct tlist
*cache_after_sp
;
1493 /* Obstack to use when allocating tlist structures, and corresponding
1495 static struct obstack tlist_obstack
;
1496 static char *tlist_firstobj
= 0;
1498 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
1500 static struct tlist
*warned_ids
;
1501 /* SAVE_EXPRs need special treatment. We process them only once and then
1502 cache the results. */
1503 static struct tlist_cache
*save_expr_cache
;
1505 static void add_tlist
PARAMS ((struct tlist
**, struct tlist
*, tree
, int));
1506 static void merge_tlist
PARAMS ((struct tlist
**, struct tlist
*, int));
1507 static void verify_tree
PARAMS ((tree
, struct tlist
**, struct tlist
**, tree
));
1508 static int warning_candidate_p
PARAMS ((tree
));
1509 static void warn_for_collisions
PARAMS ((struct tlist
*));
1510 static void warn_for_collisions_1
PARAMS ((tree
, tree
, struct tlist
*, int));
1511 static struct tlist
*new_tlist
PARAMS ((struct tlist
*, tree
, tree
));
1512 static void verify_sequence_points
PARAMS ((tree
));
1514 /* Create a new struct tlist and fill in its fields. */
1515 static struct tlist
*
1516 new_tlist (next
, t
, writer
)
1522 l
= (struct tlist
*) obstack_alloc (&tlist_obstack
, sizeof *l
);
1529 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
1530 is nonnull, we ignore any node we find which has a writer equal to it. */
1533 add_tlist (to
, add
, exclude_writer
, copy
)
1536 tree exclude_writer
;
1541 struct tlist
*next
= add
->next
;
1544 if (! exclude_writer
|| add
->writer
!= exclude_writer
)
1545 *to
= copy
? new_tlist (*to
, add
->expr
, add
->writer
) : add
;
1550 /* Merge the nodes of ADD into TO. This merging process is done so that for
1551 each variable that already exists in TO, no new node is added; however if
1552 there is a write access recorded in ADD, and an occurrence on TO is only
1553 a read access, then the occurrence in TO will be modified to record the
1557 merge_tlist (to
, add
, copy
)
1562 struct tlist
**end
= to
;
1565 end
= &(*end
)->next
;
1571 struct tlist
*next
= add
->next
;
1573 for (tmp2
= *to
; tmp2
; tmp2
= tmp2
->next
)
1574 if (tmp2
->expr
== add
->expr
)
1578 tmp2
->writer
= add
->writer
;
1582 *end
= copy
? add
: new_tlist (NULL
, add
->expr
, add
->writer
);
1583 end
= &(*end
)->next
;
1590 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
1591 references in list LIST conflict with it, excluding reads if ONLY writers
1595 warn_for_collisions_1 (written
, writer
, list
, only_writes
)
1596 tree written
, writer
;
1602 /* Avoid duplicate warnings. */
1603 for (tmp
= warned_ids
; tmp
; tmp
= tmp
->next
)
1604 if (tmp
->expr
== written
)
1609 if (list
->expr
== written
1610 && list
->writer
!= writer
1611 && (! only_writes
|| list
->writer
))
1613 warned_ids
= new_tlist (warned_ids
, written
, NULL_TREE
);
1614 warning ("operation on `%s' may be undefined",
1615 IDENTIFIER_POINTER (DECL_NAME (list
->expr
)));
1621 /* Given a list LIST of references to variables, find whether any of these
1622 can cause conflicts due to missing sequence points. */
1625 warn_for_collisions (list
)
1630 for (tmp
= list
; tmp
; tmp
= tmp
->next
)
1633 warn_for_collisions_1 (tmp
->expr
, tmp
->writer
, list
, 0);
1637 /* Return nonzero if X is a tree that can be verified by the sequence point
1640 warning_candidate_p (x
)
1643 return TREE_CODE (x
) == VAR_DECL
|| TREE_CODE (x
) == PARM_DECL
;
1646 /* Walk the tree X, and record accesses to variables. If X is written by the
1647 parent tree, WRITER is the parent.
1648 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
1649 expression or its only operand forces a sequence point, then everything up
1650 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
1652 Once we return, we will have emitted warnings if any subexpression before
1653 such a sequence point could be undefined. On a higher level, however, the
1654 sequence point may not be relevant, and we'll merge the two lists.
1656 Example: (b++, a) + b;
1657 The call that processes the COMPOUND_EXPR will store the increment of B
1658 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
1659 processes the PLUS_EXPR will need to merge the two lists so that
1660 eventually, all accesses end up on the same list (and we'll warn about the
1661 unordered subexpressions b++ and b.
1663 A note on merging. If we modify the former example so that our expression
1666 care must be taken not simply to add all three expressions into the final
1667 PNO_SP list. The function merge_tlist takes care of that by merging the
1668 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1669 way, so that no more than one access to B is recorded. */
1672 verify_tree (x
, pbefore_sp
, pno_sp
, writer
)
1674 struct tlist
**pbefore_sp
, **pno_sp
;
1677 struct tlist
*tmp_before
, *tmp_nosp
, *tmp_list2
, *tmp_list3
;
1678 enum tree_code code
;
1681 /* X may be NULL if it is the operand of an empty statement expression
1687 code
= TREE_CODE (x
);
1688 class = TREE_CODE_CLASS (code
);
1690 if (warning_candidate_p (x
))
1692 *pno_sp
= new_tlist (*pno_sp
, x
, writer
);
1702 case TRUTH_ANDIF_EXPR
:
1703 case TRUTH_ORIF_EXPR
:
1704 tmp_before
= tmp_nosp
= tmp_list3
= 0;
1705 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1706 warn_for_collisions (tmp_nosp
);
1707 merge_tlist (pbefore_sp
, tmp_before
, 0);
1708 merge_tlist (pbefore_sp
, tmp_nosp
, 0);
1709 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, pno_sp
, NULL_TREE
);
1710 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1714 tmp_before
= tmp_list2
= 0;
1715 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_list2
, NULL_TREE
);
1716 warn_for_collisions (tmp_list2
);
1717 merge_tlist (pbefore_sp
, tmp_before
, 0);
1718 merge_tlist (pbefore_sp
, tmp_list2
, 1);
1720 tmp_list3
= tmp_nosp
= 0;
1721 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, &tmp_nosp
, NULL_TREE
);
1722 warn_for_collisions (tmp_nosp
);
1723 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1725 tmp_list3
= tmp_list2
= 0;
1726 verify_tree (TREE_OPERAND (x
, 2), &tmp_list3
, &tmp_list2
, NULL_TREE
);
1727 warn_for_collisions (tmp_list2
);
1728 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1729 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1730 two first, to avoid warning for (a ? b++ : b++). */
1731 merge_tlist (&tmp_nosp
, tmp_list2
, 0);
1732 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1735 case PREDECREMENT_EXPR
:
1736 case PREINCREMENT_EXPR
:
1737 case POSTDECREMENT_EXPR
:
1738 case POSTINCREMENT_EXPR
:
1739 verify_tree (TREE_OPERAND (x
, 0), pno_sp
, pno_sp
, x
);
1743 tmp_before
= tmp_nosp
= tmp_list3
= 0;
1744 verify_tree (TREE_OPERAND (x
, 1), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1745 verify_tree (TREE_OPERAND (x
, 0), &tmp_list3
, &tmp_list3
, x
);
1746 /* Expressions inside the LHS are not ordered wrt. the sequence points
1747 in the RHS. Example:
1749 Despite the fact that the modification of "a" is in the before_sp
1750 list (tmp_before), it conflicts with the use of "a" in the LHS.
1751 We can handle this by adding the contents of tmp_list3
1752 to those of tmp_before, and redoing the collision warnings for that
1754 add_tlist (&tmp_before
, tmp_list3
, x
, 1);
1755 warn_for_collisions (tmp_before
);
1756 /* Exclude the LHS itself here; we first have to merge it into the
1757 tmp_nosp list. This is done to avoid warning for "a = a"; if we
1758 didn't exclude the LHS, we'd get it twice, once as a read and once
1760 add_tlist (pno_sp
, tmp_list3
, x
, 0);
1761 warn_for_collisions_1 (TREE_OPERAND (x
, 0), x
, tmp_nosp
, 1);
1763 merge_tlist (pbefore_sp
, tmp_before
, 0);
1764 if (warning_candidate_p (TREE_OPERAND (x
, 0)))
1765 merge_tlist (&tmp_nosp
, new_tlist (NULL
, TREE_OPERAND (x
, 0), x
), 0);
1766 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 1);
1770 /* We need to warn about conflicts among arguments and conflicts between
1771 args and the function address. Side effects of the function address,
1772 however, are not ordered by the sequence point of the call. */
1773 tmp_before
= tmp_nosp
= tmp_list2
= tmp_list3
= 0;
1774 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1775 if (TREE_OPERAND (x
, 1))
1776 verify_tree (TREE_OPERAND (x
, 1), &tmp_list2
, &tmp_list3
, NULL_TREE
);
1777 merge_tlist (&tmp_list3
, tmp_list2
, 0);
1778 add_tlist (&tmp_before
, tmp_list3
, NULL_TREE
, 0);
1779 add_tlist (&tmp_before
, tmp_nosp
, NULL_TREE
, 0);
1780 warn_for_collisions (tmp_before
);
1781 add_tlist (pbefore_sp
, tmp_before
, NULL_TREE
, 0);
1785 /* Scan all the list, e.g. indices of multi dimensional array. */
1788 tmp_before
= tmp_nosp
= 0;
1789 verify_tree (TREE_VALUE (x
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1790 merge_tlist (&tmp_nosp
, tmp_before
, 0);
1791 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1798 struct tlist_cache
*t
;
1799 for (t
= save_expr_cache
; t
; t
= t
->next
)
1805 t
= (struct tlist_cache
*) obstack_alloc (&tlist_obstack
,
1807 t
->next
= save_expr_cache
;
1809 save_expr_cache
= t
;
1811 tmp_before
= tmp_nosp
= 0;
1812 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1813 warn_for_collisions (tmp_nosp
);
1818 struct tlist
*t
= tmp_nosp
;
1820 merge_tlist (&tmp_list3
, t
, 0);
1822 t
->cache_before_sp
= tmp_before
;
1823 t
->cache_after_sp
= tmp_list3
;
1825 merge_tlist (pbefore_sp
, t
->cache_before_sp
, 1);
1826 add_tlist (pno_sp
, t
->cache_after_sp
, NULL_TREE
, 1);
1835 if (first_rtl_op (code
) == 0)
1837 x
= TREE_OPERAND (x
, 0);
1853 int max
= first_rtl_op (TREE_CODE (x
));
1854 for (lp
= 0; lp
< max
; lp
++)
1856 tmp_before
= tmp_nosp
= 0;
1857 verify_tree (TREE_OPERAND (x
, lp
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1858 merge_tlist (&tmp_nosp
, tmp_before
, 0);
1859 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1866 /* Try to warn for undefined behavior in EXPR due to missing sequence
1870 verify_sequence_points (expr
)
1873 struct tlist
*before_sp
= 0, *after_sp
= 0;
1876 save_expr_cache
= 0;
1877 if (tlist_firstobj
== 0)
1879 gcc_obstack_init (&tlist_obstack
);
1880 tlist_firstobj
= obstack_alloc (&tlist_obstack
, 0);
1883 verify_tree (expr
, &before_sp
, &after_sp
, 0);
1884 warn_for_collisions (after_sp
);
1885 obstack_free (&tlist_obstack
, tlist_firstobj
);
1889 c_expand_expr_stmt (expr
)
1892 /* Do default conversion if safe and possibly important,
1893 in case within ({...}). */
1894 if ((TREE_CODE (TREE_TYPE (expr
)) == ARRAY_TYPE
1895 && (flag_isoc99
|| lvalue_p (expr
)))
1896 || TREE_CODE (TREE_TYPE (expr
)) == FUNCTION_TYPE
)
1897 expr
= default_conversion (expr
);
1899 if (warn_sequence_point
)
1900 verify_sequence_points (expr
);
1902 if (TREE_TYPE (expr
) != error_mark_node
1903 && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr
))
1904 && TREE_CODE (TREE_TYPE (expr
)) != ARRAY_TYPE
)
1905 error ("expression statement has incomplete type");
1907 last_expr_type
= TREE_TYPE (expr
);
1908 return add_stmt (build_stmt (EXPR_STMT
, expr
));
1911 /* Validate the expression after `case' and apply default promotions. */
1914 check_case_value (value
)
1917 if (value
== NULL_TREE
)
1920 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
1921 STRIP_TYPE_NOPS (value
);
1922 /* In C++, the following is allowed:
1925 switch (...) { case i: ... }
1927 So, we try to reduce the VALUE to a constant that way. */
1928 if (c_language
== clk_cplusplus
)
1930 value
= decl_constant_value (value
);
1931 STRIP_TYPE_NOPS (value
);
1932 value
= fold (value
);
1935 if (TREE_CODE (value
) != INTEGER_CST
1936 && value
!= error_mark_node
)
1938 error ("case label does not reduce to an integer constant");
1939 value
= error_mark_node
;
1942 /* Promote char or short to int. */
1943 value
= default_conversion (value
);
1945 constant_expression_warning (value
);
1950 /* Return an integer type with BITS bits of precision,
1951 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1954 c_common_type_for_size (bits
, unsignedp
)
1958 if (bits
== TYPE_PRECISION (integer_type_node
))
1959 return unsignedp
? unsigned_type_node
: integer_type_node
;
1961 if (bits
== TYPE_PRECISION (signed_char_type_node
))
1962 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1964 if (bits
== TYPE_PRECISION (short_integer_type_node
))
1965 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1967 if (bits
== TYPE_PRECISION (long_integer_type_node
))
1968 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1970 if (bits
== TYPE_PRECISION (long_long_integer_type_node
))
1971 return (unsignedp
? long_long_unsigned_type_node
1972 : long_long_integer_type_node
);
1974 if (bits
== TYPE_PRECISION (widest_integer_literal_type_node
))
1975 return (unsignedp
? widest_unsigned_literal_type_node
1976 : widest_integer_literal_type_node
);
1978 if (bits
<= TYPE_PRECISION (intQI_type_node
))
1979 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
1981 if (bits
<= TYPE_PRECISION (intHI_type_node
))
1982 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
1984 if (bits
<= TYPE_PRECISION (intSI_type_node
))
1985 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
1987 if (bits
<= TYPE_PRECISION (intDI_type_node
))
1988 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
1993 /* Return a data type that has machine mode MODE.
1994 If the mode is an integer,
1995 then UNSIGNEDP selects between signed and unsigned types. */
1998 c_common_type_for_mode (mode
, unsignedp
)
1999 enum machine_mode mode
;
2002 if (mode
== TYPE_MODE (integer_type_node
))
2003 return unsignedp
? unsigned_type_node
: integer_type_node
;
2005 if (mode
== TYPE_MODE (signed_char_type_node
))
2006 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2008 if (mode
== TYPE_MODE (short_integer_type_node
))
2009 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2011 if (mode
== TYPE_MODE (long_integer_type_node
))
2012 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2014 if (mode
== TYPE_MODE (long_long_integer_type_node
))
2015 return unsignedp
? long_long_unsigned_type_node
: long_long_integer_type_node
;
2017 if (mode
== TYPE_MODE (widest_integer_literal_type_node
))
2018 return unsignedp
? widest_unsigned_literal_type_node
2019 : widest_integer_literal_type_node
;
2022 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2025 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2028 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2031 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2033 #if HOST_BITS_PER_WIDE_INT >= 64
2034 if (mode
== TYPE_MODE (intTI_type_node
))
2035 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2038 if (mode
== TYPE_MODE (float_type_node
))
2039 return float_type_node
;
2041 if (mode
== TYPE_MODE (double_type_node
))
2042 return double_type_node
;
2044 if (mode
== TYPE_MODE (long_double_type_node
))
2045 return long_double_type_node
;
2047 if (mode
== TYPE_MODE (build_pointer_type (char_type_node
)))
2048 return build_pointer_type (char_type_node
);
2050 if (mode
== TYPE_MODE (build_pointer_type (integer_type_node
)))
2051 return build_pointer_type (integer_type_node
);
2056 return unsignedp
? unsigned_V16QI_type_node
: V16QI_type_node
;
2058 return unsignedp
? unsigned_V8HI_type_node
: V8HI_type_node
;
2060 return unsignedp
? unsigned_V4SI_type_node
: V4SI_type_node
;
2062 return unsignedp
? unsigned_V2DI_type_node
: V2DI_type_node
;
2064 return unsignedp
? unsigned_V2SI_type_node
: V2SI_type_node
;
2066 return unsignedp
? unsigned_V2HI_type_node
: V2HI_type_node
;
2068 return unsignedp
? unsigned_V4HI_type_node
: V4HI_type_node
;
2070 return unsignedp
? unsigned_V8QI_type_node
: V8QI_type_node
;
2072 return unsignedp
? unsigned_V1DI_type_node
: V1DI_type_node
;
2074 return V16SF_type_node
;
2076 return V4SF_type_node
;
2078 return V2SF_type_node
;
2080 return V2DF_type_node
;
2088 /* Return an unsigned type the same as TYPE in other respects. */
2090 c_common_unsigned_type (type
)
2093 tree type1
= TYPE_MAIN_VARIANT (type
);
2094 if (type1
== signed_char_type_node
|| type1
== char_type_node
)
2095 return unsigned_char_type_node
;
2096 if (type1
== integer_type_node
)
2097 return unsigned_type_node
;
2098 if (type1
== short_integer_type_node
)
2099 return short_unsigned_type_node
;
2100 if (type1
== long_integer_type_node
)
2101 return long_unsigned_type_node
;
2102 if (type1
== long_long_integer_type_node
)
2103 return long_long_unsigned_type_node
;
2104 if (type1
== widest_integer_literal_type_node
)
2105 return widest_unsigned_literal_type_node
;
2106 #if HOST_BITS_PER_WIDE_INT >= 64
2107 if (type1
== intTI_type_node
)
2108 return unsigned_intTI_type_node
;
2110 if (type1
== intDI_type_node
)
2111 return unsigned_intDI_type_node
;
2112 if (type1
== intSI_type_node
)
2113 return unsigned_intSI_type_node
;
2114 if (type1
== intHI_type_node
)
2115 return unsigned_intHI_type_node
;
2116 if (type1
== intQI_type_node
)
2117 return unsigned_intQI_type_node
;
2119 return c_common_signed_or_unsigned_type (1, type
);
2122 /* Return a signed type the same as TYPE in other respects. */
2125 c_common_signed_type (type
)
2128 tree type1
= TYPE_MAIN_VARIANT (type
);
2129 if (type1
== unsigned_char_type_node
|| type1
== char_type_node
)
2130 return signed_char_type_node
;
2131 if (type1
== unsigned_type_node
)
2132 return integer_type_node
;
2133 if (type1
== short_unsigned_type_node
)
2134 return short_integer_type_node
;
2135 if (type1
== long_unsigned_type_node
)
2136 return long_integer_type_node
;
2137 if (type1
== long_long_unsigned_type_node
)
2138 return long_long_integer_type_node
;
2139 if (type1
== widest_unsigned_literal_type_node
)
2140 return widest_integer_literal_type_node
;
2141 #if HOST_BITS_PER_WIDE_INT >= 64
2142 if (type1
== unsigned_intTI_type_node
)
2143 return intTI_type_node
;
2145 if (type1
== unsigned_intDI_type_node
)
2146 return intDI_type_node
;
2147 if (type1
== unsigned_intSI_type_node
)
2148 return intSI_type_node
;
2149 if (type1
== unsigned_intHI_type_node
)
2150 return intHI_type_node
;
2151 if (type1
== unsigned_intQI_type_node
)
2152 return intQI_type_node
;
2154 return c_common_signed_or_unsigned_type (0, type
);
2157 /* Return a type the same as TYPE except unsigned or
2158 signed according to UNSIGNEDP. */
2161 c_common_signed_or_unsigned_type (unsignedp
, type
)
2165 if (! INTEGRAL_TYPE_P (type
)
2166 || TREE_UNSIGNED (type
) == unsignedp
)
2169 if (TYPE_PRECISION (type
) == TYPE_PRECISION (signed_char_type_node
))
2170 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2171 if (TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
))
2172 return unsignedp
? unsigned_type_node
: integer_type_node
;
2173 if (TYPE_PRECISION (type
) == TYPE_PRECISION (short_integer_type_node
))
2174 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2175 if (TYPE_PRECISION (type
) == TYPE_PRECISION (long_integer_type_node
))
2176 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2177 if (TYPE_PRECISION (type
) == TYPE_PRECISION (long_long_integer_type_node
))
2178 return (unsignedp
? long_long_unsigned_type_node
2179 : long_long_integer_type_node
);
2180 if (TYPE_PRECISION (type
) == TYPE_PRECISION (widest_integer_literal_type_node
))
2181 return (unsignedp
? widest_unsigned_literal_type_node
2182 : widest_integer_literal_type_node
);
2184 #if HOST_BITS_PER_WIDE_INT >= 64
2185 if (TYPE_PRECISION (type
) == TYPE_PRECISION (intTI_type_node
))
2186 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2188 if (TYPE_PRECISION (type
) == TYPE_PRECISION (intDI_type_node
))
2189 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2190 if (TYPE_PRECISION (type
) == TYPE_PRECISION (intSI_type_node
))
2191 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2192 if (TYPE_PRECISION (type
) == TYPE_PRECISION (intHI_type_node
))
2193 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2194 if (TYPE_PRECISION (type
) == TYPE_PRECISION (intQI_type_node
))
2195 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2200 /* Return the minimum number of bits needed to represent VALUE in a
2201 signed or unsigned type, UNSIGNEDP says which. */
2204 min_precision (value
, unsignedp
)
2210 /* If the value is negative, compute its negative minus 1. The latter
2211 adjustment is because the absolute value of the largest negative value
2212 is one larger than the largest positive value. This is equivalent to
2213 a bit-wise negation, so use that operation instead. */
2215 if (tree_int_cst_sgn (value
) < 0)
2216 value
= fold (build1 (BIT_NOT_EXPR
, TREE_TYPE (value
), value
));
2218 /* Return the number of bits needed, taking into account the fact
2219 that we need one more bit for a signed than unsigned type. */
2221 if (integer_zerop (value
))
2224 log
= tree_floor_log2 (value
);
2226 return log
+ 1 + ! unsignedp
;
2229 /* Print an error message for invalid operands to arith operation
2230 CODE. NOP_EXPR is used as a special case (see
2231 c_common_truthvalue_conversion). */
2234 binary_op_error (code
)
2235 enum tree_code code
;
2242 error ("invalid truth-value expression");
2246 opname
= "+"; break;
2248 opname
= "-"; break;
2250 opname
= "*"; break;
2252 opname
= "max"; break;
2254 opname
= "min"; break;
2256 opname
= "=="; break;
2258 opname
= "!="; break;
2260 opname
= "<="; break;
2262 opname
= ">="; break;
2264 opname
= "<"; break;
2266 opname
= ">"; break;
2268 opname
= "<<"; break;
2270 opname
= ">>"; break;
2271 case TRUNC_MOD_EXPR
:
2272 case FLOOR_MOD_EXPR
:
2273 opname
= "%"; break;
2274 case TRUNC_DIV_EXPR
:
2275 case FLOOR_DIV_EXPR
:
2276 opname
= "/"; break;
2278 opname
= "&"; break;
2280 opname
= "|"; break;
2281 case TRUTH_ANDIF_EXPR
:
2282 opname
= "&&"; break;
2283 case TRUTH_ORIF_EXPR
:
2284 opname
= "||"; break;
2286 opname
= "^"; break;
2289 opname
= "rotate"; break;
2291 opname
= "unknown"; break;
2293 error ("invalid operands to binary %s", opname
);
2296 /* Subroutine of build_binary_op, used for comparison operations.
2297 See if the operands have both been converted from subword integer types
2298 and, if so, perhaps change them both back to their original type.
2299 This function is also responsible for converting the two operands
2300 to the proper common type for comparison.
2302 The arguments of this function are all pointers to local variables
2303 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2304 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2306 If this function returns nonzero, it means that the comparison has
2307 a constant value. What this function returns is an expression for
2311 shorten_compare (op0_ptr
, op1_ptr
, restype_ptr
, rescode_ptr
)
2312 tree
*op0_ptr
, *op1_ptr
;
2314 enum tree_code
*rescode_ptr
;
2317 tree op0
= *op0_ptr
;
2318 tree op1
= *op1_ptr
;
2319 int unsignedp0
, unsignedp1
;
2321 tree primop0
, primop1
;
2322 enum tree_code code
= *rescode_ptr
;
2324 /* Throw away any conversions to wider types
2325 already present in the operands. */
2327 primop0
= get_narrower (op0
, &unsignedp0
);
2328 primop1
= get_narrower (op1
, &unsignedp1
);
2330 /* Handle the case that OP0 does not *contain* a conversion
2331 but it *requires* conversion to FINAL_TYPE. */
2333 if (op0
== primop0
&& TREE_TYPE (op0
) != *restype_ptr
)
2334 unsignedp0
= TREE_UNSIGNED (TREE_TYPE (op0
));
2335 if (op1
== primop1
&& TREE_TYPE (op1
) != *restype_ptr
)
2336 unsignedp1
= TREE_UNSIGNED (TREE_TYPE (op1
));
2338 /* If one of the operands must be floated, we cannot optimize. */
2339 real1
= TREE_CODE (TREE_TYPE (primop0
)) == REAL_TYPE
;
2340 real2
= TREE_CODE (TREE_TYPE (primop1
)) == REAL_TYPE
;
2342 /* If first arg is constant, swap the args (changing operation
2343 so value is preserved), for canonicalization. Don't do this if
2344 the second arg is 0. */
2346 if (TREE_CONSTANT (primop0
)
2347 && ! integer_zerop (primop1
) && ! real_zerop (primop1
))
2350 int temi
= unsignedp0
;
2358 unsignedp0
= unsignedp1
;
2381 *rescode_ptr
= code
;
2384 /* If comparing an integer against a constant more bits wide,
2385 maybe we can deduce a value of 1 or 0 independent of the data.
2386 Or else truncate the constant now
2387 rather than extend the variable at run time.
2389 This is only interesting if the constant is the wider arg.
2390 Also, it is not safe if the constant is unsigned and the
2391 variable arg is signed, since in this case the variable
2392 would be sign-extended and then regarded as unsigned.
2393 Our technique fails in this case because the lowest/highest
2394 possible unsigned results don't follow naturally from the
2395 lowest/highest possible values of the variable operand.
2396 For just EQ_EXPR and NE_EXPR there is another technique that
2397 could be used: see if the constant can be faithfully represented
2398 in the other operand's type, by truncating it and reextending it
2399 and see if that preserves the constant's value. */
2401 if (!real1
&& !real2
2402 && TREE_CODE (primop1
) == INTEGER_CST
2403 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
))
2405 int min_gt
, max_gt
, min_lt
, max_lt
;
2406 tree maxval
, minval
;
2407 /* 1 if comparison is nominally unsigned. */
2408 int unsignedp
= TREE_UNSIGNED (*restype_ptr
);
2411 type
= c_common_signed_or_unsigned_type (unsignedp0
,
2412 TREE_TYPE (primop0
));
2414 /* If TYPE is an enumeration, then we need to get its min/max
2415 values from it's underlying integral type, not the enumerated
2417 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
2418 type
= c_common_type_for_size (TYPE_PRECISION (type
), unsignedp0
);
2420 maxval
= TYPE_MAX_VALUE (type
);
2421 minval
= TYPE_MIN_VALUE (type
);
2423 if (unsignedp
&& !unsignedp0
)
2424 *restype_ptr
= c_common_signed_type (*restype_ptr
);
2426 if (TREE_TYPE (primop1
) != *restype_ptr
)
2427 primop1
= convert (*restype_ptr
, primop1
);
2428 if (type
!= *restype_ptr
)
2430 minval
= convert (*restype_ptr
, minval
);
2431 maxval
= convert (*restype_ptr
, maxval
);
2434 if (unsignedp
&& unsignedp0
)
2436 min_gt
= INT_CST_LT_UNSIGNED (primop1
, minval
);
2437 max_gt
= INT_CST_LT_UNSIGNED (primop1
, maxval
);
2438 min_lt
= INT_CST_LT_UNSIGNED (minval
, primop1
);
2439 max_lt
= INT_CST_LT_UNSIGNED (maxval
, primop1
);
2443 min_gt
= INT_CST_LT (primop1
, minval
);
2444 max_gt
= INT_CST_LT (primop1
, maxval
);
2445 min_lt
= INT_CST_LT (minval
, primop1
);
2446 max_lt
= INT_CST_LT (maxval
, primop1
);
2450 /* This used to be a switch, but Genix compiler can't handle that. */
2451 if (code
== NE_EXPR
)
2453 if (max_lt
|| min_gt
)
2454 val
= boolean_true_node
;
2456 else if (code
== EQ_EXPR
)
2458 if (max_lt
|| min_gt
)
2459 val
= boolean_false_node
;
2461 else if (code
== LT_EXPR
)
2464 val
= boolean_true_node
;
2466 val
= boolean_false_node
;
2468 else if (code
== GT_EXPR
)
2471 val
= boolean_true_node
;
2473 val
= boolean_false_node
;
2475 else if (code
== LE_EXPR
)
2478 val
= boolean_true_node
;
2480 val
= boolean_false_node
;
2482 else if (code
== GE_EXPR
)
2485 val
= boolean_true_node
;
2487 val
= boolean_false_node
;
2490 /* If primop0 was sign-extended and unsigned comparison specd,
2491 we did a signed comparison above using the signed type bounds.
2492 But the comparison we output must be unsigned.
2494 Also, for inequalities, VAL is no good; but if the signed
2495 comparison had *any* fixed result, it follows that the
2496 unsigned comparison just tests the sign in reverse
2497 (positive values are LE, negative ones GE).
2498 So we can generate an unsigned comparison
2499 against an extreme value of the signed type. */
2501 if (unsignedp
&& !unsignedp0
)
2508 primop1
= TYPE_MIN_VALUE (type
);
2514 primop1
= TYPE_MAX_VALUE (type
);
2521 type
= c_common_unsigned_type (type
);
2524 if (TREE_CODE (primop0
) != INTEGER_CST
)
2526 if (val
== boolean_false_node
)
2527 warning ("comparison is always false due to limited range of data type");
2528 if (val
== boolean_true_node
)
2529 warning ("comparison is always true due to limited range of data type");
2534 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2535 if (TREE_SIDE_EFFECTS (primop0
))
2536 return build (COMPOUND_EXPR
, TREE_TYPE (val
), primop0
, val
);
2540 /* Value is not predetermined, but do the comparison
2541 in the type of the operand that is not constant.
2542 TYPE is already properly set. */
2544 else if (real1
&& real2
2545 && (TYPE_PRECISION (TREE_TYPE (primop0
))
2546 == TYPE_PRECISION (TREE_TYPE (primop1
))))
2547 type
= TREE_TYPE (primop0
);
2549 /* If args' natural types are both narrower than nominal type
2550 and both extend in the same manner, compare them
2551 in the type of the wider arg.
2552 Otherwise must actually extend both to the nominal
2553 common type lest different ways of extending
2555 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
2557 else if (unsignedp0
== unsignedp1
&& real1
== real2
2558 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
)
2559 && TYPE_PRECISION (TREE_TYPE (primop1
)) < TYPE_PRECISION (*restype_ptr
))
2561 type
= common_type (TREE_TYPE (primop0
), TREE_TYPE (primop1
));
2562 type
= c_common_signed_or_unsigned_type (unsignedp0
2563 || TREE_UNSIGNED (*restype_ptr
),
2565 /* Make sure shorter operand is extended the right way
2566 to match the longer operand. */
2568 = convert (c_common_signed_or_unsigned_type (unsignedp0
,
2569 TREE_TYPE (primop0
)),
2572 = convert (c_common_signed_or_unsigned_type (unsignedp1
,
2573 TREE_TYPE (primop1
)),
2578 /* Here we must do the comparison on the nominal type
2579 using the args exactly as we received them. */
2580 type
= *restype_ptr
;
2584 if (!real1
&& !real2
&& integer_zerop (primop1
)
2585 && TREE_UNSIGNED (*restype_ptr
))
2591 /* All unsigned values are >= 0, so we warn if extra warnings
2592 are requested. However, if OP0 is a constant that is
2593 >= 0, the signedness of the comparison isn't an issue,
2594 so suppress the warning. */
2595 if (extra_warnings
&& !in_system_header
2596 && ! (TREE_CODE (primop0
) == INTEGER_CST
2597 && ! TREE_OVERFLOW (convert (c_common_signed_type (type
),
2599 warning ("comparison of unsigned expression >= 0 is always true");
2600 value
= boolean_true_node
;
2604 if (extra_warnings
&& !in_system_header
2605 && ! (TREE_CODE (primop0
) == INTEGER_CST
2606 && ! TREE_OVERFLOW (convert (c_common_signed_type (type
),
2608 warning ("comparison of unsigned expression < 0 is always false");
2609 value
= boolean_false_node
;
2618 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2619 if (TREE_SIDE_EFFECTS (primop0
))
2620 return build (COMPOUND_EXPR
, TREE_TYPE (value
),
2627 *op0_ptr
= convert (type
, primop0
);
2628 *op1_ptr
= convert (type
, primop1
);
2630 *restype_ptr
= boolean_type_node
;
2635 /* Return a tree for the sum or difference (RESULTCODE says which)
2636 of pointer PTROP and integer INTOP. */
2639 pointer_int_sum (resultcode
, ptrop
, intop
)
2640 enum tree_code resultcode
;
2648 /* The result is a pointer of the same type that is being added. */
2650 tree result_type
= TREE_TYPE (ptrop
);
2652 if (TREE_CODE (TREE_TYPE (result_type
)) == VOID_TYPE
)
2654 if (pedantic
|| warn_pointer_arith
)
2655 pedwarn ("pointer of type `void *' used in arithmetic");
2656 size_exp
= integer_one_node
;
2658 else if (TREE_CODE (TREE_TYPE (result_type
)) == FUNCTION_TYPE
)
2660 if (pedantic
|| warn_pointer_arith
)
2661 pedwarn ("pointer to a function used in arithmetic");
2662 size_exp
= integer_one_node
;
2664 else if (TREE_CODE (TREE_TYPE (result_type
)) == METHOD_TYPE
)
2666 if (pedantic
|| warn_pointer_arith
)
2667 pedwarn ("pointer to member function used in arithmetic");
2668 size_exp
= integer_one_node
;
2670 else if (TREE_CODE (TREE_TYPE (result_type
)) == OFFSET_TYPE
)
2672 if (pedantic
|| warn_pointer_arith
)
2673 pedwarn ("pointer to a member used in arithmetic");
2674 size_exp
= integer_one_node
;
2677 size_exp
= size_in_bytes (TREE_TYPE (result_type
));
2679 /* If what we are about to multiply by the size of the elements
2680 contains a constant term, apply distributive law
2681 and multiply that constant term separately.
2682 This helps produce common subexpressions. */
2684 if ((TREE_CODE (intop
) == PLUS_EXPR
|| TREE_CODE (intop
) == MINUS_EXPR
)
2685 && ! TREE_CONSTANT (intop
)
2686 && TREE_CONSTANT (TREE_OPERAND (intop
, 1))
2687 && TREE_CONSTANT (size_exp
)
2688 /* If the constant comes from pointer subtraction,
2689 skip this optimization--it would cause an error. */
2690 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop
, 0))) == INTEGER_TYPE
2691 /* If the constant is unsigned, and smaller than the pointer size,
2692 then we must skip this optimization. This is because it could cause
2693 an overflow error if the constant is negative but INTOP is not. */
2694 && (! TREE_UNSIGNED (TREE_TYPE (intop
))
2695 || (TYPE_PRECISION (TREE_TYPE (intop
))
2696 == TYPE_PRECISION (TREE_TYPE (ptrop
)))))
2698 enum tree_code subcode
= resultcode
;
2699 tree int_type
= TREE_TYPE (intop
);
2700 if (TREE_CODE (intop
) == MINUS_EXPR
)
2701 subcode
= (subcode
== PLUS_EXPR
? MINUS_EXPR
: PLUS_EXPR
);
2702 /* Convert both subexpression types to the type of intop,
2703 because weird cases involving pointer arithmetic
2704 can result in a sum or difference with different type args. */
2705 ptrop
= build_binary_op (subcode
, ptrop
,
2706 convert (int_type
, TREE_OPERAND (intop
, 1)), 1);
2707 intop
= convert (int_type
, TREE_OPERAND (intop
, 0));
2710 /* Convert the integer argument to a type the same size as sizetype
2711 so the multiply won't overflow spuriously. */
2713 if (TYPE_PRECISION (TREE_TYPE (intop
)) != TYPE_PRECISION (sizetype
)
2714 || TREE_UNSIGNED (TREE_TYPE (intop
)) != TREE_UNSIGNED (sizetype
))
2715 intop
= convert (c_common_type_for_size (TYPE_PRECISION (sizetype
),
2716 TREE_UNSIGNED (sizetype
)), intop
);
2718 /* Replace the integer argument with a suitable product by the object size.
2719 Do this multiplication as signed, then convert to the appropriate
2720 pointer type (actually unsigned integral). */
2722 intop
= convert (result_type
,
2723 build_binary_op (MULT_EXPR
, intop
,
2724 convert (TREE_TYPE (intop
), size_exp
), 1));
2726 /* Create the sum or difference. */
2728 result
= build (resultcode
, result_type
, ptrop
, intop
);
2730 folded
= fold (result
);
2731 if (folded
== result
)
2732 TREE_CONSTANT (folded
) = TREE_CONSTANT (ptrop
) & TREE_CONSTANT (intop
);
2736 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2737 or validate its data type for an `if' or `while' statement or ?..: exp.
2739 This preparation consists of taking the ordinary
2740 representation of an expression expr and producing a valid tree
2741 boolean expression describing whether expr is nonzero. We could
2742 simply always do build_binary_op (NE_EXPR, expr, boolean_false_node, 1),
2743 but we optimize comparisons, &&, ||, and !.
2745 The resulting type should always be `boolean_type_node'. */
2748 c_common_truthvalue_conversion (expr
)
2751 if (TREE_CODE (expr
) == ERROR_MARK
)
2754 #if 0 /* This appears to be wrong for C++. */
2755 /* These really should return error_mark_node after 2.4 is stable.
2756 But not all callers handle ERROR_MARK properly. */
2757 switch (TREE_CODE (TREE_TYPE (expr
)))
2760 error ("struct type value used where scalar is required");
2761 return boolean_false_node
;
2764 error ("union type value used where scalar is required");
2765 return boolean_false_node
;
2768 error ("array type value used where scalar is required");
2769 return boolean_false_node
;
2776 switch (TREE_CODE (expr
))
2779 case NE_EXPR
: case LE_EXPR
: case GE_EXPR
: case LT_EXPR
: case GT_EXPR
:
2780 case TRUTH_ANDIF_EXPR
:
2781 case TRUTH_ORIF_EXPR
:
2782 case TRUTH_AND_EXPR
:
2784 case TRUTH_XOR_EXPR
:
2785 case TRUTH_NOT_EXPR
:
2786 TREE_TYPE (expr
) = boolean_type_node
;
2793 return integer_zerop (expr
) ? boolean_false_node
: boolean_true_node
;
2796 return real_zerop (expr
) ? boolean_false_node
: boolean_true_node
;
2799 /* If we are taking the address of an external decl, it might be zero
2800 if it is weak, so we cannot optimize. */
2801 if (DECL_P (TREE_OPERAND (expr
, 0))
2802 && DECL_EXTERNAL (TREE_OPERAND (expr
, 0)))
2805 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 0)))
2806 return build (COMPOUND_EXPR
, boolean_type_node
,
2807 TREE_OPERAND (expr
, 0), boolean_true_node
);
2809 return boolean_true_node
;
2812 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1))
2813 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
2814 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0)),
2815 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 1)),
2823 /* These don't change whether an object is nonzero or zero. */
2824 return c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0));
2828 /* These don't change whether an object is zero or nonzero, but
2829 we can't ignore them if their second arg has side-effects. */
2830 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1)))
2831 return build (COMPOUND_EXPR
, boolean_type_node
, TREE_OPERAND (expr
, 1),
2832 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0)));
2834 return c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0));
2837 /* Distribute the conversion into the arms of a COND_EXPR. */
2838 return fold (build (COND_EXPR
, boolean_type_node
, TREE_OPERAND (expr
, 0),
2839 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 1)),
2840 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 2))));
2843 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2844 since that affects how `default_conversion' will behave. */
2845 if (TREE_CODE (TREE_TYPE (expr
)) == REFERENCE_TYPE
2846 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == REFERENCE_TYPE
)
2848 /* fall through... */
2850 /* If this is widening the argument, we can ignore it. */
2851 if (TYPE_PRECISION (TREE_TYPE (expr
))
2852 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr
, 0))))
2853 return c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0));
2857 /* Perhaps reduce (x - y) != 0 to (x != y). The expressions
2858 aren't guaranteed to the be same for modes that can represent
2859 infinity, since if x and y are both +infinity, or both
2860 -infinity, then x - y is not a number.
2862 Note that this transformation is safe when x or y is NaN.
2863 (x - y) is then NaN, and both (x - y) != 0 and x != y will
2865 if (HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr
, 0)))))
2867 /* fall through... */
2869 /* This and MINUS_EXPR can be changed into a comparison of the
2871 if (TREE_TYPE (TREE_OPERAND (expr
, 0))
2872 == TREE_TYPE (TREE_OPERAND (expr
, 1)))
2873 return build_binary_op (NE_EXPR
, TREE_OPERAND (expr
, 0),
2874 TREE_OPERAND (expr
, 1), 1);
2875 return build_binary_op (NE_EXPR
, TREE_OPERAND (expr
, 0),
2876 fold (build1 (NOP_EXPR
,
2877 TREE_TYPE (TREE_OPERAND (expr
, 0)),
2878 TREE_OPERAND (expr
, 1))), 1);
2881 if (integer_onep (TREE_OPERAND (expr
, 1))
2882 && TREE_TYPE (expr
) != boolean_type_node
)
2883 /* Using convert here would cause infinite recursion. */
2884 return build1 (NOP_EXPR
, boolean_type_node
, expr
);
2888 if (warn_parentheses
&& C_EXP_ORIGINAL_CODE (expr
) == MODIFY_EXPR
)
2889 warning ("suggest parentheses around assignment used as truth value");
2896 if (TREE_CODE (TREE_TYPE (expr
)) == COMPLEX_TYPE
)
2898 tree t
= save_expr (expr
);
2899 return (build_binary_op
2900 ((TREE_SIDE_EFFECTS (expr
)
2901 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
2902 c_common_truthvalue_conversion (build_unary_op (REALPART_EXPR
, t
, 0)),
2903 c_common_truthvalue_conversion (build_unary_op (IMAGPART_EXPR
, t
, 0)),
2907 return build_binary_op (NE_EXPR
, expr
, integer_zero_node
, 1);
2910 static tree builtin_function_2
PARAMS ((const char *, const char *, tree
, tree
,
2911 int, enum built_in_class
, int, int,
2914 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2915 down to the element type of an array. */
2918 c_build_qualified_type (type
, type_quals
)
2922 /* A restrict-qualified pointer type must be a pointer to object or
2923 incomplete type. Note that the use of POINTER_TYPE_P also allows
2924 REFERENCE_TYPEs, which is appropriate for C++. Unfortunately,
2925 the C++ front-end also use POINTER_TYPE for pointer-to-member
2926 values, so even though it should be illegal to use `restrict'
2927 with such an entity we don't flag that here. Thus, special case
2928 code for that case is required in the C++ front-end. */
2929 if ((type_quals
& TYPE_QUAL_RESTRICT
)
2930 && (!POINTER_TYPE_P (type
)
2931 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type
))))
2933 error ("invalid use of `restrict'");
2934 type_quals
&= ~TYPE_QUAL_RESTRICT
;
2937 if (TREE_CODE (type
) == ARRAY_TYPE
)
2938 return build_array_type (c_build_qualified_type (TREE_TYPE (type
),
2940 TYPE_DOMAIN (type
));
2941 return build_qualified_type (type
, type_quals
);
2944 /* Apply the TYPE_QUALS to the new DECL. */
2947 c_apply_type_quals_to_decl (type_quals
, decl
)
2951 if ((type_quals
& TYPE_QUAL_CONST
)
2952 || (TREE_TYPE (decl
)
2953 && TREE_CODE (TREE_TYPE (decl
)) == REFERENCE_TYPE
))
2954 TREE_READONLY (decl
) = 1;
2955 if (type_quals
& TYPE_QUAL_VOLATILE
)
2957 TREE_SIDE_EFFECTS (decl
) = 1;
2958 TREE_THIS_VOLATILE (decl
) = 1;
2960 if (type_quals
& TYPE_QUAL_RESTRICT
)
2962 if (!TREE_TYPE (decl
)
2963 || !POINTER_TYPE_P (TREE_TYPE (decl
))
2964 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (TREE_TYPE (decl
))))
2965 error ("invalid use of `restrict'");
2966 else if (flag_strict_aliasing
)
2967 /* Indicate we need to make a unique alias set for this pointer.
2968 We can't do it here because it might be pointing to an
2970 DECL_POINTER_ALIAS_SET (decl
) = -2;
2974 /* Return the typed-based alias set for T, which may be an expression
2975 or a type. Return -1 if we don't do anything special. */
2978 c_common_get_alias_set (t
)
2983 /* Permit type-punning when accessing a union, provided the access
2984 is directly through the union. For example, this code does not
2985 permit taking the address of a union member and then storing
2986 through it. Even the type-punning allowed here is a GCC
2987 extension, albeit a common and useful one; the C standard says
2988 that such accesses have implementation-defined behavior. */
2990 TREE_CODE (u
) == COMPONENT_REF
|| TREE_CODE (u
) == ARRAY_REF
;
2991 u
= TREE_OPERAND (u
, 0))
2992 if (TREE_CODE (u
) == COMPONENT_REF
2993 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u
, 0))) == UNION_TYPE
)
2996 /* That's all the expressions we handle specially. */
3000 /* The C standard guarantees that any object may be accessed via an
3001 lvalue that has character type. */
3002 if (t
== char_type_node
3003 || t
== signed_char_type_node
3004 || t
== unsigned_char_type_node
)
3007 /* If it has the may_alias attribute, it can alias anything. */
3008 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (t
)))
3011 /* The C standard specifically allows aliasing between signed and
3012 unsigned variants of the same type. We treat the signed
3013 variant as canonical. */
3014 if (TREE_CODE (t
) == INTEGER_TYPE
&& TREE_UNSIGNED (t
))
3016 tree t1
= c_common_signed_type (t
);
3018 /* t1 == t can happen for boolean nodes which are always unsigned. */
3020 return get_alias_set (t1
);
3022 else if (POINTER_TYPE_P (t
))
3026 /* Unfortunately, there is no canonical form of a pointer type.
3027 In particular, if we have `typedef int I', then `int *', and
3028 `I *' are different types. So, we have to pick a canonical
3029 representative. We do this below.
3031 Technically, this approach is actually more conservative that
3032 it needs to be. In particular, `const int *' and `int *'
3033 should be in different alias sets, according to the C and C++
3034 standard, since their types are not the same, and so,
3035 technically, an `int **' and `const int **' cannot point at
3038 But, the standard is wrong. In particular, this code is
3043 const int* const* cipp = &ipp;
3045 And, it doesn't make sense for that to be legal unless you
3046 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
3047 the pointed-to types. This issue has been reported to the
3049 t1
= build_type_no_quals (t
);
3051 return get_alias_set (t1
);
3057 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
3058 second parameter indicates which OPERATOR is being applied. The COMPLAIN
3059 flag controls whether we should diagnose possibly ill-formed
3060 constructs or not. */
3062 c_sizeof_or_alignof_type (type
, op
, complain
)
3067 const char *op_name
;
3069 enum tree_code type_code
= TREE_CODE (type
);
3071 my_friendly_assert (op
== SIZEOF_EXPR
|| op
== ALIGNOF_EXPR
, 20020720);
3072 op_name
= op
== SIZEOF_EXPR
? "sizeof" : "__alignof__";
3074 if (type_code
== FUNCTION_TYPE
)
3076 if (op
== SIZEOF_EXPR
)
3078 if (complain
&& (pedantic
|| warn_pointer_arith
))
3079 pedwarn ("invalid application of `sizeof' to a function type");
3080 value
= size_one_node
;
3083 value
= size_int (FUNCTION_BOUNDARY
/ BITS_PER_UNIT
);
3085 else if (type_code
== VOID_TYPE
|| type_code
== ERROR_MARK
)
3087 if (type_code
== VOID_TYPE
3088 && complain
&& (pedantic
|| warn_pointer_arith
))
3089 pedwarn ("invalid application of `%s' to a void type", op_name
);
3090 value
= size_one_node
;
3092 else if (!COMPLETE_TYPE_P (type
))
3095 error ("invalid application of `%s' to an incomplete type", op_name
);
3096 value
= size_zero_node
;
3100 if (op
== SIZEOF_EXPR
)
3101 /* Convert in case a char is more than one unit. */
3102 value
= size_binop (CEIL_DIV_EXPR
, TYPE_SIZE_UNIT (type
),
3103 size_int (TYPE_PRECISION (char_type_node
)
3106 value
= size_int (TYPE_ALIGN (type
) / BITS_PER_UNIT
);
3109 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
3110 TYPE_IS_SIZETYPE means that certain things (like overflow) will
3111 never happen. However, this node should really have type
3112 `size_t', which is just a typedef for an ordinary integer type. */
3113 value
= fold (build1 (NOP_EXPR
, size_type_node
, value
));
3114 my_friendly_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value
)), 20001021);
3119 /* Implement the __alignof keyword: Return the minimum required
3120 alignment of EXPR, measured in bytes. For VAR_DECL's and
3121 FIELD_DECL's return DECL_ALIGN (which can be set from an
3122 "aligned" __attribute__ specification). */
3125 c_alignof_expr (expr
)
3130 if (TREE_CODE (expr
) == VAR_DECL
)
3131 t
= size_int (DECL_ALIGN (expr
) / BITS_PER_UNIT
);
3133 else if (TREE_CODE (expr
) == COMPONENT_REF
3134 && DECL_C_BIT_FIELD (TREE_OPERAND (expr
, 1)))
3136 error ("`__alignof' applied to a bit-field");
3139 else if (TREE_CODE (expr
) == COMPONENT_REF
3140 && TREE_CODE (TREE_OPERAND (expr
, 1)) == FIELD_DECL
)
3141 t
= size_int (DECL_ALIGN (TREE_OPERAND (expr
, 1)) / BITS_PER_UNIT
);
3143 else if (TREE_CODE (expr
) == INDIRECT_REF
)
3145 tree t
= TREE_OPERAND (expr
, 0);
3147 int bestalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
3149 while (TREE_CODE (t
) == NOP_EXPR
3150 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0))) == POINTER_TYPE
)
3154 t
= TREE_OPERAND (t
, 0);
3155 thisalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
3156 if (thisalign
> bestalign
)
3157 best
= t
, bestalign
= thisalign
;
3159 return c_alignof (TREE_TYPE (TREE_TYPE (best
)));
3162 return c_alignof (TREE_TYPE (expr
));
3164 return fold (build1 (NOP_EXPR
, size_type_node
, t
));
3167 /* Handle C and C++ default attributes. */
3169 enum built_in_attribute
3171 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
3172 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
3173 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
3174 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
3175 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No entry needed in enum. */
3176 #include "builtin-attrs.def"
3177 #undef DEF_ATTR_NULL_TREE
3179 #undef DEF_ATTR_IDENT
3180 #undef DEF_ATTR_TREE_LIST
3185 static GTY(()) tree built_in_attributes
[(int) ATTR_LAST
];
3187 static bool c_attrs_initialized
= false;
3189 static void c_init_attributes
PARAMS ((void));
3191 /* Build tree nodes and builtin functions common to both C and C++ language
3195 c_common_nodes_and_builtins ()
3199 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
3200 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
3201 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
3202 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
3203 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3204 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3205 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
3206 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
3207 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
3208 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3209 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
3210 #include "builtin-types.def"
3211 #undef DEF_PRIMITIVE_TYPE
3212 #undef DEF_FUNCTION_TYPE_0
3213 #undef DEF_FUNCTION_TYPE_1
3214 #undef DEF_FUNCTION_TYPE_2
3215 #undef DEF_FUNCTION_TYPE_3
3216 #undef DEF_FUNCTION_TYPE_4
3217 #undef DEF_FUNCTION_TYPE_VAR_0
3218 #undef DEF_FUNCTION_TYPE_VAR_1
3219 #undef DEF_FUNCTION_TYPE_VAR_2
3220 #undef DEF_FUNCTION_TYPE_VAR_3
3221 #undef DEF_POINTER_TYPE
3225 typedef enum builtin_type builtin_type
;
3227 tree builtin_types
[(int) BT_LAST
];
3228 int wchar_type_size
;
3229 tree array_domain_type
;
3230 tree va_list_ref_type_node
;
3231 tree va_list_arg_type_node
;
3233 /* Define `int' and `char' first so that dbx will output them first. */
3234 record_builtin_type (RID_INT
, NULL
, integer_type_node
);
3235 record_builtin_type (RID_CHAR
, "char", char_type_node
);
3237 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
3238 "unsigned long", "long long unsigned" and "unsigned short" were in C++
3239 but not C. Are the conditionals here needed? */
3240 if (c_language
== clk_cplusplus
)
3241 record_builtin_type (RID_SIGNED
, NULL
, integer_type_node
);
3242 record_builtin_type (RID_LONG
, "long int", long_integer_type_node
);
3243 record_builtin_type (RID_UNSIGNED
, "unsigned int", unsigned_type_node
);
3244 record_builtin_type (RID_MAX
, "long unsigned int",
3245 long_unsigned_type_node
);
3246 if (c_language
== clk_cplusplus
)
3247 record_builtin_type (RID_MAX
, "unsigned long", long_unsigned_type_node
);
3248 record_builtin_type (RID_MAX
, "long long int",
3249 long_long_integer_type_node
);
3250 record_builtin_type (RID_MAX
, "long long unsigned int",
3251 long_long_unsigned_type_node
);
3252 if (c_language
== clk_cplusplus
)
3253 record_builtin_type (RID_MAX
, "long long unsigned",
3254 long_long_unsigned_type_node
);
3255 record_builtin_type (RID_SHORT
, "short int", short_integer_type_node
);
3256 record_builtin_type (RID_MAX
, "short unsigned int",
3257 short_unsigned_type_node
);
3258 if (c_language
== clk_cplusplus
)
3259 record_builtin_type (RID_MAX
, "unsigned short",
3260 short_unsigned_type_node
);
3262 /* Define both `signed char' and `unsigned char'. */
3263 record_builtin_type (RID_MAX
, "signed char", signed_char_type_node
);
3264 record_builtin_type (RID_MAX
, "unsigned char", unsigned_char_type_node
);
3266 /* These are types that c_common_type_for_size and
3267 c_common_type_for_mode use. */
3268 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
3270 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
3272 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
3274 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
3276 #if HOST_BITS_PER_WIDE_INT >= 64
3277 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
,
3278 get_identifier ("__int128_t"),
3281 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
3282 unsigned_intQI_type_node
));
3283 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
3284 unsigned_intHI_type_node
));
3285 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
3286 unsigned_intSI_type_node
));
3287 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
3288 unsigned_intDI_type_node
));
3289 #if HOST_BITS_PER_WIDE_INT >= 64
3290 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
,
3291 get_identifier ("__uint128_t"),
3292 unsigned_intTI_type_node
));
3295 /* Create the widest literal types. */
3296 widest_integer_literal_type_node
3297 = make_signed_type (HOST_BITS_PER_WIDE_INT
* 2);
3298 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
3299 widest_integer_literal_type_node
));
3301 widest_unsigned_literal_type_node
3302 = make_unsigned_type (HOST_BITS_PER_WIDE_INT
* 2);
3303 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
3304 widest_unsigned_literal_type_node
));
3306 /* `unsigned long' is the standard type for sizeof.
3307 Note that stddef.h uses `unsigned long',
3308 and this must agree, even if long and int are the same size. */
3310 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE
)));
3311 signed_size_type_node
= c_common_signed_type (size_type_node
);
3312 set_sizetype (size_type_node
);
3314 build_common_tree_nodes_2 (flag_short_double
);
3316 record_builtin_type (RID_FLOAT
, NULL
, float_type_node
);
3317 record_builtin_type (RID_DOUBLE
, NULL
, double_type_node
);
3318 record_builtin_type (RID_MAX
, "long double", long_double_type_node
);
3320 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
,
3321 get_identifier ("complex int"),
3322 complex_integer_type_node
));
3323 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
,
3324 get_identifier ("complex float"),
3325 complex_float_type_node
));
3326 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
,
3327 get_identifier ("complex double"),
3328 complex_double_type_node
));
3329 (*lang_hooks
.decls
.pushdecl
)
3330 (build_decl (TYPE_DECL
, get_identifier ("complex long double"),
3331 complex_long_double_type_node
));
3333 /* Types which are common to the fortran compiler and libf2c. When
3334 changing these, you also need to be concerned with f/com.h. */
3336 if (TYPE_PRECISION (float_type_node
)
3337 == TYPE_PRECISION (long_integer_type_node
))
3339 g77_integer_type_node
= long_integer_type_node
;
3340 g77_uinteger_type_node
= long_unsigned_type_node
;
3342 else if (TYPE_PRECISION (float_type_node
)
3343 == TYPE_PRECISION (integer_type_node
))
3345 g77_integer_type_node
= integer_type_node
;
3346 g77_uinteger_type_node
= unsigned_type_node
;
3349 g77_integer_type_node
= g77_uinteger_type_node
= NULL_TREE
;
3351 if (g77_integer_type_node
!= NULL_TREE
)
3353 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
,
3354 get_identifier ("__g77_integer"),
3355 g77_integer_type_node
));
3356 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
,
3357 get_identifier ("__g77_uinteger"),
3358 g77_uinteger_type_node
));
3361 if (TYPE_PRECISION (float_type_node
) * 2
3362 == TYPE_PRECISION (long_integer_type_node
))
3364 g77_longint_type_node
= long_integer_type_node
;
3365 g77_ulongint_type_node
= long_unsigned_type_node
;
3367 else if (TYPE_PRECISION (float_type_node
) * 2
3368 == TYPE_PRECISION (long_long_integer_type_node
))
3370 g77_longint_type_node
= long_long_integer_type_node
;
3371 g77_ulongint_type_node
= long_long_unsigned_type_node
;
3374 g77_longint_type_node
= g77_ulongint_type_node
= NULL_TREE
;
3376 if (g77_longint_type_node
!= NULL_TREE
)
3378 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
,
3379 get_identifier ("__g77_longint"),
3380 g77_longint_type_node
));
3381 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
,
3382 get_identifier ("__g77_ulongint"),
3383 g77_ulongint_type_node
));
3386 record_builtin_type (RID_VOID
, NULL
, void_type_node
);
3388 void_zero_node
= build_int_2 (0, 0);
3389 TREE_TYPE (void_zero_node
) = void_type_node
;
3391 void_list_node
= build_void_list_node ();
3393 /* Make a type to be the domain of a few array types
3394 whose domains don't really matter.
3395 200 is small enough that it always fits in size_t
3396 and large enough that it can hold most function names for the
3397 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
3398 array_domain_type
= build_index_type (size_int (200));
3400 /* Make a type for arrays of characters.
3401 With luck nothing will ever really depend on the length of this
3403 char_array_type_node
3404 = build_array_type (char_type_node
, array_domain_type
);
3406 /* Likewise for arrays of ints. */
3408 = build_array_type (integer_type_node
, array_domain_type
);
3410 string_type_node
= build_pointer_type (char_type_node
);
3411 const_string_type_node
3412 = build_pointer_type (build_qualified_type
3413 (char_type_node
, TYPE_QUAL_CONST
));
3415 /* This is special for C++ so functions can be overloaded. */
3416 wchar_type_node
= get_identifier (MODIFIED_WCHAR_TYPE
);
3417 wchar_type_node
= TREE_TYPE (identifier_global_value (wchar_type_node
));
3418 wchar_type_size
= TYPE_PRECISION (wchar_type_node
);
3419 if (c_language
== clk_cplusplus
)
3421 if (TREE_UNSIGNED (wchar_type_node
))
3422 wchar_type_node
= make_unsigned_type (wchar_type_size
);
3424 wchar_type_node
= make_signed_type (wchar_type_size
);
3425 record_builtin_type (RID_WCHAR
, "wchar_t", wchar_type_node
);
3429 signed_wchar_type_node
= c_common_signed_type (wchar_type_node
);
3430 unsigned_wchar_type_node
= c_common_unsigned_type (wchar_type_node
);
3433 /* This is for wide string constants. */
3434 wchar_array_type_node
3435 = build_array_type (wchar_type_node
, array_domain_type
);
3438 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE
)));
3441 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE
)));
3443 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE
)));
3445 default_function_type
= build_function_type (integer_type_node
, NULL_TREE
);
3447 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE
)));
3448 unsigned_ptrdiff_type_node
= c_common_unsigned_type (ptrdiff_type_node
);
3450 (*lang_hooks
.decls
.pushdecl
)
3451 (build_decl (TYPE_DECL
, get_identifier ("__builtin_va_list"),
3452 va_list_type_node
));
3454 (*lang_hooks
.decls
.pushdecl
)
3455 (build_decl (TYPE_DECL
, get_identifier ("__builtin_ptrdiff_t"),
3456 ptrdiff_type_node
));
3458 (*lang_hooks
.decls
.pushdecl
)
3459 (build_decl (TYPE_DECL
, get_identifier ("__builtin_size_t"),
3462 if (TREE_CODE (va_list_type_node
) == ARRAY_TYPE
)
3464 va_list_arg_type_node
= va_list_ref_type_node
=
3465 build_pointer_type (TREE_TYPE (va_list_type_node
));
3469 va_list_arg_type_node
= va_list_type_node
;
3470 va_list_ref_type_node
= build_reference_type (va_list_type_node
);
3473 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3474 builtin_types[(int) ENUM] = VALUE;
3475 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
3476 builtin_types[(int) ENUM] \
3477 = build_function_type (builtin_types[(int) RETURN], \
3479 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
3480 builtin_types[(int) ENUM] \
3481 = build_function_type (builtin_types[(int) RETURN], \
3482 tree_cons (NULL_TREE, \
3483 builtin_types[(int) ARG1], \
3485 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
3486 builtin_types[(int) ENUM] \
3487 = build_function_type \
3488 (builtin_types[(int) RETURN], \
3489 tree_cons (NULL_TREE, \
3490 builtin_types[(int) ARG1], \
3491 tree_cons (NULL_TREE, \
3492 builtin_types[(int) ARG2], \
3494 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3495 builtin_types[(int) ENUM] \
3496 = build_function_type \
3497 (builtin_types[(int) RETURN], \
3498 tree_cons (NULL_TREE, \
3499 builtin_types[(int) ARG1], \
3500 tree_cons (NULL_TREE, \
3501 builtin_types[(int) ARG2], \
3502 tree_cons (NULL_TREE, \
3503 builtin_types[(int) ARG3], \
3505 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3506 builtin_types[(int) ENUM] \
3507 = build_function_type \
3508 (builtin_types[(int) RETURN], \
3509 tree_cons (NULL_TREE, \
3510 builtin_types[(int) ARG1], \
3511 tree_cons (NULL_TREE, \
3512 builtin_types[(int) ARG2], \
3515 builtin_types[(int) ARG3], \
3516 tree_cons (NULL_TREE, \
3517 builtin_types[(int) ARG4], \
3518 void_list_node)))));
3519 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
3520 builtin_types[(int) ENUM] \
3521 = build_function_type (builtin_types[(int) RETURN], NULL_TREE);
3522 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
3523 builtin_types[(int) ENUM] \
3524 = build_function_type (builtin_types[(int) RETURN], \
3525 tree_cons (NULL_TREE, \
3526 builtin_types[(int) ARG1], \
3529 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
3530 builtin_types[(int) ENUM] \
3531 = build_function_type \
3532 (builtin_types[(int) RETURN], \
3533 tree_cons (NULL_TREE, \
3534 builtin_types[(int) ARG1], \
3535 tree_cons (NULL_TREE, \
3536 builtin_types[(int) ARG2], \
3539 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3540 builtin_types[(int) ENUM] \
3541 = build_function_type \
3542 (builtin_types[(int) RETURN], \
3543 tree_cons (NULL_TREE, \
3544 builtin_types[(int) ARG1], \
3545 tree_cons (NULL_TREE, \
3546 builtin_types[(int) ARG2], \
3547 tree_cons (NULL_TREE, \
3548 builtin_types[(int) ARG3], \
3551 #define DEF_POINTER_TYPE(ENUM, TYPE) \
3552 builtin_types[(int) ENUM] \
3553 = build_pointer_type (builtin_types[(int) TYPE]);
3554 #include "builtin-types.def"
3555 #undef DEF_PRIMITIVE_TYPE
3556 #undef DEF_FUNCTION_TYPE_1
3557 #undef DEF_FUNCTION_TYPE_2
3558 #undef DEF_FUNCTION_TYPE_3
3559 #undef DEF_FUNCTION_TYPE_4
3560 #undef DEF_FUNCTION_TYPE_VAR_0
3561 #undef DEF_FUNCTION_TYPE_VAR_1
3562 #undef DEF_FUNCTION_TYPE_VAR_2
3563 #undef DEF_FUNCTION_TYPE_VAR_3
3564 #undef DEF_POINTER_TYPE
3566 if (!c_attrs_initialized
)
3567 c_init_attributes ();
3569 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, \
3570 BOTH_P, FALLBACK_P, NONANSI_P, ATTRS, IMPLICIT) \
3575 if (strncmp (NAME, "__builtin_", strlen ("__builtin_")) != 0) \
3579 decl = builtin_function (NAME, builtin_types[TYPE], ENUM, \
3582 ? (NAME + strlen ("__builtin_")) \
3584 built_in_attributes[(int) ATTRS]); \
3586 decl = builtin_function_2 (NAME, \
3587 NAME + strlen ("__builtin_"), \
3588 builtin_types[TYPE], \
3589 builtin_types[LIBTYPE], \
3594 built_in_attributes[(int) ATTRS]); \
3596 built_in_decls[(int) ENUM] = decl; \
3598 implicit_built_in_decls[(int) ENUM] = decl; \
3600 #include "builtins.def"
3603 (*targetm
.init_builtins
) ();
3605 main_identifier_node
= get_identifier ("main");
3609 build_va_arg (expr
, type
)
3612 return build1 (VA_ARG_EXPR
, type
, expr
);
3616 /* Linked list of disabled built-in functions. */
3618 typedef struct disabled_builtin
3621 struct disabled_builtin
*next
;
3623 static disabled_builtin
*disabled_builtins
= NULL
;
3625 static bool builtin_function_disabled_p
PARAMS ((const char *));
3627 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
3628 begins with "__builtin_", give an error. */
3631 disable_builtin_function (name
)
3634 if (strncmp (name
, "__builtin_", strlen ("__builtin_")) == 0)
3635 error ("cannot disable built-in function `%s'", name
);
3638 disabled_builtin
*new = xmalloc (sizeof (disabled_builtin
));
3640 new->next
= disabled_builtins
;
3641 disabled_builtins
= new;
3646 /* Return true if the built-in function NAME has been disabled, false
3650 builtin_function_disabled_p (name
)
3653 disabled_builtin
*p
;
3654 for (p
= disabled_builtins
; p
!= NULL
; p
= p
->next
)
3656 if (strcmp (name
, p
->name
) == 0)
3663 /* Possibly define a builtin function with one or two names. BUILTIN_NAME
3664 is an __builtin_-prefixed name; NAME is the ordinary name; one or both
3665 of these may be NULL (though both being NULL is useless).
3666 BUILTIN_TYPE is the type of the __builtin_-prefixed function;
3667 TYPE is the type of the function with the ordinary name. These
3668 may differ if the ordinary name is declared with a looser type to avoid
3669 conflicts with headers. FUNCTION_CODE and CLASS are as for
3670 builtin_function. If LIBRARY_NAME_P is nonzero, NAME is passed as
3671 the LIBRARY_NAME parameter to builtin_function when declaring BUILTIN_NAME.
3672 If NONANSI_P is nonzero, the name NAME is treated as a non-ANSI name;
3673 ATTRS is the tree list representing the builtin's function attributes.
3674 Returns the declaration of BUILTIN_NAME, if any, otherwise
3675 the declaration of NAME. Does not declare NAME if flag_no_builtin,
3676 or if NONANSI_P and flag_no_nonansi_builtin. */
3679 builtin_function_2 (builtin_name
, name
, builtin_type
, type
, function_code
,
3680 class, library_name_p
, nonansi_p
, attrs
)
3681 const char *builtin_name
;
3686 enum built_in_class
class;
3691 tree bdecl
= NULL_TREE
;
3692 tree decl
= NULL_TREE
;
3693 if (builtin_name
!= 0)
3695 bdecl
= builtin_function (builtin_name
, builtin_type
, function_code
,
3696 class, library_name_p
? name
: NULL
,
3699 if (name
!= 0 && !flag_no_builtin
&& !builtin_function_disabled_p (name
)
3700 && !(nonansi_p
&& flag_no_nonansi_builtin
))
3702 decl
= builtin_function (name
, type
, function_code
, class, NULL
,
3705 DECL_BUILT_IN_NONANSI (decl
) = 1;
3707 return (bdecl
!= 0 ? bdecl
: decl
);
3710 /* Nonzero if the type T promotes to int. This is (nearly) the
3711 integral promotions defined in ISO C99 6.3.1.1/2. */
3714 c_promoting_integer_type_p (t
)
3717 switch (TREE_CODE (t
))
3720 return (TYPE_MAIN_VARIANT (t
) == char_type_node
3721 || TYPE_MAIN_VARIANT (t
) == signed_char_type_node
3722 || TYPE_MAIN_VARIANT (t
) == unsigned_char_type_node
3723 || TYPE_MAIN_VARIANT (t
) == short_integer_type_node
3724 || TYPE_MAIN_VARIANT (t
) == short_unsigned_type_node
3725 || TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
));
3728 /* ??? Technically all enumerations not larger than an int
3729 promote to an int. But this is used along code paths
3730 that only want to notice a size change. */
3731 return TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
);
3741 /* Return 1 if PARMS specifies a fixed number of parameters
3742 and none of their types is affected by default promotions. */
3745 self_promoting_args_p (parms
)
3749 for (t
= parms
; t
; t
= TREE_CHAIN (t
))
3751 tree type
= TREE_VALUE (t
);
3753 if (TREE_CHAIN (t
) == 0 && type
!= void_type_node
)
3759 if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
3762 if (c_promoting_integer_type_p (type
))
3768 /* Recursively examines the array elements of TYPE, until a non-array
3769 element type is found. */
3772 strip_array_types (type
)
3775 while (TREE_CODE (type
) == ARRAY_TYPE
)
3776 type
= TREE_TYPE (type
);
3781 static tree expand_unordered_cmp
PARAMS ((tree
, tree
, enum tree_code
,
3784 /* Expand a call to an unordered comparison function such as
3785 __builtin_isgreater(). FUNCTION is the function's declaration and
3786 PARAMS a list of the values passed. For __builtin_isunordered(),
3787 UNORDERED_CODE is UNORDERED_EXPR and ORDERED_CODE is NOP_EXPR. In
3788 other cases, UNORDERED_CODE and ORDERED_CODE are comparison codes
3789 that give the opposite of the desired result. UNORDERED_CODE is
3790 used for modes that can hold NaNs and ORDERED_CODE is used for the
3794 expand_unordered_cmp (function
, params
, unordered_code
, ordered_code
)
3795 tree function
, params
;
3796 enum tree_code unordered_code
, ordered_code
;
3798 tree arg0
, arg1
, type
;
3799 enum tree_code code0
, code1
;
3801 /* Check that we have exactly two arguments. */
3802 if (params
== 0 || TREE_CHAIN (params
) == 0)
3804 error ("too few arguments to function `%s'",
3805 IDENTIFIER_POINTER (DECL_NAME (function
)));
3806 return error_mark_node
;
3808 else if (TREE_CHAIN (TREE_CHAIN (params
)) != 0)
3810 error ("too many arguments to function `%s'",
3811 IDENTIFIER_POINTER (DECL_NAME (function
)));
3812 return error_mark_node
;
3815 arg0
= TREE_VALUE (params
);
3816 arg1
= TREE_VALUE (TREE_CHAIN (params
));
3818 code0
= TREE_CODE (TREE_TYPE (arg0
));
3819 code1
= TREE_CODE (TREE_TYPE (arg1
));
3821 /* Make sure that the arguments have a common type of REAL. */
3823 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
)
3824 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
))
3825 type
= common_type (TREE_TYPE (arg0
), TREE_TYPE (arg1
));
3827 if (type
== 0 || TREE_CODE (type
) != REAL_TYPE
)
3829 error ("non-floating-point argument to function `%s'",
3830 IDENTIFIER_POINTER (DECL_NAME (function
)));
3831 return error_mark_node
;
3834 if (unordered_code
== UNORDERED_EXPR
)
3836 if (MODE_HAS_NANS (TYPE_MODE (type
)))
3837 return build_binary_op (unordered_code
,
3838 convert (type
, arg0
),
3839 convert (type
, arg1
),
3842 return integer_zero_node
;
3845 return build_unary_op (TRUTH_NOT_EXPR
,
3846 build_binary_op (MODE_HAS_NANS (TYPE_MODE (type
))
3849 convert (type
, arg0
),
3850 convert (type
, arg1
),
3856 /* Recognize certain built-in functions so we can make tree-codes
3857 other than CALL_EXPR. We do this when it enables fold-const.c
3858 to do something useful. */
3859 /* ??? By rights this should go in builtins.c, but only C and C++
3860 implement build_{binary,unary}_op. Not exactly sure what bits
3861 of functionality are actually needed from those functions, or
3862 where the similar functionality exists in the other front ends. */
3865 expand_tree_builtin (function
, params
, coerced_params
)
3866 tree function
, params
, coerced_params
;
3868 if (DECL_BUILT_IN_CLASS (function
) != BUILT_IN_NORMAL
)
3871 switch (DECL_FUNCTION_CODE (function
))
3875 case BUILT_IN_LLABS
:
3876 case BUILT_IN_IMAXABS
:
3878 case BUILT_IN_FABSL
:
3879 case BUILT_IN_FABSF
:
3880 if (coerced_params
== 0)
3881 return integer_zero_node
;
3882 return build_unary_op (ABS_EXPR
, TREE_VALUE (coerced_params
), 0);
3885 case BUILT_IN_CONJF
:
3886 case BUILT_IN_CONJL
:
3887 if (coerced_params
== 0)
3888 return integer_zero_node
;
3889 return build_unary_op (CONJ_EXPR
, TREE_VALUE (coerced_params
), 0);
3891 case BUILT_IN_CREAL
:
3892 case BUILT_IN_CREALF
:
3893 case BUILT_IN_CREALL
:
3894 if (coerced_params
== 0)
3895 return integer_zero_node
;
3896 return build_unary_op (REALPART_EXPR
, TREE_VALUE (coerced_params
), 0);
3898 case BUILT_IN_CIMAG
:
3899 case BUILT_IN_CIMAGF
:
3900 case BUILT_IN_CIMAGL
:
3901 if (coerced_params
== 0)
3902 return integer_zero_node
;
3903 return build_unary_op (IMAGPART_EXPR
, TREE_VALUE (coerced_params
), 0);
3905 case BUILT_IN_ISGREATER
:
3906 return expand_unordered_cmp (function
, params
, UNLE_EXPR
, LE_EXPR
);
3908 case BUILT_IN_ISGREATEREQUAL
:
3909 return expand_unordered_cmp (function
, params
, UNLT_EXPR
, LT_EXPR
);
3911 case BUILT_IN_ISLESS
:
3912 return expand_unordered_cmp (function
, params
, UNGE_EXPR
, GE_EXPR
);
3914 case BUILT_IN_ISLESSEQUAL
:
3915 return expand_unordered_cmp (function
, params
, UNGT_EXPR
, GT_EXPR
);
3917 case BUILT_IN_ISLESSGREATER
:
3918 return expand_unordered_cmp (function
, params
, UNEQ_EXPR
, EQ_EXPR
);
3920 case BUILT_IN_ISUNORDERED
:
3921 return expand_unordered_cmp (function
, params
, UNORDERED_EXPR
, NOP_EXPR
);
3930 /* Returns nonzero if CODE is the code for a statement. */
3933 statement_code_p (code
)
3934 enum tree_code code
;
3959 if (lang_statement_code_p
)
3960 return (*lang_statement_code_p
) (code
);
3965 /* Walk the statement tree, rooted at *tp. Apply FUNC to all the
3966 sub-trees of *TP in a pre-order traversal. FUNC is called with the
3967 DATA and the address of each sub-tree. If FUNC returns a non-NULL
3968 value, the traversal is aborted, and the value returned by FUNC is
3969 returned. If FUNC sets WALK_SUBTREES to zero, then the subtrees of
3970 the node being visited are not walked.
3972 We don't need a without_duplicates variant of this one because the
3973 statement tree is a tree, not a graph. */
3976 walk_stmt_tree (tp
, func
, data
)
3981 enum tree_code code
;
3986 #define WALK_SUBTREE(NODE) \
3989 result = walk_stmt_tree (&(NODE), func, data); \
3995 /* Skip empty subtrees. */
3999 /* Skip subtrees below non-statement nodes. */
4000 if (!statement_code_p (TREE_CODE (*tp
)))
4003 /* Call the function. */
4005 result
= (*func
) (tp
, &walk_subtrees
, data
);
4007 /* If we found something, return it. */
4011 /* FUNC may have modified the tree, recheck that we're looking at a
4013 code
= TREE_CODE (*tp
);
4014 if (!statement_code_p (code
))
4017 /* Visit the subtrees unless FUNC decided that there was nothing
4018 interesting below this point in the tree. */
4021 /* Walk over all the sub-trees of this operand. Statement nodes
4022 never contain RTL, and we needn't worry about TARGET_EXPRs. */
4023 len
= TREE_CODE_LENGTH (code
);
4025 /* Go through the subtrees. We need to do this in forward order so
4026 that the scope of a FOR_EXPR is handled properly. */
4027 for (i
= 0; i
< len
; ++i
)
4028 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
4031 /* Finally visit the chain. This can be tail-recursion optimized if
4032 we write it this way. */
4033 return walk_stmt_tree (&TREE_CHAIN (*tp
), func
, data
);
4038 /* Used to compare case labels. K1 and K2 are actually tree nodes
4039 representing case labels, or NULL_TREE for a `default' label.
4040 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
4041 K2, and 0 if K1 and K2 are equal. */
4044 case_compare (k1
, k2
)
4048 /* Consider a NULL key (such as arises with a `default' label) to be
4049 smaller than anything else. */
4055 return tree_int_cst_compare ((tree
) k1
, (tree
) k2
);
4058 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
4059 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
4060 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
4061 case label was declared using the usual C/C++ syntax, rather than
4062 the GNU case range extension. CASES is a tree containing all the
4063 case ranges processed so far; COND is the condition for the
4064 switch-statement itself. Returns the CASE_LABEL created, or
4065 ERROR_MARK_NODE if no CASE_LABEL is created. */
4068 c_add_case_label (cases
, cond
, low_value
, high_value
)
4077 splay_tree_node node
;
4079 /* Create the LABEL_DECL itself. */
4080 label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
4081 DECL_CONTEXT (label
) = current_function_decl
;
4083 /* If there was an error processing the switch condition, bail now
4084 before we get more confused. */
4085 if (!cond
|| cond
== error_mark_node
)
4087 /* Add a label anyhow so that the back-end doesn't think that
4088 the beginning of the switch is unreachable. */
4090 add_stmt (build_case_label (NULL_TREE
, NULL_TREE
, label
));
4091 return error_mark_node
;
4094 if ((low_value
&& TREE_TYPE (low_value
)
4095 && POINTER_TYPE_P (TREE_TYPE (low_value
)))
4096 || (high_value
&& TREE_TYPE (high_value
)
4097 && POINTER_TYPE_P (TREE_TYPE (high_value
))))
4098 error ("pointers are not permitted as case values");
4100 /* Case ranges are a GNU extension. */
4101 if (high_value
&& pedantic
)
4103 if (c_language
== clk_cplusplus
)
4104 pedwarn ("ISO C++ forbids range expressions in switch statements");
4106 pedwarn ("ISO C forbids range expressions in switch statements");
4109 type
= TREE_TYPE (cond
);
4112 low_value
= check_case_value (low_value
);
4113 low_value
= convert_and_check (type
, low_value
);
4117 high_value
= check_case_value (high_value
);
4118 high_value
= convert_and_check (type
, high_value
);
4121 /* If an error has occurred, bail out now. */
4122 if (low_value
== error_mark_node
|| high_value
== error_mark_node
)
4125 add_stmt (build_case_label (NULL_TREE
, NULL_TREE
, label
));
4126 return error_mark_node
;
4129 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
4130 really a case range, even though it was written that way. Remove
4131 the HIGH_VALUE to simplify later processing. */
4132 if (tree_int_cst_equal (low_value
, high_value
))
4133 high_value
= NULL_TREE
;
4134 if (low_value
&& high_value
4135 && !tree_int_cst_lt (low_value
, high_value
))
4136 warning ("empty range specified");
4138 /* Look up the LOW_VALUE in the table of case labels we already
4140 node
= splay_tree_lookup (cases
, (splay_tree_key
) low_value
);
4141 /* If there was not an exact match, check for overlapping ranges.
4142 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
4143 that's a `default' label and the only overlap is an exact match. */
4144 if (!node
&& (low_value
|| high_value
))
4146 splay_tree_node low_bound
;
4147 splay_tree_node high_bound
;
4149 /* Even though there wasn't an exact match, there might be an
4150 overlap between this case range and another case range.
4151 Since we've (inductively) not allowed any overlapping case
4152 ranges, we simply need to find the greatest low case label
4153 that is smaller that LOW_VALUE, and the smallest low case
4154 label that is greater than LOW_VALUE. If there is an overlap
4155 it will occur in one of these two ranges. */
4156 low_bound
= splay_tree_predecessor (cases
,
4157 (splay_tree_key
) low_value
);
4158 high_bound
= splay_tree_successor (cases
,
4159 (splay_tree_key
) low_value
);
4161 /* Check to see if the LOW_BOUND overlaps. It is smaller than
4162 the LOW_VALUE, so there is no need to check unless the
4163 LOW_BOUND is in fact itself a case range. */
4165 && CASE_HIGH ((tree
) low_bound
->value
)
4166 && tree_int_cst_compare (CASE_HIGH ((tree
) low_bound
->value
),
4169 /* Check to see if the HIGH_BOUND overlaps. The low end of that
4170 range is bigger than the low end of the current range, so we
4171 are only interested if the current range is a real range, and
4172 not an ordinary case label. */
4175 && (tree_int_cst_compare ((tree
) high_bound
->key
,
4180 /* If there was an overlap, issue an error. */
4183 tree duplicate
= CASE_LABEL_DECL ((tree
) node
->value
);
4187 error ("duplicate (or overlapping) case value");
4188 error_with_decl (duplicate
,
4189 "this is the first entry overlapping that value");
4193 error ("duplicate case value") ;
4194 error_with_decl (duplicate
, "previously used here");
4198 error ("multiple default labels in one switch");
4199 error_with_decl (duplicate
, "this is the first default label");
4202 add_stmt (build_case_label (NULL_TREE
, NULL_TREE
, label
));
4205 /* Add a CASE_LABEL to the statement-tree. */
4206 case_label
= add_stmt (build_case_label (low_value
, high_value
, label
));
4207 /* Register this case label in the splay tree. */
4208 splay_tree_insert (cases
,
4209 (splay_tree_key
) low_value
,
4210 (splay_tree_value
) case_label
);
4215 /* Finish an expression taking the address of LABEL (an
4216 IDENTIFIER_NODE). Returns an expression for the address. */
4219 finish_label_address_expr (label
)
4226 if (c_language
== clk_cplusplus
)
4227 pedwarn ("ISO C++ forbids taking the address of a label");
4229 pedwarn ("ISO C forbids taking the address of a label");
4232 if (label
== error_mark_node
)
4233 return error_mark_node
;
4235 label
= lookup_label (label
);
4236 if (label
== NULL_TREE
)
4237 result
= null_pointer_node
;
4240 TREE_USED (label
) = 1;
4241 result
= build1 (ADDR_EXPR
, ptr_type_node
, label
);
4242 TREE_CONSTANT (result
) = 1;
4243 /* The current function in not necessarily uninlinable.
4244 Computed gotos are incompatible with inlining, but the value
4245 here could be used only in a diagnostic, for example. */
4251 /* Hook used by expand_expr to expand language-specific tree codes. */
4254 c_expand_expr (exp
, target
, tmode
, modifier
)
4257 enum machine_mode tmode
;
4258 int modifier
; /* Actually enum_modifier. */
4260 switch (TREE_CODE (exp
))
4266 bool preserve_result
= false;
4267 bool return_target
= false;
4269 /* Since expand_expr_stmt calls free_temp_slots after every
4270 expression statement, we must call push_temp_slots here.
4271 Otherwise, any temporaries in use now would be considered
4272 out-of-scope after the first EXPR_STMT from within the
4275 rtl_expr
= expand_start_stmt_expr (!STMT_EXPR_NO_SCOPE (exp
));
4277 /* If we want the result of this expression, find the last
4278 EXPR_STMT in the COMPOUND_STMT and mark it as addressable. */
4279 if (target
!= const0_rtx
4280 && TREE_CODE (STMT_EXPR_STMT (exp
)) == COMPOUND_STMT
4281 && TREE_CODE (COMPOUND_BODY (STMT_EXPR_STMT (exp
))) == SCOPE_STMT
)
4283 tree expr
= COMPOUND_BODY (STMT_EXPR_STMT (exp
));
4284 tree last
= TREE_CHAIN (expr
);
4286 while (TREE_CHAIN (last
))
4289 last
= TREE_CHAIN (last
);
4292 if (TREE_CODE (last
) == SCOPE_STMT
4293 && TREE_CODE (expr
) == EXPR_STMT
)
4295 if (target
&& TREE_CODE (EXPR_STMT_EXPR (expr
)) == VAR_DECL
4296 && DECL_RTL_IF_SET (EXPR_STMT_EXPR (expr
)) == target
)
4297 /* If the last expression is a variable whose RTL is the
4298 same as our target, just return the target; if it
4299 isn't valid expanding the decl would produce different
4300 RTL, and store_expr would try to do a copy. */
4301 return_target
= true;
4304 /* Otherwise, note that we want the value from the last
4306 TREE_ADDRESSABLE (expr
) = 1;
4307 preserve_result
= true;
4312 expand_stmt (STMT_EXPR_STMT (exp
));
4313 expand_end_stmt_expr (rtl_expr
);
4315 result
= expand_expr (rtl_expr
, target
, tmode
, modifier
);
4318 else if (preserve_result
&& GET_CODE (result
) == MEM
)
4320 if (GET_MODE (result
) != BLKmode
)
4321 result
= copy_to_reg (result
);
4323 preserve_temp_slots (result
);
4326 /* If the statment-expression does not have a scope, then the
4327 new temporaries we created within it must live beyond the
4328 statement-expression. */
4329 if (STMT_EXPR_NO_SCOPE (exp
))
4330 preserve_temp_slots (NULL_RTX
);
4339 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == ADDR_EXPR
4340 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
4342 && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
4343 && (DECL_BUILT_IN_CLASS (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
4344 == BUILT_IN_FRONTEND
))
4345 return c_expand_builtin (exp
, target
, tmode
, modifier
);
4351 case COMPOUND_LITERAL_EXPR
:
4353 /* Initialize the anonymous variable declared in the compound
4354 literal, then return the variable. */
4355 tree decl
= COMPOUND_LITERAL_EXPR_DECL (exp
);
4356 emit_local_var (decl
);
4357 return expand_expr (decl
, target
, tmode
, modifier
);
4368 /* Hook used by safe_from_p to handle language-specific tree codes. */
4371 c_safe_from_p (target
, exp
)
4375 /* We can see statements here when processing the body of a
4376 statement-expression. For a declaration statement declaring a
4377 variable, look at the variable's initializer. */
4378 if (TREE_CODE (exp
) == DECL_STMT
)
4380 tree decl
= DECL_STMT_DECL (exp
);
4382 if (TREE_CODE (decl
) == VAR_DECL
4383 && DECL_INITIAL (decl
)
4384 && !safe_from_p (target
, DECL_INITIAL (decl
), /*top_p=*/0))
4388 /* For any statement, we must follow the statement-chain. */
4389 if (statement_code_p (TREE_CODE (exp
)) && TREE_CHAIN (exp
))
4390 return safe_from_p (target
, TREE_CHAIN (exp
), /*top_p=*/0);
4392 /* Assume everything else is safe. */
4396 /* Hook used by unsafe_for_reeval to handle language-specific tree codes. */
4399 c_common_unsafe_for_reeval (exp
)
4402 /* Statement expressions may not be reevaluated, likewise compound
4404 if (TREE_CODE (exp
) == STMT_EXPR
4405 || TREE_CODE (exp
) == COMPOUND_LITERAL_EXPR
)
4408 /* Walk all other expressions. */
4412 /* Hook used by staticp to handle language-specific tree codes. */
4418 if (TREE_CODE (exp
) == COMPOUND_LITERAL_EXPR
4419 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp
)))
4424 #define CALLED_AS_BUILT_IN(NODE) \
4425 (!strncmp (IDENTIFIER_POINTER (DECL_NAME (NODE)), "__builtin_", 10))
4428 c_expand_builtin (exp
, target
, tmode
, modifier
)
4431 enum machine_mode tmode
;
4432 enum expand_modifier modifier
;
4434 tree type
= TREE_TYPE (exp
);
4435 tree fndecl
= TREE_OPERAND (TREE_OPERAND (exp
, 0), 0);
4436 tree arglist
= TREE_OPERAND (exp
, 1);
4437 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
4438 enum tree_code code
= TREE_CODE (exp
);
4439 const int ignore
= (target
== const0_rtx
4440 || ((code
== NON_LVALUE_EXPR
|| code
== NOP_EXPR
4441 || code
== CONVERT_EXPR
|| code
== REFERENCE_EXPR
4442 || code
== COND_EXPR
)
4443 && TREE_CODE (type
) == VOID_TYPE
));
4445 if (! optimize
&& ! CALLED_AS_BUILT_IN (fndecl
))
4446 return expand_call (exp
, target
, ignore
);
4450 case BUILT_IN_PRINTF
:
4451 target
= c_expand_builtin_printf (arglist
, target
, tmode
,
4452 modifier
, ignore
, /*unlocked=*/ 0);
4457 case BUILT_IN_PRINTF_UNLOCKED
:
4458 target
= c_expand_builtin_printf (arglist
, target
, tmode
,
4459 modifier
, ignore
, /*unlocked=*/ 1);
4464 case BUILT_IN_FPRINTF
:
4465 target
= c_expand_builtin_fprintf (arglist
, target
, tmode
,
4466 modifier
, ignore
, /*unlocked=*/ 0);
4471 case BUILT_IN_FPRINTF_UNLOCKED
:
4472 target
= c_expand_builtin_fprintf (arglist
, target
, tmode
,
4473 modifier
, ignore
, /*unlocked=*/ 1);
4478 default: /* just do library call, if unknown builtin */
4479 error ("built-in function `%s' not currently supported",
4480 IDENTIFIER_POINTER (DECL_NAME (fndecl
)));
4483 /* The switch statement above can drop through to cause the function
4484 to be called normally. */
4485 return expand_call (exp
, target
, ignore
);
4488 /* Check an arglist to *printf for problems. The arglist should start
4489 at the format specifier, with the remaining arguments immediately
4492 is_valid_printf_arglist (arglist
)
4495 /* Save this value so we can restore it later. */
4496 const int SAVE_pedantic
= pedantic
;
4497 int diagnostic_occurred
= 0;
4500 /* Set this to a known value so the user setting won't affect code
4503 /* Check to make sure there are no format specifier errors. */
4504 attrs
= tree_cons (get_identifier ("format"),
4505 tree_cons (NULL_TREE
,
4506 get_identifier ("printf"),
4507 tree_cons (NULL_TREE
,
4509 tree_cons (NULL_TREE
,
4513 check_function_format (&diagnostic_occurred
, attrs
, arglist
);
4515 /* Restore the value of `pedantic'. */
4516 pedantic
= SAVE_pedantic
;
4518 /* If calling `check_function_format_ptr' produces a warning, we
4519 return false, otherwise we return true. */
4520 return ! diagnostic_occurred
;
4523 /* If the arguments passed to printf are suitable for optimizations,
4524 we attempt to transform the call. */
4526 c_expand_builtin_printf (arglist
, target
, tmode
, modifier
, ignore
, unlocked
)
4529 enum machine_mode tmode
;
4530 enum expand_modifier modifier
;
4534 tree fn_putchar
= unlocked
?
4535 implicit_built_in_decls
[BUILT_IN_PUTCHAR_UNLOCKED
] : implicit_built_in_decls
[BUILT_IN_PUTCHAR
];
4536 tree fn_puts
= unlocked
?
4537 implicit_built_in_decls
[BUILT_IN_PUTS_UNLOCKED
] : implicit_built_in_decls
[BUILT_IN_PUTS
];
4538 tree fn
, format_arg
, stripped_string
;
4540 /* If the return value is used, or the replacement _DECL isn't
4541 initialized, don't do the transformation. */
4542 if (!ignore
|| !fn_putchar
|| !fn_puts
)
4545 /* Verify the required arguments in the original call. */
4547 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != POINTER_TYPE
))
4550 /* Check the specifier vs. the parameters. */
4551 if (!is_valid_printf_arglist (arglist
))
4554 format_arg
= TREE_VALUE (arglist
);
4555 stripped_string
= format_arg
;
4556 STRIP_NOPS (stripped_string
);
4557 if (stripped_string
&& TREE_CODE (stripped_string
) == ADDR_EXPR
)
4558 stripped_string
= TREE_OPERAND (stripped_string
, 0);
4560 /* If the format specifier isn't a STRING_CST, punt. */
4561 if (TREE_CODE (stripped_string
) != STRING_CST
)
4564 /* OK! We can attempt optimization. */
4566 /* If the format specifier was "%s\n", call __builtin_puts(arg2). */
4567 if (strcmp (TREE_STRING_POINTER (stripped_string
), "%s\n") == 0)
4569 arglist
= TREE_CHAIN (arglist
);
4572 /* If the format specifier was "%c", call __builtin_putchar (arg2). */
4573 else if (strcmp (TREE_STRING_POINTER (stripped_string
), "%c") == 0)
4575 arglist
= TREE_CHAIN (arglist
);
4580 /* We can't handle anything else with % args or %% ... yet. */
4581 if (strchr (TREE_STRING_POINTER (stripped_string
), '%'))
4584 /* If the resulting constant string has a length of 1, call
4585 putchar. Note, TREE_STRING_LENGTH includes the terminating
4586 NULL in its count. */
4587 if (TREE_STRING_LENGTH (stripped_string
) == 2)
4589 /* Given printf("c"), (where c is any one character,)
4590 convert "c"[0] to an int and pass that to the replacement
4592 arglist
= build_int_2 (TREE_STRING_POINTER (stripped_string
)[0], 0);
4593 arglist
= build_tree_list (NULL_TREE
, arglist
);
4597 /* If the resulting constant was "string\n", call
4598 __builtin_puts("string"). Ensure "string" has at least one
4599 character besides the trailing \n. Note, TREE_STRING_LENGTH
4600 includes the terminating NULL in its count. */
4601 else if (TREE_STRING_LENGTH (stripped_string
) > 2
4602 && TREE_STRING_POINTER (stripped_string
)
4603 [TREE_STRING_LENGTH (stripped_string
) - 2] == '\n')
4605 /* Create a NULL-terminated string that's one char shorter
4606 than the original, stripping off the trailing '\n'. */
4607 const int newlen
= TREE_STRING_LENGTH (stripped_string
) - 1;
4608 char *newstr
= (char *) alloca (newlen
);
4609 memcpy (newstr
, TREE_STRING_POINTER (stripped_string
), newlen
- 1);
4610 newstr
[newlen
- 1] = 0;
4612 arglist
= fix_string_type (build_string (newlen
, newstr
));
4613 arglist
= build_tree_list (NULL_TREE
, arglist
);
4617 /* We'd like to arrange to call fputs(string) here, but we
4618 need stdout and don't have a way to get it ... yet. */
4622 return expand_expr (build_function_call (fn
, arglist
),
4623 (ignore
? const0_rtx
: target
),
4627 /* If the arguments passed to fprintf are suitable for optimizations,
4628 we attempt to transform the call. */
4630 c_expand_builtin_fprintf (arglist
, target
, tmode
, modifier
, ignore
, unlocked
)
4633 enum machine_mode tmode
;
4634 enum expand_modifier modifier
;
4638 tree fn_fputc
= unlocked
?
4639 implicit_built_in_decls
[BUILT_IN_FPUTC_UNLOCKED
] : implicit_built_in_decls
[BUILT_IN_FPUTC
];
4640 tree fn_fputs
= unlocked
?
4641 implicit_built_in_decls
[BUILT_IN_FPUTS_UNLOCKED
] : implicit_built_in_decls
[BUILT_IN_FPUTS
];
4642 tree fn
, format_arg
, stripped_string
;
4644 /* If the return value is used, or the replacement _DECL isn't
4645 initialized, don't do the transformation. */
4646 if (!ignore
|| !fn_fputc
|| !fn_fputs
)
4649 /* Verify the required arguments in the original call. */
4651 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != POINTER_TYPE
)
4652 || (TREE_CHAIN (arglist
) == 0)
4653 || (TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist
)))) !=
4657 /* Check the specifier vs. the parameters. */
4658 if (!is_valid_printf_arglist (TREE_CHAIN (arglist
)))
4661 format_arg
= TREE_VALUE (TREE_CHAIN (arglist
));
4662 stripped_string
= format_arg
;
4663 STRIP_NOPS (stripped_string
);
4664 if (stripped_string
&& TREE_CODE (stripped_string
) == ADDR_EXPR
)
4665 stripped_string
= TREE_OPERAND (stripped_string
, 0);
4667 /* If the format specifier isn't a STRING_CST, punt. */
4668 if (TREE_CODE (stripped_string
) != STRING_CST
)
4671 /* OK! We can attempt optimization. */
4673 /* If the format specifier was "%s", call __builtin_fputs(arg3, arg1). */
4674 if (strcmp (TREE_STRING_POINTER (stripped_string
), "%s") == 0)
4676 tree newarglist
= build_tree_list (NULL_TREE
, TREE_VALUE (arglist
));
4677 arglist
= tree_cons (NULL_TREE
,
4678 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
))),
4682 /* If the format specifier was "%c", call __builtin_fputc (arg3, arg1). */
4683 else if (strcmp (TREE_STRING_POINTER (stripped_string
), "%c") == 0)
4685 tree newarglist
= build_tree_list (NULL_TREE
, TREE_VALUE (arglist
));
4686 arglist
= tree_cons (NULL_TREE
,
4687 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
))),
4693 /* We can't handle anything else with % args or %% ... yet. */
4694 if (strchr (TREE_STRING_POINTER (stripped_string
), '%'))
4697 /* When "string" doesn't contain %, replace all cases of
4698 fprintf(stream,string) with fputs(string,stream). The fputs
4699 builtin will take take of special cases like length==1. */
4700 arglist
= tree_cons (NULL_TREE
, TREE_VALUE (TREE_CHAIN (arglist
)),
4701 build_tree_list (NULL_TREE
, TREE_VALUE (arglist
)));
4705 return expand_expr (build_function_call (fn
, arglist
),
4706 (ignore
? const0_rtx
: target
),
4711 /* Given a boolean expression ARG, return a tree representing an increment
4712 or decrement (as indicated by CODE) of ARG. The front end must check for
4713 invalid cases (e.g., decrement in C++). */
4715 boolean_increment (code
, arg
)
4716 enum tree_code code
;
4720 tree true_res
= (c_language
== clk_cplusplus
4722 : c_bool_true_node
);
4723 arg
= stabilize_reference (arg
);
4726 case PREINCREMENT_EXPR
:
4727 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
4729 case POSTINCREMENT_EXPR
:
4730 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
4731 arg
= save_expr (arg
);
4732 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
4733 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
4735 case PREDECREMENT_EXPR
:
4736 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, invert_truthvalue (arg
));
4738 case POSTDECREMENT_EXPR
:
4739 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, invert_truthvalue (arg
));
4740 arg
= save_expr (arg
);
4741 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
4742 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
4747 TREE_SIDE_EFFECTS (val
) = 1;
4751 /* Built-in macros for stddef.h, that require macros defined in this
4754 c_stddef_cpp_builtins()
4756 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE
, 0);
4757 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE
, 0);
4758 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE
, 0);
4759 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE
, 0);
4763 c_init_attributes ()
4765 /* Fill in the built_in_attributes array. */
4766 #define DEF_ATTR_NULL_TREE(ENUM) \
4767 built_in_attributes[(int) ENUM] = NULL_TREE;
4768 #define DEF_ATTR_INT(ENUM, VALUE) \
4769 built_in_attributes[(int) ENUM] = build_int_2 (VALUE, VALUE < 0 ? -1 : 0);
4770 #define DEF_ATTR_IDENT(ENUM, STRING) \
4771 built_in_attributes[(int) ENUM] = get_identifier (STRING);
4772 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
4773 built_in_attributes[(int) ENUM] \
4774 = tree_cons (built_in_attributes[(int) PURPOSE], \
4775 built_in_attributes[(int) VALUE], \
4776 built_in_attributes[(int) CHAIN]);
4777 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No initialization needed. */
4778 #include "builtin-attrs.def"
4779 #undef DEF_ATTR_NULL_TREE
4781 #undef DEF_ATTR_IDENT
4782 #undef DEF_ATTR_TREE_LIST
4784 c_attrs_initialized
= true;
4787 /* Depending on the name of DECL, apply default attributes to it. */
4790 c_common_insert_default_attributes (decl
)
4793 tree name
= DECL_NAME (decl
);
4795 if (!c_attrs_initialized
)
4796 c_init_attributes ();
4798 #define DEF_ATTR_NULL_TREE(ENUM) /* Nothing needed after initialization. */
4799 #define DEF_ATTR_INT(ENUM, VALUE)
4800 #define DEF_ATTR_IDENT(ENUM, STRING)
4801 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN)
4802 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) \
4803 if ((PREDICATE) && name == built_in_attributes[(int) NAME]) \
4804 decl_attributes (&decl, built_in_attributes[(int) ATTRS], \
4805 ATTR_FLAG_BUILT_IN);
4806 #include "builtin-attrs.def"
4807 #undef DEF_ATTR_NULL_TREE
4809 #undef DEF_ATTR_IDENT
4810 #undef DEF_ATTR_TREE_LIST
4814 /* Output a -Wshadow warning MSGCODE about NAME, and give the location
4815 of the previous declaration DECL. MANDATORY says whether this is a
4816 mandatory warning (i.e. use pedwarn). */
4818 shadow_warning (msgcode
, mandatory
, name
, decl
)
4819 enum sw_kind msgcode
;
4820 int mandatory
; /* really bool */
4824 static const char *const msgs
[] = {
4825 /* SW_PARAM */ N_("declaration of \"%s\" shadows a parameter"),
4826 /* SW_LOCAL */ N_("declaration of \"%s\" shadows a previous local"),
4827 /* SW_GLOBAL */ N_("declaration of \"%s\" shadows a global declaration")
4830 (mandatory
? pedwarn
: warning
) (msgs
[msgcode
], name
);
4831 warning_with_file_and_line (DECL_SOURCE_FILE (decl
),
4832 DECL_SOURCE_LINE (decl
),
4833 "shadowed declaration is here");
4836 /* Attribute handlers common to C front ends. */
4838 /* Handle a "packed" attribute; arguments as in
4839 struct attribute_spec.handler. */
4842 handle_packed_attribute (node
, name
, args
, flags
, no_add_attrs
)
4845 tree args ATTRIBUTE_UNUSED
;
4852 if (TREE_CODE (*node
) == TYPE_DECL
)
4853 type
= &TREE_TYPE (*node
);
4860 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
4861 *type
= build_type_copy (*type
);
4862 TYPE_PACKED (*type
) = 1;
4864 else if (TREE_CODE (*node
) == FIELD_DECL
)
4865 DECL_PACKED (*node
) = 1;
4866 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
4867 used for DECL_REGISTER. It wouldn't mean anything anyway. */
4870 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4871 *no_add_attrs
= true;
4877 /* Handle a "nocommon" attribute; arguments as in
4878 struct attribute_spec.handler. */
4881 handle_nocommon_attribute (node
, name
, args
, flags
, no_add_attrs
)
4884 tree args ATTRIBUTE_UNUSED
;
4885 int flags ATTRIBUTE_UNUSED
;
4888 if (TREE_CODE (*node
) == VAR_DECL
)
4889 DECL_COMMON (*node
) = 0;
4892 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4893 *no_add_attrs
= true;
4899 /* Handle a "common" attribute; arguments as in
4900 struct attribute_spec.handler. */
4903 handle_common_attribute (node
, name
, args
, flags
, no_add_attrs
)
4906 tree args ATTRIBUTE_UNUSED
;
4907 int flags ATTRIBUTE_UNUSED
;
4910 if (TREE_CODE (*node
) == VAR_DECL
)
4911 DECL_COMMON (*node
) = 1;
4914 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4915 *no_add_attrs
= true;
4921 /* Handle a "noreturn" attribute; arguments as in
4922 struct attribute_spec.handler. */
4925 handle_noreturn_attribute (node
, name
, args
, flags
, no_add_attrs
)
4928 tree args ATTRIBUTE_UNUSED
;
4929 int flags ATTRIBUTE_UNUSED
;
4932 tree type
= TREE_TYPE (*node
);
4934 /* See FIXME comment in c_common_attribute_table. */
4935 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4936 TREE_THIS_VOLATILE (*node
) = 1;
4937 else if (TREE_CODE (type
) == POINTER_TYPE
4938 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
4940 = build_pointer_type
4941 (build_type_variant (TREE_TYPE (type
),
4942 TREE_READONLY (TREE_TYPE (type
)), 1));
4945 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4946 *no_add_attrs
= true;
4952 /* Handle a "noinline" attribute; arguments as in
4953 struct attribute_spec.handler. */
4956 handle_noinline_attribute (node
, name
, args
, flags
, no_add_attrs
)
4959 tree args ATTRIBUTE_UNUSED
;
4960 int flags ATTRIBUTE_UNUSED
;
4963 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4964 DECL_UNINLINABLE (*node
) = 1;
4967 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4968 *no_add_attrs
= true;
4974 /* Handle a "always_inline" attribute; arguments as in
4975 struct attribute_spec.handler. */
4978 handle_always_inline_attribute (node
, name
, args
, flags
, no_add_attrs
)
4981 tree args ATTRIBUTE_UNUSED
;
4982 int flags ATTRIBUTE_UNUSED
;
4985 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4987 /* Do nothing else, just set the attribute. We'll get at
4988 it later with lookup_attribute. */
4992 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4993 *no_add_attrs
= true;
4999 /* Handle a "used" attribute; arguments as in
5000 struct attribute_spec.handler. */
5003 handle_used_attribute (pnode
, name
, args
, flags
, no_add_attrs
)
5006 tree args ATTRIBUTE_UNUSED
;
5007 int flags ATTRIBUTE_UNUSED
;
5012 if (TREE_CODE (node
) == FUNCTION_DECL
5013 || (TREE_CODE (node
) == VAR_DECL
&& TREE_STATIC (node
)))
5014 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (node
))
5015 = TREE_USED (node
) = 1;
5018 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5019 *no_add_attrs
= true;
5025 /* Handle a "unused" attribute; arguments as in
5026 struct attribute_spec.handler. */
5029 handle_unused_attribute (node
, name
, args
, flags
, no_add_attrs
)
5032 tree args ATTRIBUTE_UNUSED
;
5040 if (TREE_CODE (decl
) == PARM_DECL
5041 || TREE_CODE (decl
) == VAR_DECL
5042 || TREE_CODE (decl
) == FUNCTION_DECL
5043 || TREE_CODE (decl
) == LABEL_DECL
5044 || TREE_CODE (decl
) == TYPE_DECL
)
5045 TREE_USED (decl
) = 1;
5048 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5049 *no_add_attrs
= true;
5054 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
5055 *node
= build_type_copy (*node
);
5056 TREE_USED (*node
) = 1;
5062 /* Handle a "const" attribute; arguments as in
5063 struct attribute_spec.handler. */
5066 handle_const_attribute (node
, name
, args
, flags
, no_add_attrs
)
5069 tree args ATTRIBUTE_UNUSED
;
5070 int flags ATTRIBUTE_UNUSED
;
5073 tree type
= TREE_TYPE (*node
);
5075 /* See FIXME comment on noreturn in c_common_attribute_table. */
5076 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5077 TREE_READONLY (*node
) = 1;
5078 else if (TREE_CODE (type
) == POINTER_TYPE
5079 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
5081 = build_pointer_type
5082 (build_type_variant (TREE_TYPE (type
), 1,
5083 TREE_THIS_VOLATILE (TREE_TYPE (type
))));
5086 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5087 *no_add_attrs
= true;
5093 /* Handle a "transparent_union" attribute; arguments as in
5094 struct attribute_spec.handler. */
5097 handle_transparent_union_attribute (node
, name
, args
, flags
, no_add_attrs
)
5100 tree args ATTRIBUTE_UNUSED
;
5104 tree decl
= NULL_TREE
;
5111 type
= &TREE_TYPE (decl
);
5112 is_type
= TREE_CODE (*node
) == TYPE_DECL
;
5114 else if (TYPE_P (*node
))
5115 type
= node
, is_type
= 1;
5118 && TREE_CODE (*type
) == UNION_TYPE
5120 || (TYPE_FIELDS (*type
) != 0
5121 && TYPE_MODE (*type
) == DECL_MODE (TYPE_FIELDS (*type
)))))
5123 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
5124 *type
= build_type_copy (*type
);
5125 TYPE_TRANSPARENT_UNION (*type
) = 1;
5127 else if (decl
!= 0 && TREE_CODE (decl
) == PARM_DECL
5128 && TREE_CODE (*type
) == UNION_TYPE
5129 && TYPE_MODE (*type
) == DECL_MODE (TYPE_FIELDS (*type
)))
5130 DECL_TRANSPARENT_UNION (decl
) = 1;
5133 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5134 *no_add_attrs
= true;
5140 /* Handle a "constructor" attribute; arguments as in
5141 struct attribute_spec.handler. */
5144 handle_constructor_attribute (node
, name
, args
, flags
, no_add_attrs
)
5147 tree args ATTRIBUTE_UNUSED
;
5148 int flags ATTRIBUTE_UNUSED
;
5152 tree type
= TREE_TYPE (decl
);
5154 if (TREE_CODE (decl
) == FUNCTION_DECL
5155 && TREE_CODE (type
) == FUNCTION_TYPE
5156 && decl_function_context (decl
) == 0)
5158 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
5159 TREE_USED (decl
) = 1;
5163 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5164 *no_add_attrs
= true;
5170 /* Handle a "destructor" attribute; arguments as in
5171 struct attribute_spec.handler. */
5174 handle_destructor_attribute (node
, name
, args
, flags
, no_add_attrs
)
5177 tree args ATTRIBUTE_UNUSED
;
5178 int flags ATTRIBUTE_UNUSED
;
5182 tree type
= TREE_TYPE (decl
);
5184 if (TREE_CODE (decl
) == FUNCTION_DECL
5185 && TREE_CODE (type
) == FUNCTION_TYPE
5186 && decl_function_context (decl
) == 0)
5188 DECL_STATIC_DESTRUCTOR (decl
) = 1;
5189 TREE_USED (decl
) = 1;
5193 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5194 *no_add_attrs
= true;
5200 /* Handle a "mode" attribute; arguments as in
5201 struct attribute_spec.handler. */
5204 handle_mode_attribute (node
, name
, args
, flags
, no_add_attrs
)
5208 int flags ATTRIBUTE_UNUSED
;
5213 *no_add_attrs
= true;
5215 if (TREE_CODE (TREE_VALUE (args
)) != IDENTIFIER_NODE
)
5216 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5220 const char *p
= IDENTIFIER_POINTER (TREE_VALUE (args
));
5221 int len
= strlen (p
);
5222 enum machine_mode mode
= VOIDmode
;
5226 if (len
> 4 && p
[0] == '_' && p
[1] == '_'
5227 && p
[len
- 1] == '_' && p
[len
- 2] == '_')
5229 char *newp
= (char *) alloca (len
- 1);
5231 strcpy (newp
, &p
[2]);
5232 newp
[len
- 4] = '\0';
5236 /* Change this type to have a type with the specified mode.
5237 First check for the special modes. */
5238 if (! strcmp (p
, "byte"))
5240 else if (!strcmp (p
, "word"))
5242 else if (! strcmp (p
, "pointer"))
5245 for (j
= 0; j
< NUM_MACHINE_MODES
; j
++)
5246 if (!strcmp (p
, GET_MODE_NAME (j
)))
5247 mode
= (enum machine_mode
) j
;
5249 if (mode
== VOIDmode
)
5250 error ("unknown machine mode `%s'", p
);
5251 else if (0 == (typefm
= (*lang_hooks
.types
.type_for_mode
)
5252 (mode
, TREE_UNSIGNED (type
))))
5253 error ("no data type for mode `%s'", p
);
5254 else if ((TREE_CODE (type
) == POINTER_TYPE
5255 || TREE_CODE (type
) == REFERENCE_TYPE
)
5256 && !(*targetm
.valid_pointer_mode
) (mode
))
5257 error ("invalid pointer mode `%s'", p
);
5260 /* If this is a vector, make sure we either have hardware
5261 support, or we can emulate it. */
5262 if ((GET_MODE_CLASS (mode
) == MODE_VECTOR_INT
5263 || GET_MODE_CLASS (mode
) == MODE_VECTOR_FLOAT
)
5264 && !vector_mode_valid_p (mode
))
5266 error ("unable to emulate '%s'", GET_MODE_NAME (mode
));
5270 if (TREE_CODE (type
) == POINTER_TYPE
)
5272 ptr_type
= build_pointer_type_for_mode (TREE_TYPE (type
),
5276 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
5278 ptr_type
= build_reference_type_for_mode (TREE_TYPE (type
),
5284 /* No need to layout the type here. The caller should do this. */
5291 /* Handle a "section" attribute; arguments as in
5292 struct attribute_spec.handler. */
5295 handle_section_attribute (node
, name
, args
, flags
, no_add_attrs
)
5297 tree name ATTRIBUTE_UNUSED
;
5299 int flags ATTRIBUTE_UNUSED
;
5304 if (targetm
.have_named_sections
)
5306 if ((TREE_CODE (decl
) == FUNCTION_DECL
5307 || TREE_CODE (decl
) == VAR_DECL
)
5308 && TREE_CODE (TREE_VALUE (args
)) == STRING_CST
)
5310 if (TREE_CODE (decl
) == VAR_DECL
5311 && current_function_decl
!= NULL_TREE
5312 && ! TREE_STATIC (decl
))
5314 error_with_decl (decl
,
5315 "section attribute cannot be specified for local variables");
5316 *no_add_attrs
= true;
5319 /* The decl may have already been given a section attribute
5320 from a previous declaration. Ensure they match. */
5321 else if (DECL_SECTION_NAME (decl
) != NULL_TREE
5322 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl
)),
5323 TREE_STRING_POINTER (TREE_VALUE (args
))) != 0)
5325 error_with_decl (*node
,
5326 "section of `%s' conflicts with previous declaration");
5327 *no_add_attrs
= true;
5330 DECL_SECTION_NAME (decl
) = TREE_VALUE (args
);
5334 error_with_decl (*node
,
5335 "section attribute not allowed for `%s'");
5336 *no_add_attrs
= true;
5341 error_with_decl (*node
,
5342 "section attributes are not supported for this target");
5343 *no_add_attrs
= true;
5349 /* Handle a "aligned" attribute; arguments as in
5350 struct attribute_spec.handler. */
5353 handle_aligned_attribute (node
, name
, args
, flags
, no_add_attrs
)
5355 tree name ATTRIBUTE_UNUSED
;
5360 tree decl
= NULL_TREE
;
5363 tree align_expr
= (args
? TREE_VALUE (args
)
5364 : size_int (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
));
5370 type
= &TREE_TYPE (decl
);
5371 is_type
= TREE_CODE (*node
) == TYPE_DECL
;
5373 else if (TYPE_P (*node
))
5374 type
= node
, is_type
= 1;
5376 /* Strip any NOPs of any kind. */
5377 while (TREE_CODE (align_expr
) == NOP_EXPR
5378 || TREE_CODE (align_expr
) == CONVERT_EXPR
5379 || TREE_CODE (align_expr
) == NON_LVALUE_EXPR
)
5380 align_expr
= TREE_OPERAND (align_expr
, 0);
5382 if (TREE_CODE (align_expr
) != INTEGER_CST
)
5384 error ("requested alignment is not a constant");
5385 *no_add_attrs
= true;
5387 else if ((i
= tree_log2 (align_expr
)) == -1)
5389 error ("requested alignment is not a power of 2");
5390 *no_add_attrs
= true;
5392 else if (i
> HOST_BITS_PER_INT
- 2)
5394 error ("requested alignment is too large");
5395 *no_add_attrs
= true;
5399 /* If we have a TYPE_DECL, then copy the type, so that we
5400 don't accidentally modify a builtin type. See pushdecl. */
5401 if (decl
&& TREE_TYPE (decl
) != error_mark_node
5402 && DECL_ORIGINAL_TYPE (decl
) == NULL_TREE
)
5404 tree tt
= TREE_TYPE (decl
);
5405 *type
= build_type_copy (*type
);
5406 DECL_ORIGINAL_TYPE (decl
) = tt
;
5407 TYPE_NAME (*type
) = decl
;
5408 TREE_USED (*type
) = TREE_USED (decl
);
5409 TREE_TYPE (decl
) = *type
;
5411 else if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
5412 *type
= build_type_copy (*type
);
5414 TYPE_ALIGN (*type
) = (1 << i
) * BITS_PER_UNIT
;
5415 TYPE_USER_ALIGN (*type
) = 1;
5417 else if (TREE_CODE (decl
) != VAR_DECL
5418 && TREE_CODE (decl
) != FIELD_DECL
)
5420 error_with_decl (decl
,
5421 "alignment may not be specified for `%s'");
5422 *no_add_attrs
= true;
5426 DECL_ALIGN (decl
) = (1 << i
) * BITS_PER_UNIT
;
5427 DECL_USER_ALIGN (decl
) = 1;
5433 /* Handle a "weak" attribute; arguments as in
5434 struct attribute_spec.handler. */
5437 handle_weak_attribute (node
, name
, args
, flags
, no_add_attrs
)
5439 tree name ATTRIBUTE_UNUSED
;
5440 tree args ATTRIBUTE_UNUSED
;
5441 int flags ATTRIBUTE_UNUSED
;
5442 bool *no_add_attrs ATTRIBUTE_UNUSED
;
5444 declare_weak (*node
);
5449 /* Handle an "alias" attribute; arguments as in
5450 struct attribute_spec.handler. */
5453 handle_alias_attribute (node
, name
, args
, flags
, no_add_attrs
)
5457 int flags ATTRIBUTE_UNUSED
;
5462 if ((TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_INITIAL (decl
))
5463 || (TREE_CODE (decl
) != FUNCTION_DECL
&& ! DECL_EXTERNAL (decl
)))
5465 error_with_decl (decl
,
5466 "`%s' defined both normally and as an alias");
5467 *no_add_attrs
= true;
5469 else if (decl_function_context (decl
) == 0)
5473 id
= TREE_VALUE (args
);
5474 if (TREE_CODE (id
) != STRING_CST
)
5476 error ("alias arg not a string");
5477 *no_add_attrs
= true;
5480 id
= get_identifier (TREE_STRING_POINTER (id
));
5481 /* This counts as a use of the object pointed to. */
5484 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5485 DECL_INITIAL (decl
) = error_mark_node
;
5487 DECL_EXTERNAL (decl
) = 0;
5491 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5492 *no_add_attrs
= true;
5498 /* Handle an "visibility" attribute; arguments as in
5499 struct attribute_spec.handler. */
5502 handle_visibility_attribute (node
, name
, args
, flags
, no_add_attrs
)
5506 int flags ATTRIBUTE_UNUSED
;
5511 if (decl_function_context (decl
) != 0 || ! TREE_PUBLIC (decl
))
5513 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5514 *no_add_attrs
= true;
5520 id
= TREE_VALUE (args
);
5521 if (TREE_CODE (id
) != STRING_CST
)
5523 error ("visibility arg not a string");
5524 *no_add_attrs
= true;
5527 if (strcmp (TREE_STRING_POINTER (id
), "hidden")
5528 && strcmp (TREE_STRING_POINTER (id
), "protected")
5529 && strcmp (TREE_STRING_POINTER (id
), "internal")
5530 && strcmp (TREE_STRING_POINTER (id
), "default"))
5532 error ("visibility arg must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
5533 *no_add_attrs
= true;
5541 /* Handle an "tls_model" attribute; arguments as in
5542 struct attribute_spec.handler. */
5545 handle_tls_model_attribute (node
, name
, args
, flags
, no_add_attrs
)
5549 int flags ATTRIBUTE_UNUSED
;
5554 if (! DECL_THREAD_LOCAL (decl
))
5556 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5557 *no_add_attrs
= true;
5563 id
= TREE_VALUE (args
);
5564 if (TREE_CODE (id
) != STRING_CST
)
5566 error ("tls_model arg not a string");
5567 *no_add_attrs
= true;
5570 if (strcmp (TREE_STRING_POINTER (id
), "local-exec")
5571 && strcmp (TREE_STRING_POINTER (id
), "initial-exec")
5572 && strcmp (TREE_STRING_POINTER (id
), "local-dynamic")
5573 && strcmp (TREE_STRING_POINTER (id
), "global-dynamic"))
5575 error ("tls_model arg must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
5576 *no_add_attrs
= true;
5584 /* Handle a "no_instrument_function" attribute; arguments as in
5585 struct attribute_spec.handler. */
5588 handle_no_instrument_function_attribute (node
, name
, args
, flags
, no_add_attrs
)
5591 tree args ATTRIBUTE_UNUSED
;
5592 int flags ATTRIBUTE_UNUSED
;
5597 if (TREE_CODE (decl
) != FUNCTION_DECL
)
5599 error_with_decl (decl
,
5600 "`%s' attribute applies only to functions",
5601 IDENTIFIER_POINTER (name
));
5602 *no_add_attrs
= true;
5604 else if (DECL_INITIAL (decl
))
5606 error_with_decl (decl
,
5607 "can't set `%s' attribute after definition",
5608 IDENTIFIER_POINTER (name
));
5609 *no_add_attrs
= true;
5612 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl
) = 1;
5617 /* Handle a "malloc" attribute; arguments as in
5618 struct attribute_spec.handler. */
5621 handle_malloc_attribute (node
, name
, args
, flags
, no_add_attrs
)
5624 tree args ATTRIBUTE_UNUSED
;
5625 int flags ATTRIBUTE_UNUSED
;
5628 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5629 DECL_IS_MALLOC (*node
) = 1;
5630 /* ??? TODO: Support types. */
5633 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5634 *no_add_attrs
= true;
5640 /* Handle a "no_limit_stack" attribute; arguments as in
5641 struct attribute_spec.handler. */
5644 handle_no_limit_stack_attribute (node
, name
, args
, flags
, no_add_attrs
)
5647 tree args ATTRIBUTE_UNUSED
;
5648 int flags ATTRIBUTE_UNUSED
;
5653 if (TREE_CODE (decl
) != FUNCTION_DECL
)
5655 error_with_decl (decl
,
5656 "`%s' attribute applies only to functions",
5657 IDENTIFIER_POINTER (name
));
5658 *no_add_attrs
= true;
5660 else if (DECL_INITIAL (decl
))
5662 error_with_decl (decl
,
5663 "can't set `%s' attribute after definition",
5664 IDENTIFIER_POINTER (name
));
5665 *no_add_attrs
= true;
5668 DECL_NO_LIMIT_STACK (decl
) = 1;
5673 /* Handle a "pure" attribute; arguments as in
5674 struct attribute_spec.handler. */
5677 handle_pure_attribute (node
, name
, args
, flags
, no_add_attrs
)
5680 tree args ATTRIBUTE_UNUSED
;
5681 int flags ATTRIBUTE_UNUSED
;
5684 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5685 DECL_IS_PURE (*node
) = 1;
5686 /* ??? TODO: Support types. */
5689 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5690 *no_add_attrs
= true;
5696 /* Handle a "deprecated" attribute; arguments as in
5697 struct attribute_spec.handler. */
5700 handle_deprecated_attribute (node
, name
, args
, flags
, no_add_attrs
)
5703 tree args ATTRIBUTE_UNUSED
;
5707 tree type
= NULL_TREE
;
5709 const char *what
= NULL
;
5714 type
= TREE_TYPE (decl
);
5716 if (TREE_CODE (decl
) == TYPE_DECL
5717 || TREE_CODE (decl
) == PARM_DECL
5718 || TREE_CODE (decl
) == VAR_DECL
5719 || TREE_CODE (decl
) == FUNCTION_DECL
5720 || TREE_CODE (decl
) == FIELD_DECL
)
5721 TREE_DEPRECATED (decl
) = 1;
5725 else if (TYPE_P (*node
))
5727 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
5728 *node
= build_type_copy (*node
);
5729 TREE_DEPRECATED (*node
) = 1;
5737 *no_add_attrs
= true;
5738 if (type
&& TYPE_NAME (type
))
5740 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
5741 what
= IDENTIFIER_POINTER (TYPE_NAME (*node
));
5742 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
5743 && DECL_NAME (TYPE_NAME (type
)))
5744 what
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)));
5747 warning ("`%s' attribute ignored for `%s'",
5748 IDENTIFIER_POINTER (name
), what
);
5750 warning ("`%s' attribute ignored",
5751 IDENTIFIER_POINTER (name
));
5757 /* Keep a list of vector type nodes we created in handle_vector_size_attribute,
5758 to prevent us from duplicating type nodes unnecessarily.
5759 The normal mechanism to prevent duplicates is to use type_hash_canon, but
5760 since we want to distinguish types that are essentially identical (except
5761 for their debug representation), we use a local list here. */
5762 static GTY(()) tree vector_type_node_list
= 0;
5764 /* Handle a "vector_size" attribute; arguments as in
5765 struct attribute_spec.handler. */
5768 handle_vector_size_attribute (node
, name
, args
, flags
, no_add_attrs
)
5772 int flags ATTRIBUTE_UNUSED
;
5775 unsigned HOST_WIDE_INT vecsize
, nunits
;
5776 enum machine_mode mode
, orig_mode
, new_mode
;
5777 tree type
= *node
, new_type
= NULL_TREE
;
5778 tree type_list_node
;
5780 *no_add_attrs
= true;
5782 if (! host_integerp (TREE_VALUE (args
), 1))
5784 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5788 /* Get the vector size (in bytes). */
5789 vecsize
= tree_low_cst (TREE_VALUE (args
), 1);
5791 /* We need to provide for vector pointers, vector arrays, and
5792 functions returning vectors. For example:
5794 __attribute__((vector_size(16))) short *foo;
5796 In this case, the mode is SI, but the type being modified is
5797 HI, so we need to look further. */
5799 while (POINTER_TYPE_P (type
)
5800 || TREE_CODE (type
) == FUNCTION_TYPE
5801 || TREE_CODE (type
) == ARRAY_TYPE
)
5802 type
= TREE_TYPE (type
);
5804 /* Get the mode of the type being modified. */
5805 orig_mode
= TYPE_MODE (type
);
5807 if (TREE_CODE (type
) == RECORD_TYPE
5808 || (GET_MODE_CLASS (orig_mode
) != MODE_FLOAT
5809 && GET_MODE_CLASS (orig_mode
) != MODE_INT
)
5810 || ! host_integerp (TYPE_SIZE_UNIT (type
), 1))
5812 error ("invalid vector type for attribute `%s'",
5813 IDENTIFIER_POINTER (name
));
5817 /* Calculate how many units fit in the vector. */
5818 nunits
= vecsize
/ tree_low_cst (TYPE_SIZE_UNIT (type
), 1);
5820 /* Find a suitably sized vector. */
5821 new_mode
= VOIDmode
;
5822 for (mode
= GET_CLASS_NARROWEST_MODE (GET_MODE_CLASS (orig_mode
) == MODE_INT
5824 : MODE_VECTOR_FLOAT
);
5826 mode
= GET_MODE_WIDER_MODE (mode
))
5827 if (vecsize
== GET_MODE_SIZE (mode
)
5828 && nunits
== (unsigned HOST_WIDE_INT
) GET_MODE_NUNITS (mode
))
5834 if (new_mode
== VOIDmode
)
5836 error ("no vector mode with the size and type specified could be found");
5840 for (type_list_node
= vector_type_node_list
; type_list_node
;
5841 type_list_node
= TREE_CHAIN (type_list_node
))
5843 tree other_type
= TREE_VALUE (type_list_node
);
5844 tree record
= TYPE_DEBUG_REPRESENTATION_TYPE (other_type
);
5845 tree fields
= TYPE_FIELDS (record
);
5846 tree field_type
= TREE_TYPE (fields
);
5847 tree array_type
= TREE_TYPE (field_type
);
5848 if (TREE_CODE (fields
) != FIELD_DECL
5849 || TREE_CODE (field_type
) != ARRAY_TYPE
)
5852 if (TYPE_MODE (other_type
) == mode
&& type
== array_type
)
5854 new_type
= other_type
;
5859 if (new_type
== NULL_TREE
)
5861 tree index
, array
, rt
, list_node
;
5863 new_type
= (*lang_hooks
.types
.type_for_mode
) (new_mode
,
5864 TREE_UNSIGNED (type
));
5868 error ("no vector mode with the size and type specified could be found");
5872 new_type
= build_type_copy (new_type
);
5874 /* If this is a vector, make sure we either have hardware
5875 support, or we can emulate it. */
5876 if ((GET_MODE_CLASS (mode
) == MODE_VECTOR_INT
5877 || GET_MODE_CLASS (mode
) == MODE_VECTOR_FLOAT
)
5878 && !vector_mode_valid_p (mode
))
5880 error ("unable to emulate '%s'", GET_MODE_NAME (mode
));
5884 /* Set the debug information here, because this is the only
5885 place where we know the underlying type for a vector made
5886 with vector_size. For debugging purposes we pretend a vector
5887 is an array within a structure. */
5888 index
= build_int_2 (TYPE_VECTOR_SUBPARTS (new_type
) - 1, 0);
5889 array
= build_array_type (type
, build_index_type (index
));
5890 rt
= make_node (RECORD_TYPE
);
5892 TYPE_FIELDS (rt
) = build_decl (FIELD_DECL
, get_identifier ("f"), array
);
5893 DECL_CONTEXT (TYPE_FIELDS (rt
)) = rt
;
5895 TYPE_DEBUG_REPRESENTATION_TYPE (new_type
) = rt
;
5897 list_node
= build_tree_list (NULL
, new_type
);
5898 TREE_CHAIN (list_node
) = vector_type_node_list
;
5899 vector_type_node_list
= list_node
;
5902 /* Build back pointers if needed. */
5903 *node
= vector_size_helper (*node
, new_type
);
5908 /* HACK. GROSS. This is absolutely disgusting. I wish there was a
5911 If we requested a pointer to a vector, build up the pointers that
5912 we stripped off while looking for the inner type. Similarly for
5913 return values from functions.
5915 The argument "type" is the top of the chain, and "bottom" is the
5916 new type which we will point to. */
5919 vector_size_helper (type
, bottom
)
5924 if (POINTER_TYPE_P (type
))
5926 inner
= vector_size_helper (TREE_TYPE (type
), bottom
);
5927 outer
= build_pointer_type (inner
);
5929 else if (TREE_CODE (type
) == ARRAY_TYPE
)
5931 inner
= vector_size_helper (TREE_TYPE (type
), bottom
);
5932 outer
= build_array_type (inner
, TYPE_VALUES (type
));
5934 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
5936 inner
= vector_size_helper (TREE_TYPE (type
), bottom
);
5937 outer
= build_function_type (inner
, TYPE_VALUES (type
));
5942 TREE_READONLY (outer
) = TREE_READONLY (type
);
5943 TREE_THIS_VOLATILE (outer
) = TREE_THIS_VOLATILE (type
);
5948 /* Handle the "nonnull" attribute. */
5950 handle_nonnull_attribute (node
, name
, args
, flags
, no_add_attrs
)
5952 tree name ATTRIBUTE_UNUSED
;
5954 int flags ATTRIBUTE_UNUSED
;
5958 unsigned HOST_WIDE_INT attr_arg_num
;
5960 /* If no arguments are specified, all pointer arguments should be
5961 non-null. Verify a full prototype is given so that the arguments
5962 will have the correct types when we actually check them later. */
5965 if (! TYPE_ARG_TYPES (type
))
5967 error ("nonnull attribute without arguments on a non-prototype");
5968 *no_add_attrs
= true;
5973 /* Argument list specified. Verify that each argument number references
5974 a pointer argument. */
5975 for (attr_arg_num
= 1; args
; args
= TREE_CHAIN (args
))
5978 unsigned HOST_WIDE_INT arg_num
, ck_num
;
5980 if (! get_nonnull_operand (TREE_VALUE (args
), &arg_num
))
5982 error ("nonnull argument has invalid operand number (arg %lu)",
5983 (unsigned long) attr_arg_num
);
5984 *no_add_attrs
= true;
5988 argument
= TYPE_ARG_TYPES (type
);
5991 for (ck_num
= 1; ; ck_num
++)
5993 if (! argument
|| ck_num
== arg_num
)
5995 argument
= TREE_CHAIN (argument
);
5999 || TREE_CODE (TREE_VALUE (argument
)) == VOID_TYPE
)
6001 error ("nonnull argument with out-of-range operand number (arg %lu, operand %lu)",
6002 (unsigned long) attr_arg_num
, (unsigned long) arg_num
);
6003 *no_add_attrs
= true;
6007 if (TREE_CODE (TREE_VALUE (argument
)) != POINTER_TYPE
)
6009 error ("nonnull argument references non-pointer operand (arg %lu, operand %lu)",
6010 (unsigned long) attr_arg_num
, (unsigned long) arg_num
);
6011 *no_add_attrs
= true;
6020 /* Check the argument list of a function call for null in argument slots
6021 that are marked as requiring a non-null pointer argument. */
6024 check_function_nonnull (attrs
, params
)
6028 tree a
, args
, param
;
6031 for (a
= attrs
; a
; a
= TREE_CHAIN (a
))
6033 if (is_attribute_p ("nonnull", TREE_PURPOSE (a
)))
6035 args
= TREE_VALUE (a
);
6037 /* Walk the argument list. If we encounter an argument number we
6038 should check for non-null, do it. If the attribute has no args,
6039 then every pointer argument is checked (in which case the check
6040 for pointer type is done in check_nonnull_arg). */
6041 for (param
= params
, param_num
= 1; ;
6042 param_num
++, param
= TREE_CHAIN (param
))
6046 if (! args
|| nonnull_check_p (args
, param_num
))
6047 check_function_arguments_recurse (check_nonnull_arg
, NULL
,
6055 /* Helper for check_function_nonnull; given a list of operands which
6056 must be non-null in ARGS, determine if operand PARAM_NUM should be
6060 nonnull_check_p (args
, param_num
)
6062 unsigned HOST_WIDE_INT param_num
;
6064 unsigned HOST_WIDE_INT arg_num
;
6066 for (; args
; args
= TREE_CHAIN (args
))
6068 if (! get_nonnull_operand (TREE_VALUE (args
), &arg_num
))
6071 if (arg_num
== param_num
)
6077 /* Check that the function argument PARAM (which is operand number
6078 PARAM_NUM) is non-null. This is called by check_function_nonnull
6079 via check_function_arguments_recurse. */
6082 check_nonnull_arg (ctx
, param
, param_num
)
6083 void *ctx ATTRIBUTE_UNUSED
;
6085 unsigned HOST_WIDE_INT param_num
;
6087 /* Just skip checking the argument if it's not a pointer. This can
6088 happen if the "nonnull" attribute was given without an operand
6089 list (which means to check every pointer argument). */
6091 if (TREE_CODE (TREE_TYPE (param
)) != POINTER_TYPE
)
6094 if (integer_zerop (param
))
6095 warning ("null argument where non-null required (arg %lu)",
6096 (unsigned long) param_num
);
6099 /* Helper for nonnull attribute handling; fetch the operand number
6100 from the attribute argument list. */
6103 get_nonnull_operand (arg_num_expr
, valp
)
6105 unsigned HOST_WIDE_INT
*valp
;
6107 /* Strip any conversions from the arg number and verify they
6109 while (TREE_CODE (arg_num_expr
) == NOP_EXPR
6110 || TREE_CODE (arg_num_expr
) == CONVERT_EXPR
6111 || TREE_CODE (arg_num_expr
) == NON_LVALUE_EXPR
)
6112 arg_num_expr
= TREE_OPERAND (arg_num_expr
, 0);
6114 if (TREE_CODE (arg_num_expr
) != INTEGER_CST
6115 || TREE_INT_CST_HIGH (arg_num_expr
) != 0)
6118 *valp
= TREE_INT_CST_LOW (arg_num_expr
);
6122 /* Handle a "nothrow" attribute; arguments as in
6123 struct attribute_spec.handler. */
6126 handle_nothrow_attribute (node
, name
, args
, flags
, no_add_attrs
)
6129 tree args ATTRIBUTE_UNUSED
;
6130 int flags ATTRIBUTE_UNUSED
;
6133 if (TREE_CODE (*node
) == FUNCTION_DECL
)
6134 TREE_NOTHROW (*node
) = 1;
6135 /* ??? TODO: Support types. */
6138 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
6139 *no_add_attrs
= true;
6145 /* Check for valid arguments being passed to a function. */
6147 check_function_arguments (attrs
, params
)
6151 /* Check for null being passed in a pointer argument that must be
6152 non-null. We also need to do this if format checking is enabled. */
6155 check_function_nonnull (attrs
, params
);
6157 /* Check for errors in format strings. */
6160 check_function_format (NULL
, attrs
, params
);
6163 /* Generic argument checking recursion routine. PARAM is the argument to
6164 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
6165 once the argument is resolved. CTX is context for the callback. */
6167 check_function_arguments_recurse (callback
, ctx
, param
, param_num
)
6168 void (*callback
) PARAMS ((void *, tree
, unsigned HOST_WIDE_INT
));
6171 unsigned HOST_WIDE_INT param_num
;
6173 if (TREE_CODE (param
) == NOP_EXPR
)
6175 /* Strip coercion. */
6176 check_function_arguments_recurse (callback
, ctx
,
6177 TREE_OPERAND (param
, 0), param_num
);
6181 if (TREE_CODE (param
) == CALL_EXPR
)
6183 tree type
= TREE_TYPE (TREE_TYPE (TREE_OPERAND (param
, 0)));
6185 bool found_format_arg
= false;
6187 /* See if this is a call to a known internationalization function
6188 that modifies a format arg. Such a function may have multiple
6189 format_arg attributes (for example, ngettext). */
6191 for (attrs
= TYPE_ATTRIBUTES (type
);
6193 attrs
= TREE_CHAIN (attrs
))
6194 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs
)))
6197 tree format_num_expr
;
6201 /* Extract the argument number, which was previously checked
6203 format_num_expr
= TREE_VALUE (TREE_VALUE (attrs
));
6204 while (TREE_CODE (format_num_expr
) == NOP_EXPR
6205 || TREE_CODE (format_num_expr
) == CONVERT_EXPR
6206 || TREE_CODE (format_num_expr
) == NON_LVALUE_EXPR
)
6207 format_num_expr
= TREE_OPERAND (format_num_expr
, 0);
6209 if (TREE_CODE (format_num_expr
) != INTEGER_CST
6210 || TREE_INT_CST_HIGH (format_num_expr
) != 0)
6213 format_num
= TREE_INT_CST_LOW (format_num_expr
);
6215 for (inner_args
= TREE_OPERAND (param
, 1), i
= 1;
6217 inner_args
= TREE_CHAIN (inner_args
), i
++)
6218 if (i
== format_num
)
6220 check_function_arguments_recurse (callback
, ctx
,
6221 TREE_VALUE (inner_args
),
6223 found_format_arg
= true;
6228 /* If we found a format_arg attribute and did a recursive check,
6229 we are done with checking this argument. Otherwise, we continue
6230 and this will be considered a non-literal. */
6231 if (found_format_arg
)
6235 if (TREE_CODE (param
) == COND_EXPR
)
6237 /* Check both halves of the conditional expression. */
6238 check_function_arguments_recurse (callback
, ctx
,
6239 TREE_OPERAND (param
, 1), param_num
);
6240 check_function_arguments_recurse (callback
, ctx
,
6241 TREE_OPERAND (param
, 2), param_num
);
6245 (*callback
) (ctx
, param
, param_num
);
6248 #include "gt-c-common.h"