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 /* TRUE if a code represents a statement. The front end init
191 langhook should take care of initialization of this array. */
193 bool statement_code_p
[MAX_TREE_CODES
];
195 /* Nonzero if we can read a PCH file now. */
199 /* Switches common to the C front ends. */
201 /* Nonzero if prepreprocessing only. */
203 int flag_preprocess_only
;
205 /* Nonzero means don't output line number information. */
207 char flag_no_line_commands
;
209 /* Nonzero causes -E output not to be done, but directives such as
210 #define that have side effects are still obeyed. */
214 /* Nonzero means dump macros in some fashion. */
216 char flag_dump_macros
;
218 /* Nonzero means pass #include lines through to the output. */
220 char flag_dump_includes
;
222 /* The file name to which we should write a precompiled header, or
223 NULL if no header will be written in this compile. */
225 const char *pch_file
;
227 /* Nonzero if an ISO standard was selected. It rejects macros in the
231 /* Nonzero whenever Objective-C functionality is being used. */
234 /* Nonzero if -undef was given. It suppresses target built-in macros
238 /* Nonzero means don't recognize the non-ANSI builtin functions. */
242 /* Nonzero means don't recognize the non-ANSI builtin functions.
245 int flag_no_nonansi_builtin
;
247 /* Nonzero means give `double' the same size as `float'. */
249 int flag_short_double
;
251 /* Nonzero means give `wchar_t' the same size as `short'. */
253 int flag_short_wchar
;
255 /* Nonzero means allow Microsoft extensions without warnings or errors. */
256 int flag_ms_extensions
;
258 /* Nonzero means don't recognize the keyword `asm'. */
262 /* Nonzero means give string constants the type `const char *', as mandated
265 int flag_const_strings
;
267 /* Nonzero means `$' can be in an identifier. */
269 #ifndef DOLLARS_IN_IDENTIFIERS
270 #define DOLLARS_IN_IDENTIFIERS 1
272 int dollars_in_ident
= DOLLARS_IN_IDENTIFIERS
;
274 /* Nonzero means to treat bitfields as signed unless they say `unsigned'. */
276 int flag_signed_bitfields
= 1;
277 int explicit_flag_signed_bitfields
;
279 /* Nonzero means warn about pointer casts that can drop a type qualifier
280 from the pointer target type. */
284 /* Warn about functions which might be candidates for format attributes. */
286 int warn_missing_format_attribute
;
288 /* Nonzero means warn about sizeof(function) or addition/subtraction
289 of function pointers. */
291 int warn_pointer_arith
;
293 /* Nonzero means warn for any global function def
294 without separate previous prototype decl. */
296 int warn_missing_prototypes
;
298 /* Warn if adding () is suggested. */
300 int warn_parentheses
;
302 /* Warn if initializer is not completely bracketed. */
304 int warn_missing_braces
;
306 /* Warn about comparison of signed and unsigned values.
307 If -1, neither -Wsign-compare nor -Wno-sign-compare has been specified. */
309 int warn_sign_compare
;
311 /* Nonzero means warn about usage of long long when `-pedantic'. */
313 int warn_long_long
= 1;
315 /* Nonzero means warn about deprecated conversion from string constant to
318 int warn_write_strings
;
320 /* Nonzero means warn about multiple (redundant) decls for the same single
321 variable or function. */
323 int warn_redundant_decls
;
325 /* Warn about testing equality of floating point numbers. */
327 int warn_float_equal
;
329 /* Warn about a subscript that has type char. */
331 int warn_char_subscripts
;
333 /* Warn if a type conversion is done that might have confusing results. */
337 /* Warn about #pragma directives that are not recognized. */
339 int warn_unknown_pragmas
; /* Tri state variable. */
341 /* Warn about format/argument anomalies in calls to formatted I/O functions
342 (*printf, *scanf, strftime, strfmon, etc.). */
346 /* Warn about Y2K problems with strftime formats. */
350 /* Warn about excess arguments to formats. */
352 int warn_format_extra_args
;
354 /* Warn about zero-length formats. */
356 int warn_format_zero_length
;
358 /* Warn about non-literal format arguments. */
360 int warn_format_nonliteral
;
362 /* Warn about possible security problems with calls to format functions. */
364 int warn_format_security
;
367 /* C/ObjC language option variables. */
370 /* Nonzero means message about use of implicit function declarations;
371 1 means warning; 2 means error. */
373 int mesg_implicit_function_declaration
= -1;
375 /* Nonzero means allow type mismatches in conditional expressions;
376 just make their values `void'. */
378 int flag_cond_mismatch
;
380 /* Nonzero means enable C89 Amendment 1 features. */
384 /* Nonzero means use the ISO C99 dialect of C. */
388 /* Nonzero means that we have builtin functions, and main is an int */
392 /* Nonzero means add default format_arg attributes for functions not
395 int flag_noniso_default_format_attributes
= 1;
397 /* Nonzero means warn when casting a function call to a type that does
398 not match the return type (e.g. (float)sqrt() or (anything*)malloc()
399 when there is no previous declaration of sqrt or malloc. */
401 int warn_bad_function_cast
;
403 /* Warn about traditional constructs whose meanings changed in ANSI C. */
405 int warn_traditional
;
407 /* Nonzero means warn for non-prototype function decls
408 or non-prototyped defs without previous prototype. */
410 int warn_strict_prototypes
;
412 /* Nonzero means warn for any global function def
413 without separate previous decl. */
415 int warn_missing_declarations
;
417 /* Nonzero means warn about declarations of objects not at
418 file-scope level and about *all* declarations of functions (whether
419 or static) not at file-scope level. Note that we exclude
420 implicit function declarations. To get warnings about those, use
423 int warn_nested_externs
;
425 /* Warn if main is suspicious. */
429 /* Nonzero means warn about possible violations of sequence point rules. */
431 int warn_sequence_point
;
433 /* Nonzero means to warn about compile-time division by zero. */
434 int warn_div_by_zero
= 1;
436 /* Nonzero means warn about use of implicit int. */
438 int warn_implicit_int
;
440 /* Warn about NULL being passed to argument slots marked as requiring
446 /* ObjC language option variables. */
449 /* Open and close the file for outputting class declarations, if
452 int flag_gen_declaration
;
454 /* Generate code for GNU or NeXT runtime environment. */
456 #ifdef NEXT_OBJC_RUNTIME
457 int flag_next_runtime
= 1;
459 int flag_next_runtime
= 0;
462 /* Tells the compiler that this is a special run. Do not perform any
463 compiling, instead we are to test some platform dependent features
464 and output a C header file with appropriate definitions. */
466 int print_struct_values
;
468 /* ???. Undocumented. */
470 const char *constant_string_class_name
;
472 /* Warn if multiple methods are seen for the same selector, but with
473 different argument types. Performs the check on the whole selector
474 table at the end of compilation. */
478 /* Warn if a @selector() is found, and no method with that selector
479 has been previously declared. The check is done on each
480 @selector() as soon as it is found - so it warns about forward
483 int warn_undeclared_selector
;
485 /* Warn if methods required by a protocol are not implemented in the
486 class adopting it. When turned off, methods inherited to that
487 class are also considered implemented. */
489 int warn_protocol
= 1;
492 /* C++ language option variables. */
495 /* Nonzero means don't recognize any extension keywords. */
497 int flag_no_gnu_keywords
;
499 /* Nonzero means do emit exported implementations of functions even if
500 they can be inlined. */
502 int flag_implement_inlines
= 1;
504 /* Nonzero means do emit exported implementations of templates, instead of
505 multiple static copies in each file that needs a definition. */
507 int flag_external_templates
;
509 /* Nonzero means that the decision to emit or not emit the implementation of a
510 template depends on where the template is instantiated, rather than where
513 int flag_alt_external_templates
;
515 /* Nonzero means that implicit instantiations will be emitted if needed. */
517 int flag_implicit_templates
= 1;
519 /* Nonzero means that implicit instantiations of inline templates will be
520 emitted if needed, even if instantiations of non-inline templates
523 int flag_implicit_inline_templates
= 1;
525 /* Nonzero means generate separate instantiation control files and
526 juggle them at link time. */
528 int flag_use_repository
;
530 /* Nonzero if we want to issue diagnostics that the standard says are not
533 int flag_optional_diags
= 1;
535 /* Nonzero means we should attempt to elide constructors when possible. */
537 int flag_elide_constructors
= 1;
539 /* Nonzero means that member functions defined in class scope are
540 inline by default. */
542 int flag_default_inline
= 1;
544 /* Controls whether compiler generates 'type descriptor' that give
545 run-time type information. */
549 /* Nonzero if we want to conserve space in the .o files. We do this
550 by putting uninitialized data and runtime initialized data into
551 .common instead of .data at the expense of not flagging multiple
554 int flag_conserve_space
;
556 /* Nonzero if we want to obey access control semantics. */
558 int flag_access_control
= 1;
560 /* Nonzero if we want to check the return value of new and avoid calling
561 constructors if it is a null pointer. */
565 /* Nonzero if we want the new ISO rules for pushing a new scope for `for'
566 initialization variables.
567 0: Old rules, set by -fno-for-scope.
568 2: New ISO rules, set by -ffor-scope.
569 1: Try to implement new ISO rules, but with backup compatibility
570 (and warnings). This is the default, for now. */
572 int flag_new_for_scope
= 1;
574 /* Nonzero if we want to emit defined symbols with common-like linkage as
575 weak symbols where possible, in order to conform to C++ semantics.
576 Otherwise, emit them as local symbols. */
580 /* Nonzero to use __cxa_atexit, rather than atexit, to register
581 destructors for local statics and global objects. */
583 int flag_use_cxa_atexit
= DEFAULT_USE_CXA_ATEXIT
;
585 /* Nonzero means output .vtable_{entry,inherit} for use in doing vtable gc. */
589 /* Nonzero means make the default pedwarns warnings instead of errors.
590 The value of this flag is ignored if -pedantic is specified. */
594 /* Nonzero means to implement standard semantics for exception
595 specifications, calling unexpected if an exception is thrown that
596 doesn't match the specification. Zero means to treat them as
597 assertions and optimize accordingly, but not check them. */
599 int flag_enforce_eh_specs
= 1;
601 /* The version of the C++ ABI in use. The following values are
604 0: The version of the ABI believed most conformant with the
605 C++ ABI specification. This ABI may change as bugs are
606 discovered and fixed. Therefore, 0 will not necessarily
607 indicate the same ABI in different versions of G++.
609 1: The version of the ABI first used in G++ 3.2.
611 Additional positive integers will be assigned as new versions of
612 the ABI become the default version of the ABI. */
614 int flag_abi_version
= 1;
616 /* Nonzero means warn about things that will change when compiling
617 with an ABI-compliant compiler. */
621 /* Nonzero means warn about implicit declarations. */
623 int warn_implicit
= 1;
625 /* Nonzero means warn when all ctors or dtors are private, and the class
628 int warn_ctor_dtor_privacy
= 1;
630 /* Nonzero means warn in function declared in derived class has the
631 same name as a virtual in the base class, but fails to match the
632 type signature of any virtual function in the base class. */
634 int warn_overloaded_virtual
;
636 /* Nonzero means warn when declaring a class that has a non virtual
637 destructor, when it really ought to have a virtual one. */
641 /* Nonzero means warn when the compiler will reorder code. */
645 /* Nonzero means warn when synthesis behavior differs from Cfront's. */
649 /* Nonzero means warn when we convert a pointer to member function
650 into a pointer to (void or function). */
652 int warn_pmf2ptr
= 1;
654 /* Nonzero means warn about violation of some Effective C++ style rules. */
658 /* Nonzero means warn where overload resolution chooses a promotion from
659 unsigned to signed over a conversion to an unsigned of the same size. */
663 /* Nonzero means warn when an old-style cast is used. */
665 int warn_old_style_cast
;
667 /* Nonzero means warn when non-templatized friend functions are
668 declared within a template */
670 int warn_nontemplate_friend
= 1;
672 /* Nonzero means complain about deprecated features. */
674 int warn_deprecated
= 1;
676 /* Maximum template instantiation depth. This limit is rather
677 arbitrary, but it exists to limit the time it takes to notice
678 infinite template instantiations. */
680 int max_tinst_depth
= 500;
684 /* The elements of `ridpointers' are identifier nodes for the reserved
685 type names and storage classes. It is indexed by a RID_... value. */
688 tree (*make_fname_decl
) PARAMS ((tree
, int));
690 /* If non-NULL, the address of a language-specific function that takes
691 any action required right before expand_function_end is called. */
692 void (*lang_expand_function_end
) PARAMS ((void));
694 /* Nonzero means the expression being parsed will never be evaluated.
695 This is a count, since unevaluated expressions can nest. */
698 /* Information about how a function name is generated. */
701 tree
*const decl
; /* pointer to the VAR_DECL. */
702 const unsigned rid
; /* RID number for the identifier. */
703 const int pretty
; /* How pretty is it? */
706 /* The three ways of getting then name of the current function. */
708 const struct fname_var_t fname_vars
[] =
710 /* C99 compliant __func__, must be first. */
711 {&c99_function_name_decl_node
, RID_C99_FUNCTION_NAME
, 0},
712 /* GCC __FUNCTION__ compliant. */
713 {&function_name_decl_node
, RID_FUNCTION_NAME
, 0},
714 /* GCC __PRETTY_FUNCTION__ compliant. */
715 {&pretty_function_name_decl_node
, RID_PRETTY_FUNCTION_NAME
, 1},
719 static int constant_fits_type_p
PARAMS ((tree
, tree
));
721 /* Keep a stack of if statements. We record the number of compound
722 statements seen up to the if keyword, as well as the line number
723 and file of the if. If a potentially ambiguous else is seen, that
724 fact is recorded; the warning is issued when we can be sure that
725 the enclosing if statement does not have an else branch. */
735 static if_elt
*if_stack
;
737 /* Amount of space in the if statement stack. */
738 static int if_stack_space
= 0;
741 static int if_stack_pointer
= 0;
743 static tree handle_packed_attribute
PARAMS ((tree
*, tree
, tree
, int,
745 static tree handle_nocommon_attribute
PARAMS ((tree
*, tree
, tree
, int,
747 static tree handle_common_attribute
PARAMS ((tree
*, tree
, tree
, int,
749 static tree handle_noreturn_attribute
PARAMS ((tree
*, tree
, tree
, int,
751 static tree handle_noinline_attribute
PARAMS ((tree
*, tree
, tree
, int,
753 static tree handle_always_inline_attribute
PARAMS ((tree
*, tree
, tree
, int,
755 static tree handle_used_attribute
PARAMS ((tree
*, tree
, tree
, int,
757 static tree handle_unused_attribute
PARAMS ((tree
*, tree
, tree
, int,
759 static tree handle_const_attribute
PARAMS ((tree
*, tree
, tree
, int,
761 static tree handle_transparent_union_attribute
PARAMS ((tree
*, tree
, tree
,
763 static tree handle_constructor_attribute
PARAMS ((tree
*, tree
, tree
, int,
765 static tree handle_destructor_attribute
PARAMS ((tree
*, tree
, tree
, int,
767 static tree handle_mode_attribute
PARAMS ((tree
*, tree
, tree
, int,
769 static tree handle_section_attribute
PARAMS ((tree
*, tree
, tree
, int,
771 static tree handle_aligned_attribute
PARAMS ((tree
*, tree
, tree
, int,
773 static tree handle_weak_attribute
PARAMS ((tree
*, tree
, tree
, int,
775 static tree handle_alias_attribute
PARAMS ((tree
*, tree
, tree
, int,
777 static tree handle_visibility_attribute
PARAMS ((tree
*, tree
, tree
, int,
779 static tree handle_tls_model_attribute
PARAMS ((tree
*, tree
, tree
, int,
781 static tree handle_no_instrument_function_attribute
PARAMS ((tree
*, tree
,
784 static tree handle_malloc_attribute
PARAMS ((tree
*, tree
, tree
, int,
786 static tree handle_no_limit_stack_attribute
PARAMS ((tree
*, tree
, tree
, int,
788 static tree handle_pure_attribute
PARAMS ((tree
*, tree
, tree
, int,
790 static tree handle_deprecated_attribute
PARAMS ((tree
*, tree
, tree
, int,
792 static tree handle_vector_size_attribute
PARAMS ((tree
*, tree
, tree
, int,
794 static tree handle_nonnull_attribute
PARAMS ((tree
*, tree
, tree
, int,
796 static tree handle_nothrow_attribute
PARAMS ((tree
*, tree
, tree
, int,
798 static tree vector_size_helper
PARAMS ((tree
, tree
));
800 static void check_function_nonnull
PARAMS ((tree
, tree
));
801 static void check_nonnull_arg
PARAMS ((void *, tree
,
802 unsigned HOST_WIDE_INT
));
803 static bool nonnull_check_p
PARAMS ((tree
, unsigned HOST_WIDE_INT
));
804 static bool get_nonnull_operand
PARAMS ((tree
,
805 unsigned HOST_WIDE_INT
*));
807 /* Table of machine-independent attributes common to all C-like languages. */
808 const struct attribute_spec c_common_attribute_table
[] =
810 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
811 { "packed", 0, 0, false, false, false,
812 handle_packed_attribute
},
813 { "nocommon", 0, 0, true, false, false,
814 handle_nocommon_attribute
},
815 { "common", 0, 0, true, false, false,
816 handle_common_attribute
},
817 /* FIXME: logically, noreturn attributes should be listed as
818 "false, true, true" and apply to function types. But implementing this
819 would require all the places in the compiler that use TREE_THIS_VOLATILE
820 on a decl to identify non-returning functions to be located and fixed
821 to check the function type instead. */
822 { "noreturn", 0, 0, true, false, false,
823 handle_noreturn_attribute
},
824 { "volatile", 0, 0, true, false, false,
825 handle_noreturn_attribute
},
826 { "noinline", 0, 0, true, false, false,
827 handle_noinline_attribute
},
828 { "always_inline", 0, 0, true, false, false,
829 handle_always_inline_attribute
},
830 { "used", 0, 0, true, false, false,
831 handle_used_attribute
},
832 { "unused", 0, 0, false, false, false,
833 handle_unused_attribute
},
834 /* The same comments as for noreturn attributes apply to const ones. */
835 { "const", 0, 0, true, false, false,
836 handle_const_attribute
},
837 { "transparent_union", 0, 0, false, false, false,
838 handle_transparent_union_attribute
},
839 { "constructor", 0, 0, true, false, false,
840 handle_constructor_attribute
},
841 { "destructor", 0, 0, true, false, false,
842 handle_destructor_attribute
},
843 { "mode", 1, 1, false, true, false,
844 handle_mode_attribute
},
845 { "section", 1, 1, true, false, false,
846 handle_section_attribute
},
847 { "aligned", 0, 1, false, false, false,
848 handle_aligned_attribute
},
849 { "weak", 0, 0, true, false, false,
850 handle_weak_attribute
},
851 { "alias", 1, 1, true, false, false,
852 handle_alias_attribute
},
853 { "no_instrument_function", 0, 0, true, false, false,
854 handle_no_instrument_function_attribute
},
855 { "malloc", 0, 0, true, false, false,
856 handle_malloc_attribute
},
857 { "no_stack_limit", 0, 0, true, false, false,
858 handle_no_limit_stack_attribute
},
859 { "pure", 0, 0, true, false, false,
860 handle_pure_attribute
},
861 { "deprecated", 0, 0, false, false, false,
862 handle_deprecated_attribute
},
863 { "vector_size", 1, 1, false, true, false,
864 handle_vector_size_attribute
},
865 { "visibility", 1, 1, true, false, false,
866 handle_visibility_attribute
},
867 { "tls_model", 1, 1, true, false, false,
868 handle_tls_model_attribute
},
869 { "nonnull", 0, -1, false, true, true,
870 handle_nonnull_attribute
},
871 { "nothrow", 0, 0, true, false, false,
872 handle_nothrow_attribute
},
873 { "may_alias", 0, 0, false, true, false, NULL
},
874 { NULL
, 0, 0, false, false, false, NULL
}
877 /* Give the specifications for the format attributes, used by C and all
880 const struct attribute_spec c_common_format_attribute_table
[] =
882 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
883 { "format", 3, 3, false, true, true,
884 handle_format_attribute
},
885 { "format_arg", 1, 1, false, true, true,
886 handle_format_arg_attribute
},
887 { NULL
, 0, 0, false, false, false, NULL
}
890 /* Record the start of an if-then, and record the start of it
891 for ambiguous else detection.
893 COND is the condition for the if-then statement.
895 IF_STMT is the statement node that has already been created for
896 this if-then statement. It is created before parsing the
897 condition to keep line number information accurate. */
900 c_expand_start_cond (cond
, compstmt_count
, if_stmt
)
905 /* Make sure there is enough space on the stack. */
906 if (if_stack_space
== 0)
909 if_stack
= (if_elt
*) xmalloc (10 * sizeof (if_elt
));
911 else if (if_stack_space
== if_stack_pointer
)
913 if_stack_space
+= 10;
914 if_stack
= (if_elt
*) xrealloc (if_stack
, if_stack_space
* sizeof (if_elt
));
917 IF_COND (if_stmt
) = cond
;
920 /* Record this if statement. */
921 if_stack
[if_stack_pointer
].compstmt_count
= compstmt_count
;
922 if_stack
[if_stack_pointer
].file
= input_filename
;
923 if_stack
[if_stack_pointer
].line
= lineno
;
924 if_stack
[if_stack_pointer
].needs_warning
= 0;
925 if_stack
[if_stack_pointer
].if_stmt
= if_stmt
;
929 /* Called after the then-clause for an if-statement is processed. */
934 tree if_stmt
= if_stack
[if_stack_pointer
- 1].if_stmt
;
935 RECHAIN_STMTS (if_stmt
, THEN_CLAUSE (if_stmt
));
938 /* Record the end of an if-then. Optionally warn if a nested
939 if statement had an ambiguous else clause. */
945 if (if_stack
[if_stack_pointer
].needs_warning
)
946 warning_with_file_and_line (if_stack
[if_stack_pointer
].file
,
947 if_stack
[if_stack_pointer
].line
,
948 "suggest explicit braces to avoid ambiguous `else'");
949 last_expr_type
= NULL_TREE
;
952 /* Called between the then-clause and the else-clause
953 of an if-then-else. */
956 c_expand_start_else ()
958 /* An ambiguous else warning must be generated for the enclosing if
959 statement, unless we see an else branch for that one, too. */
961 && if_stack_pointer
> 1
962 && (if_stack
[if_stack_pointer
- 1].compstmt_count
963 == if_stack
[if_stack_pointer
- 2].compstmt_count
))
964 if_stack
[if_stack_pointer
- 2].needs_warning
= 1;
966 /* Even if a nested if statement had an else branch, it can't be
967 ambiguous if this one also has an else. So don't warn in that
968 case. Also don't warn for any if statements nested in this else. */
969 if_stack
[if_stack_pointer
- 1].needs_warning
= 0;
970 if_stack
[if_stack_pointer
- 1].compstmt_count
--;
973 /* Called after the else-clause for an if-statement is processed. */
978 tree if_stmt
= if_stack
[if_stack_pointer
- 1].if_stmt
;
979 RECHAIN_STMTS (if_stmt
, ELSE_CLAUSE (if_stmt
));
982 /* Begin an if-statement. Returns a newly created IF_STMT if
985 Unlike the C++ front-end, we do not call add_stmt here; it is
986 probably safe to do so, but I am not very familiar with this
987 code so I am being extra careful not to change its behavior
988 beyond what is strictly necessary for correctness. */
994 r
= build_stmt (IF_STMT
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
998 /* Begin a while statement. Returns a newly created WHILE_STMT if
1001 Unlike the C++ front-end, we do not call add_stmt here; it is
1002 probably safe to do so, but I am not very familiar with this
1003 code so I am being extra careful not to change its behavior
1004 beyond what is strictly necessary for correctness. */
1007 c_begin_while_stmt ()
1010 r
= build_stmt (WHILE_STMT
, NULL_TREE
, NULL_TREE
);
1015 c_finish_while_stmt_cond (cond
, while_stmt
)
1019 WHILE_COND (while_stmt
) = cond
;
1022 /* Push current bindings for the function name VAR_DECLS. */
1025 start_fname_decls ()
1028 tree saved
= NULL_TREE
;
1030 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
1032 tree decl
= *fname_vars
[ix
].decl
;
1036 saved
= tree_cons (decl
, build_int_2 (ix
, 0), saved
);
1037 *fname_vars
[ix
].decl
= NULL_TREE
;
1040 if (saved
|| saved_function_name_decls
)
1041 /* Normally they'll have been NULL, so only push if we've got a
1042 stack, or they are non-NULL. */
1043 saved_function_name_decls
= tree_cons (saved
, NULL_TREE
,
1044 saved_function_name_decls
);
1047 /* Finish up the current bindings, adding them into the
1048 current function's statement tree. This is done by wrapping the
1049 function's body in a COMPOUND_STMT containing these decls too. This
1050 must be done _before_ finish_stmt_tree is called. If there is no
1051 current function, we must be at file scope and no statements are
1052 involved. Pop the previous bindings. */
1055 finish_fname_decls ()
1058 tree body
= NULL_TREE
;
1059 tree stack
= saved_function_name_decls
;
1061 for (; stack
&& TREE_VALUE (stack
); stack
= TREE_CHAIN (stack
))
1062 body
= chainon (TREE_VALUE (stack
), body
);
1066 /* They were called into existence, so add to statement tree. Add
1067 the DECL_STMTs inside the outermost scope. */
1068 tree
*p
= &DECL_SAVED_TREE (current_function_decl
);
1069 /* Skip the dummy EXPR_STMT and any EH_SPEC_BLOCK. */
1070 while (TREE_CODE (*p
) != COMPOUND_STMT
)
1071 p
= &TREE_CHAIN (*p
);
1072 p
= &COMPOUND_BODY (*p
);
1073 if (TREE_CODE (*p
) == SCOPE_STMT
)
1074 p
= &TREE_CHAIN (*p
);
1076 body
= chainon (body
, *p
);
1080 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
1081 *fname_vars
[ix
].decl
= NULL_TREE
;
1085 /* We had saved values, restore them. */
1088 for (saved
= TREE_PURPOSE (stack
); saved
; saved
= TREE_CHAIN (saved
))
1090 tree decl
= TREE_PURPOSE (saved
);
1091 unsigned ix
= TREE_INT_CST_LOW (TREE_VALUE (saved
));
1093 *fname_vars
[ix
].decl
= decl
;
1095 stack
= TREE_CHAIN (stack
);
1097 saved_function_name_decls
= stack
;
1100 /* Return the text name of the current function, suitably prettified
1104 fname_as_string (pretty_p
)
1107 const char *name
= NULL
;
1110 name
= (current_function_decl
1111 ? (*lang_hooks
.decl_printable_name
) (current_function_decl
, 2)
1113 else if (current_function_decl
&& DECL_NAME (current_function_decl
))
1114 name
= IDENTIFIER_POINTER (DECL_NAME (current_function_decl
));
1120 /* Return the text name of the current function, formatted as
1121 required by the supplied RID value. */
1129 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
1130 if (fname_vars
[ix
].rid
== rid
)
1132 return fname_as_string (fname_vars
[ix
].pretty
);
1135 /* Return the VAR_DECL for a const char array naming the current
1136 function. If the VAR_DECL has not yet been created, create it
1137 now. RID indicates how it should be formatted and IDENTIFIER_NODE
1138 ID is its name (unfortunately C and C++ hold the RID values of
1139 keywords in different places, so we can't derive RID from ID in
1140 this language independent code. */
1143 fname_decl (rid
, id
)
1148 tree decl
= NULL_TREE
;
1150 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
1151 if (fname_vars
[ix
].rid
== rid
)
1154 decl
= *fname_vars
[ix
].decl
;
1157 tree saved_last_tree
= last_tree
;
1158 /* If a tree is built here, it would normally have the lineno of
1159 the current statement. Later this tree will be moved to the
1160 beginning of the function and this line number will be wrong.
1161 To avoid this problem set the lineno to 0 here; that prevents
1162 it from appearing in the RTL. */
1163 int saved_lineno
= lineno
;
1166 decl
= (*make_fname_decl
) (id
, fname_vars
[ix
].pretty
);
1167 if (last_tree
!= saved_last_tree
)
1169 /* We created some statement tree for the decl. This belongs
1170 at the start of the function, so remove it now and reinsert
1171 it after the function is complete. */
1172 tree stmts
= TREE_CHAIN (saved_last_tree
);
1174 TREE_CHAIN (saved_last_tree
) = NULL_TREE
;
1175 last_tree
= saved_last_tree
;
1176 saved_function_name_decls
= tree_cons (decl
, stmts
,
1177 saved_function_name_decls
);
1179 *fname_vars
[ix
].decl
= decl
;
1180 lineno
= saved_lineno
;
1182 if (!ix
&& !current_function_decl
)
1183 pedwarn_with_decl (decl
, "`%s' is not defined outside of function scope");
1188 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
1191 fix_string_type (value
)
1194 const int wchar_bytes
= TYPE_PRECISION (wchar_type_node
) / BITS_PER_UNIT
;
1195 const int wide_flag
= TREE_TYPE (value
) == wchar_array_type_node
;
1196 const int nchars_max
= flag_isoc99
? 4095 : 509;
1197 int length
= TREE_STRING_LENGTH (value
);
1200 /* Compute the number of elements, for the array type. */
1201 nchars
= wide_flag
? length
/ wchar_bytes
: length
;
1203 if (pedantic
&& nchars
- 1 > nchars_max
&& c_language
== clk_c
)
1204 pedwarn ("string length `%d' is greater than the length `%d' ISO C%d compilers are required to support",
1205 nchars
- 1, nchars_max
, flag_isoc99
? 99 : 89);
1207 /* Create the array type for the string constant.
1208 -Wwrite-strings says make the string constant an array of const char
1209 so that copying it to a non-const pointer will get a warning.
1210 For C++, this is the standard behavior. */
1211 if (flag_const_strings
&& ! flag_writable_strings
)
1214 = build_type_variant (wide_flag
? wchar_type_node
: char_type_node
,
1217 = build_array_type (elements
,
1218 build_index_type (build_int_2 (nchars
- 1, 0)));
1222 = build_array_type (wide_flag
? wchar_type_node
: char_type_node
,
1223 build_index_type (build_int_2 (nchars
- 1, 0)));
1225 TREE_CONSTANT (value
) = 1;
1226 TREE_READONLY (value
) = ! flag_writable_strings
;
1227 TREE_STATIC (value
) = 1;
1231 /* Given a VARRAY of STRING_CST nodes, concatenate them into one
1235 combine_strings (strings
)
1236 varray_type strings
;
1238 const int wchar_bytes
= TYPE_PRECISION (wchar_type_node
) / BITS_PER_UNIT
;
1239 const int nstrings
= VARRAY_ACTIVE_SIZE (strings
);
1242 int wide_length
= 0;
1247 /* Don't include the \0 at the end of each substring. Count wide
1248 strings and ordinary strings separately. */
1249 for (i
= 0; i
< nstrings
; ++i
)
1251 t
= VARRAY_TREE (strings
, i
);
1253 if (TREE_TYPE (t
) == wchar_array_type_node
)
1255 wide_length
+= TREE_STRING_LENGTH (t
) - wchar_bytes
;
1260 length
+= (TREE_STRING_LENGTH (t
) - 1);
1261 if (C_ARTIFICIAL_STRING_P (t
) && !in_system_header
)
1262 warning ("concatenation of string literals with __FUNCTION__ is deprecated");
1266 /* If anything is wide, the non-wides will be converted,
1267 which makes them take more space. */
1269 length
= length
* wchar_bytes
+ wide_length
;
1271 p
= xmalloc (length
);
1273 /* Copy the individual strings into the new combined string.
1274 If the combined string is wide, convert the chars to ints
1275 for any individual strings that are not wide. */
1278 for (i
= 0; i
< nstrings
; ++i
)
1282 t
= VARRAY_TREE (strings
, i
);
1283 this_wide
= TREE_TYPE (t
) == wchar_array_type_node
;
1284 len
= TREE_STRING_LENGTH (t
) - (this_wide
? wchar_bytes
: 1);
1285 if (this_wide
== wide_flag
)
1287 memcpy (q
, TREE_STRING_POINTER (t
), len
);
1292 const int nzeros
= (TYPE_PRECISION (wchar_type_node
)
1293 / BITS_PER_UNIT
) - 1;
1296 if (BYTES_BIG_ENDIAN
)
1298 for (k
= 0; k
< len
; k
++)
1300 for (j
= 0; j
< nzeros
; j
++)
1302 *q
++ = TREE_STRING_POINTER (t
)[k
];
1307 for (k
= 0; k
< len
; k
++)
1309 *q
++ = TREE_STRING_POINTER (t
)[k
];
1310 for (j
= 0; j
< nzeros
; j
++)
1317 /* Nul terminate the string. */
1320 for (i
= 0; i
< wchar_bytes
; i
++)
1326 value
= build_string (length
, p
);
1330 TREE_TYPE (value
) = wchar_array_type_node
;
1332 TREE_TYPE (value
) = char_array_type_node
;
1337 static int is_valid_printf_arglist
PARAMS ((tree
));
1338 static rtx c_expand_builtin
PARAMS ((tree
, rtx
, enum machine_mode
, enum expand_modifier
));
1339 static rtx c_expand_builtin_printf
PARAMS ((tree
, rtx
, enum machine_mode
,
1340 enum expand_modifier
, int, int));
1341 static rtx c_expand_builtin_fprintf
PARAMS ((tree
, rtx
, enum machine_mode
,
1342 enum expand_modifier
, int, int));
1344 /* Print a warning if a constant expression had overflow in folding.
1345 Invoke this function on every expression that the language
1346 requires to be a constant expression.
1347 Note the ANSI C standard says it is erroneous for a
1348 constant expression to overflow. */
1351 constant_expression_warning (value
)
1354 if ((TREE_CODE (value
) == INTEGER_CST
|| TREE_CODE (value
) == REAL_CST
1355 || TREE_CODE (value
) == VECTOR_CST
1356 || TREE_CODE (value
) == COMPLEX_CST
)
1357 && TREE_CONSTANT_OVERFLOW (value
) && pedantic
)
1358 pedwarn ("overflow in constant expression");
1361 /* Print a warning if an expression had overflow in folding.
1362 Invoke this function on every expression that
1363 (1) appears in the source code, and
1364 (2) might be a constant expression that overflowed, and
1365 (3) is not already checked by convert_and_check;
1366 however, do not invoke this function on operands of explicit casts. */
1369 overflow_warning (value
)
1372 if ((TREE_CODE (value
) == INTEGER_CST
1373 || (TREE_CODE (value
) == COMPLEX_CST
1374 && TREE_CODE (TREE_REALPART (value
)) == INTEGER_CST
))
1375 && TREE_OVERFLOW (value
))
1377 TREE_OVERFLOW (value
) = 0;
1378 if (skip_evaluation
== 0)
1379 warning ("integer overflow in expression");
1381 else if ((TREE_CODE (value
) == REAL_CST
1382 || (TREE_CODE (value
) == COMPLEX_CST
1383 && TREE_CODE (TREE_REALPART (value
)) == REAL_CST
))
1384 && TREE_OVERFLOW (value
))
1386 TREE_OVERFLOW (value
) = 0;
1387 if (skip_evaluation
== 0)
1388 warning ("floating point overflow in expression");
1390 else if (TREE_CODE (value
) == VECTOR_CST
&& TREE_OVERFLOW (value
))
1392 TREE_OVERFLOW (value
) = 0;
1393 if (skip_evaluation
== 0)
1394 warning ("vector overflow in expression");
1398 /* Print a warning if a large constant is truncated to unsigned,
1399 or if -Wconversion is used and a constant < 0 is converted to unsigned.
1400 Invoke this function on every expression that might be implicitly
1401 converted to an unsigned type. */
1404 unsigned_conversion_warning (result
, operand
)
1405 tree result
, operand
;
1407 tree type
= TREE_TYPE (result
);
1409 if (TREE_CODE (operand
) == INTEGER_CST
1410 && TREE_CODE (type
) == INTEGER_TYPE
1411 && TREE_UNSIGNED (type
)
1412 && skip_evaluation
== 0
1413 && !int_fits_type_p (operand
, type
))
1415 if (!int_fits_type_p (operand
, c_common_signed_type (type
)))
1416 /* This detects cases like converting -129 or 256 to unsigned char. */
1417 warning ("large integer implicitly truncated to unsigned type");
1418 else if (warn_conversion
)
1419 warning ("negative integer implicitly converted to unsigned type");
1423 /* Nonzero if constant C has a value that is permissible
1424 for type TYPE (an INTEGER_TYPE). */
1427 constant_fits_type_p (c
, type
)
1430 if (TREE_CODE (c
) == INTEGER_CST
)
1431 return int_fits_type_p (c
, type
);
1433 c
= convert (type
, c
);
1434 return !TREE_OVERFLOW (c
);
1437 /* Convert EXPR to TYPE, warning about conversion problems with constants.
1438 Invoke this function on every expression that is converted implicitly,
1439 i.e. because of language rules and not because of an explicit cast. */
1442 convert_and_check (type
, expr
)
1445 tree t
= convert (type
, expr
);
1446 if (TREE_CODE (t
) == INTEGER_CST
)
1448 if (TREE_OVERFLOW (t
))
1450 TREE_OVERFLOW (t
) = 0;
1452 /* Do not diagnose overflow in a constant expression merely
1453 because a conversion overflowed. */
1454 TREE_CONSTANT_OVERFLOW (t
) = TREE_CONSTANT_OVERFLOW (expr
);
1456 /* No warning for converting 0x80000000 to int. */
1457 if (!(TREE_UNSIGNED (type
) < TREE_UNSIGNED (TREE_TYPE (expr
))
1458 && TREE_CODE (TREE_TYPE (expr
)) == INTEGER_TYPE
1459 && TYPE_PRECISION (type
) == TYPE_PRECISION (TREE_TYPE (expr
))))
1460 /* If EXPR fits in the unsigned version of TYPE,
1461 don't warn unless pedantic. */
1463 || TREE_UNSIGNED (type
)
1464 || ! constant_fits_type_p (expr
,
1465 c_common_unsigned_type (type
)))
1466 && skip_evaluation
== 0)
1467 warning ("overflow in implicit constant conversion");
1470 unsigned_conversion_warning (t
, expr
);
1475 /* A node in a list that describes references to variables (EXPR), which are
1476 either read accesses if WRITER is zero, or write accesses, in which case
1477 WRITER is the parent of EXPR. */
1484 /* Used to implement a cache the results of a call to verify_tree. We only
1485 use this for SAVE_EXPRs. */
1488 struct tlist_cache
*next
;
1489 struct tlist
*cache_before_sp
;
1490 struct tlist
*cache_after_sp
;
1494 /* Obstack to use when allocating tlist structures, and corresponding
1496 static struct obstack tlist_obstack
;
1497 static char *tlist_firstobj
= 0;
1499 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
1501 static struct tlist
*warned_ids
;
1502 /* SAVE_EXPRs need special treatment. We process them only once and then
1503 cache the results. */
1504 static struct tlist_cache
*save_expr_cache
;
1506 static void add_tlist
PARAMS ((struct tlist
**, struct tlist
*, tree
, int));
1507 static void merge_tlist
PARAMS ((struct tlist
**, struct tlist
*, int));
1508 static void verify_tree
PARAMS ((tree
, struct tlist
**, struct tlist
**, tree
));
1509 static int warning_candidate_p
PARAMS ((tree
));
1510 static void warn_for_collisions
PARAMS ((struct tlist
*));
1511 static void warn_for_collisions_1
PARAMS ((tree
, tree
, struct tlist
*, int));
1512 static struct tlist
*new_tlist
PARAMS ((struct tlist
*, tree
, tree
));
1513 static void verify_sequence_points
PARAMS ((tree
));
1515 /* Create a new struct tlist and fill in its fields. */
1516 static struct tlist
*
1517 new_tlist (next
, t
, writer
)
1523 l
= (struct tlist
*) obstack_alloc (&tlist_obstack
, sizeof *l
);
1530 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
1531 is nonnull, we ignore any node we find which has a writer equal to it. */
1534 add_tlist (to
, add
, exclude_writer
, copy
)
1537 tree exclude_writer
;
1542 struct tlist
*next
= add
->next
;
1545 if (! exclude_writer
|| add
->writer
!= exclude_writer
)
1546 *to
= copy
? new_tlist (*to
, add
->expr
, add
->writer
) : add
;
1551 /* Merge the nodes of ADD into TO. This merging process is done so that for
1552 each variable that already exists in TO, no new node is added; however if
1553 there is a write access recorded in ADD, and an occurrence on TO is only
1554 a read access, then the occurrence in TO will be modified to record the
1558 merge_tlist (to
, add
, copy
)
1563 struct tlist
**end
= to
;
1566 end
= &(*end
)->next
;
1572 struct tlist
*next
= add
->next
;
1574 for (tmp2
= *to
; tmp2
; tmp2
= tmp2
->next
)
1575 if (tmp2
->expr
== add
->expr
)
1579 tmp2
->writer
= add
->writer
;
1583 *end
= copy
? add
: new_tlist (NULL
, add
->expr
, add
->writer
);
1584 end
= &(*end
)->next
;
1591 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
1592 references in list LIST conflict with it, excluding reads if ONLY writers
1596 warn_for_collisions_1 (written
, writer
, list
, only_writes
)
1597 tree written
, writer
;
1603 /* Avoid duplicate warnings. */
1604 for (tmp
= warned_ids
; tmp
; tmp
= tmp
->next
)
1605 if (tmp
->expr
== written
)
1610 if (list
->expr
== written
1611 && list
->writer
!= writer
1612 && (! only_writes
|| list
->writer
))
1614 warned_ids
= new_tlist (warned_ids
, written
, NULL_TREE
);
1615 warning ("operation on `%s' may be undefined",
1616 IDENTIFIER_POINTER (DECL_NAME (list
->expr
)));
1622 /* Given a list LIST of references to variables, find whether any of these
1623 can cause conflicts due to missing sequence points. */
1626 warn_for_collisions (list
)
1631 for (tmp
= list
; tmp
; tmp
= tmp
->next
)
1634 warn_for_collisions_1 (tmp
->expr
, tmp
->writer
, list
, 0);
1638 /* Return nonzero if X is a tree that can be verified by the sequence point
1641 warning_candidate_p (x
)
1644 return TREE_CODE (x
) == VAR_DECL
|| TREE_CODE (x
) == PARM_DECL
;
1647 /* Walk the tree X, and record accesses to variables. If X is written by the
1648 parent tree, WRITER is the parent.
1649 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
1650 expression or its only operand forces a sequence point, then everything up
1651 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
1653 Once we return, we will have emitted warnings if any subexpression before
1654 such a sequence point could be undefined. On a higher level, however, the
1655 sequence point may not be relevant, and we'll merge the two lists.
1657 Example: (b++, a) + b;
1658 The call that processes the COMPOUND_EXPR will store the increment of B
1659 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
1660 processes the PLUS_EXPR will need to merge the two lists so that
1661 eventually, all accesses end up on the same list (and we'll warn about the
1662 unordered subexpressions b++ and b.
1664 A note on merging. If we modify the former example so that our expression
1667 care must be taken not simply to add all three expressions into the final
1668 PNO_SP list. The function merge_tlist takes care of that by merging the
1669 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1670 way, so that no more than one access to B is recorded. */
1673 verify_tree (x
, pbefore_sp
, pno_sp
, writer
)
1675 struct tlist
**pbefore_sp
, **pno_sp
;
1678 struct tlist
*tmp_before
, *tmp_nosp
, *tmp_list2
, *tmp_list3
;
1679 enum tree_code code
;
1682 /* X may be NULL if it is the operand of an empty statement expression
1688 code
= TREE_CODE (x
);
1689 class = TREE_CODE_CLASS (code
);
1691 if (warning_candidate_p (x
))
1693 *pno_sp
= new_tlist (*pno_sp
, x
, writer
);
1703 case TRUTH_ANDIF_EXPR
:
1704 case TRUTH_ORIF_EXPR
:
1705 tmp_before
= tmp_nosp
= tmp_list3
= 0;
1706 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1707 warn_for_collisions (tmp_nosp
);
1708 merge_tlist (pbefore_sp
, tmp_before
, 0);
1709 merge_tlist (pbefore_sp
, tmp_nosp
, 0);
1710 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, pno_sp
, NULL_TREE
);
1711 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1715 tmp_before
= tmp_list2
= 0;
1716 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_list2
, NULL_TREE
);
1717 warn_for_collisions (tmp_list2
);
1718 merge_tlist (pbefore_sp
, tmp_before
, 0);
1719 merge_tlist (pbefore_sp
, tmp_list2
, 1);
1721 tmp_list3
= tmp_nosp
= 0;
1722 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, &tmp_nosp
, NULL_TREE
);
1723 warn_for_collisions (tmp_nosp
);
1724 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1726 tmp_list3
= tmp_list2
= 0;
1727 verify_tree (TREE_OPERAND (x
, 2), &tmp_list3
, &tmp_list2
, NULL_TREE
);
1728 warn_for_collisions (tmp_list2
);
1729 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1730 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1731 two first, to avoid warning for (a ? b++ : b++). */
1732 merge_tlist (&tmp_nosp
, tmp_list2
, 0);
1733 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1736 case PREDECREMENT_EXPR
:
1737 case PREINCREMENT_EXPR
:
1738 case POSTDECREMENT_EXPR
:
1739 case POSTINCREMENT_EXPR
:
1740 verify_tree (TREE_OPERAND (x
, 0), pno_sp
, pno_sp
, x
);
1744 tmp_before
= tmp_nosp
= tmp_list3
= 0;
1745 verify_tree (TREE_OPERAND (x
, 1), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1746 verify_tree (TREE_OPERAND (x
, 0), &tmp_list3
, &tmp_list3
, x
);
1747 /* Expressions inside the LHS are not ordered wrt. the sequence points
1748 in the RHS. Example:
1750 Despite the fact that the modification of "a" is in the before_sp
1751 list (tmp_before), it conflicts with the use of "a" in the LHS.
1752 We can handle this by adding the contents of tmp_list3
1753 to those of tmp_before, and redoing the collision warnings for that
1755 add_tlist (&tmp_before
, tmp_list3
, x
, 1);
1756 warn_for_collisions (tmp_before
);
1757 /* Exclude the LHS itself here; we first have to merge it into the
1758 tmp_nosp list. This is done to avoid warning for "a = a"; if we
1759 didn't exclude the LHS, we'd get it twice, once as a read and once
1761 add_tlist (pno_sp
, tmp_list3
, x
, 0);
1762 warn_for_collisions_1 (TREE_OPERAND (x
, 0), x
, tmp_nosp
, 1);
1764 merge_tlist (pbefore_sp
, tmp_before
, 0);
1765 if (warning_candidate_p (TREE_OPERAND (x
, 0)))
1766 merge_tlist (&tmp_nosp
, new_tlist (NULL
, TREE_OPERAND (x
, 0), x
), 0);
1767 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 1);
1771 /* We need to warn about conflicts among arguments and conflicts between
1772 args and the function address. Side effects of the function address,
1773 however, are not ordered by the sequence point of the call. */
1774 tmp_before
= tmp_nosp
= tmp_list2
= tmp_list3
= 0;
1775 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1776 if (TREE_OPERAND (x
, 1))
1777 verify_tree (TREE_OPERAND (x
, 1), &tmp_list2
, &tmp_list3
, NULL_TREE
);
1778 merge_tlist (&tmp_list3
, tmp_list2
, 0);
1779 add_tlist (&tmp_before
, tmp_list3
, NULL_TREE
, 0);
1780 add_tlist (&tmp_before
, tmp_nosp
, NULL_TREE
, 0);
1781 warn_for_collisions (tmp_before
);
1782 add_tlist (pbefore_sp
, tmp_before
, NULL_TREE
, 0);
1786 /* Scan all the list, e.g. indices of multi dimensional array. */
1789 tmp_before
= tmp_nosp
= 0;
1790 verify_tree (TREE_VALUE (x
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1791 merge_tlist (&tmp_nosp
, tmp_before
, 0);
1792 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1799 struct tlist_cache
*t
;
1800 for (t
= save_expr_cache
; t
; t
= t
->next
)
1806 t
= (struct tlist_cache
*) obstack_alloc (&tlist_obstack
,
1808 t
->next
= save_expr_cache
;
1810 save_expr_cache
= t
;
1812 tmp_before
= tmp_nosp
= 0;
1813 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1814 warn_for_collisions (tmp_nosp
);
1819 struct tlist
*t
= tmp_nosp
;
1821 merge_tlist (&tmp_list3
, t
, 0);
1823 t
->cache_before_sp
= tmp_before
;
1824 t
->cache_after_sp
= tmp_list3
;
1826 merge_tlist (pbefore_sp
, t
->cache_before_sp
, 1);
1827 add_tlist (pno_sp
, t
->cache_after_sp
, NULL_TREE
, 1);
1836 if (first_rtl_op (code
) == 0)
1838 x
= TREE_OPERAND (x
, 0);
1854 int max
= first_rtl_op (TREE_CODE (x
));
1855 for (lp
= 0; lp
< max
; lp
++)
1857 tmp_before
= tmp_nosp
= 0;
1858 verify_tree (TREE_OPERAND (x
, lp
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1859 merge_tlist (&tmp_nosp
, tmp_before
, 0);
1860 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1867 /* Try to warn for undefined behavior in EXPR due to missing sequence
1871 verify_sequence_points (expr
)
1874 struct tlist
*before_sp
= 0, *after_sp
= 0;
1877 save_expr_cache
= 0;
1878 if (tlist_firstobj
== 0)
1880 gcc_obstack_init (&tlist_obstack
);
1881 tlist_firstobj
= obstack_alloc (&tlist_obstack
, 0);
1884 verify_tree (expr
, &before_sp
, &after_sp
, 0);
1885 warn_for_collisions (after_sp
);
1886 obstack_free (&tlist_obstack
, tlist_firstobj
);
1890 c_expand_expr_stmt (expr
)
1893 /* Do default conversion if safe and possibly important,
1894 in case within ({...}). */
1895 if ((TREE_CODE (TREE_TYPE (expr
)) == ARRAY_TYPE
1896 && (flag_isoc99
|| lvalue_p (expr
)))
1897 || TREE_CODE (TREE_TYPE (expr
)) == FUNCTION_TYPE
)
1898 expr
= default_conversion (expr
);
1900 if (warn_sequence_point
)
1901 verify_sequence_points (expr
);
1903 if (TREE_TYPE (expr
) != error_mark_node
1904 && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr
))
1905 && TREE_CODE (TREE_TYPE (expr
)) != ARRAY_TYPE
)
1906 error ("expression statement has incomplete type");
1908 last_expr_type
= TREE_TYPE (expr
);
1909 return add_stmt (build_stmt (EXPR_STMT
, expr
));
1912 /* Validate the expression after `case' and apply default promotions. */
1915 check_case_value (value
)
1918 if (value
== NULL_TREE
)
1921 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
1922 STRIP_TYPE_NOPS (value
);
1923 /* In C++, the following is allowed:
1926 switch (...) { case i: ... }
1928 So, we try to reduce the VALUE to a constant that way. */
1929 if (c_language
== clk_cplusplus
)
1931 value
= decl_constant_value (value
);
1932 STRIP_TYPE_NOPS (value
);
1933 value
= fold (value
);
1936 if (TREE_CODE (value
) != INTEGER_CST
1937 && value
!= error_mark_node
)
1939 error ("case label does not reduce to an integer constant");
1940 value
= error_mark_node
;
1943 /* Promote char or short to int. */
1944 value
= default_conversion (value
);
1946 constant_expression_warning (value
);
1951 /* Return an integer type with BITS bits of precision,
1952 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1955 c_common_type_for_size (bits
, unsignedp
)
1959 if (bits
== TYPE_PRECISION (integer_type_node
))
1960 return unsignedp
? unsigned_type_node
: integer_type_node
;
1962 if (bits
== TYPE_PRECISION (signed_char_type_node
))
1963 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1965 if (bits
== TYPE_PRECISION (short_integer_type_node
))
1966 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1968 if (bits
== TYPE_PRECISION (long_integer_type_node
))
1969 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1971 if (bits
== TYPE_PRECISION (long_long_integer_type_node
))
1972 return (unsignedp
? long_long_unsigned_type_node
1973 : long_long_integer_type_node
);
1975 if (bits
== TYPE_PRECISION (widest_integer_literal_type_node
))
1976 return (unsignedp
? widest_unsigned_literal_type_node
1977 : widest_integer_literal_type_node
);
1979 if (bits
<= TYPE_PRECISION (intQI_type_node
))
1980 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
1982 if (bits
<= TYPE_PRECISION (intHI_type_node
))
1983 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
1985 if (bits
<= TYPE_PRECISION (intSI_type_node
))
1986 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
1988 if (bits
<= TYPE_PRECISION (intDI_type_node
))
1989 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
1994 /* Return a data type that has machine mode MODE.
1995 If the mode is an integer,
1996 then UNSIGNEDP selects between signed and unsigned types. */
1999 c_common_type_for_mode (mode
, unsignedp
)
2000 enum machine_mode mode
;
2003 if (mode
== TYPE_MODE (integer_type_node
))
2004 return unsignedp
? unsigned_type_node
: integer_type_node
;
2006 if (mode
== TYPE_MODE (signed_char_type_node
))
2007 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2009 if (mode
== TYPE_MODE (short_integer_type_node
))
2010 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2012 if (mode
== TYPE_MODE (long_integer_type_node
))
2013 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2015 if (mode
== TYPE_MODE (long_long_integer_type_node
))
2016 return unsignedp
? long_long_unsigned_type_node
: long_long_integer_type_node
;
2018 if (mode
== TYPE_MODE (widest_integer_literal_type_node
))
2019 return unsignedp
? widest_unsigned_literal_type_node
2020 : widest_integer_literal_type_node
;
2023 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2026 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2029 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2032 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2034 #if HOST_BITS_PER_WIDE_INT >= 64
2035 if (mode
== TYPE_MODE (intTI_type_node
))
2036 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2039 if (mode
== TYPE_MODE (float_type_node
))
2040 return float_type_node
;
2042 if (mode
== TYPE_MODE (double_type_node
))
2043 return double_type_node
;
2045 if (mode
== TYPE_MODE (long_double_type_node
))
2046 return long_double_type_node
;
2048 if (mode
== TYPE_MODE (build_pointer_type (char_type_node
)))
2049 return build_pointer_type (char_type_node
);
2051 if (mode
== TYPE_MODE (build_pointer_type (integer_type_node
)))
2052 return build_pointer_type (integer_type_node
);
2057 return unsignedp
? unsigned_V16QI_type_node
: V16QI_type_node
;
2059 return unsignedp
? unsigned_V8HI_type_node
: V8HI_type_node
;
2061 return unsignedp
? unsigned_V4SI_type_node
: V4SI_type_node
;
2063 return unsignedp
? unsigned_V2DI_type_node
: V2DI_type_node
;
2065 return unsignedp
? unsigned_V2SI_type_node
: V2SI_type_node
;
2067 return unsignedp
? unsigned_V2HI_type_node
: V2HI_type_node
;
2069 return unsignedp
? unsigned_V4HI_type_node
: V4HI_type_node
;
2071 return unsignedp
? unsigned_V8QI_type_node
: V8QI_type_node
;
2073 return unsignedp
? unsigned_V1DI_type_node
: V1DI_type_node
;
2075 return V16SF_type_node
;
2077 return V4SF_type_node
;
2079 return V2SF_type_node
;
2081 return V2DF_type_node
;
2089 /* Return an unsigned type the same as TYPE in other respects. */
2091 c_common_unsigned_type (type
)
2094 tree type1
= TYPE_MAIN_VARIANT (type
);
2095 if (type1
== signed_char_type_node
|| type1
== char_type_node
)
2096 return unsigned_char_type_node
;
2097 if (type1
== integer_type_node
)
2098 return unsigned_type_node
;
2099 if (type1
== short_integer_type_node
)
2100 return short_unsigned_type_node
;
2101 if (type1
== long_integer_type_node
)
2102 return long_unsigned_type_node
;
2103 if (type1
== long_long_integer_type_node
)
2104 return long_long_unsigned_type_node
;
2105 if (type1
== widest_integer_literal_type_node
)
2106 return widest_unsigned_literal_type_node
;
2107 #if HOST_BITS_PER_WIDE_INT >= 64
2108 if (type1
== intTI_type_node
)
2109 return unsigned_intTI_type_node
;
2111 if (type1
== intDI_type_node
)
2112 return unsigned_intDI_type_node
;
2113 if (type1
== intSI_type_node
)
2114 return unsigned_intSI_type_node
;
2115 if (type1
== intHI_type_node
)
2116 return unsigned_intHI_type_node
;
2117 if (type1
== intQI_type_node
)
2118 return unsigned_intQI_type_node
;
2120 return c_common_signed_or_unsigned_type (1, type
);
2123 /* Return a signed type the same as TYPE in other respects. */
2126 c_common_signed_type (type
)
2129 tree type1
= TYPE_MAIN_VARIANT (type
);
2130 if (type1
== unsigned_char_type_node
|| type1
== char_type_node
)
2131 return signed_char_type_node
;
2132 if (type1
== unsigned_type_node
)
2133 return integer_type_node
;
2134 if (type1
== short_unsigned_type_node
)
2135 return short_integer_type_node
;
2136 if (type1
== long_unsigned_type_node
)
2137 return long_integer_type_node
;
2138 if (type1
== long_long_unsigned_type_node
)
2139 return long_long_integer_type_node
;
2140 if (type1
== widest_unsigned_literal_type_node
)
2141 return widest_integer_literal_type_node
;
2142 #if HOST_BITS_PER_WIDE_INT >= 64
2143 if (type1
== unsigned_intTI_type_node
)
2144 return intTI_type_node
;
2146 if (type1
== unsigned_intDI_type_node
)
2147 return intDI_type_node
;
2148 if (type1
== unsigned_intSI_type_node
)
2149 return intSI_type_node
;
2150 if (type1
== unsigned_intHI_type_node
)
2151 return intHI_type_node
;
2152 if (type1
== unsigned_intQI_type_node
)
2153 return intQI_type_node
;
2155 return c_common_signed_or_unsigned_type (0, type
);
2158 /* Return a type the same as TYPE except unsigned or
2159 signed according to UNSIGNEDP. */
2162 c_common_signed_or_unsigned_type (unsignedp
, type
)
2166 if (! INTEGRAL_TYPE_P (type
)
2167 || TREE_UNSIGNED (type
) == unsignedp
)
2170 if (TYPE_PRECISION (type
) == TYPE_PRECISION (signed_char_type_node
))
2171 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2172 if (TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
))
2173 return unsignedp
? unsigned_type_node
: integer_type_node
;
2174 if (TYPE_PRECISION (type
) == TYPE_PRECISION (short_integer_type_node
))
2175 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2176 if (TYPE_PRECISION (type
) == TYPE_PRECISION (long_integer_type_node
))
2177 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2178 if (TYPE_PRECISION (type
) == TYPE_PRECISION (long_long_integer_type_node
))
2179 return (unsignedp
? long_long_unsigned_type_node
2180 : long_long_integer_type_node
);
2181 if (TYPE_PRECISION (type
) == TYPE_PRECISION (widest_integer_literal_type_node
))
2182 return (unsignedp
? widest_unsigned_literal_type_node
2183 : widest_integer_literal_type_node
);
2185 #if HOST_BITS_PER_WIDE_INT >= 64
2186 if (TYPE_PRECISION (type
) == TYPE_PRECISION (intTI_type_node
))
2187 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2189 if (TYPE_PRECISION (type
) == TYPE_PRECISION (intDI_type_node
))
2190 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2191 if (TYPE_PRECISION (type
) == TYPE_PRECISION (intSI_type_node
))
2192 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2193 if (TYPE_PRECISION (type
) == TYPE_PRECISION (intHI_type_node
))
2194 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2195 if (TYPE_PRECISION (type
) == TYPE_PRECISION (intQI_type_node
))
2196 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2201 /* Return the minimum number of bits needed to represent VALUE in a
2202 signed or unsigned type, UNSIGNEDP says which. */
2205 min_precision (value
, unsignedp
)
2211 /* If the value is negative, compute its negative minus 1. The latter
2212 adjustment is because the absolute value of the largest negative value
2213 is one larger than the largest positive value. This is equivalent to
2214 a bit-wise negation, so use that operation instead. */
2216 if (tree_int_cst_sgn (value
) < 0)
2217 value
= fold (build1 (BIT_NOT_EXPR
, TREE_TYPE (value
), value
));
2219 /* Return the number of bits needed, taking into account the fact
2220 that we need one more bit for a signed than unsigned type. */
2222 if (integer_zerop (value
))
2225 log
= tree_floor_log2 (value
);
2227 return log
+ 1 + ! unsignedp
;
2230 /* Print an error message for invalid operands to arith operation
2231 CODE. NOP_EXPR is used as a special case (see
2232 c_common_truthvalue_conversion). */
2235 binary_op_error (code
)
2236 enum tree_code code
;
2243 error ("invalid truth-value expression");
2247 opname
= "+"; break;
2249 opname
= "-"; break;
2251 opname
= "*"; break;
2253 opname
= "max"; break;
2255 opname
= "min"; break;
2257 opname
= "=="; break;
2259 opname
= "!="; break;
2261 opname
= "<="; break;
2263 opname
= ">="; break;
2265 opname
= "<"; break;
2267 opname
= ">"; break;
2269 opname
= "<<"; break;
2271 opname
= ">>"; break;
2272 case TRUNC_MOD_EXPR
:
2273 case FLOOR_MOD_EXPR
:
2274 opname
= "%"; break;
2275 case TRUNC_DIV_EXPR
:
2276 case FLOOR_DIV_EXPR
:
2277 opname
= "/"; break;
2279 opname
= "&"; break;
2281 opname
= "|"; break;
2282 case TRUTH_ANDIF_EXPR
:
2283 opname
= "&&"; break;
2284 case TRUTH_ORIF_EXPR
:
2285 opname
= "||"; break;
2287 opname
= "^"; break;
2290 opname
= "rotate"; break;
2292 opname
= "unknown"; break;
2294 error ("invalid operands to binary %s", opname
);
2297 /* Subroutine of build_binary_op, used for comparison operations.
2298 See if the operands have both been converted from subword integer types
2299 and, if so, perhaps change them both back to their original type.
2300 This function is also responsible for converting the two operands
2301 to the proper common type for comparison.
2303 The arguments of this function are all pointers to local variables
2304 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2305 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2307 If this function returns nonzero, it means that the comparison has
2308 a constant value. What this function returns is an expression for
2312 shorten_compare (op0_ptr
, op1_ptr
, restype_ptr
, rescode_ptr
)
2313 tree
*op0_ptr
, *op1_ptr
;
2315 enum tree_code
*rescode_ptr
;
2318 tree op0
= *op0_ptr
;
2319 tree op1
= *op1_ptr
;
2320 int unsignedp0
, unsignedp1
;
2322 tree primop0
, primop1
;
2323 enum tree_code code
= *rescode_ptr
;
2325 /* Throw away any conversions to wider types
2326 already present in the operands. */
2328 primop0
= get_narrower (op0
, &unsignedp0
);
2329 primop1
= get_narrower (op1
, &unsignedp1
);
2331 /* Handle the case that OP0 does not *contain* a conversion
2332 but it *requires* conversion to FINAL_TYPE. */
2334 if (op0
== primop0
&& TREE_TYPE (op0
) != *restype_ptr
)
2335 unsignedp0
= TREE_UNSIGNED (TREE_TYPE (op0
));
2336 if (op1
== primop1
&& TREE_TYPE (op1
) != *restype_ptr
)
2337 unsignedp1
= TREE_UNSIGNED (TREE_TYPE (op1
));
2339 /* If one of the operands must be floated, we cannot optimize. */
2340 real1
= TREE_CODE (TREE_TYPE (primop0
)) == REAL_TYPE
;
2341 real2
= TREE_CODE (TREE_TYPE (primop1
)) == REAL_TYPE
;
2343 /* If first arg is constant, swap the args (changing operation
2344 so value is preserved), for canonicalization. Don't do this if
2345 the second arg is 0. */
2347 if (TREE_CONSTANT (primop0
)
2348 && ! integer_zerop (primop1
) && ! real_zerop (primop1
))
2351 int temi
= unsignedp0
;
2359 unsignedp0
= unsignedp1
;
2382 *rescode_ptr
= code
;
2385 /* If comparing an integer against a constant more bits wide,
2386 maybe we can deduce a value of 1 or 0 independent of the data.
2387 Or else truncate the constant now
2388 rather than extend the variable at run time.
2390 This is only interesting if the constant is the wider arg.
2391 Also, it is not safe if the constant is unsigned and the
2392 variable arg is signed, since in this case the variable
2393 would be sign-extended and then regarded as unsigned.
2394 Our technique fails in this case because the lowest/highest
2395 possible unsigned results don't follow naturally from the
2396 lowest/highest possible values of the variable operand.
2397 For just EQ_EXPR and NE_EXPR there is another technique that
2398 could be used: see if the constant can be faithfully represented
2399 in the other operand's type, by truncating it and reextending it
2400 and see if that preserves the constant's value. */
2402 if (!real1
&& !real2
2403 && TREE_CODE (primop1
) == INTEGER_CST
2404 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
))
2406 int min_gt
, max_gt
, min_lt
, max_lt
;
2407 tree maxval
, minval
;
2408 /* 1 if comparison is nominally unsigned. */
2409 int unsignedp
= TREE_UNSIGNED (*restype_ptr
);
2412 type
= c_common_signed_or_unsigned_type (unsignedp0
,
2413 TREE_TYPE (primop0
));
2415 /* If TYPE is an enumeration, then we need to get its min/max
2416 values from it's underlying integral type, not the enumerated
2418 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
2419 type
= c_common_type_for_size (TYPE_PRECISION (type
), unsignedp0
);
2421 maxval
= TYPE_MAX_VALUE (type
);
2422 minval
= TYPE_MIN_VALUE (type
);
2424 if (unsignedp
&& !unsignedp0
)
2425 *restype_ptr
= c_common_signed_type (*restype_ptr
);
2427 if (TREE_TYPE (primop1
) != *restype_ptr
)
2428 primop1
= convert (*restype_ptr
, primop1
);
2429 if (type
!= *restype_ptr
)
2431 minval
= convert (*restype_ptr
, minval
);
2432 maxval
= convert (*restype_ptr
, maxval
);
2435 if (unsignedp
&& unsignedp0
)
2437 min_gt
= INT_CST_LT_UNSIGNED (primop1
, minval
);
2438 max_gt
= INT_CST_LT_UNSIGNED (primop1
, maxval
);
2439 min_lt
= INT_CST_LT_UNSIGNED (minval
, primop1
);
2440 max_lt
= INT_CST_LT_UNSIGNED (maxval
, primop1
);
2444 min_gt
= INT_CST_LT (primop1
, minval
);
2445 max_gt
= INT_CST_LT (primop1
, maxval
);
2446 min_lt
= INT_CST_LT (minval
, primop1
);
2447 max_lt
= INT_CST_LT (maxval
, primop1
);
2451 /* This used to be a switch, but Genix compiler can't handle that. */
2452 if (code
== NE_EXPR
)
2454 if (max_lt
|| min_gt
)
2455 val
= boolean_true_node
;
2457 else if (code
== EQ_EXPR
)
2459 if (max_lt
|| min_gt
)
2460 val
= boolean_false_node
;
2462 else if (code
== LT_EXPR
)
2465 val
= boolean_true_node
;
2467 val
= boolean_false_node
;
2469 else if (code
== GT_EXPR
)
2472 val
= boolean_true_node
;
2474 val
= boolean_false_node
;
2476 else if (code
== LE_EXPR
)
2479 val
= boolean_true_node
;
2481 val
= boolean_false_node
;
2483 else if (code
== GE_EXPR
)
2486 val
= boolean_true_node
;
2488 val
= boolean_false_node
;
2491 /* If primop0 was sign-extended and unsigned comparison specd,
2492 we did a signed comparison above using the signed type bounds.
2493 But the comparison we output must be unsigned.
2495 Also, for inequalities, VAL is no good; but if the signed
2496 comparison had *any* fixed result, it follows that the
2497 unsigned comparison just tests the sign in reverse
2498 (positive values are LE, negative ones GE).
2499 So we can generate an unsigned comparison
2500 against an extreme value of the signed type. */
2502 if (unsignedp
&& !unsignedp0
)
2509 primop1
= TYPE_MIN_VALUE (type
);
2515 primop1
= TYPE_MAX_VALUE (type
);
2522 type
= c_common_unsigned_type (type
);
2525 if (TREE_CODE (primop0
) != INTEGER_CST
)
2527 if (val
== boolean_false_node
)
2528 warning ("comparison is always false due to limited range of data type");
2529 if (val
== boolean_true_node
)
2530 warning ("comparison is always true due to limited range of data type");
2535 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2536 if (TREE_SIDE_EFFECTS (primop0
))
2537 return build (COMPOUND_EXPR
, TREE_TYPE (val
), primop0
, val
);
2541 /* Value is not predetermined, but do the comparison
2542 in the type of the operand that is not constant.
2543 TYPE is already properly set. */
2545 else if (real1
&& real2
2546 && (TYPE_PRECISION (TREE_TYPE (primop0
))
2547 == TYPE_PRECISION (TREE_TYPE (primop1
))))
2548 type
= TREE_TYPE (primop0
);
2550 /* If args' natural types are both narrower than nominal type
2551 and both extend in the same manner, compare them
2552 in the type of the wider arg.
2553 Otherwise must actually extend both to the nominal
2554 common type lest different ways of extending
2556 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
2558 else if (unsignedp0
== unsignedp1
&& real1
== real2
2559 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
)
2560 && TYPE_PRECISION (TREE_TYPE (primop1
)) < TYPE_PRECISION (*restype_ptr
))
2562 type
= common_type (TREE_TYPE (primop0
), TREE_TYPE (primop1
));
2563 type
= c_common_signed_or_unsigned_type (unsignedp0
2564 || TREE_UNSIGNED (*restype_ptr
),
2566 /* Make sure shorter operand is extended the right way
2567 to match the longer operand. */
2569 = convert (c_common_signed_or_unsigned_type (unsignedp0
,
2570 TREE_TYPE (primop0
)),
2573 = convert (c_common_signed_or_unsigned_type (unsignedp1
,
2574 TREE_TYPE (primop1
)),
2579 /* Here we must do the comparison on the nominal type
2580 using the args exactly as we received them. */
2581 type
= *restype_ptr
;
2585 if (!real1
&& !real2
&& integer_zerop (primop1
)
2586 && TREE_UNSIGNED (*restype_ptr
))
2592 /* All unsigned values are >= 0, so we warn if extra warnings
2593 are requested. However, if OP0 is a constant that is
2594 >= 0, the signedness of the comparison isn't an issue,
2595 so suppress the warning. */
2596 if (extra_warnings
&& !in_system_header
2597 && ! (TREE_CODE (primop0
) == INTEGER_CST
2598 && ! TREE_OVERFLOW (convert (c_common_signed_type (type
),
2600 warning ("comparison of unsigned expression >= 0 is always true");
2601 value
= boolean_true_node
;
2605 if (extra_warnings
&& !in_system_header
2606 && ! (TREE_CODE (primop0
) == INTEGER_CST
2607 && ! TREE_OVERFLOW (convert (c_common_signed_type (type
),
2609 warning ("comparison of unsigned expression < 0 is always false");
2610 value
= boolean_false_node
;
2619 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2620 if (TREE_SIDE_EFFECTS (primop0
))
2621 return build (COMPOUND_EXPR
, TREE_TYPE (value
),
2628 *op0_ptr
= convert (type
, primop0
);
2629 *op1_ptr
= convert (type
, primop1
);
2631 *restype_ptr
= boolean_type_node
;
2636 /* Return a tree for the sum or difference (RESULTCODE says which)
2637 of pointer PTROP and integer INTOP. */
2640 pointer_int_sum (resultcode
, ptrop
, intop
)
2641 enum tree_code resultcode
;
2649 /* The result is a pointer of the same type that is being added. */
2651 tree result_type
= TREE_TYPE (ptrop
);
2653 if (TREE_CODE (TREE_TYPE (result_type
)) == VOID_TYPE
)
2655 if (pedantic
|| warn_pointer_arith
)
2656 pedwarn ("pointer of type `void *' used in arithmetic");
2657 size_exp
= integer_one_node
;
2659 else if (TREE_CODE (TREE_TYPE (result_type
)) == FUNCTION_TYPE
)
2661 if (pedantic
|| warn_pointer_arith
)
2662 pedwarn ("pointer to a function used in arithmetic");
2663 size_exp
= integer_one_node
;
2665 else if (TREE_CODE (TREE_TYPE (result_type
)) == METHOD_TYPE
)
2667 if (pedantic
|| warn_pointer_arith
)
2668 pedwarn ("pointer to member function used in arithmetic");
2669 size_exp
= integer_one_node
;
2671 else if (TREE_CODE (TREE_TYPE (result_type
)) == OFFSET_TYPE
)
2673 if (pedantic
|| warn_pointer_arith
)
2674 pedwarn ("pointer to a member used in arithmetic");
2675 size_exp
= integer_one_node
;
2678 size_exp
= size_in_bytes (TREE_TYPE (result_type
));
2680 /* If what we are about to multiply by the size of the elements
2681 contains a constant term, apply distributive law
2682 and multiply that constant term separately.
2683 This helps produce common subexpressions. */
2685 if ((TREE_CODE (intop
) == PLUS_EXPR
|| TREE_CODE (intop
) == MINUS_EXPR
)
2686 && ! TREE_CONSTANT (intop
)
2687 && TREE_CONSTANT (TREE_OPERAND (intop
, 1))
2688 && TREE_CONSTANT (size_exp
)
2689 /* If the constant comes from pointer subtraction,
2690 skip this optimization--it would cause an error. */
2691 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop
, 0))) == INTEGER_TYPE
2692 /* If the constant is unsigned, and smaller than the pointer size,
2693 then we must skip this optimization. This is because it could cause
2694 an overflow error if the constant is negative but INTOP is not. */
2695 && (! TREE_UNSIGNED (TREE_TYPE (intop
))
2696 || (TYPE_PRECISION (TREE_TYPE (intop
))
2697 == TYPE_PRECISION (TREE_TYPE (ptrop
)))))
2699 enum tree_code subcode
= resultcode
;
2700 tree int_type
= TREE_TYPE (intop
);
2701 if (TREE_CODE (intop
) == MINUS_EXPR
)
2702 subcode
= (subcode
== PLUS_EXPR
? MINUS_EXPR
: PLUS_EXPR
);
2703 /* Convert both subexpression types to the type of intop,
2704 because weird cases involving pointer arithmetic
2705 can result in a sum or difference with different type args. */
2706 ptrop
= build_binary_op (subcode
, ptrop
,
2707 convert (int_type
, TREE_OPERAND (intop
, 1)), 1);
2708 intop
= convert (int_type
, TREE_OPERAND (intop
, 0));
2711 /* Convert the integer argument to a type the same size as sizetype
2712 so the multiply won't overflow spuriously. */
2714 if (TYPE_PRECISION (TREE_TYPE (intop
)) != TYPE_PRECISION (sizetype
)
2715 || TREE_UNSIGNED (TREE_TYPE (intop
)) != TREE_UNSIGNED (sizetype
))
2716 intop
= convert (c_common_type_for_size (TYPE_PRECISION (sizetype
),
2717 TREE_UNSIGNED (sizetype
)), intop
);
2719 /* Replace the integer argument with a suitable product by the object size.
2720 Do this multiplication as signed, then convert to the appropriate
2721 pointer type (actually unsigned integral). */
2723 intop
= convert (result_type
,
2724 build_binary_op (MULT_EXPR
, intop
,
2725 convert (TREE_TYPE (intop
), size_exp
), 1));
2727 /* Create the sum or difference. */
2729 result
= build (resultcode
, result_type
, ptrop
, intop
);
2731 folded
= fold (result
);
2732 if (folded
== result
)
2733 TREE_CONSTANT (folded
) = TREE_CONSTANT (ptrop
) & TREE_CONSTANT (intop
);
2737 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2738 or validate its data type for an `if' or `while' statement or ?..: exp.
2740 This preparation consists of taking the ordinary
2741 representation of an expression expr and producing a valid tree
2742 boolean expression describing whether expr is nonzero. We could
2743 simply always do build_binary_op (NE_EXPR, expr, boolean_false_node, 1),
2744 but we optimize comparisons, &&, ||, and !.
2746 The resulting type should always be `boolean_type_node'. */
2749 c_common_truthvalue_conversion (expr
)
2752 if (TREE_CODE (expr
) == ERROR_MARK
)
2755 #if 0 /* This appears to be wrong for C++. */
2756 /* These really should return error_mark_node after 2.4 is stable.
2757 But not all callers handle ERROR_MARK properly. */
2758 switch (TREE_CODE (TREE_TYPE (expr
)))
2761 error ("struct type value used where scalar is required");
2762 return boolean_false_node
;
2765 error ("union type value used where scalar is required");
2766 return boolean_false_node
;
2769 error ("array type value used where scalar is required");
2770 return boolean_false_node
;
2777 switch (TREE_CODE (expr
))
2780 case NE_EXPR
: case LE_EXPR
: case GE_EXPR
: case LT_EXPR
: case GT_EXPR
:
2781 case TRUTH_ANDIF_EXPR
:
2782 case TRUTH_ORIF_EXPR
:
2783 case TRUTH_AND_EXPR
:
2785 case TRUTH_XOR_EXPR
:
2786 case TRUTH_NOT_EXPR
:
2787 TREE_TYPE (expr
) = boolean_type_node
;
2794 return integer_zerop (expr
) ? boolean_false_node
: boolean_true_node
;
2797 return real_zerop (expr
) ? boolean_false_node
: boolean_true_node
;
2800 /* If we are taking the address of an external decl, it might be zero
2801 if it is weak, so we cannot optimize. */
2802 if (DECL_P (TREE_OPERAND (expr
, 0))
2803 && DECL_EXTERNAL (TREE_OPERAND (expr
, 0)))
2806 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 0)))
2807 return build (COMPOUND_EXPR
, boolean_type_node
,
2808 TREE_OPERAND (expr
, 0), boolean_true_node
);
2810 return boolean_true_node
;
2813 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1))
2814 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
2815 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0)),
2816 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 1)),
2824 /* These don't change whether an object is nonzero or zero. */
2825 return c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0));
2829 /* These don't change whether an object is zero or nonzero, but
2830 we can't ignore them if their second arg has side-effects. */
2831 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1)))
2832 return build (COMPOUND_EXPR
, boolean_type_node
, TREE_OPERAND (expr
, 1),
2833 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0)));
2835 return c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0));
2838 /* Distribute the conversion into the arms of a COND_EXPR. */
2839 return fold (build (COND_EXPR
, boolean_type_node
, TREE_OPERAND (expr
, 0),
2840 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 1)),
2841 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 2))));
2844 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2845 since that affects how `default_conversion' will behave. */
2846 if (TREE_CODE (TREE_TYPE (expr
)) == REFERENCE_TYPE
2847 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == REFERENCE_TYPE
)
2849 /* fall through... */
2851 /* If this is widening the argument, we can ignore it. */
2852 if (TYPE_PRECISION (TREE_TYPE (expr
))
2853 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr
, 0))))
2854 return c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0));
2858 /* Perhaps reduce (x - y) != 0 to (x != y). The expressions
2859 aren't guaranteed to the be same for modes that can represent
2860 infinity, since if x and y are both +infinity, or both
2861 -infinity, then x - y is not a number.
2863 Note that this transformation is safe when x or y is NaN.
2864 (x - y) is then NaN, and both (x - y) != 0 and x != y will
2866 if (HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr
, 0)))))
2868 /* fall through... */
2870 /* This and MINUS_EXPR can be changed into a comparison of the
2872 if (TREE_TYPE (TREE_OPERAND (expr
, 0))
2873 == TREE_TYPE (TREE_OPERAND (expr
, 1)))
2874 return build_binary_op (NE_EXPR
, TREE_OPERAND (expr
, 0),
2875 TREE_OPERAND (expr
, 1), 1);
2876 return build_binary_op (NE_EXPR
, TREE_OPERAND (expr
, 0),
2877 fold (build1 (NOP_EXPR
,
2878 TREE_TYPE (TREE_OPERAND (expr
, 0)),
2879 TREE_OPERAND (expr
, 1))), 1);
2882 if (integer_onep (TREE_OPERAND (expr
, 1))
2883 && TREE_TYPE (expr
) != boolean_type_node
)
2884 /* Using convert here would cause infinite recursion. */
2885 return build1 (NOP_EXPR
, boolean_type_node
, expr
);
2889 if (warn_parentheses
&& C_EXP_ORIGINAL_CODE (expr
) == MODIFY_EXPR
)
2890 warning ("suggest parentheses around assignment used as truth value");
2897 if (TREE_CODE (TREE_TYPE (expr
)) == COMPLEX_TYPE
)
2899 tree t
= save_expr (expr
);
2900 return (build_binary_op
2901 ((TREE_SIDE_EFFECTS (expr
)
2902 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
2903 c_common_truthvalue_conversion (build_unary_op (REALPART_EXPR
, t
, 0)),
2904 c_common_truthvalue_conversion (build_unary_op (IMAGPART_EXPR
, t
, 0)),
2908 return build_binary_op (NE_EXPR
, expr
, integer_zero_node
, 1);
2911 static tree builtin_function_2
PARAMS ((const char *, const char *, tree
, tree
,
2912 int, enum built_in_class
, int, int,
2915 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2916 down to the element type of an array. */
2919 c_build_qualified_type (type
, type_quals
)
2923 /* A restrict-qualified pointer type must be a pointer to object or
2924 incomplete type. Note that the use of POINTER_TYPE_P also allows
2925 REFERENCE_TYPEs, which is appropriate for C++. Unfortunately,
2926 the C++ front-end also use POINTER_TYPE for pointer-to-member
2927 values, so even though it should be illegal to use `restrict'
2928 with such an entity we don't flag that here. Thus, special case
2929 code for that case is required in the C++ front-end. */
2930 if ((type_quals
& TYPE_QUAL_RESTRICT
)
2931 && (!POINTER_TYPE_P (type
)
2932 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type
))))
2934 error ("invalid use of `restrict'");
2935 type_quals
&= ~TYPE_QUAL_RESTRICT
;
2938 if (TREE_CODE (type
) == ARRAY_TYPE
)
2939 return build_array_type (c_build_qualified_type (TREE_TYPE (type
),
2941 TYPE_DOMAIN (type
));
2942 return build_qualified_type (type
, type_quals
);
2945 /* Apply the TYPE_QUALS to the new DECL. */
2948 c_apply_type_quals_to_decl (type_quals
, decl
)
2952 if ((type_quals
& TYPE_QUAL_CONST
)
2953 || (TREE_TYPE (decl
)
2954 && TREE_CODE (TREE_TYPE (decl
)) == REFERENCE_TYPE
))
2955 TREE_READONLY (decl
) = 1;
2956 if (type_quals
& TYPE_QUAL_VOLATILE
)
2958 TREE_SIDE_EFFECTS (decl
) = 1;
2959 TREE_THIS_VOLATILE (decl
) = 1;
2961 if (type_quals
& TYPE_QUAL_RESTRICT
)
2963 if (!TREE_TYPE (decl
)
2964 || !POINTER_TYPE_P (TREE_TYPE (decl
))
2965 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (TREE_TYPE (decl
))))
2966 error ("invalid use of `restrict'");
2967 else if (flag_strict_aliasing
)
2968 /* Indicate we need to make a unique alias set for this pointer.
2969 We can't do it here because it might be pointing to an
2971 DECL_POINTER_ALIAS_SET (decl
) = -2;
2975 /* Return the typed-based alias set for T, which may be an expression
2976 or a type. Return -1 if we don't do anything special. */
2979 c_common_get_alias_set (t
)
2984 /* Permit type-punning when accessing a union, provided the access
2985 is directly through the union. For example, this code does not
2986 permit taking the address of a union member and then storing
2987 through it. Even the type-punning allowed here is a GCC
2988 extension, albeit a common and useful one; the C standard says
2989 that such accesses have implementation-defined behavior. */
2991 TREE_CODE (u
) == COMPONENT_REF
|| TREE_CODE (u
) == ARRAY_REF
;
2992 u
= TREE_OPERAND (u
, 0))
2993 if (TREE_CODE (u
) == COMPONENT_REF
2994 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u
, 0))) == UNION_TYPE
)
2997 /* That's all the expressions we handle specially. */
3001 /* The C standard guarantees that any object may be accessed via an
3002 lvalue that has character type. */
3003 if (t
== char_type_node
3004 || t
== signed_char_type_node
3005 || t
== unsigned_char_type_node
)
3008 /* If it has the may_alias attribute, it can alias anything. */
3009 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (t
)))
3012 /* The C standard specifically allows aliasing between signed and
3013 unsigned variants of the same type. We treat the signed
3014 variant as canonical. */
3015 if (TREE_CODE (t
) == INTEGER_TYPE
&& TREE_UNSIGNED (t
))
3017 tree t1
= c_common_signed_type (t
);
3019 /* t1 == t can happen for boolean nodes which are always unsigned. */
3021 return get_alias_set (t1
);
3023 else if (POINTER_TYPE_P (t
))
3027 /* Unfortunately, there is no canonical form of a pointer type.
3028 In particular, if we have `typedef int I', then `int *', and
3029 `I *' are different types. So, we have to pick a canonical
3030 representative. We do this below.
3032 Technically, this approach is actually more conservative that
3033 it needs to be. In particular, `const int *' and `int *'
3034 should be in different alias sets, according to the C and C++
3035 standard, since their types are not the same, and so,
3036 technically, an `int **' and `const int **' cannot point at
3039 But, the standard is wrong. In particular, this code is
3044 const int* const* cipp = &ipp;
3046 And, it doesn't make sense for that to be legal unless you
3047 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
3048 the pointed-to types. This issue has been reported to the
3050 t1
= build_type_no_quals (t
);
3052 return get_alias_set (t1
);
3058 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
3059 second parameter indicates which OPERATOR is being applied. The COMPLAIN
3060 flag controls whether we should diagnose possibly ill-formed
3061 constructs or not. */
3063 c_sizeof_or_alignof_type (type
, op
, complain
)
3068 const char *op_name
;
3070 enum tree_code type_code
= TREE_CODE (type
);
3072 my_friendly_assert (op
== SIZEOF_EXPR
|| op
== ALIGNOF_EXPR
, 20020720);
3073 op_name
= op
== SIZEOF_EXPR
? "sizeof" : "__alignof__";
3075 if (type_code
== FUNCTION_TYPE
)
3077 if (op
== SIZEOF_EXPR
)
3079 if (complain
&& (pedantic
|| warn_pointer_arith
))
3080 pedwarn ("invalid application of `sizeof' to a function type");
3081 value
= size_one_node
;
3084 value
= size_int (FUNCTION_BOUNDARY
/ BITS_PER_UNIT
);
3086 else if (type_code
== VOID_TYPE
|| type_code
== ERROR_MARK
)
3088 if (type_code
== VOID_TYPE
3089 && complain
&& (pedantic
|| warn_pointer_arith
))
3090 pedwarn ("invalid application of `%s' to a void type", op_name
);
3091 value
= size_one_node
;
3093 else if (!COMPLETE_TYPE_P (type
))
3096 error ("invalid application of `%s' to an incomplete type", op_name
);
3097 value
= size_zero_node
;
3101 if (op
== SIZEOF_EXPR
)
3102 /* Convert in case a char is more than one unit. */
3103 value
= size_binop (CEIL_DIV_EXPR
, TYPE_SIZE_UNIT (type
),
3104 size_int (TYPE_PRECISION (char_type_node
)
3107 value
= size_int (TYPE_ALIGN (type
) / BITS_PER_UNIT
);
3110 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
3111 TYPE_IS_SIZETYPE means that certain things (like overflow) will
3112 never happen. However, this node should really have type
3113 `size_t', which is just a typedef for an ordinary integer type. */
3114 value
= fold (build1 (NOP_EXPR
, size_type_node
, value
));
3115 my_friendly_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value
)), 20001021);
3120 /* Implement the __alignof keyword: Return the minimum required
3121 alignment of EXPR, measured in bytes. For VAR_DECL's and
3122 FIELD_DECL's return DECL_ALIGN (which can be set from an
3123 "aligned" __attribute__ specification). */
3126 c_alignof_expr (expr
)
3131 if (TREE_CODE (expr
) == VAR_DECL
)
3132 t
= size_int (DECL_ALIGN (expr
) / BITS_PER_UNIT
);
3134 else if (TREE_CODE (expr
) == COMPONENT_REF
3135 && DECL_C_BIT_FIELD (TREE_OPERAND (expr
, 1)))
3137 error ("`__alignof' applied to a bit-field");
3140 else if (TREE_CODE (expr
) == COMPONENT_REF
3141 && TREE_CODE (TREE_OPERAND (expr
, 1)) == FIELD_DECL
)
3142 t
= size_int (DECL_ALIGN (TREE_OPERAND (expr
, 1)) / BITS_PER_UNIT
);
3144 else if (TREE_CODE (expr
) == INDIRECT_REF
)
3146 tree t
= TREE_OPERAND (expr
, 0);
3148 int bestalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
3150 while (TREE_CODE (t
) == NOP_EXPR
3151 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0))) == POINTER_TYPE
)
3155 t
= TREE_OPERAND (t
, 0);
3156 thisalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
3157 if (thisalign
> bestalign
)
3158 best
= t
, bestalign
= thisalign
;
3160 return c_alignof (TREE_TYPE (TREE_TYPE (best
)));
3163 return c_alignof (TREE_TYPE (expr
));
3165 return fold (build1 (NOP_EXPR
, size_type_node
, t
));
3168 /* Handle C and C++ default attributes. */
3170 enum built_in_attribute
3172 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
3173 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
3174 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
3175 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
3176 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No entry needed in enum. */
3177 #include "builtin-attrs.def"
3178 #undef DEF_ATTR_NULL_TREE
3180 #undef DEF_ATTR_IDENT
3181 #undef DEF_ATTR_TREE_LIST
3186 static GTY(()) tree built_in_attributes
[(int) ATTR_LAST
];
3188 static bool c_attrs_initialized
= false;
3190 static void c_init_attributes
PARAMS ((void));
3192 /* Build tree nodes and builtin functions common to both C and C++ language
3196 c_common_nodes_and_builtins ()
3200 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
3201 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
3202 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
3203 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
3204 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3205 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3206 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
3207 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
3208 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
3209 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3210 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
3211 #include "builtin-types.def"
3212 #undef DEF_PRIMITIVE_TYPE
3213 #undef DEF_FUNCTION_TYPE_0
3214 #undef DEF_FUNCTION_TYPE_1
3215 #undef DEF_FUNCTION_TYPE_2
3216 #undef DEF_FUNCTION_TYPE_3
3217 #undef DEF_FUNCTION_TYPE_4
3218 #undef DEF_FUNCTION_TYPE_VAR_0
3219 #undef DEF_FUNCTION_TYPE_VAR_1
3220 #undef DEF_FUNCTION_TYPE_VAR_2
3221 #undef DEF_FUNCTION_TYPE_VAR_3
3222 #undef DEF_POINTER_TYPE
3226 typedef enum builtin_type builtin_type
;
3228 tree builtin_types
[(int) BT_LAST
];
3229 int wchar_type_size
;
3230 tree array_domain_type
;
3231 tree va_list_ref_type_node
;
3232 tree va_list_arg_type_node
;
3234 /* Define `int' and `char' first so that dbx will output them first. */
3235 record_builtin_type (RID_INT
, NULL
, integer_type_node
);
3236 record_builtin_type (RID_CHAR
, "char", char_type_node
);
3238 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
3239 "unsigned long", "long long unsigned" and "unsigned short" were in C++
3240 but not C. Are the conditionals here needed? */
3241 if (c_language
== clk_cplusplus
)
3242 record_builtin_type (RID_SIGNED
, NULL
, integer_type_node
);
3243 record_builtin_type (RID_LONG
, "long int", long_integer_type_node
);
3244 record_builtin_type (RID_UNSIGNED
, "unsigned int", unsigned_type_node
);
3245 record_builtin_type (RID_MAX
, "long unsigned int",
3246 long_unsigned_type_node
);
3247 if (c_language
== clk_cplusplus
)
3248 record_builtin_type (RID_MAX
, "unsigned long", long_unsigned_type_node
);
3249 record_builtin_type (RID_MAX
, "long long int",
3250 long_long_integer_type_node
);
3251 record_builtin_type (RID_MAX
, "long long unsigned int",
3252 long_long_unsigned_type_node
);
3253 if (c_language
== clk_cplusplus
)
3254 record_builtin_type (RID_MAX
, "long long unsigned",
3255 long_long_unsigned_type_node
);
3256 record_builtin_type (RID_SHORT
, "short int", short_integer_type_node
);
3257 record_builtin_type (RID_MAX
, "short unsigned int",
3258 short_unsigned_type_node
);
3259 if (c_language
== clk_cplusplus
)
3260 record_builtin_type (RID_MAX
, "unsigned short",
3261 short_unsigned_type_node
);
3263 /* Define both `signed char' and `unsigned char'. */
3264 record_builtin_type (RID_MAX
, "signed char", signed_char_type_node
);
3265 record_builtin_type (RID_MAX
, "unsigned char", unsigned_char_type_node
);
3267 /* These are types that c_common_type_for_size and
3268 c_common_type_for_mode use. */
3269 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
3271 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
3273 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
3275 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
3277 #if HOST_BITS_PER_WIDE_INT >= 64
3278 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
,
3279 get_identifier ("__int128_t"),
3282 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
3283 unsigned_intQI_type_node
));
3284 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
3285 unsigned_intHI_type_node
));
3286 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
3287 unsigned_intSI_type_node
));
3288 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
3289 unsigned_intDI_type_node
));
3290 #if HOST_BITS_PER_WIDE_INT >= 64
3291 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
,
3292 get_identifier ("__uint128_t"),
3293 unsigned_intTI_type_node
));
3296 /* Create the widest literal types. */
3297 widest_integer_literal_type_node
3298 = make_signed_type (HOST_BITS_PER_WIDE_INT
* 2);
3299 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
3300 widest_integer_literal_type_node
));
3302 widest_unsigned_literal_type_node
3303 = make_unsigned_type (HOST_BITS_PER_WIDE_INT
* 2);
3304 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
3305 widest_unsigned_literal_type_node
));
3307 /* `unsigned long' is the standard type for sizeof.
3308 Note that stddef.h uses `unsigned long',
3309 and this must agree, even if long and int are the same size. */
3311 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE
)));
3312 signed_size_type_node
= c_common_signed_type (size_type_node
);
3313 set_sizetype (size_type_node
);
3315 build_common_tree_nodes_2 (flag_short_double
);
3317 record_builtin_type (RID_FLOAT
, NULL
, float_type_node
);
3318 record_builtin_type (RID_DOUBLE
, NULL
, double_type_node
);
3319 record_builtin_type (RID_MAX
, "long double", long_double_type_node
);
3321 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
,
3322 get_identifier ("complex int"),
3323 complex_integer_type_node
));
3324 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
,
3325 get_identifier ("complex float"),
3326 complex_float_type_node
));
3327 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
,
3328 get_identifier ("complex double"),
3329 complex_double_type_node
));
3330 (*lang_hooks
.decls
.pushdecl
)
3331 (build_decl (TYPE_DECL
, get_identifier ("complex long double"),
3332 complex_long_double_type_node
));
3334 /* Types which are common to the fortran compiler and libf2c. When
3335 changing these, you also need to be concerned with f/com.h. */
3337 if (TYPE_PRECISION (float_type_node
)
3338 == TYPE_PRECISION (long_integer_type_node
))
3340 g77_integer_type_node
= long_integer_type_node
;
3341 g77_uinteger_type_node
= long_unsigned_type_node
;
3343 else if (TYPE_PRECISION (float_type_node
)
3344 == TYPE_PRECISION (integer_type_node
))
3346 g77_integer_type_node
= integer_type_node
;
3347 g77_uinteger_type_node
= unsigned_type_node
;
3350 g77_integer_type_node
= g77_uinteger_type_node
= NULL_TREE
;
3352 if (g77_integer_type_node
!= NULL_TREE
)
3354 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
,
3355 get_identifier ("__g77_integer"),
3356 g77_integer_type_node
));
3357 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
,
3358 get_identifier ("__g77_uinteger"),
3359 g77_uinteger_type_node
));
3362 if (TYPE_PRECISION (float_type_node
) * 2
3363 == TYPE_PRECISION (long_integer_type_node
))
3365 g77_longint_type_node
= long_integer_type_node
;
3366 g77_ulongint_type_node
= long_unsigned_type_node
;
3368 else if (TYPE_PRECISION (float_type_node
) * 2
3369 == TYPE_PRECISION (long_long_integer_type_node
))
3371 g77_longint_type_node
= long_long_integer_type_node
;
3372 g77_ulongint_type_node
= long_long_unsigned_type_node
;
3375 g77_longint_type_node
= g77_ulongint_type_node
= NULL_TREE
;
3377 if (g77_longint_type_node
!= NULL_TREE
)
3379 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
,
3380 get_identifier ("__g77_longint"),
3381 g77_longint_type_node
));
3382 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
,
3383 get_identifier ("__g77_ulongint"),
3384 g77_ulongint_type_node
));
3387 record_builtin_type (RID_VOID
, NULL
, void_type_node
);
3389 void_zero_node
= build_int_2 (0, 0);
3390 TREE_TYPE (void_zero_node
) = void_type_node
;
3392 void_list_node
= build_void_list_node ();
3394 /* Make a type to be the domain of a few array types
3395 whose domains don't really matter.
3396 200 is small enough that it always fits in size_t
3397 and large enough that it can hold most function names for the
3398 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
3399 array_domain_type
= build_index_type (size_int (200));
3401 /* Make a type for arrays of characters.
3402 With luck nothing will ever really depend on the length of this
3404 char_array_type_node
3405 = build_array_type (char_type_node
, array_domain_type
);
3407 /* Likewise for arrays of ints. */
3409 = build_array_type (integer_type_node
, array_domain_type
);
3411 string_type_node
= build_pointer_type (char_type_node
);
3412 const_string_type_node
3413 = build_pointer_type (build_qualified_type
3414 (char_type_node
, TYPE_QUAL_CONST
));
3416 /* This is special for C++ so functions can be overloaded. */
3417 wchar_type_node
= get_identifier (MODIFIED_WCHAR_TYPE
);
3418 wchar_type_node
= TREE_TYPE (identifier_global_value (wchar_type_node
));
3419 wchar_type_size
= TYPE_PRECISION (wchar_type_node
);
3420 if (c_language
== clk_cplusplus
)
3422 if (TREE_UNSIGNED (wchar_type_node
))
3423 wchar_type_node
= make_unsigned_type (wchar_type_size
);
3425 wchar_type_node
= make_signed_type (wchar_type_size
);
3426 record_builtin_type (RID_WCHAR
, "wchar_t", wchar_type_node
);
3430 signed_wchar_type_node
= c_common_signed_type (wchar_type_node
);
3431 unsigned_wchar_type_node
= c_common_unsigned_type (wchar_type_node
);
3434 /* This is for wide string constants. */
3435 wchar_array_type_node
3436 = build_array_type (wchar_type_node
, array_domain_type
);
3439 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE
)));
3442 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE
)));
3444 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE
)));
3446 default_function_type
= build_function_type (integer_type_node
, NULL_TREE
);
3448 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE
)));
3449 unsigned_ptrdiff_type_node
= c_common_unsigned_type (ptrdiff_type_node
);
3451 (*lang_hooks
.decls
.pushdecl
)
3452 (build_decl (TYPE_DECL
, get_identifier ("__builtin_va_list"),
3453 va_list_type_node
));
3455 (*lang_hooks
.decls
.pushdecl
)
3456 (build_decl (TYPE_DECL
, get_identifier ("__builtin_ptrdiff_t"),
3457 ptrdiff_type_node
));
3459 (*lang_hooks
.decls
.pushdecl
)
3460 (build_decl (TYPE_DECL
, get_identifier ("__builtin_size_t"),
3463 if (TREE_CODE (va_list_type_node
) == ARRAY_TYPE
)
3465 va_list_arg_type_node
= va_list_ref_type_node
=
3466 build_pointer_type (TREE_TYPE (va_list_type_node
));
3470 va_list_arg_type_node
= va_list_type_node
;
3471 va_list_ref_type_node
= build_reference_type (va_list_type_node
);
3474 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3475 builtin_types[(int) ENUM] = VALUE;
3476 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
3477 builtin_types[(int) ENUM] \
3478 = build_function_type (builtin_types[(int) RETURN], \
3480 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
3481 builtin_types[(int) ENUM] \
3482 = build_function_type (builtin_types[(int) RETURN], \
3483 tree_cons (NULL_TREE, \
3484 builtin_types[(int) ARG1], \
3486 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
3487 builtin_types[(int) ENUM] \
3488 = build_function_type \
3489 (builtin_types[(int) RETURN], \
3490 tree_cons (NULL_TREE, \
3491 builtin_types[(int) ARG1], \
3492 tree_cons (NULL_TREE, \
3493 builtin_types[(int) ARG2], \
3495 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3496 builtin_types[(int) ENUM] \
3497 = build_function_type \
3498 (builtin_types[(int) RETURN], \
3499 tree_cons (NULL_TREE, \
3500 builtin_types[(int) ARG1], \
3501 tree_cons (NULL_TREE, \
3502 builtin_types[(int) ARG2], \
3503 tree_cons (NULL_TREE, \
3504 builtin_types[(int) ARG3], \
3506 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3507 builtin_types[(int) ENUM] \
3508 = build_function_type \
3509 (builtin_types[(int) RETURN], \
3510 tree_cons (NULL_TREE, \
3511 builtin_types[(int) ARG1], \
3512 tree_cons (NULL_TREE, \
3513 builtin_types[(int) ARG2], \
3516 builtin_types[(int) ARG3], \
3517 tree_cons (NULL_TREE, \
3518 builtin_types[(int) ARG4], \
3519 void_list_node)))));
3520 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
3521 builtin_types[(int) ENUM] \
3522 = build_function_type (builtin_types[(int) RETURN], NULL_TREE);
3523 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
3524 builtin_types[(int) ENUM] \
3525 = build_function_type (builtin_types[(int) RETURN], \
3526 tree_cons (NULL_TREE, \
3527 builtin_types[(int) ARG1], \
3530 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
3531 builtin_types[(int) ENUM] \
3532 = build_function_type \
3533 (builtin_types[(int) RETURN], \
3534 tree_cons (NULL_TREE, \
3535 builtin_types[(int) ARG1], \
3536 tree_cons (NULL_TREE, \
3537 builtin_types[(int) ARG2], \
3540 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3541 builtin_types[(int) ENUM] \
3542 = build_function_type \
3543 (builtin_types[(int) RETURN], \
3544 tree_cons (NULL_TREE, \
3545 builtin_types[(int) ARG1], \
3546 tree_cons (NULL_TREE, \
3547 builtin_types[(int) ARG2], \
3548 tree_cons (NULL_TREE, \
3549 builtin_types[(int) ARG3], \
3552 #define DEF_POINTER_TYPE(ENUM, TYPE) \
3553 builtin_types[(int) ENUM] \
3554 = build_pointer_type (builtin_types[(int) TYPE]);
3555 #include "builtin-types.def"
3556 #undef DEF_PRIMITIVE_TYPE
3557 #undef DEF_FUNCTION_TYPE_1
3558 #undef DEF_FUNCTION_TYPE_2
3559 #undef DEF_FUNCTION_TYPE_3
3560 #undef DEF_FUNCTION_TYPE_4
3561 #undef DEF_FUNCTION_TYPE_VAR_0
3562 #undef DEF_FUNCTION_TYPE_VAR_1
3563 #undef DEF_FUNCTION_TYPE_VAR_2
3564 #undef DEF_FUNCTION_TYPE_VAR_3
3565 #undef DEF_POINTER_TYPE
3567 if (!c_attrs_initialized
)
3568 c_init_attributes ();
3570 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, \
3571 BOTH_P, FALLBACK_P, NONANSI_P, ATTRS, IMPLICIT) \
3576 if (strncmp (NAME, "__builtin_", strlen ("__builtin_")) != 0) \
3580 decl = builtin_function (NAME, builtin_types[TYPE], ENUM, \
3583 ? (NAME + strlen ("__builtin_")) \
3585 built_in_attributes[(int) ATTRS]); \
3587 decl = builtin_function_2 (NAME, \
3588 NAME + strlen ("__builtin_"), \
3589 builtin_types[TYPE], \
3590 builtin_types[LIBTYPE], \
3595 built_in_attributes[(int) ATTRS]); \
3597 built_in_decls[(int) ENUM] = decl; \
3599 implicit_built_in_decls[(int) ENUM] = decl; \
3601 #include "builtins.def"
3604 (*targetm
.init_builtins
) ();
3606 main_identifier_node
= get_identifier ("main");
3610 build_va_arg (expr
, type
)
3613 return build1 (VA_ARG_EXPR
, type
, expr
);
3617 /* Linked list of disabled built-in functions. */
3619 typedef struct disabled_builtin
3622 struct disabled_builtin
*next
;
3624 static disabled_builtin
*disabled_builtins
= NULL
;
3626 static bool builtin_function_disabled_p
PARAMS ((const char *));
3628 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
3629 begins with "__builtin_", give an error. */
3632 disable_builtin_function (name
)
3635 if (strncmp (name
, "__builtin_", strlen ("__builtin_")) == 0)
3636 error ("cannot disable built-in function `%s'", name
);
3639 disabled_builtin
*new = xmalloc (sizeof (disabled_builtin
));
3641 new->next
= disabled_builtins
;
3642 disabled_builtins
= new;
3647 /* Return true if the built-in function NAME has been disabled, false
3651 builtin_function_disabled_p (name
)
3654 disabled_builtin
*p
;
3655 for (p
= disabled_builtins
; p
!= NULL
; p
= p
->next
)
3657 if (strcmp (name
, p
->name
) == 0)
3664 /* Possibly define a builtin function with one or two names. BUILTIN_NAME
3665 is an __builtin_-prefixed name; NAME is the ordinary name; one or both
3666 of these may be NULL (though both being NULL is useless).
3667 BUILTIN_TYPE is the type of the __builtin_-prefixed function;
3668 TYPE is the type of the function with the ordinary name. These
3669 may differ if the ordinary name is declared with a looser type to avoid
3670 conflicts with headers. FUNCTION_CODE and CLASS are as for
3671 builtin_function. If LIBRARY_NAME_P is nonzero, NAME is passed as
3672 the LIBRARY_NAME parameter to builtin_function when declaring BUILTIN_NAME.
3673 If NONANSI_P is nonzero, the name NAME is treated as a non-ANSI name;
3674 ATTRS is the tree list representing the builtin's function attributes.
3675 Returns the declaration of BUILTIN_NAME, if any, otherwise
3676 the declaration of NAME. Does not declare NAME if flag_no_builtin,
3677 or if NONANSI_P and flag_no_nonansi_builtin. */
3680 builtin_function_2 (builtin_name
, name
, builtin_type
, type
, function_code
,
3681 class, library_name_p
, nonansi_p
, attrs
)
3682 const char *builtin_name
;
3687 enum built_in_class
class;
3692 tree bdecl
= NULL_TREE
;
3693 tree decl
= NULL_TREE
;
3695 if (builtin_name
!= 0)
3696 bdecl
= builtin_function (builtin_name
, builtin_type
, function_code
,
3697 class, library_name_p
? name
: NULL
, attrs
);
3699 if (name
!= 0 && !flag_no_builtin
&& !builtin_function_disabled_p (name
)
3700 && !(nonansi_p
&& flag_no_nonansi_builtin
))
3701 decl
= builtin_function (name
, type
, function_code
, class, NULL
, attrs
);
3703 return (bdecl
!= 0 ? bdecl
: decl
);
3706 /* Nonzero if the type T promotes to int. This is (nearly) the
3707 integral promotions defined in ISO C99 6.3.1.1/2. */
3710 c_promoting_integer_type_p (t
)
3713 switch (TREE_CODE (t
))
3716 return (TYPE_MAIN_VARIANT (t
) == char_type_node
3717 || TYPE_MAIN_VARIANT (t
) == signed_char_type_node
3718 || TYPE_MAIN_VARIANT (t
) == unsigned_char_type_node
3719 || TYPE_MAIN_VARIANT (t
) == short_integer_type_node
3720 || TYPE_MAIN_VARIANT (t
) == short_unsigned_type_node
3721 || TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
));
3724 /* ??? Technically all enumerations not larger than an int
3725 promote to an int. But this is used along code paths
3726 that only want to notice a size change. */
3727 return TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
);
3737 /* Return 1 if PARMS specifies a fixed number of parameters
3738 and none of their types is affected by default promotions. */
3741 self_promoting_args_p (parms
)
3745 for (t
= parms
; t
; t
= TREE_CHAIN (t
))
3747 tree type
= TREE_VALUE (t
);
3749 if (TREE_CHAIN (t
) == 0 && type
!= void_type_node
)
3755 if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
3758 if (c_promoting_integer_type_p (type
))
3764 /* Recursively examines the array elements of TYPE, until a non-array
3765 element type is found. */
3768 strip_array_types (type
)
3771 while (TREE_CODE (type
) == ARRAY_TYPE
)
3772 type
= TREE_TYPE (type
);
3777 static tree expand_unordered_cmp
PARAMS ((tree
, tree
, enum tree_code
,
3780 /* Expand a call to an unordered comparison function such as
3781 __builtin_isgreater(). FUNCTION is the function's declaration and
3782 PARAMS a list of the values passed. For __builtin_isunordered(),
3783 UNORDERED_CODE is UNORDERED_EXPR and ORDERED_CODE is NOP_EXPR. In
3784 other cases, UNORDERED_CODE and ORDERED_CODE are comparison codes
3785 that give the opposite of the desired result. UNORDERED_CODE is
3786 used for modes that can hold NaNs and ORDERED_CODE is used for the
3790 expand_unordered_cmp (function
, params
, unordered_code
, ordered_code
)
3791 tree function
, params
;
3792 enum tree_code unordered_code
, ordered_code
;
3794 tree arg0
, arg1
, type
;
3795 enum tree_code code0
, code1
;
3797 /* Check that we have exactly two arguments. */
3798 if (params
== 0 || TREE_CHAIN (params
) == 0)
3800 error ("too few arguments to function `%s'",
3801 IDENTIFIER_POINTER (DECL_NAME (function
)));
3802 return error_mark_node
;
3804 else if (TREE_CHAIN (TREE_CHAIN (params
)) != 0)
3806 error ("too many arguments to function `%s'",
3807 IDENTIFIER_POINTER (DECL_NAME (function
)));
3808 return error_mark_node
;
3811 arg0
= TREE_VALUE (params
);
3812 arg1
= TREE_VALUE (TREE_CHAIN (params
));
3814 code0
= TREE_CODE (TREE_TYPE (arg0
));
3815 code1
= TREE_CODE (TREE_TYPE (arg1
));
3817 /* Make sure that the arguments have a common type of REAL. */
3819 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
)
3820 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
))
3821 type
= common_type (TREE_TYPE (arg0
), TREE_TYPE (arg1
));
3823 if (type
== 0 || TREE_CODE (type
) != REAL_TYPE
)
3825 error ("non-floating-point argument to function `%s'",
3826 IDENTIFIER_POINTER (DECL_NAME (function
)));
3827 return error_mark_node
;
3830 if (unordered_code
== UNORDERED_EXPR
)
3832 if (MODE_HAS_NANS (TYPE_MODE (type
)))
3833 return build_binary_op (unordered_code
,
3834 convert (type
, arg0
),
3835 convert (type
, arg1
),
3838 return integer_zero_node
;
3841 return build_unary_op (TRUTH_NOT_EXPR
,
3842 build_binary_op (MODE_HAS_NANS (TYPE_MODE (type
))
3845 convert (type
, arg0
),
3846 convert (type
, arg1
),
3852 /* Recognize certain built-in functions so we can make tree-codes
3853 other than CALL_EXPR. We do this when it enables fold-const.c
3854 to do something useful. */
3855 /* ??? By rights this should go in builtins.c, but only C and C++
3856 implement build_{binary,unary}_op. Not exactly sure what bits
3857 of functionality are actually needed from those functions, or
3858 where the similar functionality exists in the other front ends. */
3861 expand_tree_builtin (function
, params
, coerced_params
)
3862 tree function
, params
, coerced_params
;
3864 if (DECL_BUILT_IN_CLASS (function
) != BUILT_IN_NORMAL
)
3867 switch (DECL_FUNCTION_CODE (function
))
3871 case BUILT_IN_LLABS
:
3872 case BUILT_IN_IMAXABS
:
3874 case BUILT_IN_FABSL
:
3875 case BUILT_IN_FABSF
:
3876 if (coerced_params
== 0)
3877 return integer_zero_node
;
3878 return build_unary_op (ABS_EXPR
, TREE_VALUE (coerced_params
), 0);
3881 case BUILT_IN_CONJF
:
3882 case BUILT_IN_CONJL
:
3883 if (coerced_params
== 0)
3884 return integer_zero_node
;
3885 return build_unary_op (CONJ_EXPR
, TREE_VALUE (coerced_params
), 0);
3887 case BUILT_IN_CREAL
:
3888 case BUILT_IN_CREALF
:
3889 case BUILT_IN_CREALL
:
3890 if (coerced_params
== 0)
3891 return integer_zero_node
;
3892 return build_unary_op (REALPART_EXPR
, TREE_VALUE (coerced_params
), 0);
3894 case BUILT_IN_CIMAG
:
3895 case BUILT_IN_CIMAGF
:
3896 case BUILT_IN_CIMAGL
:
3897 if (coerced_params
== 0)
3898 return integer_zero_node
;
3899 return build_unary_op (IMAGPART_EXPR
, TREE_VALUE (coerced_params
), 0);
3901 case BUILT_IN_ISGREATER
:
3902 return expand_unordered_cmp (function
, params
, UNLE_EXPR
, LE_EXPR
);
3904 case BUILT_IN_ISGREATEREQUAL
:
3905 return expand_unordered_cmp (function
, params
, UNLT_EXPR
, LT_EXPR
);
3907 case BUILT_IN_ISLESS
:
3908 return expand_unordered_cmp (function
, params
, UNGE_EXPR
, GE_EXPR
);
3910 case BUILT_IN_ISLESSEQUAL
:
3911 return expand_unordered_cmp (function
, params
, UNGT_EXPR
, GT_EXPR
);
3913 case BUILT_IN_ISLESSGREATER
:
3914 return expand_unordered_cmp (function
, params
, UNEQ_EXPR
, EQ_EXPR
);
3916 case BUILT_IN_ISUNORDERED
:
3917 return expand_unordered_cmp (function
, params
, UNORDERED_EXPR
, NOP_EXPR
);
3926 /* Walk the statement tree, rooted at *tp. Apply FUNC to all the
3927 sub-trees of *TP in a pre-order traversal. FUNC is called with the
3928 DATA and the address of each sub-tree. If FUNC returns a non-NULL
3929 value, the traversal is aborted, and the value returned by FUNC is
3930 returned. If FUNC sets WALK_SUBTREES to zero, then the subtrees of
3931 the node being visited are not walked.
3933 We don't need a without_duplicates variant of this one because the
3934 statement tree is a tree, not a graph. */
3937 walk_stmt_tree (tp
, func
, data
)
3942 enum tree_code code
;
3947 #define WALK_SUBTREE(NODE) \
3950 result = walk_stmt_tree (&(NODE), func, data); \
3956 /* Skip empty subtrees. */
3960 /* Skip subtrees below non-statement nodes. */
3961 if (!STATEMENT_CODE_P (TREE_CODE (*tp
)))
3964 /* Call the function. */
3966 result
= (*func
) (tp
, &walk_subtrees
, data
);
3968 /* If we found something, return it. */
3972 /* FUNC may have modified the tree, recheck that we're looking at a
3974 code
= TREE_CODE (*tp
);
3975 if (!STATEMENT_CODE_P (code
))
3978 /* Visit the subtrees unless FUNC decided that there was nothing
3979 interesting below this point in the tree. */
3982 /* Walk over all the sub-trees of this operand. Statement nodes
3983 never contain RTL, and we needn't worry about TARGET_EXPRs. */
3984 len
= TREE_CODE_LENGTH (code
);
3986 /* Go through the subtrees. We need to do this in forward order so
3987 that the scope of a FOR_EXPR is handled properly. */
3988 for (i
= 0; i
< len
; ++i
)
3989 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
3992 /* Finally visit the chain. This can be tail-recursion optimized if
3993 we write it this way. */
3994 return walk_stmt_tree (&TREE_CHAIN (*tp
), func
, data
);
3999 /* Used to compare case labels. K1 and K2 are actually tree nodes
4000 representing case labels, or NULL_TREE for a `default' label.
4001 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
4002 K2, and 0 if K1 and K2 are equal. */
4005 case_compare (k1
, k2
)
4009 /* Consider a NULL key (such as arises with a `default' label) to be
4010 smaller than anything else. */
4016 return tree_int_cst_compare ((tree
) k1
, (tree
) k2
);
4019 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
4020 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
4021 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
4022 case label was declared using the usual C/C++ syntax, rather than
4023 the GNU case range extension. CASES is a tree containing all the
4024 case ranges processed so far; COND is the condition for the
4025 switch-statement itself. Returns the CASE_LABEL created, or
4026 ERROR_MARK_NODE if no CASE_LABEL is created. */
4029 c_add_case_label (cases
, cond
, low_value
, high_value
)
4038 splay_tree_node node
;
4040 /* Create the LABEL_DECL itself. */
4041 label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
4042 DECL_CONTEXT (label
) = current_function_decl
;
4044 /* If there was an error processing the switch condition, bail now
4045 before we get more confused. */
4046 if (!cond
|| cond
== error_mark_node
)
4048 /* Add a label anyhow so that the back-end doesn't think that
4049 the beginning of the switch is unreachable. */
4051 add_stmt (build_case_label (NULL_TREE
, NULL_TREE
, label
));
4052 return error_mark_node
;
4055 if ((low_value
&& TREE_TYPE (low_value
)
4056 && POINTER_TYPE_P (TREE_TYPE (low_value
)))
4057 || (high_value
&& TREE_TYPE (high_value
)
4058 && POINTER_TYPE_P (TREE_TYPE (high_value
))))
4059 error ("pointers are not permitted as case values");
4061 /* Case ranges are a GNU extension. */
4062 if (high_value
&& pedantic
)
4064 if (c_language
== clk_cplusplus
)
4065 pedwarn ("ISO C++ forbids range expressions in switch statements");
4067 pedwarn ("ISO C forbids range expressions in switch statements");
4070 type
= TREE_TYPE (cond
);
4073 low_value
= check_case_value (low_value
);
4074 low_value
= convert_and_check (type
, low_value
);
4078 high_value
= check_case_value (high_value
);
4079 high_value
= convert_and_check (type
, high_value
);
4082 /* If an error has occurred, bail out now. */
4083 if (low_value
== error_mark_node
|| high_value
== error_mark_node
)
4086 add_stmt (build_case_label (NULL_TREE
, NULL_TREE
, label
));
4087 return error_mark_node
;
4090 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
4091 really a case range, even though it was written that way. Remove
4092 the HIGH_VALUE to simplify later processing. */
4093 if (tree_int_cst_equal (low_value
, high_value
))
4094 high_value
= NULL_TREE
;
4095 if (low_value
&& high_value
4096 && !tree_int_cst_lt (low_value
, high_value
))
4097 warning ("empty range specified");
4099 /* Look up the LOW_VALUE in the table of case labels we already
4101 node
= splay_tree_lookup (cases
, (splay_tree_key
) low_value
);
4102 /* If there was not an exact match, check for overlapping ranges.
4103 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
4104 that's a `default' label and the only overlap is an exact match. */
4105 if (!node
&& (low_value
|| high_value
))
4107 splay_tree_node low_bound
;
4108 splay_tree_node high_bound
;
4110 /* Even though there wasn't an exact match, there might be an
4111 overlap between this case range and another case range.
4112 Since we've (inductively) not allowed any overlapping case
4113 ranges, we simply need to find the greatest low case label
4114 that is smaller that LOW_VALUE, and the smallest low case
4115 label that is greater than LOW_VALUE. If there is an overlap
4116 it will occur in one of these two ranges. */
4117 low_bound
= splay_tree_predecessor (cases
,
4118 (splay_tree_key
) low_value
);
4119 high_bound
= splay_tree_successor (cases
,
4120 (splay_tree_key
) low_value
);
4122 /* Check to see if the LOW_BOUND overlaps. It is smaller than
4123 the LOW_VALUE, so there is no need to check unless the
4124 LOW_BOUND is in fact itself a case range. */
4126 && CASE_HIGH ((tree
) low_bound
->value
)
4127 && tree_int_cst_compare (CASE_HIGH ((tree
) low_bound
->value
),
4130 /* Check to see if the HIGH_BOUND overlaps. The low end of that
4131 range is bigger than the low end of the current range, so we
4132 are only interested if the current range is a real range, and
4133 not an ordinary case label. */
4136 && (tree_int_cst_compare ((tree
) high_bound
->key
,
4141 /* If there was an overlap, issue an error. */
4144 tree duplicate
= CASE_LABEL_DECL ((tree
) node
->value
);
4148 error ("duplicate (or overlapping) case value");
4149 error_with_decl (duplicate
,
4150 "this is the first entry overlapping that value");
4154 error ("duplicate case value") ;
4155 error_with_decl (duplicate
, "previously used here");
4159 error ("multiple default labels in one switch");
4160 error_with_decl (duplicate
, "this is the first default label");
4163 add_stmt (build_case_label (NULL_TREE
, NULL_TREE
, label
));
4166 /* Add a CASE_LABEL to the statement-tree. */
4167 case_label
= add_stmt (build_case_label (low_value
, high_value
, label
));
4168 /* Register this case label in the splay tree. */
4169 splay_tree_insert (cases
,
4170 (splay_tree_key
) low_value
,
4171 (splay_tree_value
) case_label
);
4176 /* Finish an expression taking the address of LABEL (an
4177 IDENTIFIER_NODE). Returns an expression for the address. */
4180 finish_label_address_expr (label
)
4187 if (c_language
== clk_cplusplus
)
4188 pedwarn ("ISO C++ forbids taking the address of a label");
4190 pedwarn ("ISO C forbids taking the address of a label");
4193 if (label
== error_mark_node
)
4194 return error_mark_node
;
4196 label
= lookup_label (label
);
4197 if (label
== NULL_TREE
)
4198 result
= null_pointer_node
;
4201 TREE_USED (label
) = 1;
4202 result
= build1 (ADDR_EXPR
, ptr_type_node
, label
);
4203 TREE_CONSTANT (result
) = 1;
4204 /* The current function in not necessarily uninlinable.
4205 Computed gotos are incompatible with inlining, but the value
4206 here could be used only in a diagnostic, for example. */
4212 /* Hook used by expand_expr to expand language-specific tree codes. */
4215 c_expand_expr (exp
, target
, tmode
, modifier
)
4218 enum machine_mode tmode
;
4219 int modifier
; /* Actually enum_modifier. */
4221 switch (TREE_CODE (exp
))
4227 bool preserve_result
= false;
4228 bool return_target
= false;
4230 /* Since expand_expr_stmt calls free_temp_slots after every
4231 expression statement, we must call push_temp_slots here.
4232 Otherwise, any temporaries in use now would be considered
4233 out-of-scope after the first EXPR_STMT from within the
4236 rtl_expr
= expand_start_stmt_expr (!STMT_EXPR_NO_SCOPE (exp
));
4238 /* If we want the result of this expression, find the last
4239 EXPR_STMT in the COMPOUND_STMT and mark it as addressable. */
4240 if (target
!= const0_rtx
4241 && TREE_CODE (STMT_EXPR_STMT (exp
)) == COMPOUND_STMT
4242 && TREE_CODE (COMPOUND_BODY (STMT_EXPR_STMT (exp
))) == SCOPE_STMT
)
4244 tree expr
= COMPOUND_BODY (STMT_EXPR_STMT (exp
));
4245 tree last
= TREE_CHAIN (expr
);
4247 while (TREE_CHAIN (last
))
4250 last
= TREE_CHAIN (last
);
4253 if (TREE_CODE (last
) == SCOPE_STMT
4254 && TREE_CODE (expr
) == EXPR_STMT
)
4256 if (target
&& TREE_CODE (EXPR_STMT_EXPR (expr
)) == VAR_DECL
4257 && DECL_RTL_IF_SET (EXPR_STMT_EXPR (expr
)) == target
)
4258 /* If the last expression is a variable whose RTL is the
4259 same as our target, just return the target; if it
4260 isn't valid expanding the decl would produce different
4261 RTL, and store_expr would try to do a copy. */
4262 return_target
= true;
4265 /* Otherwise, note that we want the value from the last
4267 TREE_ADDRESSABLE (expr
) = 1;
4268 preserve_result
= true;
4273 expand_stmt (STMT_EXPR_STMT (exp
));
4274 expand_end_stmt_expr (rtl_expr
);
4276 result
= expand_expr (rtl_expr
, target
, tmode
, modifier
);
4279 else if (preserve_result
&& GET_CODE (result
) == MEM
)
4281 if (GET_MODE (result
) != BLKmode
)
4282 result
= copy_to_reg (result
);
4284 preserve_temp_slots (result
);
4287 /* If the statment-expression does not have a scope, then the
4288 new temporaries we created within it must live beyond the
4289 statement-expression. */
4290 if (STMT_EXPR_NO_SCOPE (exp
))
4291 preserve_temp_slots (NULL_RTX
);
4300 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == ADDR_EXPR
4301 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
4303 && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
4304 && (DECL_BUILT_IN_CLASS (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
4305 == BUILT_IN_FRONTEND
))
4306 return c_expand_builtin (exp
, target
, tmode
, modifier
);
4312 case COMPOUND_LITERAL_EXPR
:
4314 /* Initialize the anonymous variable declared in the compound
4315 literal, then return the variable. */
4316 tree decl
= COMPOUND_LITERAL_EXPR_DECL (exp
);
4317 emit_local_var (decl
);
4318 return expand_expr (decl
, target
, tmode
, modifier
);
4329 /* Hook used by safe_from_p to handle language-specific tree codes. */
4332 c_safe_from_p (target
, exp
)
4336 /* We can see statements here when processing the body of a
4337 statement-expression. For a declaration statement declaring a
4338 variable, look at the variable's initializer. */
4339 if (TREE_CODE (exp
) == DECL_STMT
)
4341 tree decl
= DECL_STMT_DECL (exp
);
4343 if (TREE_CODE (decl
) == VAR_DECL
4344 && DECL_INITIAL (decl
)
4345 && !safe_from_p (target
, DECL_INITIAL (decl
), /*top_p=*/0))
4349 /* For any statement, we must follow the statement-chain. */
4350 if (STATEMENT_CODE_P (TREE_CODE (exp
)) && TREE_CHAIN (exp
))
4351 return safe_from_p (target
, TREE_CHAIN (exp
), /*top_p=*/0);
4353 /* Assume everything else is safe. */
4357 /* Hook used by unsafe_for_reeval to handle language-specific tree codes. */
4360 c_common_unsafe_for_reeval (exp
)
4363 /* Statement expressions may not be reevaluated, likewise compound
4365 if (TREE_CODE (exp
) == STMT_EXPR
4366 || TREE_CODE (exp
) == COMPOUND_LITERAL_EXPR
)
4369 /* Walk all other expressions. */
4373 /* Hook used by staticp to handle language-specific tree codes. */
4379 if (TREE_CODE (exp
) == COMPOUND_LITERAL_EXPR
4380 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp
)))
4385 #define CALLED_AS_BUILT_IN(NODE) \
4386 (!strncmp (IDENTIFIER_POINTER (DECL_NAME (NODE)), "__builtin_", 10))
4389 c_expand_builtin (exp
, target
, tmode
, modifier
)
4392 enum machine_mode tmode
;
4393 enum expand_modifier modifier
;
4395 tree type
= TREE_TYPE (exp
);
4396 tree fndecl
= TREE_OPERAND (TREE_OPERAND (exp
, 0), 0);
4397 tree arglist
= TREE_OPERAND (exp
, 1);
4398 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
4399 enum tree_code code
= TREE_CODE (exp
);
4400 const int ignore
= (target
== const0_rtx
4401 || ((code
== NON_LVALUE_EXPR
|| code
== NOP_EXPR
4402 || code
== CONVERT_EXPR
|| code
== REFERENCE_EXPR
4403 || code
== COND_EXPR
)
4404 && TREE_CODE (type
) == VOID_TYPE
));
4406 if (! optimize
&& ! CALLED_AS_BUILT_IN (fndecl
))
4407 return expand_call (exp
, target
, ignore
);
4411 case BUILT_IN_PRINTF
:
4412 target
= c_expand_builtin_printf (arglist
, target
, tmode
,
4413 modifier
, ignore
, /*unlocked=*/ 0);
4418 case BUILT_IN_PRINTF_UNLOCKED
:
4419 target
= c_expand_builtin_printf (arglist
, target
, tmode
,
4420 modifier
, ignore
, /*unlocked=*/ 1);
4425 case BUILT_IN_FPRINTF
:
4426 target
= c_expand_builtin_fprintf (arglist
, target
, tmode
,
4427 modifier
, ignore
, /*unlocked=*/ 0);
4432 case BUILT_IN_FPRINTF_UNLOCKED
:
4433 target
= c_expand_builtin_fprintf (arglist
, target
, tmode
,
4434 modifier
, ignore
, /*unlocked=*/ 1);
4439 default: /* just do library call, if unknown builtin */
4440 error ("built-in function `%s' not currently supported",
4441 IDENTIFIER_POINTER (DECL_NAME (fndecl
)));
4444 /* The switch statement above can drop through to cause the function
4445 to be called normally. */
4446 return expand_call (exp
, target
, ignore
);
4449 /* Check an arglist to *printf for problems. The arglist should start
4450 at the format specifier, with the remaining arguments immediately
4453 is_valid_printf_arglist (arglist
)
4456 /* Save this value so we can restore it later. */
4457 const int SAVE_pedantic
= pedantic
;
4458 int diagnostic_occurred
= 0;
4461 /* Set this to a known value so the user setting won't affect code
4464 /* Check to make sure there are no format specifier errors. */
4465 attrs
= tree_cons (get_identifier ("format"),
4466 tree_cons (NULL_TREE
,
4467 get_identifier ("printf"),
4468 tree_cons (NULL_TREE
,
4470 tree_cons (NULL_TREE
,
4474 check_function_format (&diagnostic_occurred
, attrs
, arglist
);
4476 /* Restore the value of `pedantic'. */
4477 pedantic
= SAVE_pedantic
;
4479 /* If calling `check_function_format_ptr' produces a warning, we
4480 return false, otherwise we return true. */
4481 return ! diagnostic_occurred
;
4484 /* If the arguments passed to printf are suitable for optimizations,
4485 we attempt to transform the call. */
4487 c_expand_builtin_printf (arglist
, target
, tmode
, modifier
, ignore
, unlocked
)
4490 enum machine_mode tmode
;
4491 enum expand_modifier modifier
;
4495 tree fn_putchar
= unlocked
?
4496 implicit_built_in_decls
[BUILT_IN_PUTCHAR_UNLOCKED
] : implicit_built_in_decls
[BUILT_IN_PUTCHAR
];
4497 tree fn_puts
= unlocked
?
4498 implicit_built_in_decls
[BUILT_IN_PUTS_UNLOCKED
] : implicit_built_in_decls
[BUILT_IN_PUTS
];
4499 tree fn
, format_arg
, stripped_string
;
4501 /* If the return value is used, or the replacement _DECL isn't
4502 initialized, don't do the transformation. */
4503 if (!ignore
|| !fn_putchar
|| !fn_puts
)
4506 /* Verify the required arguments in the original call. */
4508 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != POINTER_TYPE
))
4511 /* Check the specifier vs. the parameters. */
4512 if (!is_valid_printf_arglist (arglist
))
4515 format_arg
= TREE_VALUE (arglist
);
4516 stripped_string
= format_arg
;
4517 STRIP_NOPS (stripped_string
);
4518 if (stripped_string
&& TREE_CODE (stripped_string
) == ADDR_EXPR
)
4519 stripped_string
= TREE_OPERAND (stripped_string
, 0);
4521 /* If the format specifier isn't a STRING_CST, punt. */
4522 if (TREE_CODE (stripped_string
) != STRING_CST
)
4525 /* OK! We can attempt optimization. */
4527 /* If the format specifier was "%s\n", call __builtin_puts(arg2). */
4528 if (strcmp (TREE_STRING_POINTER (stripped_string
), "%s\n") == 0)
4530 arglist
= TREE_CHAIN (arglist
);
4533 /* If the format specifier was "%c", call __builtin_putchar (arg2). */
4534 else if (strcmp (TREE_STRING_POINTER (stripped_string
), "%c") == 0)
4536 arglist
= TREE_CHAIN (arglist
);
4541 /* We can't handle anything else with % args or %% ... yet. */
4542 if (strchr (TREE_STRING_POINTER (stripped_string
), '%'))
4545 /* If the resulting constant string has a length of 1, call
4546 putchar. Note, TREE_STRING_LENGTH includes the terminating
4547 NULL in its count. */
4548 if (TREE_STRING_LENGTH (stripped_string
) == 2)
4550 /* Given printf("c"), (where c is any one character,)
4551 convert "c"[0] to an int and pass that to the replacement
4553 arglist
= build_int_2 (TREE_STRING_POINTER (stripped_string
)[0], 0);
4554 arglist
= build_tree_list (NULL_TREE
, arglist
);
4558 /* If the resulting constant was "string\n", call
4559 __builtin_puts("string"). Ensure "string" has at least one
4560 character besides the trailing \n. Note, TREE_STRING_LENGTH
4561 includes the terminating NULL in its count. */
4562 else if (TREE_STRING_LENGTH (stripped_string
) > 2
4563 && TREE_STRING_POINTER (stripped_string
)
4564 [TREE_STRING_LENGTH (stripped_string
) - 2] == '\n')
4566 /* Create a NULL-terminated string that's one char shorter
4567 than the original, stripping off the trailing '\n'. */
4568 const int newlen
= TREE_STRING_LENGTH (stripped_string
) - 1;
4569 char *newstr
= (char *) alloca (newlen
);
4570 memcpy (newstr
, TREE_STRING_POINTER (stripped_string
), newlen
- 1);
4571 newstr
[newlen
- 1] = 0;
4573 arglist
= fix_string_type (build_string (newlen
, newstr
));
4574 arglist
= build_tree_list (NULL_TREE
, arglist
);
4578 /* We'd like to arrange to call fputs(string) here, but we
4579 need stdout and don't have a way to get it ... yet. */
4583 return expand_expr (build_function_call (fn
, arglist
),
4584 (ignore
? const0_rtx
: target
),
4588 /* If the arguments passed to fprintf are suitable for optimizations,
4589 we attempt to transform the call. */
4591 c_expand_builtin_fprintf (arglist
, target
, tmode
, modifier
, ignore
, unlocked
)
4594 enum machine_mode tmode
;
4595 enum expand_modifier modifier
;
4599 tree fn_fputc
= unlocked
?
4600 implicit_built_in_decls
[BUILT_IN_FPUTC_UNLOCKED
] : implicit_built_in_decls
[BUILT_IN_FPUTC
];
4601 tree fn_fputs
= unlocked
?
4602 implicit_built_in_decls
[BUILT_IN_FPUTS_UNLOCKED
] : implicit_built_in_decls
[BUILT_IN_FPUTS
];
4603 tree fn
, format_arg
, stripped_string
;
4605 /* If the return value is used, or the replacement _DECL isn't
4606 initialized, don't do the transformation. */
4607 if (!ignore
|| !fn_fputc
|| !fn_fputs
)
4610 /* Verify the required arguments in the original call. */
4612 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != POINTER_TYPE
)
4613 || (TREE_CHAIN (arglist
) == 0)
4614 || (TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist
)))) !=
4618 /* Check the specifier vs. the parameters. */
4619 if (!is_valid_printf_arglist (TREE_CHAIN (arglist
)))
4622 format_arg
= TREE_VALUE (TREE_CHAIN (arglist
));
4623 stripped_string
= format_arg
;
4624 STRIP_NOPS (stripped_string
);
4625 if (stripped_string
&& TREE_CODE (stripped_string
) == ADDR_EXPR
)
4626 stripped_string
= TREE_OPERAND (stripped_string
, 0);
4628 /* If the format specifier isn't a STRING_CST, punt. */
4629 if (TREE_CODE (stripped_string
) != STRING_CST
)
4632 /* OK! We can attempt optimization. */
4634 /* If the format specifier was "%s", call __builtin_fputs(arg3, arg1). */
4635 if (strcmp (TREE_STRING_POINTER (stripped_string
), "%s") == 0)
4637 tree newarglist
= build_tree_list (NULL_TREE
, TREE_VALUE (arglist
));
4638 arglist
= tree_cons (NULL_TREE
,
4639 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
))),
4643 /* If the format specifier was "%c", call __builtin_fputc (arg3, arg1). */
4644 else if (strcmp (TREE_STRING_POINTER (stripped_string
), "%c") == 0)
4646 tree newarglist
= build_tree_list (NULL_TREE
, TREE_VALUE (arglist
));
4647 arglist
= tree_cons (NULL_TREE
,
4648 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
))),
4654 /* We can't handle anything else with % args or %% ... yet. */
4655 if (strchr (TREE_STRING_POINTER (stripped_string
), '%'))
4658 /* When "string" doesn't contain %, replace all cases of
4659 fprintf(stream,string) with fputs(string,stream). The fputs
4660 builtin will take take of special cases like length==1. */
4661 arglist
= tree_cons (NULL_TREE
, TREE_VALUE (TREE_CHAIN (arglist
)),
4662 build_tree_list (NULL_TREE
, TREE_VALUE (arglist
)));
4666 return expand_expr (build_function_call (fn
, arglist
),
4667 (ignore
? const0_rtx
: target
),
4672 /* Given a boolean expression ARG, return a tree representing an increment
4673 or decrement (as indicated by CODE) of ARG. The front end must check for
4674 invalid cases (e.g., decrement in C++). */
4676 boolean_increment (code
, arg
)
4677 enum tree_code code
;
4681 tree true_res
= (c_language
== clk_cplusplus
4683 : c_bool_true_node
);
4684 arg
= stabilize_reference (arg
);
4687 case PREINCREMENT_EXPR
:
4688 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
4690 case POSTINCREMENT_EXPR
:
4691 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
4692 arg
= save_expr (arg
);
4693 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
4694 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
4696 case PREDECREMENT_EXPR
:
4697 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, invert_truthvalue (arg
));
4699 case POSTDECREMENT_EXPR
:
4700 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, invert_truthvalue (arg
));
4701 arg
= save_expr (arg
);
4702 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
4703 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
4708 TREE_SIDE_EFFECTS (val
) = 1;
4712 /* Built-in macros for stddef.h, that require macros defined in this
4715 c_stddef_cpp_builtins()
4717 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE
, 0);
4718 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE
, 0);
4719 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE
, 0);
4720 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE
, 0);
4724 c_init_attributes ()
4726 /* Fill in the built_in_attributes array. */
4727 #define DEF_ATTR_NULL_TREE(ENUM) \
4728 built_in_attributes[(int) ENUM] = NULL_TREE;
4729 #define DEF_ATTR_INT(ENUM, VALUE) \
4730 built_in_attributes[(int) ENUM] = build_int_2 (VALUE, VALUE < 0 ? -1 : 0);
4731 #define DEF_ATTR_IDENT(ENUM, STRING) \
4732 built_in_attributes[(int) ENUM] = get_identifier (STRING);
4733 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
4734 built_in_attributes[(int) ENUM] \
4735 = tree_cons (built_in_attributes[(int) PURPOSE], \
4736 built_in_attributes[(int) VALUE], \
4737 built_in_attributes[(int) CHAIN]);
4738 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No initialization needed. */
4739 #include "builtin-attrs.def"
4740 #undef DEF_ATTR_NULL_TREE
4742 #undef DEF_ATTR_IDENT
4743 #undef DEF_ATTR_TREE_LIST
4745 c_attrs_initialized
= true;
4748 /* Depending on the name of DECL, apply default attributes to it. */
4751 c_common_insert_default_attributes (decl
)
4754 tree name
= DECL_NAME (decl
);
4756 if (!c_attrs_initialized
)
4757 c_init_attributes ();
4759 #define DEF_ATTR_NULL_TREE(ENUM) /* Nothing needed after initialization. */
4760 #define DEF_ATTR_INT(ENUM, VALUE)
4761 #define DEF_ATTR_IDENT(ENUM, STRING)
4762 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN)
4763 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) \
4764 if ((PREDICATE) && name == built_in_attributes[(int) NAME]) \
4765 decl_attributes (&decl, built_in_attributes[(int) ATTRS], \
4766 ATTR_FLAG_BUILT_IN);
4767 #include "builtin-attrs.def"
4768 #undef DEF_ATTR_NULL_TREE
4770 #undef DEF_ATTR_IDENT
4771 #undef DEF_ATTR_TREE_LIST
4775 /* Output a -Wshadow warning MSGCODE about NAME, and give the location
4776 of the previous declaration DECL. */
4778 shadow_warning (msgcode
, name
, decl
)
4779 enum sw_kind msgcode
;
4783 static const char *const msgs
[] = {
4784 /* SW_PARAM */ N_("declaration of \"%s\" shadows a parameter"),
4785 /* SW_LOCAL */ N_("declaration of \"%s\" shadows a previous local"),
4786 /* SW_GLOBAL */ N_("declaration of \"%s\" shadows a global declaration")
4789 warning (msgs
[msgcode
], name
);
4790 warning_with_file_and_line (DECL_SOURCE_FILE (decl
),
4791 DECL_SOURCE_LINE (decl
),
4792 "shadowed declaration is here");
4795 /* Attribute handlers common to C front ends. */
4797 /* Handle a "packed" attribute; arguments as in
4798 struct attribute_spec.handler. */
4801 handle_packed_attribute (node
, name
, args
, flags
, no_add_attrs
)
4804 tree args ATTRIBUTE_UNUSED
;
4811 if (TREE_CODE (*node
) == TYPE_DECL
)
4812 type
= &TREE_TYPE (*node
);
4819 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
4820 *type
= build_type_copy (*type
);
4821 TYPE_PACKED (*type
) = 1;
4823 else if (TREE_CODE (*node
) == FIELD_DECL
)
4824 DECL_PACKED (*node
) = 1;
4825 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
4826 used for DECL_REGISTER. It wouldn't mean anything anyway. */
4829 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4830 *no_add_attrs
= true;
4836 /* Handle a "nocommon" attribute; arguments as in
4837 struct attribute_spec.handler. */
4840 handle_nocommon_attribute (node
, name
, args
, flags
, no_add_attrs
)
4843 tree args ATTRIBUTE_UNUSED
;
4844 int flags ATTRIBUTE_UNUSED
;
4847 if (TREE_CODE (*node
) == VAR_DECL
)
4848 DECL_COMMON (*node
) = 0;
4851 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4852 *no_add_attrs
= true;
4858 /* Handle a "common" attribute; arguments as in
4859 struct attribute_spec.handler. */
4862 handle_common_attribute (node
, name
, args
, flags
, no_add_attrs
)
4865 tree args ATTRIBUTE_UNUSED
;
4866 int flags ATTRIBUTE_UNUSED
;
4869 if (TREE_CODE (*node
) == VAR_DECL
)
4870 DECL_COMMON (*node
) = 1;
4873 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4874 *no_add_attrs
= true;
4880 /* Handle a "noreturn" attribute; arguments as in
4881 struct attribute_spec.handler. */
4884 handle_noreturn_attribute (node
, name
, args
, flags
, no_add_attrs
)
4887 tree args ATTRIBUTE_UNUSED
;
4888 int flags ATTRIBUTE_UNUSED
;
4891 tree type
= TREE_TYPE (*node
);
4893 /* See FIXME comment in c_common_attribute_table. */
4894 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4895 TREE_THIS_VOLATILE (*node
) = 1;
4896 else if (TREE_CODE (type
) == POINTER_TYPE
4897 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
4899 = build_pointer_type
4900 (build_type_variant (TREE_TYPE (type
),
4901 TREE_READONLY (TREE_TYPE (type
)), 1));
4904 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4905 *no_add_attrs
= true;
4911 /* Handle a "noinline" attribute; arguments as in
4912 struct attribute_spec.handler. */
4915 handle_noinline_attribute (node
, name
, args
, flags
, no_add_attrs
)
4918 tree args ATTRIBUTE_UNUSED
;
4919 int flags ATTRIBUTE_UNUSED
;
4922 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4923 DECL_UNINLINABLE (*node
) = 1;
4926 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4927 *no_add_attrs
= true;
4933 /* Handle a "always_inline" attribute; arguments as in
4934 struct attribute_spec.handler. */
4937 handle_always_inline_attribute (node
, name
, args
, flags
, no_add_attrs
)
4940 tree args ATTRIBUTE_UNUSED
;
4941 int flags ATTRIBUTE_UNUSED
;
4944 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4946 /* Do nothing else, just set the attribute. We'll get at
4947 it later with lookup_attribute. */
4951 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4952 *no_add_attrs
= true;
4958 /* Handle a "used" attribute; arguments as in
4959 struct attribute_spec.handler. */
4962 handle_used_attribute (pnode
, name
, args
, flags
, no_add_attrs
)
4965 tree args ATTRIBUTE_UNUSED
;
4966 int flags ATTRIBUTE_UNUSED
;
4971 if (TREE_CODE (node
) == FUNCTION_DECL
4972 || (TREE_CODE (node
) == VAR_DECL
&& TREE_STATIC (node
)))
4973 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (node
))
4974 = TREE_USED (node
) = 1;
4977 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4978 *no_add_attrs
= true;
4984 /* Handle a "unused" attribute; arguments as in
4985 struct attribute_spec.handler. */
4988 handle_unused_attribute (node
, name
, args
, flags
, no_add_attrs
)
4991 tree args ATTRIBUTE_UNUSED
;
4999 if (TREE_CODE (decl
) == PARM_DECL
5000 || TREE_CODE (decl
) == VAR_DECL
5001 || TREE_CODE (decl
) == FUNCTION_DECL
5002 || TREE_CODE (decl
) == LABEL_DECL
5003 || TREE_CODE (decl
) == TYPE_DECL
)
5004 TREE_USED (decl
) = 1;
5007 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5008 *no_add_attrs
= true;
5013 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
5014 *node
= build_type_copy (*node
);
5015 TREE_USED (*node
) = 1;
5021 /* Handle a "const" attribute; arguments as in
5022 struct attribute_spec.handler. */
5025 handle_const_attribute (node
, name
, args
, flags
, no_add_attrs
)
5028 tree args ATTRIBUTE_UNUSED
;
5029 int flags ATTRIBUTE_UNUSED
;
5032 tree type
= TREE_TYPE (*node
);
5034 /* See FIXME comment on noreturn in c_common_attribute_table. */
5035 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5036 TREE_READONLY (*node
) = 1;
5037 else if (TREE_CODE (type
) == POINTER_TYPE
5038 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
5040 = build_pointer_type
5041 (build_type_variant (TREE_TYPE (type
), 1,
5042 TREE_THIS_VOLATILE (TREE_TYPE (type
))));
5045 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5046 *no_add_attrs
= true;
5052 /* Handle a "transparent_union" attribute; arguments as in
5053 struct attribute_spec.handler. */
5056 handle_transparent_union_attribute (node
, name
, args
, flags
, no_add_attrs
)
5059 tree args ATTRIBUTE_UNUSED
;
5063 tree decl
= NULL_TREE
;
5070 type
= &TREE_TYPE (decl
);
5071 is_type
= TREE_CODE (*node
) == TYPE_DECL
;
5073 else if (TYPE_P (*node
))
5074 type
= node
, is_type
= 1;
5077 && TREE_CODE (*type
) == UNION_TYPE
5079 || (TYPE_FIELDS (*type
) != 0
5080 && TYPE_MODE (*type
) == DECL_MODE (TYPE_FIELDS (*type
)))))
5082 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
5083 *type
= build_type_copy (*type
);
5084 TYPE_TRANSPARENT_UNION (*type
) = 1;
5086 else if (decl
!= 0 && TREE_CODE (decl
) == PARM_DECL
5087 && TREE_CODE (*type
) == UNION_TYPE
5088 && TYPE_MODE (*type
) == DECL_MODE (TYPE_FIELDS (*type
)))
5089 DECL_TRANSPARENT_UNION (decl
) = 1;
5092 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5093 *no_add_attrs
= true;
5099 /* Handle a "constructor" attribute; arguments as in
5100 struct attribute_spec.handler. */
5103 handle_constructor_attribute (node
, name
, args
, flags
, no_add_attrs
)
5106 tree args ATTRIBUTE_UNUSED
;
5107 int flags ATTRIBUTE_UNUSED
;
5111 tree type
= TREE_TYPE (decl
);
5113 if (TREE_CODE (decl
) == FUNCTION_DECL
5114 && TREE_CODE (type
) == FUNCTION_TYPE
5115 && decl_function_context (decl
) == 0)
5117 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
5118 TREE_USED (decl
) = 1;
5122 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5123 *no_add_attrs
= true;
5129 /* Handle a "destructor" attribute; arguments as in
5130 struct attribute_spec.handler. */
5133 handle_destructor_attribute (node
, name
, args
, flags
, no_add_attrs
)
5136 tree args ATTRIBUTE_UNUSED
;
5137 int flags ATTRIBUTE_UNUSED
;
5141 tree type
= TREE_TYPE (decl
);
5143 if (TREE_CODE (decl
) == FUNCTION_DECL
5144 && TREE_CODE (type
) == FUNCTION_TYPE
5145 && decl_function_context (decl
) == 0)
5147 DECL_STATIC_DESTRUCTOR (decl
) = 1;
5148 TREE_USED (decl
) = 1;
5152 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5153 *no_add_attrs
= true;
5159 /* Handle a "mode" attribute; arguments as in
5160 struct attribute_spec.handler. */
5163 handle_mode_attribute (node
, name
, args
, flags
, no_add_attrs
)
5167 int flags ATTRIBUTE_UNUSED
;
5172 *no_add_attrs
= true;
5174 if (TREE_CODE (TREE_VALUE (args
)) != IDENTIFIER_NODE
)
5175 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5179 const char *p
= IDENTIFIER_POINTER (TREE_VALUE (args
));
5180 int len
= strlen (p
);
5181 enum machine_mode mode
= VOIDmode
;
5185 if (len
> 4 && p
[0] == '_' && p
[1] == '_'
5186 && p
[len
- 1] == '_' && p
[len
- 2] == '_')
5188 char *newp
= (char *) alloca (len
- 1);
5190 strcpy (newp
, &p
[2]);
5191 newp
[len
- 4] = '\0';
5195 /* Change this type to have a type with the specified mode.
5196 First check for the special modes. */
5197 if (! strcmp (p
, "byte"))
5199 else if (!strcmp (p
, "word"))
5201 else if (! strcmp (p
, "pointer"))
5204 for (j
= 0; j
< NUM_MACHINE_MODES
; j
++)
5205 if (!strcmp (p
, GET_MODE_NAME (j
)))
5206 mode
= (enum machine_mode
) j
;
5208 if (mode
== VOIDmode
)
5209 error ("unknown machine mode `%s'", p
);
5210 else if (0 == (typefm
= (*lang_hooks
.types
.type_for_mode
)
5211 (mode
, TREE_UNSIGNED (type
))))
5212 error ("no data type for mode `%s'", p
);
5213 else if ((TREE_CODE (type
) == POINTER_TYPE
5214 || TREE_CODE (type
) == REFERENCE_TYPE
)
5215 && !(*targetm
.valid_pointer_mode
) (mode
))
5216 error ("invalid pointer mode `%s'", p
);
5219 /* If this is a vector, make sure we either have hardware
5220 support, or we can emulate it. */
5221 if ((GET_MODE_CLASS (mode
) == MODE_VECTOR_INT
5222 || GET_MODE_CLASS (mode
) == MODE_VECTOR_FLOAT
)
5223 && !vector_mode_valid_p (mode
))
5225 error ("unable to emulate '%s'", GET_MODE_NAME (mode
));
5229 if (TREE_CODE (type
) == POINTER_TYPE
)
5231 ptr_type
= build_pointer_type_for_mode (TREE_TYPE (type
),
5235 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
5237 ptr_type
= build_reference_type_for_mode (TREE_TYPE (type
),
5243 /* No need to layout the type here. The caller should do this. */
5250 /* Handle a "section" attribute; arguments as in
5251 struct attribute_spec.handler. */
5254 handle_section_attribute (node
, name
, args
, flags
, no_add_attrs
)
5256 tree name ATTRIBUTE_UNUSED
;
5258 int flags ATTRIBUTE_UNUSED
;
5263 if (targetm
.have_named_sections
)
5265 if ((TREE_CODE (decl
) == FUNCTION_DECL
5266 || TREE_CODE (decl
) == VAR_DECL
)
5267 && TREE_CODE (TREE_VALUE (args
)) == STRING_CST
)
5269 if (TREE_CODE (decl
) == VAR_DECL
5270 && current_function_decl
!= NULL_TREE
5271 && ! TREE_STATIC (decl
))
5273 error_with_decl (decl
,
5274 "section attribute cannot be specified for local variables");
5275 *no_add_attrs
= true;
5278 /* The decl may have already been given a section attribute
5279 from a previous declaration. Ensure they match. */
5280 else if (DECL_SECTION_NAME (decl
) != NULL_TREE
5281 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl
)),
5282 TREE_STRING_POINTER (TREE_VALUE (args
))) != 0)
5284 error_with_decl (*node
,
5285 "section of `%s' conflicts with previous declaration");
5286 *no_add_attrs
= true;
5289 DECL_SECTION_NAME (decl
) = TREE_VALUE (args
);
5293 error_with_decl (*node
,
5294 "section attribute not allowed for `%s'");
5295 *no_add_attrs
= true;
5300 error_with_decl (*node
,
5301 "section attributes are not supported for this target");
5302 *no_add_attrs
= true;
5308 /* Handle a "aligned" attribute; arguments as in
5309 struct attribute_spec.handler. */
5312 handle_aligned_attribute (node
, name
, args
, flags
, no_add_attrs
)
5314 tree name ATTRIBUTE_UNUSED
;
5319 tree decl
= NULL_TREE
;
5322 tree align_expr
= (args
? TREE_VALUE (args
)
5323 : size_int (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
));
5329 type
= &TREE_TYPE (decl
);
5330 is_type
= TREE_CODE (*node
) == TYPE_DECL
;
5332 else if (TYPE_P (*node
))
5333 type
= node
, is_type
= 1;
5335 /* Strip any NOPs of any kind. */
5336 while (TREE_CODE (align_expr
) == NOP_EXPR
5337 || TREE_CODE (align_expr
) == CONVERT_EXPR
5338 || TREE_CODE (align_expr
) == NON_LVALUE_EXPR
)
5339 align_expr
= TREE_OPERAND (align_expr
, 0);
5341 if (TREE_CODE (align_expr
) != INTEGER_CST
)
5343 error ("requested alignment is not a constant");
5344 *no_add_attrs
= true;
5346 else if ((i
= tree_log2 (align_expr
)) == -1)
5348 error ("requested alignment is not a power of 2");
5349 *no_add_attrs
= true;
5351 else if (i
> HOST_BITS_PER_INT
- 2)
5353 error ("requested alignment is too large");
5354 *no_add_attrs
= true;
5358 /* If we have a TYPE_DECL, then copy the type, so that we
5359 don't accidentally modify a builtin type. See pushdecl. */
5360 if (decl
&& TREE_TYPE (decl
) != error_mark_node
5361 && DECL_ORIGINAL_TYPE (decl
) == NULL_TREE
)
5363 tree tt
= TREE_TYPE (decl
);
5364 *type
= build_type_copy (*type
);
5365 DECL_ORIGINAL_TYPE (decl
) = tt
;
5366 TYPE_NAME (*type
) = decl
;
5367 TREE_USED (*type
) = TREE_USED (decl
);
5368 TREE_TYPE (decl
) = *type
;
5370 else if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
5371 *type
= build_type_copy (*type
);
5373 TYPE_ALIGN (*type
) = (1 << i
) * BITS_PER_UNIT
;
5374 TYPE_USER_ALIGN (*type
) = 1;
5376 else if (TREE_CODE (decl
) != VAR_DECL
5377 && TREE_CODE (decl
) != FIELD_DECL
)
5379 error_with_decl (decl
,
5380 "alignment may not be specified for `%s'");
5381 *no_add_attrs
= true;
5385 DECL_ALIGN (decl
) = (1 << i
) * BITS_PER_UNIT
;
5386 DECL_USER_ALIGN (decl
) = 1;
5392 /* Handle a "weak" attribute; arguments as in
5393 struct attribute_spec.handler. */
5396 handle_weak_attribute (node
, name
, args
, flags
, no_add_attrs
)
5398 tree name ATTRIBUTE_UNUSED
;
5399 tree args ATTRIBUTE_UNUSED
;
5400 int flags ATTRIBUTE_UNUSED
;
5401 bool *no_add_attrs ATTRIBUTE_UNUSED
;
5403 declare_weak (*node
);
5408 /* Handle an "alias" attribute; arguments as in
5409 struct attribute_spec.handler. */
5412 handle_alias_attribute (node
, name
, args
, flags
, no_add_attrs
)
5416 int flags ATTRIBUTE_UNUSED
;
5421 if ((TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_INITIAL (decl
))
5422 || (TREE_CODE (decl
) != FUNCTION_DECL
&& ! DECL_EXTERNAL (decl
)))
5424 error_with_decl (decl
,
5425 "`%s' defined both normally and as an alias");
5426 *no_add_attrs
= true;
5428 else if (decl_function_context (decl
) == 0)
5432 id
= TREE_VALUE (args
);
5433 if (TREE_CODE (id
) != STRING_CST
)
5435 error ("alias arg not a string");
5436 *no_add_attrs
= true;
5439 id
= get_identifier (TREE_STRING_POINTER (id
));
5440 /* This counts as a use of the object pointed to. */
5443 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5444 DECL_INITIAL (decl
) = error_mark_node
;
5446 DECL_EXTERNAL (decl
) = 0;
5450 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5451 *no_add_attrs
= true;
5457 /* Handle an "visibility" attribute; arguments as in
5458 struct attribute_spec.handler. */
5461 handle_visibility_attribute (node
, name
, args
, flags
, no_add_attrs
)
5465 int flags ATTRIBUTE_UNUSED
;
5470 if (decl_function_context (decl
) != 0 || ! TREE_PUBLIC (decl
))
5472 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5473 *no_add_attrs
= true;
5479 id
= TREE_VALUE (args
);
5480 if (TREE_CODE (id
) != STRING_CST
)
5482 error ("visibility arg not a string");
5483 *no_add_attrs
= true;
5486 if (strcmp (TREE_STRING_POINTER (id
), "hidden")
5487 && strcmp (TREE_STRING_POINTER (id
), "protected")
5488 && strcmp (TREE_STRING_POINTER (id
), "internal")
5489 && strcmp (TREE_STRING_POINTER (id
), "default"))
5491 error ("visibility arg must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
5492 *no_add_attrs
= true;
5500 /* Handle an "tls_model" attribute; arguments as in
5501 struct attribute_spec.handler. */
5504 handle_tls_model_attribute (node
, name
, args
, flags
, no_add_attrs
)
5508 int flags ATTRIBUTE_UNUSED
;
5513 if (! DECL_THREAD_LOCAL (decl
))
5515 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5516 *no_add_attrs
= true;
5522 id
= TREE_VALUE (args
);
5523 if (TREE_CODE (id
) != STRING_CST
)
5525 error ("tls_model arg not a string");
5526 *no_add_attrs
= true;
5529 if (strcmp (TREE_STRING_POINTER (id
), "local-exec")
5530 && strcmp (TREE_STRING_POINTER (id
), "initial-exec")
5531 && strcmp (TREE_STRING_POINTER (id
), "local-dynamic")
5532 && strcmp (TREE_STRING_POINTER (id
), "global-dynamic"))
5534 error ("tls_model arg must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
5535 *no_add_attrs
= true;
5543 /* Handle a "no_instrument_function" attribute; arguments as in
5544 struct attribute_spec.handler. */
5547 handle_no_instrument_function_attribute (node
, name
, args
, flags
, no_add_attrs
)
5550 tree args ATTRIBUTE_UNUSED
;
5551 int flags ATTRIBUTE_UNUSED
;
5556 if (TREE_CODE (decl
) != FUNCTION_DECL
)
5558 error_with_decl (decl
,
5559 "`%s' attribute applies only to functions",
5560 IDENTIFIER_POINTER (name
));
5561 *no_add_attrs
= true;
5563 else if (DECL_INITIAL (decl
))
5565 error_with_decl (decl
,
5566 "can't set `%s' attribute after definition",
5567 IDENTIFIER_POINTER (name
));
5568 *no_add_attrs
= true;
5571 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl
) = 1;
5576 /* Handle a "malloc" attribute; arguments as in
5577 struct attribute_spec.handler. */
5580 handle_malloc_attribute (node
, name
, args
, flags
, no_add_attrs
)
5583 tree args ATTRIBUTE_UNUSED
;
5584 int flags ATTRIBUTE_UNUSED
;
5587 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5588 DECL_IS_MALLOC (*node
) = 1;
5589 /* ??? TODO: Support types. */
5592 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5593 *no_add_attrs
= true;
5599 /* Handle a "no_limit_stack" attribute; arguments as in
5600 struct attribute_spec.handler. */
5603 handle_no_limit_stack_attribute (node
, name
, args
, flags
, no_add_attrs
)
5606 tree args ATTRIBUTE_UNUSED
;
5607 int flags ATTRIBUTE_UNUSED
;
5612 if (TREE_CODE (decl
) != FUNCTION_DECL
)
5614 error_with_decl (decl
,
5615 "`%s' attribute applies only to functions",
5616 IDENTIFIER_POINTER (name
));
5617 *no_add_attrs
= true;
5619 else if (DECL_INITIAL (decl
))
5621 error_with_decl (decl
,
5622 "can't set `%s' attribute after definition",
5623 IDENTIFIER_POINTER (name
));
5624 *no_add_attrs
= true;
5627 DECL_NO_LIMIT_STACK (decl
) = 1;
5632 /* Handle a "pure" attribute; arguments as in
5633 struct attribute_spec.handler. */
5636 handle_pure_attribute (node
, name
, args
, flags
, no_add_attrs
)
5639 tree args ATTRIBUTE_UNUSED
;
5640 int flags ATTRIBUTE_UNUSED
;
5643 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5644 DECL_IS_PURE (*node
) = 1;
5645 /* ??? TODO: Support types. */
5648 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5649 *no_add_attrs
= true;
5655 /* Handle a "deprecated" attribute; arguments as in
5656 struct attribute_spec.handler. */
5659 handle_deprecated_attribute (node
, name
, args
, flags
, no_add_attrs
)
5662 tree args ATTRIBUTE_UNUSED
;
5666 tree type
= NULL_TREE
;
5668 const char *what
= NULL
;
5673 type
= TREE_TYPE (decl
);
5675 if (TREE_CODE (decl
) == TYPE_DECL
5676 || TREE_CODE (decl
) == PARM_DECL
5677 || TREE_CODE (decl
) == VAR_DECL
5678 || TREE_CODE (decl
) == FUNCTION_DECL
5679 || TREE_CODE (decl
) == FIELD_DECL
)
5680 TREE_DEPRECATED (decl
) = 1;
5684 else if (TYPE_P (*node
))
5686 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
5687 *node
= build_type_copy (*node
);
5688 TREE_DEPRECATED (*node
) = 1;
5696 *no_add_attrs
= true;
5697 if (type
&& TYPE_NAME (type
))
5699 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
5700 what
= IDENTIFIER_POINTER (TYPE_NAME (*node
));
5701 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
5702 && DECL_NAME (TYPE_NAME (type
)))
5703 what
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)));
5706 warning ("`%s' attribute ignored for `%s'",
5707 IDENTIFIER_POINTER (name
), what
);
5709 warning ("`%s' attribute ignored",
5710 IDENTIFIER_POINTER (name
));
5716 /* Keep a list of vector type nodes we created in handle_vector_size_attribute,
5717 to prevent us from duplicating type nodes unnecessarily.
5718 The normal mechanism to prevent duplicates is to use type_hash_canon, but
5719 since we want to distinguish types that are essentially identical (except
5720 for their debug representation), we use a local list here. */
5721 static GTY(()) tree vector_type_node_list
= 0;
5723 /* Handle a "vector_size" attribute; arguments as in
5724 struct attribute_spec.handler. */
5727 handle_vector_size_attribute (node
, name
, args
, flags
, no_add_attrs
)
5731 int flags ATTRIBUTE_UNUSED
;
5734 unsigned HOST_WIDE_INT vecsize
, nunits
;
5735 enum machine_mode mode
, orig_mode
, new_mode
;
5736 tree type
= *node
, new_type
= NULL_TREE
;
5737 tree type_list_node
;
5739 *no_add_attrs
= true;
5741 if (! host_integerp (TREE_VALUE (args
), 1))
5743 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5747 /* Get the vector size (in bytes). */
5748 vecsize
= tree_low_cst (TREE_VALUE (args
), 1);
5750 /* We need to provide for vector pointers, vector arrays, and
5751 functions returning vectors. For example:
5753 __attribute__((vector_size(16))) short *foo;
5755 In this case, the mode is SI, but the type being modified is
5756 HI, so we need to look further. */
5758 while (POINTER_TYPE_P (type
)
5759 || TREE_CODE (type
) == FUNCTION_TYPE
5760 || TREE_CODE (type
) == ARRAY_TYPE
)
5761 type
= TREE_TYPE (type
);
5763 /* Get the mode of the type being modified. */
5764 orig_mode
= TYPE_MODE (type
);
5766 if (TREE_CODE (type
) == RECORD_TYPE
5767 || (GET_MODE_CLASS (orig_mode
) != MODE_FLOAT
5768 && GET_MODE_CLASS (orig_mode
) != MODE_INT
)
5769 || ! host_integerp (TYPE_SIZE_UNIT (type
), 1))
5771 error ("invalid vector type for attribute `%s'",
5772 IDENTIFIER_POINTER (name
));
5776 /* Calculate how many units fit in the vector. */
5777 nunits
= vecsize
/ tree_low_cst (TYPE_SIZE_UNIT (type
), 1);
5779 /* Find a suitably sized vector. */
5780 new_mode
= VOIDmode
;
5781 for (mode
= GET_CLASS_NARROWEST_MODE (GET_MODE_CLASS (orig_mode
) == MODE_INT
5783 : MODE_VECTOR_FLOAT
);
5785 mode
= GET_MODE_WIDER_MODE (mode
))
5786 if (vecsize
== GET_MODE_SIZE (mode
)
5787 && nunits
== (unsigned HOST_WIDE_INT
) GET_MODE_NUNITS (mode
))
5793 if (new_mode
== VOIDmode
)
5795 error ("no vector mode with the size and type specified could be found");
5799 for (type_list_node
= vector_type_node_list
; type_list_node
;
5800 type_list_node
= TREE_CHAIN (type_list_node
))
5802 tree other_type
= TREE_VALUE (type_list_node
);
5803 tree record
= TYPE_DEBUG_REPRESENTATION_TYPE (other_type
);
5804 tree fields
= TYPE_FIELDS (record
);
5805 tree field_type
= TREE_TYPE (fields
);
5806 tree array_type
= TREE_TYPE (field_type
);
5807 if (TREE_CODE (fields
) != FIELD_DECL
5808 || TREE_CODE (field_type
) != ARRAY_TYPE
)
5811 if (TYPE_MODE (other_type
) == mode
&& type
== array_type
)
5813 new_type
= other_type
;
5818 if (new_type
== NULL_TREE
)
5820 tree index
, array
, rt
, list_node
;
5822 new_type
= (*lang_hooks
.types
.type_for_mode
) (new_mode
,
5823 TREE_UNSIGNED (type
));
5827 error ("no vector mode with the size and type specified could be found");
5831 new_type
= build_type_copy (new_type
);
5833 /* If this is a vector, make sure we either have hardware
5834 support, or we can emulate it. */
5835 if ((GET_MODE_CLASS (mode
) == MODE_VECTOR_INT
5836 || GET_MODE_CLASS (mode
) == MODE_VECTOR_FLOAT
)
5837 && !vector_mode_valid_p (mode
))
5839 error ("unable to emulate '%s'", GET_MODE_NAME (mode
));
5843 /* Set the debug information here, because this is the only
5844 place where we know the underlying type for a vector made
5845 with vector_size. For debugging purposes we pretend a vector
5846 is an array within a structure. */
5847 index
= build_int_2 (TYPE_VECTOR_SUBPARTS (new_type
) - 1, 0);
5848 array
= build_array_type (type
, build_index_type (index
));
5849 rt
= make_node (RECORD_TYPE
);
5851 TYPE_FIELDS (rt
) = build_decl (FIELD_DECL
, get_identifier ("f"), array
);
5852 DECL_CONTEXT (TYPE_FIELDS (rt
)) = rt
;
5854 TYPE_DEBUG_REPRESENTATION_TYPE (new_type
) = rt
;
5856 list_node
= build_tree_list (NULL
, new_type
);
5857 TREE_CHAIN (list_node
) = vector_type_node_list
;
5858 vector_type_node_list
= list_node
;
5861 /* Build back pointers if needed. */
5862 *node
= vector_size_helper (*node
, new_type
);
5867 /* HACK. GROSS. This is absolutely disgusting. I wish there was a
5870 If we requested a pointer to a vector, build up the pointers that
5871 we stripped off while looking for the inner type. Similarly for
5872 return values from functions.
5874 The argument "type" is the top of the chain, and "bottom" is the
5875 new type which we will point to. */
5878 vector_size_helper (type
, bottom
)
5883 if (POINTER_TYPE_P (type
))
5885 inner
= vector_size_helper (TREE_TYPE (type
), bottom
);
5886 outer
= build_pointer_type (inner
);
5888 else if (TREE_CODE (type
) == ARRAY_TYPE
)
5890 inner
= vector_size_helper (TREE_TYPE (type
), bottom
);
5891 outer
= build_array_type (inner
, TYPE_VALUES (type
));
5893 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
5895 inner
= vector_size_helper (TREE_TYPE (type
), bottom
);
5896 outer
= build_function_type (inner
, TYPE_VALUES (type
));
5901 TREE_READONLY (outer
) = TREE_READONLY (type
);
5902 TREE_THIS_VOLATILE (outer
) = TREE_THIS_VOLATILE (type
);
5907 /* Handle the "nonnull" attribute. */
5909 handle_nonnull_attribute (node
, name
, args
, flags
, no_add_attrs
)
5911 tree name ATTRIBUTE_UNUSED
;
5913 int flags ATTRIBUTE_UNUSED
;
5917 unsigned HOST_WIDE_INT attr_arg_num
;
5919 /* If no arguments are specified, all pointer arguments should be
5920 non-null. Verify a full prototype is given so that the arguments
5921 will have the correct types when we actually check them later. */
5924 if (! TYPE_ARG_TYPES (type
))
5926 error ("nonnull attribute without arguments on a non-prototype");
5927 *no_add_attrs
= true;
5932 /* Argument list specified. Verify that each argument number references
5933 a pointer argument. */
5934 for (attr_arg_num
= 1; args
; args
= TREE_CHAIN (args
))
5937 unsigned HOST_WIDE_INT arg_num
, ck_num
;
5939 if (! get_nonnull_operand (TREE_VALUE (args
), &arg_num
))
5941 error ("nonnull argument has invalid operand number (arg %lu)",
5942 (unsigned long) attr_arg_num
);
5943 *no_add_attrs
= true;
5947 argument
= TYPE_ARG_TYPES (type
);
5950 for (ck_num
= 1; ; ck_num
++)
5952 if (! argument
|| ck_num
== arg_num
)
5954 argument
= TREE_CHAIN (argument
);
5958 || TREE_CODE (TREE_VALUE (argument
)) == VOID_TYPE
)
5960 error ("nonnull argument with out-of-range operand number (arg %lu, operand %lu)",
5961 (unsigned long) attr_arg_num
, (unsigned long) arg_num
);
5962 *no_add_attrs
= true;
5966 if (TREE_CODE (TREE_VALUE (argument
)) != POINTER_TYPE
)
5968 error ("nonnull argument references non-pointer operand (arg %lu, operand %lu)",
5969 (unsigned long) attr_arg_num
, (unsigned long) arg_num
);
5970 *no_add_attrs
= true;
5979 /* Check the argument list of a function call for null in argument slots
5980 that are marked as requiring a non-null pointer argument. */
5983 check_function_nonnull (attrs
, params
)
5987 tree a
, args
, param
;
5990 for (a
= attrs
; a
; a
= TREE_CHAIN (a
))
5992 if (is_attribute_p ("nonnull", TREE_PURPOSE (a
)))
5994 args
= TREE_VALUE (a
);
5996 /* Walk the argument list. If we encounter an argument number we
5997 should check for non-null, do it. If the attribute has no args,
5998 then every pointer argument is checked (in which case the check
5999 for pointer type is done in check_nonnull_arg). */
6000 for (param
= params
, param_num
= 1; ;
6001 param_num
++, param
= TREE_CHAIN (param
))
6005 if (! args
|| nonnull_check_p (args
, param_num
))
6006 check_function_arguments_recurse (check_nonnull_arg
, NULL
,
6014 /* Helper for check_function_nonnull; given a list of operands which
6015 must be non-null in ARGS, determine if operand PARAM_NUM should be
6019 nonnull_check_p (args
, param_num
)
6021 unsigned HOST_WIDE_INT param_num
;
6023 unsigned HOST_WIDE_INT arg_num
;
6025 for (; args
; args
= TREE_CHAIN (args
))
6027 if (! get_nonnull_operand (TREE_VALUE (args
), &arg_num
))
6030 if (arg_num
== param_num
)
6036 /* Check that the function argument PARAM (which is operand number
6037 PARAM_NUM) is non-null. This is called by check_function_nonnull
6038 via check_function_arguments_recurse. */
6041 check_nonnull_arg (ctx
, param
, param_num
)
6042 void *ctx ATTRIBUTE_UNUSED
;
6044 unsigned HOST_WIDE_INT param_num
;
6046 /* Just skip checking the argument if it's not a pointer. This can
6047 happen if the "nonnull" attribute was given without an operand
6048 list (which means to check every pointer argument). */
6050 if (TREE_CODE (TREE_TYPE (param
)) != POINTER_TYPE
)
6053 if (integer_zerop (param
))
6054 warning ("null argument where non-null required (arg %lu)",
6055 (unsigned long) param_num
);
6058 /* Helper for nonnull attribute handling; fetch the operand number
6059 from the attribute argument list. */
6062 get_nonnull_operand (arg_num_expr
, valp
)
6064 unsigned HOST_WIDE_INT
*valp
;
6066 /* Strip any conversions from the arg number and verify they
6068 while (TREE_CODE (arg_num_expr
) == NOP_EXPR
6069 || TREE_CODE (arg_num_expr
) == CONVERT_EXPR
6070 || TREE_CODE (arg_num_expr
) == NON_LVALUE_EXPR
)
6071 arg_num_expr
= TREE_OPERAND (arg_num_expr
, 0);
6073 if (TREE_CODE (arg_num_expr
) != INTEGER_CST
6074 || TREE_INT_CST_HIGH (arg_num_expr
) != 0)
6077 *valp
= TREE_INT_CST_LOW (arg_num_expr
);
6081 /* Handle a "nothrow" attribute; arguments as in
6082 struct attribute_spec.handler. */
6085 handle_nothrow_attribute (node
, name
, args
, flags
, no_add_attrs
)
6088 tree args ATTRIBUTE_UNUSED
;
6089 int flags ATTRIBUTE_UNUSED
;
6092 if (TREE_CODE (*node
) == FUNCTION_DECL
)
6093 TREE_NOTHROW (*node
) = 1;
6094 /* ??? TODO: Support types. */
6097 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
6098 *no_add_attrs
= true;
6104 /* Check for valid arguments being passed to a function. */
6106 check_function_arguments (attrs
, params
)
6110 /* Check for null being passed in a pointer argument that must be
6111 non-null. We also need to do this if format checking is enabled. */
6114 check_function_nonnull (attrs
, params
);
6116 /* Check for errors in format strings. */
6119 check_function_format (NULL
, attrs
, params
);
6122 /* Generic argument checking recursion routine. PARAM is the argument to
6123 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
6124 once the argument is resolved. CTX is context for the callback. */
6126 check_function_arguments_recurse (callback
, ctx
, param
, param_num
)
6127 void (*callback
) PARAMS ((void *, tree
, unsigned HOST_WIDE_INT
));
6130 unsigned HOST_WIDE_INT param_num
;
6132 if (TREE_CODE (param
) == NOP_EXPR
)
6134 /* Strip coercion. */
6135 check_function_arguments_recurse (callback
, ctx
,
6136 TREE_OPERAND (param
, 0), param_num
);
6140 if (TREE_CODE (param
) == CALL_EXPR
)
6142 tree type
= TREE_TYPE (TREE_TYPE (TREE_OPERAND (param
, 0)));
6144 bool found_format_arg
= false;
6146 /* See if this is a call to a known internationalization function
6147 that modifies a format arg. Such a function may have multiple
6148 format_arg attributes (for example, ngettext). */
6150 for (attrs
= TYPE_ATTRIBUTES (type
);
6152 attrs
= TREE_CHAIN (attrs
))
6153 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs
)))
6156 tree format_num_expr
;
6160 /* Extract the argument number, which was previously checked
6162 format_num_expr
= TREE_VALUE (TREE_VALUE (attrs
));
6163 while (TREE_CODE (format_num_expr
) == NOP_EXPR
6164 || TREE_CODE (format_num_expr
) == CONVERT_EXPR
6165 || TREE_CODE (format_num_expr
) == NON_LVALUE_EXPR
)
6166 format_num_expr
= TREE_OPERAND (format_num_expr
, 0);
6168 if (TREE_CODE (format_num_expr
) != INTEGER_CST
6169 || TREE_INT_CST_HIGH (format_num_expr
) != 0)
6172 format_num
= TREE_INT_CST_LOW (format_num_expr
);
6174 for (inner_args
= TREE_OPERAND (param
, 1), i
= 1;
6176 inner_args
= TREE_CHAIN (inner_args
), i
++)
6177 if (i
== format_num
)
6179 check_function_arguments_recurse (callback
, ctx
,
6180 TREE_VALUE (inner_args
),
6182 found_format_arg
= true;
6187 /* If we found a format_arg attribute and did a recursive check,
6188 we are done with checking this argument. Otherwise, we continue
6189 and this will be considered a non-literal. */
6190 if (found_format_arg
)
6194 if (TREE_CODE (param
) == COND_EXPR
)
6196 /* Check both halves of the conditional expression. */
6197 check_function_arguments_recurse (callback
, ctx
,
6198 TREE_OPERAND (param
, 1), param_num
);
6199 check_function_arguments_recurse (callback
, ctx
,
6200 TREE_OPERAND (param
, 2), param_num
);
6204 (*callback
) (ctx
, param
, param_num
);
6207 #include "gt-c-common.h"