1 /* Subroutines shared by all languages that are variants of C.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
34 #include "diagnostic.h"
39 #include "langhooks.h"
40 #include "except.h" /* For USING_SJLJ_EXCEPTIONS. */
41 #include "tree-inline.h"
43 cpp_reader *parse_in; /* Declared in c-pragma.h. */
45 /* We let tm.h override the types used here, to handle trivial differences
46 such as the choice of unsigned int or long unsigned int for size_t.
47 When machines start needing nontrivial differences in the size type,
48 it would be best to do something here to figure out automatically
49 from other information what type to use. */
52 #define SIZE_TYPE "long unsigned int"
56 #define WCHAR_TYPE "int"
59 /* WCHAR_TYPE gets overridden by -fshort-wchar. */
60 #define MODIFIED_WCHAR_TYPE \
61 (flag_short_wchar ? "short unsigned int" : WCHAR_TYPE)
64 #define PTRDIFF_TYPE "long int"
68 #define WINT_TYPE "unsigned int"
72 #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
74 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
80 #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
82 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
83 ? "long unsigned int" \
84 : "long long unsigned int"))
87 #ifndef REGISTER_PREFIX
88 #define REGISTER_PREFIX ""
91 /* The variant of the C language being processed. */
93 enum c_language_kind c_language;
95 /* The following symbols are subsumed in the c_global_trees array, and
96 listed here individually for documentation purposes.
98 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
100 tree short_integer_type_node;
101 tree long_integer_type_node;
102 tree long_long_integer_type_node;
104 tree short_unsigned_type_node;
105 tree long_unsigned_type_node;
106 tree long_long_unsigned_type_node;
108 tree boolean_type_node;
109 tree boolean_false_node;
110 tree boolean_true_node;
112 tree ptrdiff_type_node;
114 tree unsigned_char_type_node;
115 tree signed_char_type_node;
116 tree wchar_type_node;
117 tree signed_wchar_type_node;
118 tree unsigned_wchar_type_node;
120 tree float_type_node;
121 tree double_type_node;
122 tree long_double_type_node;
124 tree complex_integer_type_node;
125 tree complex_float_type_node;
126 tree complex_double_type_node;
127 tree complex_long_double_type_node;
129 tree intQI_type_node;
130 tree intHI_type_node;
131 tree intSI_type_node;
132 tree intDI_type_node;
133 tree intTI_type_node;
135 tree unsigned_intQI_type_node;
136 tree unsigned_intHI_type_node;
137 tree unsigned_intSI_type_node;
138 tree unsigned_intDI_type_node;
139 tree unsigned_intTI_type_node;
141 tree widest_integer_literal_type_node;
142 tree widest_unsigned_literal_type_node;
144 Nodes for types `void *' and `const void *'.
146 tree ptr_type_node, const_ptr_type_node;
148 Nodes for types `char *' and `const char *'.
150 tree string_type_node, const_string_type_node;
152 Type `char[SOMENUMBER]'.
153 Used when an array of char is needed and the size is irrelevant.
155 tree char_array_type_node;
157 Type `int[SOMENUMBER]' or something like it.
158 Used when an array of int needed and the size is irrelevant.
160 tree int_array_type_node;
162 Type `wchar_t[SOMENUMBER]' or something like it.
163 Used when a wide string literal is created.
165 tree wchar_array_type_node;
167 Type `int ()' -- used for implicit declaration of functions.
169 tree default_function_type;
171 A VOID_TYPE node, packaged in a TREE_LIST.
175 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
176 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
177 VAR_DECLS, but C++ does.)
179 tree function_name_decl_node;
180 tree pretty_function_name_decl_node;
181 tree c99_function_name_decl_node;
183 Stack of nested function name VAR_DECLs.
185 tree saved_function_name_decls;
189 tree c_global_trees[CTI_MAX];
191 /* Switches common to the C front ends. */
193 /* Nonzero if prepreprocessing only. */
194 int flag_preprocess_only;
196 /* Nonzero if an ISO standard was selected. It rejects macros in the
200 /* Nonzero whenever Objective-C functionality is being used. */
203 /* Nonzero if -undef was given. It suppresses target built-in macros
207 /* Nonzero means don't recognize the non-ANSI builtin functions. */
211 /* Nonzero means don't recognize the non-ANSI builtin functions.
214 int flag_no_nonansi_builtin;
216 /* Nonzero means give `double' the same size as `float'. */
218 int flag_short_double;
220 /* Nonzero means give `wchar_t' the same size as `short'. */
222 int flag_short_wchar;
224 /* Nonzero means allow Microsoft extensions without warnings or errors. */
225 int flag_ms_extensions;
227 /* Nonzero means don't recognize the keyword `asm'. */
231 /* Nonzero means give string constants the type `const char *', as mandated
234 int flag_const_strings;
236 /* Nonzero means `$' can be in an identifier. */
238 #ifndef DOLLARS_IN_IDENTIFIERS
239 #define DOLLARS_IN_IDENTIFIERS 1
241 int dollars_in_ident = DOLLARS_IN_IDENTIFIERS;
243 /* Nonzero means to treat bitfields as signed unless they say `unsigned'. */
245 int flag_signed_bitfields = 1;
246 int explicit_flag_signed_bitfields;
248 /* Nonzero means warn about pointer casts that can drop a type qualifier
249 from the pointer target type. */
253 /* Warn about functions which might be candidates for format attributes. */
255 int warn_missing_format_attribute;
257 /* Nonzero means warn about sizeof(function) or addition/subtraction
258 of function pointers. */
260 int warn_pointer_arith;
262 /* Nonzero means warn for any global function def
263 without separate previous prototype decl. */
265 int warn_missing_prototypes;
267 /* Warn if adding () is suggested. */
269 int warn_parentheses;
271 /* Warn if initializer is not completely bracketed. */
273 int warn_missing_braces;
275 /* Warn about comparison of signed and unsigned values.
276 If -1, neither -Wsign-compare nor -Wno-sign-compare has been specified. */
278 int warn_sign_compare;
280 /* Nonzero means warn about usage of long long when `-pedantic'. */
282 int warn_long_long = 1;
284 /* Nonzero means warn about deprecated conversion from string constant to
287 int warn_write_strings;
289 /* Nonzero means warn about multiple (redundant) decls for the same single
290 variable or function. */
292 int warn_redundant_decls;
294 /* Warn about testing equality of floating point numbers. */
296 int warn_float_equal;
298 /* Warn about a subscript that has type char. */
300 int warn_char_subscripts;
302 /* Warn if a type conversion is done that might have confusing results. */
306 /* Warn about #pragma directives that are not recognized. */
308 int warn_unknown_pragmas; /* Tri state variable. */
310 /* Warn about format/argument anomalies in calls to formatted I/O functions
311 (*printf, *scanf, strftime, strfmon, etc.). */
315 /* Warn about Y2K problems with strftime formats. */
319 /* Warn about excess arguments to formats. */
321 int warn_format_extra_args;
323 /* Warn about zero-length formats. */
325 int warn_format_zero_length;
327 /* Warn about non-literal format arguments. */
329 int warn_format_nonliteral;
331 /* Warn about possible security problems with calls to format functions. */
333 int warn_format_security;
336 /* C/ObjC language option variables. */
339 /* Nonzero means message about use of implicit function declarations;
340 1 means warning; 2 means error. */
342 int mesg_implicit_function_declaration = -1;
344 /* Nonzero means allow type mismatches in conditional expressions;
345 just make their values `void'. */
347 int flag_cond_mismatch;
349 /* Nonzero means enable C89 Amendment 1 features. */
353 /* Nonzero means use the ISO C99 dialect of C. */
357 /* Nonzero means that we have builtin functions, and main is an int */
361 /* Nonzero means add default format_arg attributes for functions not
364 int flag_noniso_default_format_attributes = 1;
366 /* Nonzero means warn when casting a function call to a type that does
367 not match the return type (e.g. (float)sqrt() or (anything*)malloc()
368 when there is no previous declaration of sqrt or malloc. */
370 int warn_bad_function_cast;
372 /* Warn about traditional constructs whose meanings changed in ANSI C. */
374 int warn_traditional;
376 /* Nonzero means warn for non-prototype function decls
377 or non-prototyped defs without previous prototype. */
379 int warn_strict_prototypes;
381 /* Nonzero means warn for any global function def
382 without separate previous decl. */
384 int warn_missing_declarations;
386 /* Nonzero means warn about declarations of objects not at
387 file-scope level and about *all* declarations of functions (whether
388 or static) not at file-scope level. Note that we exclude
389 implicit function declarations. To get warnings about those, use
392 int warn_nested_externs;
394 /* Warn if main is suspicious. */
398 /* Nonzero means warn about possible violations of sequence point rules. */
400 int warn_sequence_point;
402 /* Nonzero means to warn about compile-time division by zero. */
403 int warn_div_by_zero = 1;
405 /* Nonzero means warn about use of implicit int. */
407 int warn_implicit_int;
409 /* Warn about NULL being passed to argument slots marked as requiring
415 /* ObjC language option variables. */
418 /* Open and close the file for outputting class declarations, if
421 int flag_gen_declaration;
423 /* Generate code for GNU or NeXT runtime environment. */
425 #ifdef NEXT_OBJC_RUNTIME
426 int flag_next_runtime = 1;
428 int flag_next_runtime = 0;
431 /* Tells the compiler that this is a special run. Do not perform any
432 compiling, instead we are to test some platform dependent features
433 and output a C header file with appropriate definitions. */
435 int print_struct_values;
437 /* ???. Undocumented. */
439 const char *constant_string_class_name;
441 /* Warn if multiple methods are seen for the same selector, but with
442 different argument types. Performs the check on the whole selector
443 table at the end of compilation. */
447 /* Warn if a @selector() is found, and no method with that selector
448 has been previously declared. The check is done on each
449 @selector() as soon as it is found - so it warns about forward
452 int warn_undeclared_selector;
454 /* Warn if methods required by a protocol are not implemented in the
455 class adopting it. When turned off, methods inherited to that
456 class are also considered implemented. */
458 int warn_protocol = 1;
461 /* C++ language option variables. */
464 /* Nonzero means don't recognize any extension keywords. */
466 int flag_no_gnu_keywords;
468 /* Nonzero means do emit exported implementations of functions even if
469 they can be inlined. */
471 int flag_implement_inlines = 1;
473 /* Nonzero means do emit exported implementations of templates, instead of
474 multiple static copies in each file that needs a definition. */
476 int flag_external_templates;
478 /* Nonzero means that the decision to emit or not emit the implementation of a
479 template depends on where the template is instantiated, rather than where
482 int flag_alt_external_templates;
484 /* Nonzero means that implicit instantiations will be emitted if needed. */
486 int flag_implicit_templates = 1;
488 /* Nonzero means that implicit instantiations of inline templates will be
489 emitted if needed, even if instantiations of non-inline templates
492 int flag_implicit_inline_templates = 1;
494 /* Nonzero means generate separate instantiation control files and
495 juggle them at link time. */
497 int flag_use_repository;
499 /* Nonzero if we want to issue diagnostics that the standard says are not
502 int flag_optional_diags = 1;
504 /* Nonzero means we should attempt to elide constructors when possible. */
506 int flag_elide_constructors = 1;
508 /* Nonzero means that member functions defined in class scope are
509 inline by default. */
511 int flag_default_inline = 1;
513 /* Controls whether compiler generates 'type descriptor' that give
514 run-time type information. */
518 /* Nonzero if we want to conserve space in the .o files. We do this
519 by putting uninitialized data and runtime initialized data into
520 .common instead of .data at the expense of not flagging multiple
523 int flag_conserve_space;
525 /* Nonzero if we want to obey access control semantics. */
527 int flag_access_control = 1;
529 /* Nonzero if we want to check the return value of new and avoid calling
530 constructors if it is a null pointer. */
534 /* Nonzero if we want the new ISO rules for pushing a new scope for `for'
535 initialization variables.
536 0: Old rules, set by -fno-for-scope.
537 2: New ISO rules, set by -ffor-scope.
538 1: Try to implement new ISO rules, but with backup compatibility
539 (and warnings). This is the default, for now. */
541 int flag_new_for_scope = 1;
543 /* Nonzero if we want to emit defined symbols with common-like linkage as
544 weak symbols where possible, in order to conform to C++ semantics.
545 Otherwise, emit them as local symbols. */
549 /* Nonzero to use __cxa_atexit, rather than atexit, to register
550 destructors for local statics and global objects. */
552 int flag_use_cxa_atexit = DEFAULT_USE_CXA_ATEXIT;
554 /* Nonzero means output .vtable_{entry,inherit} for use in doing vtable gc. */
558 /* Nonzero means make the default pedwarns warnings instead of errors.
559 The value of this flag is ignored if -pedantic is specified. */
563 /* Nonzero means to implement standard semantics for exception
564 specifications, calling unexpected if an exception is thrown that
565 doesn't match the specification. Zero means to treat them as
566 assertions and optimize accordingly, but not check them. */
568 int flag_enforce_eh_specs = 1;
570 /* Nonzero means warn about things that will change when compiling
571 with an ABI-compliant compiler. */
575 /* Nonzero means warn about implicit declarations. */
577 int warn_implicit = 1;
579 /* Nonzero means warn when all ctors or dtors are private, and the class
582 int warn_ctor_dtor_privacy = 1;
584 /* Nonzero means warn in function declared in derived class has the
585 same name as a virtual in the base class, but fails to match the
586 type signature of any virtual function in the base class. */
588 int warn_overloaded_virtual;
590 /* Nonzero means warn when declaring a class that has a non virtual
591 destructor, when it really ought to have a virtual one. */
595 /* Nonzero means warn when the compiler will reorder code. */
599 /* Nonzero means warn when synthesis behavior differs from Cfront's. */
603 /* Nonzero means warn when we convert a pointer to member function
604 into a pointer to (void or function). */
606 int warn_pmf2ptr = 1;
608 /* Nonzero means warn about violation of some Effective C++ style rules. */
612 /* Nonzero means warn where overload resolution chooses a promotion from
613 unsigned to signed over a conversion to an unsigned of the same size. */
617 /* Nonzero means warn when an old-style cast is used. */
619 int warn_old_style_cast;
621 /* Nonzero means warn when non-templatized friend functions are
622 declared within a template */
624 int warn_nontemplate_friend = 1;
626 /* Nonzero means complain about deprecated features. */
628 int warn_deprecated = 1;
630 /* Maximum template instantiation depth. This limit is rather
631 arbitrary, but it exists to limit the time it takes to notice
632 infinite template instantiations. */
634 int max_tinst_depth = 500;
638 /* The elements of `ridpointers' are identifier nodes for the reserved
639 type names and storage classes. It is indexed by a RID_... value. */
642 tree (*make_fname_decl) PARAMS ((tree, int));
644 /* If non-NULL, the address of a language-specific function that
645 returns 1 for language-specific statement codes. */
646 int (*lang_statement_code_p) PARAMS ((enum tree_code));
648 /* If non-NULL, the address of a language-specific function that takes
649 any action required right before expand_function_end is called. */
650 void (*lang_expand_function_end) PARAMS ((void));
652 /* Nonzero means the expression being parsed will never be evaluated.
653 This is a count, since unevaluated expressions can nest. */
656 /* Information about how a function name is generated. */
659 tree *const decl; /* pointer to the VAR_DECL. */
660 const unsigned rid; /* RID number for the identifier. */
661 const int pretty; /* How pretty is it? */
664 /* The three ways of getting then name of the current function. */
666 const struct fname_var_t fname_vars[] =
668 /* C99 compliant __func__, must be first. */
669 {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
670 /* GCC __FUNCTION__ compliant. */
671 {&function_name_decl_node, RID_FUNCTION_NAME, 0},
672 /* GCC __PRETTY_FUNCTION__ compliant. */
673 {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
677 static int constant_fits_type_p PARAMS ((tree, tree));
679 /* Keep a stack of if statements. We record the number of compound
680 statements seen up to the if keyword, as well as the line number
681 and file of the if. If a potentially ambiguous else is seen, that
682 fact is recorded; the warning is issued when we can be sure that
683 the enclosing if statement does not have an else branch. */
693 static if_elt *if_stack;
695 /* Amount of space in the if statement stack. */
696 static int if_stack_space = 0;
699 static int if_stack_pointer = 0;
701 static tree handle_packed_attribute PARAMS ((tree *, tree, tree, int,
703 static tree handle_nocommon_attribute PARAMS ((tree *, tree, tree, int,
705 static tree handle_common_attribute PARAMS ((tree *, tree, tree, int,
707 static tree handle_noreturn_attribute PARAMS ((tree *, tree, tree, int,
709 static tree handle_noinline_attribute PARAMS ((tree *, tree, tree, int,
711 static tree handle_always_inline_attribute PARAMS ((tree *, tree, tree, int,
713 static tree handle_used_attribute PARAMS ((tree *, tree, tree, int,
715 static tree handle_unused_attribute PARAMS ((tree *, tree, tree, int,
717 static tree handle_const_attribute PARAMS ((tree *, tree, tree, int,
719 static tree handle_transparent_union_attribute PARAMS ((tree *, tree, tree,
721 static tree handle_constructor_attribute PARAMS ((tree *, tree, tree, int,
723 static tree handle_destructor_attribute PARAMS ((tree *, tree, tree, int,
725 static tree handle_mode_attribute PARAMS ((tree *, tree, tree, int,
727 static tree handle_section_attribute PARAMS ((tree *, tree, tree, int,
729 static tree handle_aligned_attribute PARAMS ((tree *, tree, tree, int,
731 static tree handle_weak_attribute PARAMS ((tree *, tree, tree, int,
733 static tree handle_alias_attribute PARAMS ((tree *, tree, tree, int,
735 static tree handle_visibility_attribute PARAMS ((tree *, tree, tree, int,
737 static tree handle_no_instrument_function_attribute PARAMS ((tree *, tree,
740 static tree handle_malloc_attribute PARAMS ((tree *, tree, tree, int,
742 static tree handle_no_limit_stack_attribute PARAMS ((tree *, tree, tree, int,
744 static tree handle_pure_attribute PARAMS ((tree *, tree, tree, int,
746 static tree handle_deprecated_attribute PARAMS ((tree *, tree, tree, int,
748 static tree handle_vector_size_attribute PARAMS ((tree *, tree, tree, int,
750 static tree handle_nonnull_attribute PARAMS ((tree *, tree, tree, int,
752 static tree handle_nothrow_attribute PARAMS ((tree *, tree, tree, int,
754 static tree vector_size_helper PARAMS ((tree, tree));
756 static void check_function_nonnull PARAMS ((tree, tree));
757 static void check_nonnull_arg PARAMS ((void *, tree,
758 unsigned HOST_WIDE_INT));
759 static bool nonnull_check_p PARAMS ((tree, unsigned HOST_WIDE_INT));
760 static bool get_nonnull_operand PARAMS ((tree,
761 unsigned HOST_WIDE_INT *));
762 void builtin_define_std PARAMS ((const char *));
763 static void builtin_define_with_value PARAMS ((const char *, const char *,
765 static void builtin_define_with_int_value PARAMS ((const char *,
767 static void builtin_define_with_hex_fp_value PARAMS ((const char *, tree,
770 static void builtin_define_type_max PARAMS ((const char *, tree, int));
771 static void cpp_define_data_format PARAMS ((cpp_reader *));
772 static void builtin_define_type_precision PARAMS ((const char *, tree));
773 static void builtin_define_float_constants PARAMS ((const char *,
774 const char *, tree));
776 /* Table of machine-independent attributes common to all C-like languages. */
777 const struct attribute_spec c_common_attribute_table[] =
779 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
780 { "packed", 0, 0, false, false, false,
781 handle_packed_attribute },
782 { "nocommon", 0, 0, true, false, false,
783 handle_nocommon_attribute },
784 { "common", 0, 0, true, false, false,
785 handle_common_attribute },
786 /* FIXME: logically, noreturn attributes should be listed as
787 "false, true, true" and apply to function types. But implementing this
788 would require all the places in the compiler that use TREE_THIS_VOLATILE
789 on a decl to identify non-returning functions to be located and fixed
790 to check the function type instead. */
791 { "noreturn", 0, 0, true, false, false,
792 handle_noreturn_attribute },
793 { "volatile", 0, 0, true, false, false,
794 handle_noreturn_attribute },
795 { "noinline", 0, 0, true, false, false,
796 handle_noinline_attribute },
797 { "always_inline", 0, 0, true, false, false,
798 handle_always_inline_attribute },
799 { "used", 0, 0, true, false, false,
800 handle_used_attribute },
801 { "unused", 0, 0, false, false, false,
802 handle_unused_attribute },
803 /* The same comments as for noreturn attributes apply to const ones. */
804 { "const", 0, 0, true, false, false,
805 handle_const_attribute },
806 { "transparent_union", 0, 0, false, false, false,
807 handle_transparent_union_attribute },
808 { "constructor", 0, 0, true, false, false,
809 handle_constructor_attribute },
810 { "destructor", 0, 0, true, false, false,
811 handle_destructor_attribute },
812 { "mode", 1, 1, false, true, false,
813 handle_mode_attribute },
814 { "section", 1, 1, true, false, false,
815 handle_section_attribute },
816 { "aligned", 0, 1, false, false, false,
817 handle_aligned_attribute },
818 { "weak", 0, 0, true, false, false,
819 handle_weak_attribute },
820 { "alias", 1, 1, true, false, false,
821 handle_alias_attribute },
822 { "no_instrument_function", 0, 0, true, false, false,
823 handle_no_instrument_function_attribute },
824 { "malloc", 0, 0, true, false, false,
825 handle_malloc_attribute },
826 { "no_stack_limit", 0, 0, true, false, false,
827 handle_no_limit_stack_attribute },
828 { "pure", 0, 0, true, false, false,
829 handle_pure_attribute },
830 { "deprecated", 0, 0, false, false, false,
831 handle_deprecated_attribute },
832 { "vector_size", 1, 1, false, true, false,
833 handle_vector_size_attribute },
834 { "visibility", 1, 1, true, false, false,
835 handle_visibility_attribute },
836 { "nonnull", 0, -1, false, true, true,
837 handle_nonnull_attribute },
838 { "nothrow", 0, 0, true, false, false,
839 handle_nothrow_attribute },
840 { "may_alias", 0, 0, false, true, false, NULL },
841 { NULL, 0, 0, false, false, false, NULL }
844 /* Give the specifications for the format attributes, used by C and all
847 const struct attribute_spec c_common_format_attribute_table[] =
849 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
850 { "format", 3, 3, false, true, true,
851 handle_format_attribute },
852 { "format_arg", 1, 1, false, true, true,
853 handle_format_arg_attribute },
854 { NULL, 0, 0, false, false, false, NULL }
857 /* Record the start of an if-then, and record the start of it
858 for ambiguous else detection.
860 COND is the condition for the if-then statement.
862 IF_STMT is the statement node that has already been created for
863 this if-then statement. It is created before parsing the
864 condition to keep line number information accurate. */
867 c_expand_start_cond (cond, compstmt_count, if_stmt)
872 /* Make sure there is enough space on the stack. */
873 if (if_stack_space == 0)
876 if_stack = (if_elt *) xmalloc (10 * sizeof (if_elt));
878 else if (if_stack_space == if_stack_pointer)
880 if_stack_space += 10;
881 if_stack = (if_elt *) xrealloc (if_stack, if_stack_space * sizeof (if_elt));
884 IF_COND (if_stmt) = cond;
887 /* Record this if statement. */
888 if_stack[if_stack_pointer].compstmt_count = compstmt_count;
889 if_stack[if_stack_pointer].file = input_filename;
890 if_stack[if_stack_pointer].line = lineno;
891 if_stack[if_stack_pointer].needs_warning = 0;
892 if_stack[if_stack_pointer].if_stmt = if_stmt;
896 /* Called after the then-clause for an if-statement is processed. */
901 tree if_stmt = if_stack[if_stack_pointer - 1].if_stmt;
902 RECHAIN_STMTS (if_stmt, THEN_CLAUSE (if_stmt));
905 /* Record the end of an if-then. Optionally warn if a nested
906 if statement had an ambiguous else clause. */
912 if (if_stack[if_stack_pointer].needs_warning)
913 warning_with_file_and_line (if_stack[if_stack_pointer].file,
914 if_stack[if_stack_pointer].line,
915 "suggest explicit braces to avoid ambiguous `else'");
916 last_expr_type = NULL_TREE;
919 /* Called between the then-clause and the else-clause
920 of an if-then-else. */
923 c_expand_start_else ()
925 /* An ambiguous else warning must be generated for the enclosing if
926 statement, unless we see an else branch for that one, too. */
928 && if_stack_pointer > 1
929 && (if_stack[if_stack_pointer - 1].compstmt_count
930 == if_stack[if_stack_pointer - 2].compstmt_count))
931 if_stack[if_stack_pointer - 2].needs_warning = 1;
933 /* Even if a nested if statement had an else branch, it can't be
934 ambiguous if this one also has an else. So don't warn in that
935 case. Also don't warn for any if statements nested in this else. */
936 if_stack[if_stack_pointer - 1].needs_warning = 0;
937 if_stack[if_stack_pointer - 1].compstmt_count--;
940 /* Called after the else-clause for an if-statement is processed. */
945 tree if_stmt = if_stack[if_stack_pointer - 1].if_stmt;
946 RECHAIN_STMTS (if_stmt, ELSE_CLAUSE (if_stmt));
949 /* Begin an if-statement. Returns a newly created IF_STMT if
952 Unlike the C++ front-end, we do not call add_stmt here; it is
953 probably safe to do so, but I am not very familiar with this
954 code so I am being extra careful not to change its behavior
955 beyond what is strictly necessary for correctness. */
961 r = build_stmt (IF_STMT, NULL_TREE, NULL_TREE, NULL_TREE);
965 /* Begin a while statement. Returns a newly created WHILE_STMT if
968 Unlike the C++ front-end, we do not call add_stmt here; it is
969 probably safe to do so, but I am not very familiar with this
970 code so I am being extra careful not to change its behavior
971 beyond what is strictly necessary for correctness. */
974 c_begin_while_stmt ()
977 r = build_stmt (WHILE_STMT, NULL_TREE, NULL_TREE);
982 c_finish_while_stmt_cond (cond, while_stmt)
986 WHILE_COND (while_stmt) = cond;
989 /* Push current bindings for the function name VAR_DECLS. */
995 tree saved = NULL_TREE;
997 for (ix = 0; fname_vars[ix].decl; ix++)
999 tree decl = *fname_vars[ix].decl;
1003 saved = tree_cons (decl, build_int_2 (ix, 0), saved);
1004 *fname_vars[ix].decl = NULL_TREE;
1007 if (saved || saved_function_name_decls)
1008 /* Normally they'll have been NULL, so only push if we've got a
1009 stack, or they are non-NULL. */
1010 saved_function_name_decls = tree_cons (saved, NULL_TREE,
1011 saved_function_name_decls);
1014 /* Finish up the current bindings, adding them into the
1015 current function's statement tree. This is done by wrapping the
1016 function's body in a COMPOUND_STMT containing these decls too. This
1017 must be done _before_ finish_stmt_tree is called. If there is no
1018 current function, we must be at file scope and no statements are
1019 involved. Pop the previous bindings. */
1022 finish_fname_decls ()
1025 tree body = NULL_TREE;
1026 tree stack = saved_function_name_decls;
1028 for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
1029 body = chainon (TREE_VALUE (stack), body);
1033 /* They were called into existence, so add to statement tree. */
1034 body = chainon (body,
1035 TREE_CHAIN (DECL_SAVED_TREE (current_function_decl)));
1036 body = build_stmt (COMPOUND_STMT, body);
1038 COMPOUND_STMT_NO_SCOPE (body) = 1;
1039 TREE_CHAIN (DECL_SAVED_TREE (current_function_decl)) = body;
1042 for (ix = 0; fname_vars[ix].decl; ix++)
1043 *fname_vars[ix].decl = NULL_TREE;
1047 /* We had saved values, restore them. */
1050 for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
1052 tree decl = TREE_PURPOSE (saved);
1053 unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
1055 *fname_vars[ix].decl = decl;
1057 stack = TREE_CHAIN (stack);
1059 saved_function_name_decls = stack;
1062 /* Return the text name of the current function, suitable prettified
1066 fname_as_string (pretty_p)
1069 const char *name = NULL;
1072 name = (current_function_decl
1073 ? (*lang_hooks.decl_printable_name) (current_function_decl, 2)
1075 else if (current_function_decl && DECL_NAME (current_function_decl))
1076 name = IDENTIFIER_POINTER (DECL_NAME (current_function_decl));
1082 /* Return the text name of the current function, formatted as
1083 required by the supplied RID value. */
1091 for (ix = 0; fname_vars[ix].decl; ix++)
1092 if (fname_vars[ix].rid == rid)
1094 return fname_as_string (fname_vars[ix].pretty);
1097 /* Return the VAR_DECL for a const char array naming the current
1098 function. If the VAR_DECL has not yet been created, create it
1099 now. RID indicates how it should be formatted and IDENTIFIER_NODE
1100 ID is its name (unfortunately C and C++ hold the RID values of
1101 keywords in different places, so we can't derive RID from ID in
1102 this language independent code. */
1105 fname_decl (rid, id)
1110 tree decl = NULL_TREE;
1112 for (ix = 0; fname_vars[ix].decl; ix++)
1113 if (fname_vars[ix].rid == rid)
1116 decl = *fname_vars[ix].decl;
1119 tree saved_last_tree = last_tree;
1120 /* If a tree is built here, it would normally have the lineno of
1121 the current statement. Later this tree will be moved to the
1122 beginning of the function and this line number will be wrong.
1123 To avoid this problem set the lineno to 0 here; that prevents
1124 it from appearing in the RTL. */
1125 int saved_lineno = lineno;
1128 decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
1129 if (last_tree != saved_last_tree)
1131 /* We created some statement tree for the decl. This belongs
1132 at the start of the function, so remove it now and reinsert
1133 it after the function is complete. */
1134 tree stmts = TREE_CHAIN (saved_last_tree);
1136 TREE_CHAIN (saved_last_tree) = NULL_TREE;
1137 last_tree = saved_last_tree;
1138 saved_function_name_decls = tree_cons (decl, stmts,
1139 saved_function_name_decls);
1141 *fname_vars[ix].decl = decl;
1142 lineno = saved_lineno;
1144 if (!ix && !current_function_decl)
1145 pedwarn_with_decl (decl, "`%s' is not defined outside of function scope");
1150 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
1153 fix_string_type (value)
1156 const int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
1157 const int wide_flag = TREE_TYPE (value) == wchar_array_type_node;
1158 const int nchars_max = flag_isoc99 ? 4095 : 509;
1159 int length = TREE_STRING_LENGTH (value);
1162 /* Compute the number of elements, for the array type. */
1163 nchars = wide_flag ? length / wchar_bytes : length;
1165 if (pedantic && nchars - 1 > nchars_max && c_language == clk_c)
1166 pedwarn ("string length `%d' is greater than the length `%d' ISO C%d compilers are required to support",
1167 nchars - 1, nchars_max, flag_isoc99 ? 99 : 89);
1169 /* Create the array type for the string constant.
1170 -Wwrite-strings says make the string constant an array of const char
1171 so that copying it to a non-const pointer will get a warning.
1172 For C++, this is the standard behavior. */
1173 if (flag_const_strings && ! flag_writable_strings)
1176 = build_type_variant (wide_flag ? wchar_type_node : char_type_node,
1179 = build_array_type (elements,
1180 build_index_type (build_int_2 (nchars - 1, 0)));
1184 = build_array_type (wide_flag ? wchar_type_node : char_type_node,
1185 build_index_type (build_int_2 (nchars - 1, 0)));
1187 TREE_CONSTANT (value) = 1;
1188 TREE_READONLY (value) = ! flag_writable_strings;
1189 TREE_STATIC (value) = 1;
1193 /* Given a VARRAY of STRING_CST nodes, concatenate them into one
1197 combine_strings (strings)
1198 varray_type strings;
1200 const int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
1201 const int nstrings = VARRAY_ACTIVE_SIZE (strings);
1204 int wide_length = 0;
1209 /* Don't include the \0 at the end of each substring. Count wide
1210 strings and ordinary strings separately. */
1211 for (i = 0; i < nstrings; ++i)
1213 t = VARRAY_TREE (strings, i);
1215 if (TREE_TYPE (t) == wchar_array_type_node)
1217 wide_length += TREE_STRING_LENGTH (t) - wchar_bytes;
1222 length += (TREE_STRING_LENGTH (t) - 1);
1223 if (C_ARTIFICIAL_STRING_P (t) && !in_system_header)
1224 warning ("concatenation of string literals with __FUNCTION__ is deprecated");
1228 /* If anything is wide, the non-wides will be converted,
1229 which makes them take more space. */
1231 length = length * wchar_bytes + wide_length;
1233 p = xmalloc (length);
1235 /* Copy the individual strings into the new combined string.
1236 If the combined string is wide, convert the chars to ints
1237 for any individual strings that are not wide. */
1240 for (i = 0; i < nstrings; ++i)
1244 t = VARRAY_TREE (strings, i);
1245 this_wide = TREE_TYPE (t) == wchar_array_type_node;
1246 len = TREE_STRING_LENGTH (t) - (this_wide ? wchar_bytes : 1);
1247 if (this_wide == wide_flag)
1249 memcpy (q, TREE_STRING_POINTER (t), len);
1254 const int nzeros = (TYPE_PRECISION (wchar_type_node)
1255 / BITS_PER_UNIT) - 1;
1258 if (BYTES_BIG_ENDIAN)
1260 for (k = 0; k < len; k++)
1262 for (j = 0; j < nzeros; j++)
1264 *q++ = TREE_STRING_POINTER (t)[k];
1269 for (k = 0; k < len; k++)
1271 *q++ = TREE_STRING_POINTER (t)[k];
1272 for (j = 0; j < nzeros; j++)
1279 /* Nul terminate the string. */
1282 for (i = 0; i < wchar_bytes; i++)
1288 value = build_string (length, p);
1292 TREE_TYPE (value) = wchar_array_type_node;
1294 TREE_TYPE (value) = char_array_type_node;
1299 static int is_valid_printf_arglist PARAMS ((tree));
1300 static rtx c_expand_builtin PARAMS ((tree, rtx, enum machine_mode, enum expand_modifier));
1301 static rtx c_expand_builtin_printf PARAMS ((tree, rtx, enum machine_mode,
1302 enum expand_modifier, int, int));
1303 static rtx c_expand_builtin_fprintf PARAMS ((tree, rtx, enum machine_mode,
1304 enum expand_modifier, int, int));
1306 /* Print a warning if a constant expression had overflow in folding.
1307 Invoke this function on every expression that the language
1308 requires to be a constant expression.
1309 Note the ANSI C standard says it is erroneous for a
1310 constant expression to overflow. */
1313 constant_expression_warning (value)
1316 if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
1317 || TREE_CODE (value) == VECTOR_CST
1318 || TREE_CODE (value) == COMPLEX_CST)
1319 && TREE_CONSTANT_OVERFLOW (value) && pedantic)
1320 pedwarn ("overflow in constant expression");
1323 /* Print a warning if an expression had overflow in folding.
1324 Invoke this function on every expression that
1325 (1) appears in the source code, and
1326 (2) might be a constant expression that overflowed, and
1327 (3) is not already checked by convert_and_check;
1328 however, do not invoke this function on operands of explicit casts. */
1331 overflow_warning (value)
1334 if ((TREE_CODE (value) == INTEGER_CST
1335 || (TREE_CODE (value) == COMPLEX_CST
1336 && TREE_CODE (TREE_REALPART (value)) == INTEGER_CST))
1337 && TREE_OVERFLOW (value))
1339 TREE_OVERFLOW (value) = 0;
1340 if (skip_evaluation == 0)
1341 warning ("integer overflow in expression");
1343 else if ((TREE_CODE (value) == REAL_CST
1344 || (TREE_CODE (value) == COMPLEX_CST
1345 && TREE_CODE (TREE_REALPART (value)) == REAL_CST))
1346 && TREE_OVERFLOW (value))
1348 TREE_OVERFLOW (value) = 0;
1349 if (skip_evaluation == 0)
1350 warning ("floating point overflow in expression");
1352 else if (TREE_CODE (value) == VECTOR_CST && TREE_OVERFLOW (value))
1354 TREE_OVERFLOW (value) = 0;
1355 if (skip_evaluation == 0)
1356 warning ("vector overflow in expression");
1360 /* Print a warning if a large constant is truncated to unsigned,
1361 or if -Wconversion is used and a constant < 0 is converted to unsigned.
1362 Invoke this function on every expression that might be implicitly
1363 converted to an unsigned type. */
1366 unsigned_conversion_warning (result, operand)
1367 tree result, operand;
1369 tree type = TREE_TYPE (result);
1371 if (TREE_CODE (operand) == INTEGER_CST
1372 && TREE_CODE (type) == INTEGER_TYPE
1373 && TREE_UNSIGNED (type)
1374 && skip_evaluation == 0
1375 && !int_fits_type_p (operand, type))
1377 if (!int_fits_type_p (operand, c_common_signed_type (type)))
1378 /* This detects cases like converting -129 or 256 to unsigned char. */
1379 warning ("large integer implicitly truncated to unsigned type");
1380 else if (warn_conversion)
1381 warning ("negative integer implicitly converted to unsigned type");
1385 /* Nonzero if constant C has a value that is permissible
1386 for type TYPE (an INTEGER_TYPE). */
1389 constant_fits_type_p (c, type)
1392 if (TREE_CODE (c) == INTEGER_CST)
1393 return int_fits_type_p (c, type);
1395 c = convert (type, c);
1396 return !TREE_OVERFLOW (c);
1399 /* Convert EXPR to TYPE, warning about conversion problems with constants.
1400 Invoke this function on every expression that is converted implicitly,
1401 i.e. because of language rules and not because of an explicit cast. */
1404 convert_and_check (type, expr)
1407 tree t = convert (type, expr);
1408 if (TREE_CODE (t) == INTEGER_CST)
1410 if (TREE_OVERFLOW (t))
1412 TREE_OVERFLOW (t) = 0;
1414 /* Do not diagnose overflow in a constant expression merely
1415 because a conversion overflowed. */
1416 TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (expr);
1418 /* No warning for converting 0x80000000 to int. */
1419 if (!(TREE_UNSIGNED (type) < TREE_UNSIGNED (TREE_TYPE (expr))
1420 && TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
1421 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr))))
1422 /* If EXPR fits in the unsigned version of TYPE,
1423 don't warn unless pedantic. */
1425 || TREE_UNSIGNED (type)
1426 || ! constant_fits_type_p (expr,
1427 c_common_unsigned_type (type)))
1428 && skip_evaluation == 0)
1429 warning ("overflow in implicit constant conversion");
1432 unsigned_conversion_warning (t, expr);
1437 /* A node in a list that describes references to variables (EXPR), which are
1438 either read accesses if WRITER is zero, or write accesses, in which case
1439 WRITER is the parent of EXPR. */
1446 /* Used to implement a cache the results of a call to verify_tree. We only
1447 use this for SAVE_EXPRs. */
1450 struct tlist_cache *next;
1451 struct tlist *cache_before_sp;
1452 struct tlist *cache_after_sp;
1456 /* Obstack to use when allocating tlist structures, and corresponding
1458 static struct obstack tlist_obstack;
1459 static char *tlist_firstobj = 0;
1461 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
1463 static struct tlist *warned_ids;
1464 /* SAVE_EXPRs need special treatment. We process them only once and then
1465 cache the results. */
1466 static struct tlist_cache *save_expr_cache;
1468 static void add_tlist PARAMS ((struct tlist **, struct tlist *, tree, int));
1469 static void merge_tlist PARAMS ((struct tlist **, struct tlist *, int));
1470 static void verify_tree PARAMS ((tree, struct tlist **, struct tlist **, tree));
1471 static int warning_candidate_p PARAMS ((tree));
1472 static void warn_for_collisions PARAMS ((struct tlist *));
1473 static void warn_for_collisions_1 PARAMS ((tree, tree, struct tlist *, int));
1474 static struct tlist *new_tlist PARAMS ((struct tlist *, tree, tree));
1475 static void verify_sequence_points PARAMS ((tree));
1477 /* Create a new struct tlist and fill in its fields. */
1478 static struct tlist *
1479 new_tlist (next, t, writer)
1485 l = (struct tlist *) obstack_alloc (&tlist_obstack, sizeof *l);
1492 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
1493 is nonnull, we ignore any node we find which has a writer equal to it. */
1496 add_tlist (to, add, exclude_writer, copy)
1499 tree exclude_writer;
1504 struct tlist *next = add->next;
1507 if (! exclude_writer || add->writer != exclude_writer)
1508 *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
1513 /* Merge the nodes of ADD into TO. This merging process is done so that for
1514 each variable that already exists in TO, no new node is added; however if
1515 there is a write access recorded in ADD, and an occurrence on TO is only
1516 a read access, then the occurrence in TO will be modified to record the
1520 merge_tlist (to, add, copy)
1525 struct tlist **end = to;
1528 end = &(*end)->next;
1534 struct tlist *next = add->next;
1536 for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
1537 if (tmp2->expr == add->expr)
1541 tmp2->writer = add->writer;
1545 *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
1546 end = &(*end)->next;
1553 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
1554 references in list LIST conflict with it, excluding reads if ONLY writers
1558 warn_for_collisions_1 (written, writer, list, only_writes)
1559 tree written, writer;
1565 /* Avoid duplicate warnings. */
1566 for (tmp = warned_ids; tmp; tmp = tmp->next)
1567 if (tmp->expr == written)
1572 if (list->expr == written
1573 && list->writer != writer
1574 && (! only_writes || list->writer))
1576 warned_ids = new_tlist (warned_ids, written, NULL_TREE);
1577 warning ("operation on `%s' may be undefined",
1578 IDENTIFIER_POINTER (DECL_NAME (list->expr)));
1584 /* Given a list LIST of references to variables, find whether any of these
1585 can cause conflicts due to missing sequence points. */
1588 warn_for_collisions (list)
1593 for (tmp = list; tmp; tmp = tmp->next)
1596 warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
1600 /* Return nonzero if X is a tree that can be verified by the sequence point
1603 warning_candidate_p (x)
1606 return TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == PARM_DECL;
1609 /* Walk the tree X, and record accesses to variables. If X is written by the
1610 parent tree, WRITER is the parent.
1611 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
1612 expression or its only operand forces a sequence point, then everything up
1613 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
1615 Once we return, we will have emitted warnings if any subexpression before
1616 such a sequence point could be undefined. On a higher level, however, the
1617 sequence point may not be relevant, and we'll merge the two lists.
1619 Example: (b++, a) + b;
1620 The call that processes the COMPOUND_EXPR will store the increment of B
1621 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
1622 processes the PLUS_EXPR will need to merge the two lists so that
1623 eventually, all accesses end up on the same list (and we'll warn about the
1624 unordered subexpressions b++ and b.
1626 A note on merging. If we modify the former example so that our expression
1629 care must be taken not simply to add all three expressions into the final
1630 PNO_SP list. The function merge_tlist takes care of that by merging the
1631 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1632 way, so that no more than one access to B is recorded. */
1635 verify_tree (x, pbefore_sp, pno_sp, writer)
1637 struct tlist **pbefore_sp, **pno_sp;
1640 struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
1641 enum tree_code code;
1644 /* X may be NULL if it is the operand of an empty statement expression
1650 code = TREE_CODE (x);
1651 class = TREE_CODE_CLASS (code);
1653 if (warning_candidate_p (x))
1655 *pno_sp = new_tlist (*pno_sp, x, writer);
1665 case TRUTH_ANDIF_EXPR:
1666 case TRUTH_ORIF_EXPR:
1667 tmp_before = tmp_nosp = tmp_list3 = 0;
1668 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1669 warn_for_collisions (tmp_nosp);
1670 merge_tlist (pbefore_sp, tmp_before, 0);
1671 merge_tlist (pbefore_sp, tmp_nosp, 0);
1672 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
1673 merge_tlist (pbefore_sp, tmp_list3, 0);
1677 tmp_before = tmp_list2 = 0;
1678 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
1679 warn_for_collisions (tmp_list2);
1680 merge_tlist (pbefore_sp, tmp_before, 0);
1681 merge_tlist (pbefore_sp, tmp_list2, 1);
1683 tmp_list3 = tmp_nosp = 0;
1684 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
1685 warn_for_collisions (tmp_nosp);
1686 merge_tlist (pbefore_sp, tmp_list3, 0);
1688 tmp_list3 = tmp_list2 = 0;
1689 verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
1690 warn_for_collisions (tmp_list2);
1691 merge_tlist (pbefore_sp, tmp_list3, 0);
1692 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1693 two first, to avoid warning for (a ? b++ : b++). */
1694 merge_tlist (&tmp_nosp, tmp_list2, 0);
1695 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1698 case PREDECREMENT_EXPR:
1699 case PREINCREMENT_EXPR:
1700 case POSTDECREMENT_EXPR:
1701 case POSTINCREMENT_EXPR:
1702 verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
1706 tmp_before = tmp_nosp = tmp_list3 = 0;
1707 verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
1708 verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
1709 /* Expressions inside the LHS are not ordered wrt. the sequence points
1710 in the RHS. Example:
1712 Despite the fact that the modification of "a" is in the before_sp
1713 list (tmp_before), it conflicts with the use of "a" in the LHS.
1714 We can handle this by adding the contents of tmp_list3
1715 to those of tmp_before, and redoing the collision warnings for that
1717 add_tlist (&tmp_before, tmp_list3, x, 1);
1718 warn_for_collisions (tmp_before);
1719 /* Exclude the LHS itself here; we first have to merge it into the
1720 tmp_nosp list. This is done to avoid warning for "a = a"; if we
1721 didn't exclude the LHS, we'd get it twice, once as a read and once
1723 add_tlist (pno_sp, tmp_list3, x, 0);
1724 warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
1726 merge_tlist (pbefore_sp, tmp_before, 0);
1727 if (warning_candidate_p (TREE_OPERAND (x, 0)))
1728 merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
1729 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
1733 /* We need to warn about conflicts among arguments and conflicts between
1734 args and the function address. Side effects of the function address,
1735 however, are not ordered by the sequence point of the call. */
1736 tmp_before = tmp_nosp = tmp_list2 = tmp_list3 = 0;
1737 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1738 if (TREE_OPERAND (x, 1))
1739 verify_tree (TREE_OPERAND (x, 1), &tmp_list2, &tmp_list3, NULL_TREE);
1740 merge_tlist (&tmp_list3, tmp_list2, 0);
1741 add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
1742 add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
1743 warn_for_collisions (tmp_before);
1744 add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
1748 /* Scan all the list, e.g. indices of multi dimensional array. */
1751 tmp_before = tmp_nosp = 0;
1752 verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
1753 merge_tlist (&tmp_nosp, tmp_before, 0);
1754 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1761 struct tlist_cache *t;
1762 for (t = save_expr_cache; t; t = t->next)
1768 t = (struct tlist_cache *) obstack_alloc (&tlist_obstack,
1770 t->next = save_expr_cache;
1772 save_expr_cache = t;
1774 tmp_before = tmp_nosp = 0;
1775 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1776 warn_for_collisions (tmp_nosp);
1781 struct tlist *t = tmp_nosp;
1783 merge_tlist (&tmp_list3, t, 0);
1785 t->cache_before_sp = tmp_before;
1786 t->cache_after_sp = tmp_list3;
1788 merge_tlist (pbefore_sp, t->cache_before_sp, 1);
1789 add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
1798 if (first_rtl_op (code) == 0)
1800 x = TREE_OPERAND (x, 0);
1816 int max = first_rtl_op (TREE_CODE (x));
1817 for (lp = 0; lp < max; lp++)
1819 tmp_before = tmp_nosp = 0;
1820 verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, NULL_TREE);
1821 merge_tlist (&tmp_nosp, tmp_before, 0);
1822 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1829 /* Try to warn for undefined behavior in EXPR due to missing sequence
1833 verify_sequence_points (expr)
1836 struct tlist *before_sp = 0, *after_sp = 0;
1839 save_expr_cache = 0;
1840 if (tlist_firstobj == 0)
1842 gcc_obstack_init (&tlist_obstack);
1843 tlist_firstobj = obstack_alloc (&tlist_obstack, 0);
1846 verify_tree (expr, &before_sp, &after_sp, 0);
1847 warn_for_collisions (after_sp);
1848 obstack_free (&tlist_obstack, tlist_firstobj);
1852 c_expand_expr_stmt (expr)
1855 /* Do default conversion if safe and possibly important,
1856 in case within ({...}). */
1857 if ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE
1858 && (flag_isoc99 || lvalue_p (expr)))
1859 || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE)
1860 expr = default_conversion (expr);
1862 if (warn_sequence_point)
1863 verify_sequence_points (expr);
1865 if (TREE_TYPE (expr) != error_mark_node
1866 && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr))
1867 && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
1868 error ("expression statement has incomplete type");
1870 last_expr_type = TREE_TYPE (expr);
1871 return add_stmt (build_stmt (EXPR_STMT, expr));
1874 /* Validate the expression after `case' and apply default promotions. */
1877 check_case_value (value)
1880 if (value == NULL_TREE)
1883 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
1884 STRIP_TYPE_NOPS (value);
1885 /* In C++, the following is allowed:
1888 switch (...) { case i: ... }
1890 So, we try to reduce the VALUE to a constant that way. */
1891 if (c_language == clk_cplusplus)
1893 value = decl_constant_value (value);
1894 STRIP_TYPE_NOPS (value);
1895 value = fold (value);
1898 if (TREE_CODE (value) != INTEGER_CST
1899 && value != error_mark_node)
1901 error ("case label does not reduce to an integer constant");
1902 value = error_mark_node;
1905 /* Promote char or short to int. */
1906 value = default_conversion (value);
1908 constant_expression_warning (value);
1913 /* Return an integer type with BITS bits of precision,
1914 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1917 c_common_type_for_size (bits, unsignedp)
1921 if (bits == TYPE_PRECISION (integer_type_node))
1922 return unsignedp ? unsigned_type_node : integer_type_node;
1924 if (bits == TYPE_PRECISION (signed_char_type_node))
1925 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1927 if (bits == TYPE_PRECISION (short_integer_type_node))
1928 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1930 if (bits == TYPE_PRECISION (long_integer_type_node))
1931 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1933 if (bits == TYPE_PRECISION (long_long_integer_type_node))
1934 return (unsignedp ? long_long_unsigned_type_node
1935 : long_long_integer_type_node);
1937 if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
1938 return (unsignedp ? widest_unsigned_literal_type_node
1939 : widest_integer_literal_type_node);
1941 if (bits <= TYPE_PRECISION (intQI_type_node))
1942 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1944 if (bits <= TYPE_PRECISION (intHI_type_node))
1945 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1947 if (bits <= TYPE_PRECISION (intSI_type_node))
1948 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1950 if (bits <= TYPE_PRECISION (intDI_type_node))
1951 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1956 /* Return a data type that has machine mode MODE.
1957 If the mode is an integer,
1958 then UNSIGNEDP selects between signed and unsigned types. */
1961 c_common_type_for_mode (mode, unsignedp)
1962 enum machine_mode mode;
1965 if (mode == TYPE_MODE (integer_type_node))
1966 return unsignedp ? unsigned_type_node : integer_type_node;
1968 if (mode == TYPE_MODE (signed_char_type_node))
1969 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1971 if (mode == TYPE_MODE (short_integer_type_node))
1972 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1974 if (mode == TYPE_MODE (long_integer_type_node))
1975 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1977 if (mode == TYPE_MODE (long_long_integer_type_node))
1978 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
1980 if (mode == TYPE_MODE (widest_integer_literal_type_node))
1981 return unsignedp ? widest_unsigned_literal_type_node
1982 : widest_integer_literal_type_node;
1985 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1988 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1991 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1994 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1996 #if HOST_BITS_PER_WIDE_INT >= 64
1997 if (mode == TYPE_MODE (intTI_type_node))
1998 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2001 if (mode == TYPE_MODE (float_type_node))
2002 return float_type_node;
2004 if (mode == TYPE_MODE (double_type_node))
2005 return double_type_node;
2007 if (mode == TYPE_MODE (long_double_type_node))
2008 return long_double_type_node;
2010 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
2011 return build_pointer_type (char_type_node);
2013 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
2014 return build_pointer_type (integer_type_node);
2019 return unsignedp ? unsigned_V16QI_type_node : V16QI_type_node;
2021 return unsignedp ? unsigned_V8HI_type_node : V8HI_type_node;
2023 return unsignedp ? unsigned_V4SI_type_node : V4SI_type_node;
2025 return unsignedp ? unsigned_V2DI_type_node : V2DI_type_node;
2027 return unsignedp ? unsigned_V2SI_type_node : V2SI_type_node;
2029 return unsignedp ? unsigned_V4HI_type_node : V4HI_type_node;
2031 return unsignedp ? unsigned_V8QI_type_node : V8QI_type_node;
2033 return unsignedp ? unsigned_V1DI_type_node : V1DI_type_node;
2035 return V16SF_type_node;
2037 return V4SF_type_node;
2039 return V2SF_type_node;
2041 return V2DF_type_node;
2049 /* Return an unsigned type the same as TYPE in other respects. */
2051 c_common_unsigned_type (type)
2054 tree type1 = TYPE_MAIN_VARIANT (type);
2055 if (type1 == signed_char_type_node || type1 == char_type_node)
2056 return unsigned_char_type_node;
2057 if (type1 == integer_type_node)
2058 return unsigned_type_node;
2059 if (type1 == short_integer_type_node)
2060 return short_unsigned_type_node;
2061 if (type1 == long_integer_type_node)
2062 return long_unsigned_type_node;
2063 if (type1 == long_long_integer_type_node)
2064 return long_long_unsigned_type_node;
2065 if (type1 == widest_integer_literal_type_node)
2066 return widest_unsigned_literal_type_node;
2067 #if HOST_BITS_PER_WIDE_INT >= 64
2068 if (type1 == intTI_type_node)
2069 return unsigned_intTI_type_node;
2071 if (type1 == intDI_type_node)
2072 return unsigned_intDI_type_node;
2073 if (type1 == intSI_type_node)
2074 return unsigned_intSI_type_node;
2075 if (type1 == intHI_type_node)
2076 return unsigned_intHI_type_node;
2077 if (type1 == intQI_type_node)
2078 return unsigned_intQI_type_node;
2080 return c_common_signed_or_unsigned_type (1, type);
2083 /* Return a signed type the same as TYPE in other respects. */
2086 c_common_signed_type (type)
2089 tree type1 = TYPE_MAIN_VARIANT (type);
2090 if (type1 == unsigned_char_type_node || type1 == char_type_node)
2091 return signed_char_type_node;
2092 if (type1 == unsigned_type_node)
2093 return integer_type_node;
2094 if (type1 == short_unsigned_type_node)
2095 return short_integer_type_node;
2096 if (type1 == long_unsigned_type_node)
2097 return long_integer_type_node;
2098 if (type1 == long_long_unsigned_type_node)
2099 return long_long_integer_type_node;
2100 if (type1 == widest_unsigned_literal_type_node)
2101 return widest_integer_literal_type_node;
2102 #if HOST_BITS_PER_WIDE_INT >= 64
2103 if (type1 == unsigned_intTI_type_node)
2104 return intTI_type_node;
2106 if (type1 == unsigned_intDI_type_node)
2107 return intDI_type_node;
2108 if (type1 == unsigned_intSI_type_node)
2109 return intSI_type_node;
2110 if (type1 == unsigned_intHI_type_node)
2111 return intHI_type_node;
2112 if (type1 == unsigned_intQI_type_node)
2113 return intQI_type_node;
2115 return c_common_signed_or_unsigned_type (0, type);
2118 /* Return a type the same as TYPE except unsigned or
2119 signed according to UNSIGNEDP. */
2122 c_common_signed_or_unsigned_type (unsignedp, type)
2126 if (! INTEGRAL_TYPE_P (type)
2127 || TREE_UNSIGNED (type) == unsignedp)
2130 if (TYPE_PRECISION (type) == TYPE_PRECISION (signed_char_type_node))
2131 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2132 if (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
2133 return unsignedp ? unsigned_type_node : integer_type_node;
2134 if (TYPE_PRECISION (type) == TYPE_PRECISION (short_integer_type_node))
2135 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2136 if (TYPE_PRECISION (type) == TYPE_PRECISION (long_integer_type_node))
2137 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2138 if (TYPE_PRECISION (type) == TYPE_PRECISION (long_long_integer_type_node))
2139 return (unsignedp ? long_long_unsigned_type_node
2140 : long_long_integer_type_node);
2141 if (TYPE_PRECISION (type) == TYPE_PRECISION (widest_integer_literal_type_node))
2142 return (unsignedp ? widest_unsigned_literal_type_node
2143 : widest_integer_literal_type_node);
2145 #if HOST_BITS_PER_WIDE_INT >= 64
2146 if (TYPE_PRECISION (type) == TYPE_PRECISION (intTI_type_node))
2147 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2149 if (TYPE_PRECISION (type) == TYPE_PRECISION (intDI_type_node))
2150 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2151 if (TYPE_PRECISION (type) == TYPE_PRECISION (intSI_type_node))
2152 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2153 if (TYPE_PRECISION (type) == TYPE_PRECISION (intHI_type_node))
2154 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2155 if (TYPE_PRECISION (type) == TYPE_PRECISION (intQI_type_node))
2156 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2161 /* Return the minimum number of bits needed to represent VALUE in a
2162 signed or unsigned type, UNSIGNEDP says which. */
2165 min_precision (value, unsignedp)
2171 /* If the value is negative, compute its negative minus 1. The latter
2172 adjustment is because the absolute value of the largest negative value
2173 is one larger than the largest positive value. This is equivalent to
2174 a bit-wise negation, so use that operation instead. */
2176 if (tree_int_cst_sgn (value) < 0)
2177 value = fold (build1 (BIT_NOT_EXPR, TREE_TYPE (value), value));
2179 /* Return the number of bits needed, taking into account the fact
2180 that we need one more bit for a signed than unsigned type. */
2182 if (integer_zerop (value))
2185 log = tree_floor_log2 (value);
2187 return log + 1 + ! unsignedp;
2190 /* Print an error message for invalid operands to arith operation
2191 CODE. NOP_EXPR is used as a special case (see
2192 c_common_truthvalue_conversion). */
2195 binary_op_error (code)
2196 enum tree_code code;
2203 error ("invalid truth-value expression");
2207 opname = "+"; break;
2209 opname = "-"; break;
2211 opname = "*"; break;
2213 opname = "max"; break;
2215 opname = "min"; break;
2217 opname = "=="; break;
2219 opname = "!="; break;
2221 opname = "<="; break;
2223 opname = ">="; break;
2225 opname = "<"; break;
2227 opname = ">"; break;
2229 opname = "<<"; break;
2231 opname = ">>"; break;
2232 case TRUNC_MOD_EXPR:
2233 case FLOOR_MOD_EXPR:
2234 opname = "%"; break;
2235 case TRUNC_DIV_EXPR:
2236 case FLOOR_DIV_EXPR:
2237 opname = "/"; break;
2239 opname = "&"; break;
2241 opname = "|"; break;
2242 case TRUTH_ANDIF_EXPR:
2243 opname = "&&"; break;
2244 case TRUTH_ORIF_EXPR:
2245 opname = "||"; break;
2247 opname = "^"; break;
2250 opname = "rotate"; break;
2252 opname = "unknown"; break;
2254 error ("invalid operands to binary %s", opname);
2257 /* Subroutine of build_binary_op, used for comparison operations.
2258 See if the operands have both been converted from subword integer types
2259 and, if so, perhaps change them both back to their original type.
2260 This function is also responsible for converting the two operands
2261 to the proper common type for comparison.
2263 The arguments of this function are all pointers to local variables
2264 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2265 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2267 If this function returns nonzero, it means that the comparison has
2268 a constant value. What this function returns is an expression for
2272 shorten_compare (op0_ptr, op1_ptr, restype_ptr, rescode_ptr)
2273 tree *op0_ptr, *op1_ptr;
2275 enum tree_code *rescode_ptr;
2278 tree op0 = *op0_ptr;
2279 tree op1 = *op1_ptr;
2280 int unsignedp0, unsignedp1;
2282 tree primop0, primop1;
2283 enum tree_code code = *rescode_ptr;
2285 /* Throw away any conversions to wider types
2286 already present in the operands. */
2288 primop0 = get_narrower (op0, &unsignedp0);
2289 primop1 = get_narrower (op1, &unsignedp1);
2291 /* Handle the case that OP0 does not *contain* a conversion
2292 but it *requires* conversion to FINAL_TYPE. */
2294 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
2295 unsignedp0 = TREE_UNSIGNED (TREE_TYPE (op0));
2296 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
2297 unsignedp1 = TREE_UNSIGNED (TREE_TYPE (op1));
2299 /* If one of the operands must be floated, we cannot optimize. */
2300 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
2301 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
2303 /* If first arg is constant, swap the args (changing operation
2304 so value is preserved), for canonicalization. Don't do this if
2305 the second arg is 0. */
2307 if (TREE_CONSTANT (primop0)
2308 && ! integer_zerop (primop1) && ! real_zerop (primop1))
2311 int temi = unsignedp0;
2319 unsignedp0 = unsignedp1;
2342 *rescode_ptr = code;
2345 /* If comparing an integer against a constant more bits wide,
2346 maybe we can deduce a value of 1 or 0 independent of the data.
2347 Or else truncate the constant now
2348 rather than extend the variable at run time.
2350 This is only interesting if the constant is the wider arg.
2351 Also, it is not safe if the constant is unsigned and the
2352 variable arg is signed, since in this case the variable
2353 would be sign-extended and then regarded as unsigned.
2354 Our technique fails in this case because the lowest/highest
2355 possible unsigned results don't follow naturally from the
2356 lowest/highest possible values of the variable operand.
2357 For just EQ_EXPR and NE_EXPR there is another technique that
2358 could be used: see if the constant can be faithfully represented
2359 in the other operand's type, by truncating it and reextending it
2360 and see if that preserves the constant's value. */
2362 if (!real1 && !real2
2363 && TREE_CODE (primop1) == INTEGER_CST
2364 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
2366 int min_gt, max_gt, min_lt, max_lt;
2367 tree maxval, minval;
2368 /* 1 if comparison is nominally unsigned. */
2369 int unsignedp = TREE_UNSIGNED (*restype_ptr);
2372 type = c_common_signed_or_unsigned_type (unsignedp0,
2373 TREE_TYPE (primop0));
2375 /* If TYPE is an enumeration, then we need to get its min/max
2376 values from it's underlying integral type, not the enumerated
2378 if (TREE_CODE (type) == ENUMERAL_TYPE)
2379 type = c_common_type_for_size (TYPE_PRECISION (type), unsignedp0);
2381 maxval = TYPE_MAX_VALUE (type);
2382 minval = TYPE_MIN_VALUE (type);
2384 if (unsignedp && !unsignedp0)
2385 *restype_ptr = c_common_signed_type (*restype_ptr);
2387 if (TREE_TYPE (primop1) != *restype_ptr)
2388 primop1 = convert (*restype_ptr, primop1);
2389 if (type != *restype_ptr)
2391 minval = convert (*restype_ptr, minval);
2392 maxval = convert (*restype_ptr, maxval);
2395 if (unsignedp && unsignedp0)
2397 min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
2398 max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
2399 min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
2400 max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
2404 min_gt = INT_CST_LT (primop1, minval);
2405 max_gt = INT_CST_LT (primop1, maxval);
2406 min_lt = INT_CST_LT (minval, primop1);
2407 max_lt = INT_CST_LT (maxval, primop1);
2411 /* This used to be a switch, but Genix compiler can't handle that. */
2412 if (code == NE_EXPR)
2414 if (max_lt || min_gt)
2415 val = boolean_true_node;
2417 else if (code == EQ_EXPR)
2419 if (max_lt || min_gt)
2420 val = boolean_false_node;
2422 else if (code == LT_EXPR)
2425 val = boolean_true_node;
2427 val = boolean_false_node;
2429 else if (code == GT_EXPR)
2432 val = boolean_true_node;
2434 val = boolean_false_node;
2436 else if (code == LE_EXPR)
2439 val = boolean_true_node;
2441 val = boolean_false_node;
2443 else if (code == GE_EXPR)
2446 val = boolean_true_node;
2448 val = boolean_false_node;
2451 /* If primop0 was sign-extended and unsigned comparison specd,
2452 we did a signed comparison above using the signed type bounds.
2453 But the comparison we output must be unsigned.
2455 Also, for inequalities, VAL is no good; but if the signed
2456 comparison had *any* fixed result, it follows that the
2457 unsigned comparison just tests the sign in reverse
2458 (positive values are LE, negative ones GE).
2459 So we can generate an unsigned comparison
2460 against an extreme value of the signed type. */
2462 if (unsignedp && !unsignedp0)
2469 primop1 = TYPE_MIN_VALUE (type);
2475 primop1 = TYPE_MAX_VALUE (type);
2482 type = c_common_unsigned_type (type);
2485 if (TREE_CODE (primop0) != INTEGER_CST)
2487 if (val == boolean_false_node)
2488 warning ("comparison is always false due to limited range of data type");
2489 if (val == boolean_true_node)
2490 warning ("comparison is always true due to limited range of data type");
2495 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2496 if (TREE_SIDE_EFFECTS (primop0))
2497 return build (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
2501 /* Value is not predetermined, but do the comparison
2502 in the type of the operand that is not constant.
2503 TYPE is already properly set. */
2505 else if (real1 && real2
2506 && (TYPE_PRECISION (TREE_TYPE (primop0))
2507 == TYPE_PRECISION (TREE_TYPE (primop1))))
2508 type = TREE_TYPE (primop0);
2510 /* If args' natural types are both narrower than nominal type
2511 and both extend in the same manner, compare them
2512 in the type of the wider arg.
2513 Otherwise must actually extend both to the nominal
2514 common type lest different ways of extending
2516 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
2518 else if (unsignedp0 == unsignedp1 && real1 == real2
2519 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
2520 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
2522 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2523 type = c_common_signed_or_unsigned_type (unsignedp0
2524 || TREE_UNSIGNED (*restype_ptr),
2526 /* Make sure shorter operand is extended the right way
2527 to match the longer operand. */
2529 = convert (c_common_signed_or_unsigned_type (unsignedp0,
2530 TREE_TYPE (primop0)),
2533 = convert (c_common_signed_or_unsigned_type (unsignedp1,
2534 TREE_TYPE (primop1)),
2539 /* Here we must do the comparison on the nominal type
2540 using the args exactly as we received them. */
2541 type = *restype_ptr;
2545 if (!real1 && !real2 && integer_zerop (primop1)
2546 && TREE_UNSIGNED (*restype_ptr))
2552 /* All unsigned values are >= 0, so we warn if extra warnings
2553 are requested. However, if OP0 is a constant that is
2554 >= 0, the signedness of the comparison isn't an issue,
2555 so suppress the warning. */
2556 if (extra_warnings && !in_system_header
2557 && ! (TREE_CODE (primop0) == INTEGER_CST
2558 && ! TREE_OVERFLOW (convert (c_common_signed_type (type),
2560 warning ("comparison of unsigned expression >= 0 is always true");
2561 value = boolean_true_node;
2565 if (extra_warnings && !in_system_header
2566 && ! (TREE_CODE (primop0) == INTEGER_CST
2567 && ! TREE_OVERFLOW (convert (c_common_signed_type (type),
2569 warning ("comparison of unsigned expression < 0 is always false");
2570 value = boolean_false_node;
2579 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2580 if (TREE_SIDE_EFFECTS (primop0))
2581 return build (COMPOUND_EXPR, TREE_TYPE (value),
2588 *op0_ptr = convert (type, primop0);
2589 *op1_ptr = convert (type, primop1);
2591 *restype_ptr = boolean_type_node;
2596 /* Return a tree for the sum or difference (RESULTCODE says which)
2597 of pointer PTROP and integer INTOP. */
2600 pointer_int_sum (resultcode, ptrop, intop)
2601 enum tree_code resultcode;
2609 /* The result is a pointer of the same type that is being added. */
2611 tree result_type = TREE_TYPE (ptrop);
2613 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
2615 if (pedantic || warn_pointer_arith)
2616 pedwarn ("pointer of type `void *' used in arithmetic");
2617 size_exp = integer_one_node;
2619 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
2621 if (pedantic || warn_pointer_arith)
2622 pedwarn ("pointer to a function used in arithmetic");
2623 size_exp = integer_one_node;
2625 else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
2627 if (pedantic || warn_pointer_arith)
2628 pedwarn ("pointer to member function used in arithmetic");
2629 size_exp = integer_one_node;
2631 else if (TREE_CODE (TREE_TYPE (result_type)) == OFFSET_TYPE)
2633 if (pedantic || warn_pointer_arith)
2634 pedwarn ("pointer to a member used in arithmetic");
2635 size_exp = integer_one_node;
2638 size_exp = size_in_bytes (TREE_TYPE (result_type));
2640 /* If what we are about to multiply by the size of the elements
2641 contains a constant term, apply distributive law
2642 and multiply that constant term separately.
2643 This helps produce common subexpressions. */
2645 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
2646 && ! TREE_CONSTANT (intop)
2647 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
2648 && TREE_CONSTANT (size_exp)
2649 /* If the constant comes from pointer subtraction,
2650 skip this optimization--it would cause an error. */
2651 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
2652 /* If the constant is unsigned, and smaller than the pointer size,
2653 then we must skip this optimization. This is because it could cause
2654 an overflow error if the constant is negative but INTOP is not. */
2655 && (! TREE_UNSIGNED (TREE_TYPE (intop))
2656 || (TYPE_PRECISION (TREE_TYPE (intop))
2657 == TYPE_PRECISION (TREE_TYPE (ptrop)))))
2659 enum tree_code subcode = resultcode;
2660 tree int_type = TREE_TYPE (intop);
2661 if (TREE_CODE (intop) == MINUS_EXPR)
2662 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
2663 /* Convert both subexpression types to the type of intop,
2664 because weird cases involving pointer arithmetic
2665 can result in a sum or difference with different type args. */
2666 ptrop = build_binary_op (subcode, ptrop,
2667 convert (int_type, TREE_OPERAND (intop, 1)), 1);
2668 intop = convert (int_type, TREE_OPERAND (intop, 0));
2671 /* Convert the integer argument to a type the same size as sizetype
2672 so the multiply won't overflow spuriously. */
2674 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
2675 || TREE_UNSIGNED (TREE_TYPE (intop)) != TREE_UNSIGNED (sizetype))
2676 intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
2677 TREE_UNSIGNED (sizetype)), intop);
2679 /* Replace the integer argument with a suitable product by the object size.
2680 Do this multiplication as signed, then convert to the appropriate
2681 pointer type (actually unsigned integral). */
2683 intop = convert (result_type,
2684 build_binary_op (MULT_EXPR, intop,
2685 convert (TREE_TYPE (intop), size_exp), 1));
2687 /* Create the sum or difference. */
2689 result = build (resultcode, result_type, ptrop, intop);
2691 folded = fold (result);
2692 if (folded == result)
2693 TREE_CONSTANT (folded) = TREE_CONSTANT (ptrop) & TREE_CONSTANT (intop);
2697 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2698 or validate its data type for an `if' or `while' statement or ?..: exp.
2700 This preparation consists of taking the ordinary
2701 representation of an expression expr and producing a valid tree
2702 boolean expression describing whether expr is nonzero. We could
2703 simply always do build_binary_op (NE_EXPR, expr, boolean_false_node, 1),
2704 but we optimize comparisons, &&, ||, and !.
2706 The resulting type should always be `boolean_type_node'. */
2709 c_common_truthvalue_conversion (expr)
2712 if (TREE_CODE (expr) == ERROR_MARK)
2715 #if 0 /* This appears to be wrong for C++. */
2716 /* These really should return error_mark_node after 2.4 is stable.
2717 But not all callers handle ERROR_MARK properly. */
2718 switch (TREE_CODE (TREE_TYPE (expr)))
2721 error ("struct type value used where scalar is required");
2722 return boolean_false_node;
2725 error ("union type value used where scalar is required");
2726 return boolean_false_node;
2729 error ("array type value used where scalar is required");
2730 return boolean_false_node;
2737 switch (TREE_CODE (expr))
2740 case NE_EXPR: case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
2741 case TRUTH_ANDIF_EXPR:
2742 case TRUTH_ORIF_EXPR:
2743 case TRUTH_AND_EXPR:
2745 case TRUTH_XOR_EXPR:
2746 case TRUTH_NOT_EXPR:
2747 TREE_TYPE (expr) = boolean_type_node;
2754 return integer_zerop (expr) ? boolean_false_node : boolean_true_node;
2757 return real_zerop (expr) ? boolean_false_node : boolean_true_node;
2760 /* If we are taking the address of an external decl, it might be zero
2761 if it is weak, so we cannot optimize. */
2762 if (DECL_P (TREE_OPERAND (expr, 0))
2763 && DECL_EXTERNAL (TREE_OPERAND (expr, 0)))
2766 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 0)))
2767 return build (COMPOUND_EXPR, boolean_type_node,
2768 TREE_OPERAND (expr, 0), boolean_true_node);
2770 return boolean_true_node;
2773 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
2774 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2775 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)),
2776 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2783 /* These don't change whether an object is nonzero or zero. */
2784 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2788 /* These don't change whether an object is zero or nonzero, but
2789 we can't ignore them if their second arg has side-effects. */
2790 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2791 return build (COMPOUND_EXPR, boolean_type_node, TREE_OPERAND (expr, 1),
2792 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)));
2794 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2797 /* Distribute the conversion into the arms of a COND_EXPR. */
2798 return fold (build (COND_EXPR, boolean_type_node, TREE_OPERAND (expr, 0),
2799 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2800 c_common_truthvalue_conversion (TREE_OPERAND (expr, 2))));
2803 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2804 since that affects how `default_conversion' will behave. */
2805 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
2806 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2808 /* fall through... */
2810 /* If this is widening the argument, we can ignore it. */
2811 if (TYPE_PRECISION (TREE_TYPE (expr))
2812 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2813 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2817 /* Perhaps reduce (x - y) != 0 to (x != y). The expressions
2818 aren't guaranteed to the be same for modes that can represent
2819 infinity, since if x and y are both +infinity, or both
2820 -infinity, then x - y is not a number.
2822 Note that this transformation is safe when x or y is NaN.
2823 (x - y) is then NaN, and both (x - y) != 0 and x != y will
2825 if (HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr, 0)))))
2827 /* fall through... */
2829 /* This and MINUS_EXPR can be changed into a comparison of the
2831 if (TREE_TYPE (TREE_OPERAND (expr, 0))
2832 == TREE_TYPE (TREE_OPERAND (expr, 1)))
2833 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2834 TREE_OPERAND (expr, 1), 1);
2835 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2836 fold (build1 (NOP_EXPR,
2837 TREE_TYPE (TREE_OPERAND (expr, 0)),
2838 TREE_OPERAND (expr, 1))), 1);
2841 if (integer_onep (TREE_OPERAND (expr, 1))
2842 && TREE_TYPE (expr) != boolean_type_node)
2843 /* Using convert here would cause infinite recursion. */
2844 return build1 (NOP_EXPR, boolean_type_node, expr);
2848 if (warn_parentheses && C_EXP_ORIGINAL_CODE (expr) == MODIFY_EXPR)
2849 warning ("suggest parentheses around assignment used as truth value");
2856 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
2858 tree t = save_expr (expr);
2859 return (build_binary_op
2860 ((TREE_SIDE_EFFECTS (expr)
2861 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2862 c_common_truthvalue_conversion (build_unary_op (REALPART_EXPR, t, 0)),
2863 c_common_truthvalue_conversion (build_unary_op (IMAGPART_EXPR, t, 0)),
2867 return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
2870 static tree builtin_function_2 PARAMS ((const char *, const char *, tree, tree,
2871 int, enum built_in_class, int, int,
2874 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2875 down to the element type of an array. */
2878 c_build_qualified_type (type, type_quals)
2882 /* A restrict-qualified pointer type must be a pointer to object or
2883 incomplete type. Note that the use of POINTER_TYPE_P also allows
2884 REFERENCE_TYPEs, which is appropriate for C++. Unfortunately,
2885 the C++ front-end also use POINTER_TYPE for pointer-to-member
2886 values, so even though it should be illegal to use `restrict'
2887 with such an entity we don't flag that here. Thus, special case
2888 code for that case is required in the C++ front-end. */
2889 if ((type_quals & TYPE_QUAL_RESTRICT)
2890 && (!POINTER_TYPE_P (type)
2891 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
2893 error ("invalid use of `restrict'");
2894 type_quals &= ~TYPE_QUAL_RESTRICT;
2897 if (TREE_CODE (type) == ARRAY_TYPE)
2898 return build_array_type (c_build_qualified_type (TREE_TYPE (type),
2900 TYPE_DOMAIN (type));
2901 return build_qualified_type (type, type_quals);
2904 /* Apply the TYPE_QUALS to the new DECL. */
2907 c_apply_type_quals_to_decl (type_quals, decl)
2911 if ((type_quals & TYPE_QUAL_CONST)
2912 || (TREE_TYPE (decl)
2913 && TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE))
2914 TREE_READONLY (decl) = 1;
2915 if (type_quals & TYPE_QUAL_VOLATILE)
2917 TREE_SIDE_EFFECTS (decl) = 1;
2918 TREE_THIS_VOLATILE (decl) = 1;
2920 if (type_quals & TYPE_QUAL_RESTRICT)
2922 if (!TREE_TYPE (decl)
2923 || !POINTER_TYPE_P (TREE_TYPE (decl))
2924 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (TREE_TYPE (decl))))
2925 error ("invalid use of `restrict'");
2926 else if (flag_strict_aliasing)
2927 /* Indicate we need to make a unique alias set for this pointer.
2928 We can't do it here because it might be pointing to an
2930 DECL_POINTER_ALIAS_SET (decl) = -2;
2934 /* Return the typed-based alias set for T, which may be an expression
2935 or a type. Return -1 if we don't do anything special. */
2938 c_common_get_alias_set (t)
2943 /* Permit type-punning when accessing a union, provided the access
2944 is directly through the union. For example, this code does not
2945 permit taking the address of a union member and then storing
2946 through it. Even the type-punning allowed here is a GCC
2947 extension, albeit a common and useful one; the C standard says
2948 that such accesses have implementation-defined behavior. */
2950 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
2951 u = TREE_OPERAND (u, 0))
2952 if (TREE_CODE (u) == COMPONENT_REF
2953 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
2956 /* That's all the expressions we handle specially. */
2960 /* The C standard guarantess that any object may be accessed via an
2961 lvalue that has character type. */
2962 if (t == char_type_node
2963 || t == signed_char_type_node
2964 || t == unsigned_char_type_node)
2967 /* If it has the may_alias attribute, it can alias anything. */
2968 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (t)))
2971 /* The C standard specifically allows aliasing between signed and
2972 unsigned variants of the same type. We treat the signed
2973 variant as canonical. */
2974 if (TREE_CODE (t) == INTEGER_TYPE && TREE_UNSIGNED (t))
2976 tree t1 = c_common_signed_type (t);
2978 /* t1 == t can happen for boolean nodes which are always unsigned. */
2980 return get_alias_set (t1);
2982 else if (POINTER_TYPE_P (t))
2986 /* Unfortunately, there is no canonical form of a pointer type.
2987 In particular, if we have `typedef int I', then `int *', and
2988 `I *' are different types. So, we have to pick a canonical
2989 representative. We do this below.
2991 Technically, this approach is actually more conservative that
2992 it needs to be. In particular, `const int *' and `int *'
2993 should be in different alias sets, according to the C and C++
2994 standard, since their types are not the same, and so,
2995 technically, an `int **' and `const int **' cannot point at
2998 But, the standard is wrong. In particular, this code is
3003 const int* const* cipp = &ipp;
3005 And, it doesn't make sense for that to be legal unless you
3006 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
3007 the pointed-to types. This issue has been reported to the
3009 t1 = build_type_no_quals (t);
3011 return get_alias_set (t1);
3017 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
3018 second parameter indicates which OPERATOR is being applied. The COMPLAIN
3019 flag controls whether we should diagnose possibly ill-formed
3020 constructs or not. */
3022 c_sizeof_or_alignof_type (type, op, complain)
3027 const char *op_name;
3029 enum tree_code type_code = TREE_CODE (type);
3031 my_friendly_assert (op == SIZEOF_EXPR || op == ALIGNOF_EXPR, 20020720);
3032 op_name = op == SIZEOF_EXPR ? "sizeof" : "__alignof__";
3034 if (type_code == FUNCTION_TYPE)
3036 if (op == SIZEOF_EXPR)
3038 if (complain && (pedantic || warn_pointer_arith))
3039 pedwarn ("invalid application of `sizeof' to a function type");
3040 value = size_one_node;
3043 value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
3045 else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
3047 if (type_code == VOID_TYPE
3048 && complain && (pedantic || warn_pointer_arith))
3049 pedwarn ("invalid application of `%s' to a void type", op_name);
3050 value = size_one_node;
3052 else if (!COMPLETE_TYPE_P (type))
3055 error ("invalid application of `%s' to an incomplete type", op_name);
3056 value = size_zero_node;
3060 if (op == SIZEOF_EXPR)
3061 /* Convert in case a char is more than one unit. */
3062 value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
3063 size_int (TYPE_PRECISION (char_type_node)
3066 value = size_int (TYPE_ALIGN (type) / BITS_PER_UNIT);
3069 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
3070 TYPE_IS_SIZETYPE means that certain things (like overflow) will
3071 never happen. However, this node should really have type
3072 `size_t', which is just a typedef for an ordinary integer type. */
3073 value = fold (build1 (NOP_EXPR, c_size_type_node, value));
3074 my_friendly_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)), 20001021);
3079 /* Implement the __alignof keyword: Return the minimum required
3080 alignment of EXPR, measured in bytes. For VAR_DECL's and
3081 FIELD_DECL's return DECL_ALIGN (which can be set from an
3082 "aligned" __attribute__ specification). */
3085 c_alignof_expr (expr)
3090 if (TREE_CODE (expr) == VAR_DECL)
3091 t = size_int (DECL_ALIGN (expr) / BITS_PER_UNIT);
3093 else if (TREE_CODE (expr) == COMPONENT_REF
3094 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
3096 error ("`__alignof' applied to a bit-field");
3099 else if (TREE_CODE (expr) == COMPONENT_REF
3100 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
3101 t = size_int (DECL_ALIGN (TREE_OPERAND (expr, 1)) / BITS_PER_UNIT);
3103 else if (TREE_CODE (expr) == INDIRECT_REF)
3105 tree t = TREE_OPERAND (expr, 0);
3107 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3109 while (TREE_CODE (t) == NOP_EXPR
3110 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
3114 t = TREE_OPERAND (t, 0);
3115 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3116 if (thisalign > bestalign)
3117 best = t, bestalign = thisalign;
3119 return c_alignof (TREE_TYPE (TREE_TYPE (best)));
3122 return c_alignof (TREE_TYPE (expr));
3124 return fold (build1 (NOP_EXPR, c_size_type_node, t));
3127 /* Handle C and C++ default attributes. */
3129 enum built_in_attribute
3131 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
3132 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
3133 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
3134 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
3135 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No entry needed in enum. */
3136 #include "builtin-attrs.def"
3137 #undef DEF_ATTR_NULL_TREE
3139 #undef DEF_ATTR_IDENT
3140 #undef DEF_ATTR_TREE_LIST
3145 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
3147 static bool c_attrs_initialized = false;
3149 static void c_init_attributes PARAMS ((void));
3151 /* Build tree nodes and builtin functions common to both C and C++ language
3155 c_common_nodes_and_builtins ()
3159 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
3160 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
3161 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
3162 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
3163 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3164 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3165 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
3166 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
3167 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
3168 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
3169 #include "builtin-types.def"
3170 #undef DEF_PRIMITIVE_TYPE
3171 #undef DEF_FUNCTION_TYPE_0
3172 #undef DEF_FUNCTION_TYPE_1
3173 #undef DEF_FUNCTION_TYPE_2
3174 #undef DEF_FUNCTION_TYPE_3
3175 #undef DEF_FUNCTION_TYPE_4
3176 #undef DEF_FUNCTION_TYPE_VAR_0
3177 #undef DEF_FUNCTION_TYPE_VAR_1
3178 #undef DEF_FUNCTION_TYPE_VAR_2
3179 #undef DEF_POINTER_TYPE
3183 typedef enum builtin_type builtin_type;
3185 tree builtin_types[(int) BT_LAST];
3186 int wchar_type_size;
3187 tree array_domain_type;
3188 tree va_list_ref_type_node;
3189 tree va_list_arg_type_node;
3191 /* Define `int' and `char' first so that dbx will output them first. */
3192 record_builtin_type (RID_INT, NULL, integer_type_node);
3193 record_builtin_type (RID_CHAR, "char", char_type_node);
3195 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
3196 "unsigned long", "long long unsigned" and "unsigned short" were in C++
3197 but not C. Are the conditionals here needed? */
3198 if (c_language == clk_cplusplus)
3199 record_builtin_type (RID_SIGNED, NULL, integer_type_node);
3200 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
3201 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
3202 record_builtin_type (RID_MAX, "long unsigned int",
3203 long_unsigned_type_node);
3204 if (c_language == clk_cplusplus)
3205 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
3206 record_builtin_type (RID_MAX, "long long int",
3207 long_long_integer_type_node);
3208 record_builtin_type (RID_MAX, "long long unsigned int",
3209 long_long_unsigned_type_node);
3210 if (c_language == clk_cplusplus)
3211 record_builtin_type (RID_MAX, "long long unsigned",
3212 long_long_unsigned_type_node);
3213 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
3214 record_builtin_type (RID_MAX, "short unsigned int",
3215 short_unsigned_type_node);
3216 if (c_language == clk_cplusplus)
3217 record_builtin_type (RID_MAX, "unsigned short",
3218 short_unsigned_type_node);
3220 /* Define both `signed char' and `unsigned char'. */
3221 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
3222 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
3224 /* These are types that c_common_type_for_size and
3225 c_common_type_for_mode use. */
3226 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3228 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3230 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3232 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3234 #if HOST_BITS_PER_WIDE_INT >= 64
3235 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3236 get_identifier ("__int128_t"),
3239 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3240 unsigned_intQI_type_node));
3241 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3242 unsigned_intHI_type_node));
3243 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3244 unsigned_intSI_type_node));
3245 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3246 unsigned_intDI_type_node));
3247 #if HOST_BITS_PER_WIDE_INT >= 64
3248 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3249 get_identifier ("__uint128_t"),
3250 unsigned_intTI_type_node));
3253 /* Create the widest literal types. */
3254 widest_integer_literal_type_node
3255 = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
3256 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3257 widest_integer_literal_type_node));
3259 widest_unsigned_literal_type_node
3260 = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
3261 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3262 widest_unsigned_literal_type_node));
3264 /* `unsigned long' is the standard type for sizeof.
3265 Note that stddef.h uses `unsigned long',
3266 and this must agree, even if long and int are the same size. */
3268 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
3269 signed_size_type_node = c_common_signed_type (c_size_type_node);
3270 set_sizetype (c_size_type_node);
3272 build_common_tree_nodes_2 (flag_short_double);
3274 record_builtin_type (RID_FLOAT, NULL, float_type_node);
3275 record_builtin_type (RID_DOUBLE, NULL, double_type_node);
3276 record_builtin_type (RID_MAX, "long double", long_double_type_node);
3278 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3279 get_identifier ("complex int"),
3280 complex_integer_type_node));
3281 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3282 get_identifier ("complex float"),
3283 complex_float_type_node));
3284 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3285 get_identifier ("complex double"),
3286 complex_double_type_node));
3287 (*lang_hooks.decls.pushdecl)
3288 (build_decl (TYPE_DECL, get_identifier ("complex long double"),
3289 complex_long_double_type_node));
3291 /* Types which are common to the fortran compiler and libf2c. When
3292 changing these, you also need to be concerned with f/com.h. */
3294 if (TYPE_PRECISION (float_type_node)
3295 == TYPE_PRECISION (long_integer_type_node))
3297 g77_integer_type_node = long_integer_type_node;
3298 g77_uinteger_type_node = long_unsigned_type_node;
3300 else if (TYPE_PRECISION (float_type_node)
3301 == TYPE_PRECISION (integer_type_node))
3303 g77_integer_type_node = integer_type_node;
3304 g77_uinteger_type_node = unsigned_type_node;
3307 g77_integer_type_node = g77_uinteger_type_node = NULL_TREE;
3309 if (g77_integer_type_node != NULL_TREE)
3311 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3312 get_identifier ("__g77_integer"),
3313 g77_integer_type_node));
3314 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3315 get_identifier ("__g77_uinteger"),
3316 g77_uinteger_type_node));
3319 if (TYPE_PRECISION (float_type_node) * 2
3320 == TYPE_PRECISION (long_integer_type_node))
3322 g77_longint_type_node = long_integer_type_node;
3323 g77_ulongint_type_node = long_unsigned_type_node;
3325 else if (TYPE_PRECISION (float_type_node) * 2
3326 == TYPE_PRECISION (long_long_integer_type_node))
3328 g77_longint_type_node = long_long_integer_type_node;
3329 g77_ulongint_type_node = long_long_unsigned_type_node;
3332 g77_longint_type_node = g77_ulongint_type_node = NULL_TREE;
3334 if (g77_longint_type_node != NULL_TREE)
3336 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3337 get_identifier ("__g77_longint"),
3338 g77_longint_type_node));
3339 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3340 get_identifier ("__g77_ulongint"),
3341 g77_ulongint_type_node));
3344 record_builtin_type (RID_VOID, NULL, void_type_node);
3346 void_zero_node = build_int_2 (0, 0);
3347 TREE_TYPE (void_zero_node) = void_type_node;
3349 void_list_node = build_void_list_node ();
3351 /* Make a type to be the domain of a few array types
3352 whose domains don't really matter.
3353 200 is small enough that it always fits in size_t
3354 and large enough that it can hold most function names for the
3355 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
3356 array_domain_type = build_index_type (size_int (200));
3358 /* Make a type for arrays of characters.
3359 With luck nothing will ever really depend on the length of this
3361 char_array_type_node
3362 = build_array_type (char_type_node, array_domain_type);
3364 /* Likewise for arrays of ints. */
3366 = build_array_type (integer_type_node, array_domain_type);
3368 string_type_node = build_pointer_type (char_type_node);
3369 const_string_type_node
3370 = build_pointer_type (build_qualified_type
3371 (char_type_node, TYPE_QUAL_CONST));
3373 (*targetm.init_builtins) ();
3375 /* This is special for C++ so functions can be overloaded. */
3376 wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
3377 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
3378 wchar_type_size = TYPE_PRECISION (wchar_type_node);
3379 if (c_language == clk_cplusplus)
3381 if (TREE_UNSIGNED (wchar_type_node))
3382 wchar_type_node = make_unsigned_type (wchar_type_size);
3384 wchar_type_node = make_signed_type (wchar_type_size);
3385 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
3389 signed_wchar_type_node = c_common_signed_type (wchar_type_node);
3390 unsigned_wchar_type_node = c_common_unsigned_type (wchar_type_node);
3393 /* This is for wide string constants. */
3394 wchar_array_type_node
3395 = build_array_type (wchar_type_node, array_domain_type);
3398 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
3401 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
3403 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
3405 default_function_type = build_function_type (integer_type_node, NULL_TREE);
3407 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
3408 unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
3410 (*lang_hooks.decls.pushdecl)
3411 (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
3412 va_list_type_node));
3414 (*lang_hooks.decls.pushdecl)
3415 (build_decl (TYPE_DECL, get_identifier ("__builtin_ptrdiff_t"),
3416 ptrdiff_type_node));
3418 (*lang_hooks.decls.pushdecl)
3419 (build_decl (TYPE_DECL, get_identifier ("__builtin_size_t"),
3422 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
3424 va_list_arg_type_node = va_list_ref_type_node =
3425 build_pointer_type (TREE_TYPE (va_list_type_node));
3429 va_list_arg_type_node = va_list_type_node;
3430 va_list_ref_type_node = build_reference_type (va_list_type_node);
3433 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3434 builtin_types[(int) ENUM] = VALUE;
3435 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
3436 builtin_types[(int) ENUM] \
3437 = build_function_type (builtin_types[(int) RETURN], \
3439 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
3440 builtin_types[(int) ENUM] \
3441 = build_function_type (builtin_types[(int) RETURN], \
3442 tree_cons (NULL_TREE, \
3443 builtin_types[(int) ARG1], \
3445 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
3446 builtin_types[(int) ENUM] \
3447 = build_function_type \
3448 (builtin_types[(int) RETURN], \
3449 tree_cons (NULL_TREE, \
3450 builtin_types[(int) ARG1], \
3451 tree_cons (NULL_TREE, \
3452 builtin_types[(int) ARG2], \
3454 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3455 builtin_types[(int) ENUM] \
3456 = build_function_type \
3457 (builtin_types[(int) RETURN], \
3458 tree_cons (NULL_TREE, \
3459 builtin_types[(int) ARG1], \
3460 tree_cons (NULL_TREE, \
3461 builtin_types[(int) ARG2], \
3462 tree_cons (NULL_TREE, \
3463 builtin_types[(int) ARG3], \
3465 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3466 builtin_types[(int) ENUM] \
3467 = build_function_type \
3468 (builtin_types[(int) RETURN], \
3469 tree_cons (NULL_TREE, \
3470 builtin_types[(int) ARG1], \
3471 tree_cons (NULL_TREE, \
3472 builtin_types[(int) ARG2], \
3475 builtin_types[(int) ARG3], \
3476 tree_cons (NULL_TREE, \
3477 builtin_types[(int) ARG4], \
3478 void_list_node)))));
3479 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
3480 builtin_types[(int) ENUM] \
3481 = build_function_type (builtin_types[(int) RETURN], NULL_TREE);
3482 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
3483 builtin_types[(int) ENUM] \
3484 = build_function_type (builtin_types[(int) RETURN], \
3485 tree_cons (NULL_TREE, \
3486 builtin_types[(int) ARG1], \
3489 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
3490 builtin_types[(int) ENUM] \
3491 = build_function_type \
3492 (builtin_types[(int) RETURN], \
3493 tree_cons (NULL_TREE, \
3494 builtin_types[(int) ARG1], \
3495 tree_cons (NULL_TREE, \
3496 builtin_types[(int) ARG2], \
3498 #define DEF_POINTER_TYPE(ENUM, TYPE) \
3499 builtin_types[(int) ENUM] \
3500 = build_pointer_type (builtin_types[(int) TYPE]);
3501 #include "builtin-types.def"
3502 #undef DEF_PRIMITIVE_TYPE
3503 #undef DEF_FUNCTION_TYPE_1
3504 #undef DEF_FUNCTION_TYPE_2
3505 #undef DEF_FUNCTION_TYPE_3
3506 #undef DEF_FUNCTION_TYPE_4
3507 #undef DEF_FUNCTION_TYPE_VAR_0
3508 #undef DEF_FUNCTION_TYPE_VAR_1
3509 #undef DEF_POINTER_TYPE
3511 if (!c_attrs_initialized)
3512 c_init_attributes ();
3514 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, \
3515 BOTH_P, FALLBACK_P, NONANSI_P, ATTRS) \
3520 if (strncmp (NAME, "__builtin_", strlen ("__builtin_")) != 0) \
3524 decl = builtin_function (NAME, builtin_types[TYPE], ENUM, \
3527 ? (NAME + strlen ("__builtin_")) \
3529 built_in_attributes[(int) ATTRS]); \
3531 decl = builtin_function_2 (NAME, \
3532 NAME + strlen ("__builtin_"), \
3533 builtin_types[TYPE], \
3534 builtin_types[LIBTYPE], \
3539 built_in_attributes[(int) ATTRS]); \
3541 built_in_decls[(int) ENUM] = decl; \
3543 #include "builtins.def"
3546 main_identifier_node = get_identifier ("main");
3550 build_va_arg (expr, type)
3553 return build1 (VA_ARG_EXPR, type, expr);
3557 /* Linked list of disabled built-in functions. */
3559 typedef struct disabled_builtin
3562 struct disabled_builtin *next;
3564 static disabled_builtin *disabled_builtins = NULL;
3566 static bool builtin_function_disabled_p PARAMS ((const char *));
3568 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
3569 begins with "__builtin_", give an error. */
3572 disable_builtin_function (name)
3575 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
3576 error ("cannot disable built-in function `%s'", name);
3579 disabled_builtin *new = xmalloc (sizeof (disabled_builtin));
3581 new->next = disabled_builtins;
3582 disabled_builtins = new;
3587 /* Return true if the built-in function NAME has been disabled, false
3591 builtin_function_disabled_p (name)
3594 disabled_builtin *p;
3595 for (p = disabled_builtins; p != NULL; p = p->next)
3597 if (strcmp (name, p->name) == 0)
3604 /* Possibly define a builtin function with one or two names. BUILTIN_NAME
3605 is an __builtin_-prefixed name; NAME is the ordinary name; one or both
3606 of these may be NULL (though both being NULL is useless).
3607 BUILTIN_TYPE is the type of the __builtin_-prefixed function;
3608 TYPE is the type of the function with the ordinary name. These
3609 may differ if the ordinary name is declared with a looser type to avoid
3610 conflicts with headers. FUNCTION_CODE and CLASS are as for
3611 builtin_function. If LIBRARY_NAME_P is nonzero, NAME is passed as
3612 the LIBRARY_NAME parameter to builtin_function when declaring BUILTIN_NAME.
3613 If NONANSI_P is nonzero, the name NAME is treated as a non-ANSI name;
3614 ATTRS is the tree list representing the builtin's function attributes.
3615 Returns the declaration of BUILTIN_NAME, if any, otherwise
3616 the declaration of NAME. Does not declare NAME if flag_no_builtin,
3617 or if NONANSI_P and flag_no_nonansi_builtin. */
3620 builtin_function_2 (builtin_name, name, builtin_type, type, function_code,
3621 class, library_name_p, nonansi_p, attrs)
3622 const char *builtin_name;
3627 enum built_in_class class;
3632 tree bdecl = NULL_TREE;
3633 tree decl = NULL_TREE;
3634 if (builtin_name != 0)
3636 bdecl = builtin_function (builtin_name, builtin_type, function_code,
3637 class, library_name_p ? name : NULL,
3640 if (name != 0 && !flag_no_builtin && !builtin_function_disabled_p (name)
3641 && !(nonansi_p && flag_no_nonansi_builtin))
3643 decl = builtin_function (name, type, function_code, class, NULL,
3646 DECL_BUILT_IN_NONANSI (decl) = 1;
3648 return (bdecl != 0 ? bdecl : decl);
3651 /* Nonzero if the type T promotes to int. This is (nearly) the
3652 integral promotions defined in ISO C99 6.3.1.1/2. */
3655 c_promoting_integer_type_p (t)
3658 switch (TREE_CODE (t))
3661 return (TYPE_MAIN_VARIANT (t) == char_type_node
3662 || TYPE_MAIN_VARIANT (t) == signed_char_type_node
3663 || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
3664 || TYPE_MAIN_VARIANT (t) == short_integer_type_node
3665 || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
3666 || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
3669 /* ??? Technically all enumerations not larger than an int
3670 promote to an int. But this is used along code paths
3671 that only want to notice a size change. */
3672 return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
3682 /* Return 1 if PARMS specifies a fixed number of parameters
3683 and none of their types is affected by default promotions. */
3686 self_promoting_args_p (parms)
3690 for (t = parms; t; t = TREE_CHAIN (t))
3692 tree type = TREE_VALUE (t);
3694 if (TREE_CHAIN (t) == 0 && type != void_type_node)
3700 if (TYPE_MAIN_VARIANT (type) == float_type_node)
3703 if (c_promoting_integer_type_p (type))
3709 /* Recursively examines the array elements of TYPE, until a non-array
3710 element type is found. */
3713 strip_array_types (type)
3716 while (TREE_CODE (type) == ARRAY_TYPE)
3717 type = TREE_TYPE (type);
3722 static tree expand_unordered_cmp PARAMS ((tree, tree, enum tree_code,
3725 /* Expand a call to an unordered comparison function such as
3726 __builtin_isgreater(). FUNCTION is the function's declaration and
3727 PARAMS a list of the values passed. For __builtin_isunordered(),
3728 UNORDERED_CODE is UNORDERED_EXPR and ORDERED_CODE is NOP_EXPR. In
3729 other cases, UNORDERED_CODE and ORDERED_CODE are comparison codes
3730 that give the opposite of the desired result. UNORDERED_CODE is
3731 used for modes that can hold NaNs and ORDERED_CODE is used for the
3735 expand_unordered_cmp (function, params, unordered_code, ordered_code)
3736 tree function, params;
3737 enum tree_code unordered_code, ordered_code;
3739 tree arg0, arg1, type;
3740 enum tree_code code0, code1;
3742 /* Check that we have exactly two arguments. */
3743 if (params == 0 || TREE_CHAIN (params) == 0)
3745 error ("too few arguments to function `%s'",
3746 IDENTIFIER_POINTER (DECL_NAME (function)));
3747 return error_mark_node;
3749 else if (TREE_CHAIN (TREE_CHAIN (params)) != 0)
3751 error ("too many arguments to function `%s'",
3752 IDENTIFIER_POINTER (DECL_NAME (function)));
3753 return error_mark_node;
3756 arg0 = TREE_VALUE (params);
3757 arg1 = TREE_VALUE (TREE_CHAIN (params));
3759 code0 = TREE_CODE (TREE_TYPE (arg0));
3760 code1 = TREE_CODE (TREE_TYPE (arg1));
3762 /* Make sure that the arguments have a common type of REAL. */
3764 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
3765 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
3766 type = common_type (TREE_TYPE (arg0), TREE_TYPE (arg1));
3768 if (type == 0 || TREE_CODE (type) != REAL_TYPE)
3770 error ("non-floating-point argument to function `%s'",
3771 IDENTIFIER_POINTER (DECL_NAME (function)));
3772 return error_mark_node;
3775 if (unordered_code == UNORDERED_EXPR)
3777 if (MODE_HAS_NANS (TYPE_MODE (type)))
3778 return build_binary_op (unordered_code,
3779 convert (type, arg0),
3780 convert (type, arg1),
3783 return integer_zero_node;
3786 return build_unary_op (TRUTH_NOT_EXPR,
3787 build_binary_op (MODE_HAS_NANS (TYPE_MODE (type))
3790 convert (type, arg0),
3791 convert (type, arg1),
3797 /* Recognize certain built-in functions so we can make tree-codes
3798 other than CALL_EXPR. We do this when it enables fold-const.c
3799 to do something useful. */
3800 /* ??? By rights this should go in builtins.c, but only C and C++
3801 implement build_{binary,unary}_op. Not exactly sure what bits
3802 of functionality are actually needed from those functions, or
3803 where the similar functionality exists in the other front ends. */
3806 expand_tree_builtin (function, params, coerced_params)
3807 tree function, params, coerced_params;
3809 if (DECL_BUILT_IN_CLASS (function) != BUILT_IN_NORMAL)
3812 switch (DECL_FUNCTION_CODE (function))
3816 case BUILT_IN_LLABS:
3817 case BUILT_IN_IMAXABS:
3819 case BUILT_IN_FABSL:
3820 case BUILT_IN_FABSF:
3821 if (coerced_params == 0)
3822 return integer_zero_node;
3823 return build_unary_op (ABS_EXPR, TREE_VALUE (coerced_params), 0);
3826 case BUILT_IN_CONJF:
3827 case BUILT_IN_CONJL:
3828 if (coerced_params == 0)
3829 return integer_zero_node;
3830 return build_unary_op (CONJ_EXPR, TREE_VALUE (coerced_params), 0);
3832 case BUILT_IN_CREAL:
3833 case BUILT_IN_CREALF:
3834 case BUILT_IN_CREALL:
3835 if (coerced_params == 0)
3836 return integer_zero_node;
3837 return build_unary_op (REALPART_EXPR, TREE_VALUE (coerced_params), 0);
3839 case BUILT_IN_CIMAG:
3840 case BUILT_IN_CIMAGF:
3841 case BUILT_IN_CIMAGL:
3842 if (coerced_params == 0)
3843 return integer_zero_node;
3844 return build_unary_op (IMAGPART_EXPR, TREE_VALUE (coerced_params), 0);
3846 case BUILT_IN_ISGREATER:
3847 return expand_unordered_cmp (function, params, UNLE_EXPR, LE_EXPR);
3849 case BUILT_IN_ISGREATEREQUAL:
3850 return expand_unordered_cmp (function, params, UNLT_EXPR, LT_EXPR);
3852 case BUILT_IN_ISLESS:
3853 return expand_unordered_cmp (function, params, UNGE_EXPR, GE_EXPR);
3855 case BUILT_IN_ISLESSEQUAL:
3856 return expand_unordered_cmp (function, params, UNGT_EXPR, GT_EXPR);
3858 case BUILT_IN_ISLESSGREATER:
3859 return expand_unordered_cmp (function, params, UNEQ_EXPR, EQ_EXPR);
3861 case BUILT_IN_ISUNORDERED:
3862 return expand_unordered_cmp (function, params, UNORDERED_EXPR, NOP_EXPR);
3871 /* Returns nonzero if CODE is the code for a statement. */
3874 statement_code_p (code)
3875 enum tree_code code;
3900 if (lang_statement_code_p)
3901 return (*lang_statement_code_p) (code);
3906 /* Walk the statement tree, rooted at *tp. Apply FUNC to all the
3907 sub-trees of *TP in a pre-order traversal. FUNC is called with the
3908 DATA and the address of each sub-tree. If FUNC returns a non-NULL
3909 value, the traversal is aborted, and the value returned by FUNC is
3910 returned. If FUNC sets WALK_SUBTREES to zero, then the subtrees of
3911 the node being visited are not walked.
3913 We don't need a without_duplicates variant of this one because the
3914 statement tree is a tree, not a graph. */
3917 walk_stmt_tree (tp, func, data)
3922 enum tree_code code;
3927 #define WALK_SUBTREE(NODE) \
3930 result = walk_stmt_tree (&(NODE), func, data); \
3936 /* Skip empty subtrees. */
3940 /* Skip subtrees below non-statement nodes. */
3941 if (!statement_code_p (TREE_CODE (*tp)))
3944 /* Call the function. */
3946 result = (*func) (tp, &walk_subtrees, data);
3948 /* If we found something, return it. */
3952 /* FUNC may have modified the tree, recheck that we're looking at a
3954 code = TREE_CODE (*tp);
3955 if (!statement_code_p (code))
3958 /* Visit the subtrees unless FUNC decided that there was nothing
3959 interesting below this point in the tree. */
3962 /* Walk over all the sub-trees of this operand. Statement nodes
3963 never contain RTL, and we needn't worry about TARGET_EXPRs. */
3964 len = TREE_CODE_LENGTH (code);
3966 /* Go through the subtrees. We need to do this in forward order so
3967 that the scope of a FOR_EXPR is handled properly. */
3968 for (i = 0; i < len; ++i)
3969 WALK_SUBTREE (TREE_OPERAND (*tp, i));
3972 /* Finally visit the chain. This can be tail-recursion optimized if
3973 we write it this way. */
3974 return walk_stmt_tree (&TREE_CHAIN (*tp), func, data);
3979 /* Used to compare case labels. K1 and K2 are actually tree nodes
3980 representing case labels, or NULL_TREE for a `default' label.
3981 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3982 K2, and 0 if K1 and K2 are equal. */
3985 case_compare (k1, k2)
3989 /* Consider a NULL key (such as arises with a `default' label) to be
3990 smaller than anything else. */
3996 return tree_int_cst_compare ((tree) k1, (tree) k2);
3999 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
4000 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
4001 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
4002 case label was declared using the usual C/C++ syntax, rather than
4003 the GNU case range extension. CASES is a tree containing all the
4004 case ranges processed so far; COND is the condition for the
4005 switch-statement itself. Returns the CASE_LABEL created, or
4006 ERROR_MARK_NODE if no CASE_LABEL is created. */
4009 c_add_case_label (cases, cond, low_value, high_value)
4018 splay_tree_node node;
4020 /* Create the LABEL_DECL itself. */
4021 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
4022 DECL_CONTEXT (label) = current_function_decl;
4024 /* If there was an error processing the switch condition, bail now
4025 before we get more confused. */
4026 if (!cond || cond == error_mark_node)
4028 /* Add a label anyhow so that the back-end doesn't think that
4029 the beginning of the switch is unreachable. */
4031 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
4032 return error_mark_node;
4035 if ((low_value && TREE_TYPE (low_value)
4036 && POINTER_TYPE_P (TREE_TYPE (low_value)))
4037 || (high_value && TREE_TYPE (high_value)
4038 && POINTER_TYPE_P (TREE_TYPE (high_value))))
4039 error ("pointers are not permitted as case values");
4041 /* Case ranges are a GNU extension. */
4042 if (high_value && pedantic)
4044 if (c_language == clk_cplusplus)
4045 pedwarn ("ISO C++ forbids range expressions in switch statements");
4047 pedwarn ("ISO C forbids range expressions in switch statements");
4050 type = TREE_TYPE (cond);
4053 low_value = check_case_value (low_value);
4054 low_value = convert_and_check (type, low_value);
4058 high_value = check_case_value (high_value);
4059 high_value = convert_and_check (type, high_value);
4062 /* If an error has occurred, bail out now. */
4063 if (low_value == error_mark_node || high_value == error_mark_node)
4066 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
4067 return error_mark_node;
4070 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
4071 really a case range, even though it was written that way. Remove
4072 the HIGH_VALUE to simplify later processing. */
4073 if (tree_int_cst_equal (low_value, high_value))
4074 high_value = NULL_TREE;
4075 if (low_value && high_value
4076 && !tree_int_cst_lt (low_value, high_value))
4077 warning ("empty range specified");
4079 /* Look up the LOW_VALUE in the table of case labels we already
4081 node = splay_tree_lookup (cases, (splay_tree_key) low_value);
4082 /* If there was not an exact match, check for overlapping ranges.
4083 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
4084 that's a `default' label and the only overlap is an exact match. */
4085 if (!node && (low_value || high_value))
4087 splay_tree_node low_bound;
4088 splay_tree_node high_bound;
4090 /* Even though there wasn't an exact match, there might be an
4091 overlap between this case range and another case range.
4092 Since we've (inductively) not allowed any overlapping case
4093 ranges, we simply need to find the greatest low case label
4094 that is smaller that LOW_VALUE, and the smallest low case
4095 label that is greater than LOW_VALUE. If there is an overlap
4096 it will occur in one of these two ranges. */
4097 low_bound = splay_tree_predecessor (cases,
4098 (splay_tree_key) low_value);
4099 high_bound = splay_tree_successor (cases,
4100 (splay_tree_key) low_value);
4102 /* Check to see if the LOW_BOUND overlaps. It is smaller than
4103 the LOW_VALUE, so there is no need to check unless the
4104 LOW_BOUND is in fact itself a case range. */
4106 && CASE_HIGH ((tree) low_bound->value)
4107 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
4110 /* Check to see if the HIGH_BOUND overlaps. The low end of that
4111 range is bigger than the low end of the current range, so we
4112 are only interested if the current range is a real range, and
4113 not an ordinary case label. */
4116 && (tree_int_cst_compare ((tree) high_bound->key,
4121 /* If there was an overlap, issue an error. */
4124 tree duplicate = CASE_LABEL_DECL ((tree) node->value);
4128 error ("duplicate (or overlapping) case value");
4129 error_with_decl (duplicate,
4130 "this is the first entry overlapping that value");
4134 error ("duplicate case value") ;
4135 error_with_decl (duplicate, "previously used here");
4139 error ("multiple default labels in one switch");
4140 error_with_decl (duplicate, "this is the first default label");
4143 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
4146 /* Add a CASE_LABEL to the statement-tree. */
4147 case_label = add_stmt (build_case_label (low_value, high_value, label));
4148 /* Register this case label in the splay tree. */
4149 splay_tree_insert (cases,
4150 (splay_tree_key) low_value,
4151 (splay_tree_value) case_label);
4156 /* Finish an expression taking the address of LABEL. Returns an
4157 expression for the address. */
4160 finish_label_address_expr (label)
4167 if (c_language == clk_cplusplus)
4168 pedwarn ("ISO C++ forbids taking the address of a label");
4170 pedwarn ("ISO C forbids taking the address of a label");
4173 label = lookup_label (label);
4174 if (label == NULL_TREE)
4175 result = null_pointer_node;
4178 TREE_USED (label) = 1;
4179 result = build1 (ADDR_EXPR, ptr_type_node, label);
4180 TREE_CONSTANT (result) = 1;
4181 /* The current function in not necessarily uninlinable.
4182 Computed gotos are incompatible with inlining, but the value
4183 here could be used only in a diagnostic, for example. */
4189 /* Hook used by expand_expr to expand language-specific tree codes. */
4192 c_expand_expr (exp, target, tmode, modifier)
4195 enum machine_mode tmode;
4196 int modifier; /* Actually enum_modifier. */
4198 switch (TREE_CODE (exp))
4204 bool preserve_result = false;
4205 bool return_target = false;
4207 /* Since expand_expr_stmt calls free_temp_slots after every
4208 expression statement, we must call push_temp_slots here.
4209 Otherwise, any temporaries in use now would be considered
4210 out-of-scope after the first EXPR_STMT from within the
4213 rtl_expr = expand_start_stmt_expr (!STMT_EXPR_NO_SCOPE (exp));
4215 /* If we want the result of this expression, find the last
4216 EXPR_STMT in the COMPOUND_STMT and mark it as addressable. */
4217 if (target != const0_rtx
4218 && TREE_CODE (STMT_EXPR_STMT (exp)) == COMPOUND_STMT
4219 && TREE_CODE (COMPOUND_BODY (STMT_EXPR_STMT (exp))) == SCOPE_STMT)
4221 tree expr = COMPOUND_BODY (STMT_EXPR_STMT (exp));
4222 tree last = TREE_CHAIN (expr);
4224 while (TREE_CHAIN (last))
4227 last = TREE_CHAIN (last);
4230 if (TREE_CODE (last) == SCOPE_STMT
4231 && TREE_CODE (expr) == EXPR_STMT)
4233 if (target && TREE_CODE (EXPR_STMT_EXPR (expr)) == VAR_DECL
4234 && DECL_RTL_IF_SET (EXPR_STMT_EXPR (expr)) == target)
4235 /* If the last expression is a variable whose RTL is the
4236 same as our target, just return the target; if it
4237 isn't valid expanding the decl would produce different
4238 RTL, and store_expr would try to do a copy. */
4239 return_target = true;
4242 /* Otherwise, note that we want the value from the last
4244 TREE_ADDRESSABLE (expr) = 1;
4245 preserve_result = true;
4250 expand_stmt (STMT_EXPR_STMT (exp));
4251 expand_end_stmt_expr (rtl_expr);
4253 result = expand_expr (rtl_expr, target, tmode, modifier);
4256 else if (preserve_result && GET_CODE (result) == MEM)
4258 if (GET_MODE (result) != BLKmode)
4259 result = copy_to_reg (result);
4261 preserve_temp_slots (result);
4264 /* If the statment-expression does not have a scope, then the
4265 new temporaries we created within it must live beyond the
4266 statement-expression. */
4267 if (STMT_EXPR_NO_SCOPE (exp))
4268 preserve_temp_slots (NULL_RTX);
4277 if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
4278 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
4280 && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
4281 && (DECL_BUILT_IN_CLASS (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
4282 == BUILT_IN_FRONTEND))
4283 return c_expand_builtin (exp, target, tmode, modifier);
4289 case COMPOUND_LITERAL_EXPR:
4291 /* Initialize the anonymous variable declared in the compound
4292 literal, then return the variable. */
4293 tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
4294 emit_local_var (decl);
4295 return expand_expr (decl, target, tmode, modifier);
4306 /* Hook used by safe_from_p to handle language-specific tree codes. */
4309 c_safe_from_p (target, exp)
4313 /* We can see statements here when processing the body of a
4314 statement-expression. For a declaration statement declaring a
4315 variable, look at the variable's initializer. */
4316 if (TREE_CODE (exp) == DECL_STMT)
4318 tree decl = DECL_STMT_DECL (exp);
4320 if (TREE_CODE (decl) == VAR_DECL
4321 && DECL_INITIAL (decl)
4322 && !safe_from_p (target, DECL_INITIAL (decl), /*top_p=*/0))
4326 /* For any statement, we must follow the statement-chain. */
4327 if (statement_code_p (TREE_CODE (exp)) && TREE_CHAIN (exp))
4328 return safe_from_p (target, TREE_CHAIN (exp), /*top_p=*/0);
4330 /* Assume everything else is safe. */
4334 /* Hook used by unsafe_for_reeval to handle language-specific tree codes. */
4337 c_common_unsafe_for_reeval (exp)
4340 /* Statement expressions may not be reevaluated, likewise compound
4342 if (TREE_CODE (exp) == STMT_EXPR
4343 || TREE_CODE (exp) == COMPOUND_LITERAL_EXPR)
4346 /* Walk all other expressions. */
4350 /* Hook used by staticp to handle language-specific tree codes. */
4356 if (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR
4357 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp)))
4362 #define CALLED_AS_BUILT_IN(NODE) \
4363 (!strncmp (IDENTIFIER_POINTER (DECL_NAME (NODE)), "__builtin_", 10))
4366 c_expand_builtin (exp, target, tmode, modifier)
4369 enum machine_mode tmode;
4370 enum expand_modifier modifier;
4372 tree type = TREE_TYPE (exp);
4373 tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
4374 tree arglist = TREE_OPERAND (exp, 1);
4375 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
4376 enum tree_code code = TREE_CODE (exp);
4377 const int ignore = (target == const0_rtx
4378 || ((code == NON_LVALUE_EXPR || code == NOP_EXPR
4379 || code == CONVERT_EXPR || code == REFERENCE_EXPR
4380 || code == COND_EXPR)
4381 && TREE_CODE (type) == VOID_TYPE));
4383 if (! optimize && ! CALLED_AS_BUILT_IN (fndecl))
4384 return expand_call (exp, target, ignore);
4388 case BUILT_IN_PRINTF:
4389 target = c_expand_builtin_printf (arglist, target, tmode,
4390 modifier, ignore, /*unlocked=*/ 0);
4395 case BUILT_IN_PRINTF_UNLOCKED:
4396 target = c_expand_builtin_printf (arglist, target, tmode,
4397 modifier, ignore, /*unlocked=*/ 1);
4402 case BUILT_IN_FPRINTF:
4403 target = c_expand_builtin_fprintf (arglist, target, tmode,
4404 modifier, ignore, /*unlocked=*/ 0);
4409 case BUILT_IN_FPRINTF_UNLOCKED:
4410 target = c_expand_builtin_fprintf (arglist, target, tmode,
4411 modifier, ignore, /*unlocked=*/ 1);
4416 default: /* just do library call, if unknown builtin */
4417 error ("built-in function `%s' not currently supported",
4418 IDENTIFIER_POINTER (DECL_NAME (fndecl)));
4421 /* The switch statement above can drop through to cause the function
4422 to be called normally. */
4423 return expand_call (exp, target, ignore);
4426 /* Check an arglist to *printf for problems. The arglist should start
4427 at the format specifier, with the remaining arguments immediately
4430 is_valid_printf_arglist (arglist)
4433 /* Save this value so we can restore it later. */
4434 const int SAVE_pedantic = pedantic;
4435 int diagnostic_occurred = 0;
4438 /* Set this to a known value so the user setting won't affect code
4441 /* Check to make sure there are no format specifier errors. */
4442 attrs = tree_cons (get_identifier ("format"),
4443 tree_cons (NULL_TREE,
4444 get_identifier ("printf"),
4445 tree_cons (NULL_TREE,
4447 tree_cons (NULL_TREE,
4451 check_function_format (&diagnostic_occurred, attrs, arglist);
4453 /* Restore the value of `pedantic'. */
4454 pedantic = SAVE_pedantic;
4456 /* If calling `check_function_format_ptr' produces a warning, we
4457 return false, otherwise we return true. */
4458 return ! diagnostic_occurred;
4461 /* If the arguments passed to printf are suitable for optimizations,
4462 we attempt to transform the call. */
4464 c_expand_builtin_printf (arglist, target, tmode, modifier, ignore, unlocked)
4467 enum machine_mode tmode;
4468 enum expand_modifier modifier;
4472 tree fn_putchar = unlocked ?
4473 built_in_decls[BUILT_IN_PUTCHAR_UNLOCKED] : built_in_decls[BUILT_IN_PUTCHAR];
4474 tree fn_puts = unlocked ?
4475 built_in_decls[BUILT_IN_PUTS_UNLOCKED] : built_in_decls[BUILT_IN_PUTS];
4476 tree fn, format_arg, stripped_string;
4478 /* If the return value is used, or the replacement _DECL isn't
4479 initialized, don't do the transformation. */
4480 if (!ignore || !fn_putchar || !fn_puts)
4483 /* Verify the required arguments in the original call. */
4485 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE))
4488 /* Check the specifier vs. the parameters. */
4489 if (!is_valid_printf_arglist (arglist))
4492 format_arg = TREE_VALUE (arglist);
4493 stripped_string = format_arg;
4494 STRIP_NOPS (stripped_string);
4495 if (stripped_string && TREE_CODE (stripped_string) == ADDR_EXPR)
4496 stripped_string = TREE_OPERAND (stripped_string, 0);
4498 /* If the format specifier isn't a STRING_CST, punt. */
4499 if (TREE_CODE (stripped_string) != STRING_CST)
4502 /* OK! We can attempt optimization. */
4504 /* If the format specifier was "%s\n", call __builtin_puts(arg2). */
4505 if (strcmp (TREE_STRING_POINTER (stripped_string), "%s\n") == 0)
4507 arglist = TREE_CHAIN (arglist);
4510 /* If the format specifier was "%c", call __builtin_putchar (arg2). */
4511 else if (strcmp (TREE_STRING_POINTER (stripped_string), "%c") == 0)
4513 arglist = TREE_CHAIN (arglist);
4518 /* We can't handle anything else with % args or %% ... yet. */
4519 if (strchr (TREE_STRING_POINTER (stripped_string), '%'))
4522 /* If the resulting constant string has a length of 1, call
4523 putchar. Note, TREE_STRING_LENGTH includes the terminating
4524 NULL in its count. */
4525 if (TREE_STRING_LENGTH (stripped_string) == 2)
4527 /* Given printf("c"), (where c is any one character,)
4528 convert "c"[0] to an int and pass that to the replacement
4530 arglist = build_int_2 (TREE_STRING_POINTER (stripped_string)[0], 0);
4531 arglist = build_tree_list (NULL_TREE, arglist);
4535 /* If the resulting constant was "string\n", call
4536 __builtin_puts("string"). Ensure "string" has at least one
4537 character besides the trailing \n. Note, TREE_STRING_LENGTH
4538 includes the terminating NULL in its count. */
4539 else if (TREE_STRING_LENGTH (stripped_string) > 2
4540 && TREE_STRING_POINTER (stripped_string)
4541 [TREE_STRING_LENGTH (stripped_string) - 2] == '\n')
4543 /* Create a NULL-terminated string that's one char shorter
4544 than the original, stripping off the trailing '\n'. */
4545 const int newlen = TREE_STRING_LENGTH (stripped_string) - 1;
4546 char *newstr = (char *) alloca (newlen);
4547 memcpy (newstr, TREE_STRING_POINTER (stripped_string), newlen - 1);
4548 newstr[newlen - 1] = 0;
4550 arglist = fix_string_type (build_string (newlen, newstr));
4551 arglist = build_tree_list (NULL_TREE, arglist);
4555 /* We'd like to arrange to call fputs(string) here, but we
4556 need stdout and don't have a way to get it ... yet. */
4560 return expand_expr (build_function_call (fn, arglist),
4561 (ignore ? const0_rtx : target),
4565 /* If the arguments passed to fprintf are suitable for optimizations,
4566 we attempt to transform the call. */
4568 c_expand_builtin_fprintf (arglist, target, tmode, modifier, ignore, unlocked)
4571 enum machine_mode tmode;
4572 enum expand_modifier modifier;
4576 tree fn_fputc = unlocked ?
4577 built_in_decls[BUILT_IN_FPUTC_UNLOCKED] : built_in_decls[BUILT_IN_FPUTC];
4578 tree fn_fputs = unlocked ?
4579 built_in_decls[BUILT_IN_FPUTS_UNLOCKED] : built_in_decls[BUILT_IN_FPUTS];
4580 tree fn, format_arg, stripped_string;
4582 /* If the return value is used, or the replacement _DECL isn't
4583 initialized, don't do the transformation. */
4584 if (!ignore || !fn_fputc || !fn_fputs)
4587 /* Verify the required arguments in the original call. */
4589 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE)
4590 || (TREE_CHAIN (arglist) == 0)
4591 || (TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist)))) !=
4595 /* Check the specifier vs. the parameters. */
4596 if (!is_valid_printf_arglist (TREE_CHAIN (arglist)))
4599 format_arg = TREE_VALUE (TREE_CHAIN (arglist));
4600 stripped_string = format_arg;
4601 STRIP_NOPS (stripped_string);
4602 if (stripped_string && TREE_CODE (stripped_string) == ADDR_EXPR)
4603 stripped_string = TREE_OPERAND (stripped_string, 0);
4605 /* If the format specifier isn't a STRING_CST, punt. */
4606 if (TREE_CODE (stripped_string) != STRING_CST)
4609 /* OK! We can attempt optimization. */
4611 /* If the format specifier was "%s", call __builtin_fputs(arg3, arg1). */
4612 if (strcmp (TREE_STRING_POINTER (stripped_string), "%s") == 0)
4614 tree newarglist = build_tree_list (NULL_TREE, TREE_VALUE (arglist));
4615 arglist = tree_cons (NULL_TREE,
4616 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))),
4620 /* If the format specifier was "%c", call __builtin_fputc (arg3, arg1). */
4621 else if (strcmp (TREE_STRING_POINTER (stripped_string), "%c") == 0)
4623 tree newarglist = build_tree_list (NULL_TREE, TREE_VALUE (arglist));
4624 arglist = tree_cons (NULL_TREE,
4625 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))),
4631 /* We can't handle anything else with % args or %% ... yet. */
4632 if (strchr (TREE_STRING_POINTER (stripped_string), '%'))
4635 /* When "string" doesn't contain %, replace all cases of
4636 fprintf(stream,string) with fputs(string,stream). The fputs
4637 builtin will take take of special cases like length==1. */
4638 arglist = tree_cons (NULL_TREE, TREE_VALUE (TREE_CHAIN (arglist)),
4639 build_tree_list (NULL_TREE, TREE_VALUE (arglist)));
4643 return expand_expr (build_function_call (fn, arglist),
4644 (ignore ? const0_rtx : target),
4649 /* Given a boolean expression ARG, return a tree representing an increment
4650 or decrement (as indicated by CODE) of ARG. The front end must check for
4651 invalid cases (e.g., decrement in C++). */
4653 boolean_increment (code, arg)
4654 enum tree_code code;
4658 tree true_res = (c_language == clk_cplusplus
4660 : c_bool_true_node);
4661 arg = stabilize_reference (arg);
4664 case PREINCREMENT_EXPR:
4665 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4667 case POSTINCREMENT_EXPR:
4668 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4669 arg = save_expr (arg);
4670 val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4671 val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4673 case PREDECREMENT_EXPR:
4674 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
4676 case POSTDECREMENT_EXPR:
4677 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
4678 arg = save_expr (arg);
4679 val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4680 val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4685 TREE_SIDE_EFFECTS (val) = 1;
4689 /* Define macros necessary to describe fundamental data type formats. */
4691 cpp_define_data_format (pfile)
4696 /* Define supported floating-point format enumeration values. */
4697 cpp_define (pfile, "__UNKNOWN_FORMAT__=0");
4698 cpp_define (pfile, "__IEEE_FORMAT__=1");
4699 cpp_define (pfile, "__IBM_FORMAT__=2");
4700 cpp_define (pfile, "__C4X_FORMAT__=3");
4701 cpp_define (pfile, "__VAX_FORMAT__=4");
4703 switch (TARGET_FLOAT_FORMAT)
4705 case UNKNOWN_FLOAT_FORMAT:
4706 format = "__UNKNOWN_FORMAT__";
4708 case IEEE_FLOAT_FORMAT:
4709 format = "__IEEE_FORMAT__";
4711 case VAX_FLOAT_FORMAT:
4712 format = "__VAX_FORMAT__";
4714 case IBM_FLOAT_FORMAT:
4715 format = "__IBM_FORMAT__";
4717 case C4X_FLOAT_FORMAT:
4718 format = "__C4X_FORMAT__";
4724 builtin_define_with_value ("__GCC_FLOAT_FORMAT__", format, 0);
4727 /* Define NAME with value TYPE precision. */
4729 builtin_define_type_precision (name, type)
4733 builtin_define_with_int_value (name, TYPE_PRECISION (type));
4736 /* Define the float.h constants for TYPE using NAME_PREFIX and FP_SUFFIX. */
4738 builtin_define_float_constants (name_prefix, fp_suffix, type)
4739 const char *name_prefix;
4740 const char *fp_suffix;
4743 /* Used to convert radix-based values to base 10 values in several cases.
4745 In the max_exp -> max_10_exp conversion for 128-bit IEEE, we need at
4746 least 6 significant digits for correct results. Using the fraction
4747 formed by (log(2)*1e6)/(log(10)*1e6) overflows a 32-bit integer as an
4748 intermediate; perhaps someone can find a better approximation, in the
4749 mean time, I suspect using doubles won't harm the bootstrap here. */
4751 const double log10_2 = .30102999566398119521;
4753 const struct real_format *fmt;
4755 char name[64], buf[128];
4756 int dig, min_10_exp, max_10_exp;
4759 fmt = real_format_for_mode[TYPE_MODE (type) - QFmode];
4761 /* The radix of the exponent representation. */
4762 if (type == float_type_node)
4763 builtin_define_with_int_value ("__FLT_RADIX__", fmt->b);
4764 log10_b = log10_2 * fmt->log2_b;
4766 /* The number of radix digits, p, in the floating-point significand. */
4767 sprintf (name, "__%s_MANT_DIG__", name_prefix);
4768 builtin_define_with_int_value (name, fmt->p);
4770 /* The number of decimal digits, q, such that any floating-point number
4771 with q decimal digits can be rounded into a floating-point number with
4772 p radix b digits and back again without change to the q decimal digits,
4774 p log10 b if b is a power of 10
4775 floor((p - 1) log10 b) otherwise
4777 dig = (fmt->p - 1) * log10_b;
4778 sprintf (name, "__%s_DIG__", name_prefix);
4779 builtin_define_with_int_value (name, dig);
4781 /* The minimum negative int x such that b**(x-1) is a normalized float. */
4782 sprintf (name, "__%s_MIN_EXP__", name_prefix);
4783 sprintf (buf, "(%d)", fmt->emin);
4784 builtin_define_with_value (name, buf, 0);
4786 /* The minimum negative int x such that 10**x is a normalized float,
4788 ceil (log10 (b ** (emin - 1)))
4789 = ceil (log10 (b) * (emin - 1))
4791 Recall that emin is negative, so the integer truncation calculates
4792 the ceiling, not the floor, in this case. */
4793 min_10_exp = (fmt->emin - 1) * log10_b;
4794 sprintf (name, "__%s_MIN_10_EXP__", name_prefix);
4795 sprintf (buf, "(%d)", min_10_exp);
4796 builtin_define_with_value (name, buf, 0);
4798 /* The maximum int x such that b**(x-1) is a representable float. */
4799 sprintf (name, "__%s_MAX_EXP__", name_prefix);
4800 builtin_define_with_int_value (name, fmt->emax);
4802 /* The maximum int x such that 10**x is in the range of representable
4803 finite floating-point numbers,
4805 floor (log10((1 - b**-p) * b**emax))
4806 = floor (log10(1 - b**-p) + log10(b**emax))
4807 = floor (log10(1 - b**-p) + log10(b)*emax)
4809 The safest thing to do here is to just compute this number. But since
4810 we don't link cc1 with libm, we cannot. We could implement log10 here
4811 a series expansion, but that seems too much effort because:
4813 Note that the first term, for all extant p, is a number exceedingly close
4814 to zero, but slightly negative. Note that the second term is an integer
4815 scaling an irrational number, and that because of the floor we are only
4816 interested in its integral portion.
4818 In order for the first term to have any effect on the integral portion
4819 of the second term, the second term has to be exceedingly close to an
4820 integer itself (e.g. 123.000000000001 or something). Getting a result
4821 that close to an integer requires that the irrational multiplicand have
4822 a long series of zeros in its expansion, which doesn't occur in the
4823 first 20 digits or so of log10(b).
4825 Hand-waving aside, crunching all of the sets of constants above by hand
4826 does not yield a case for which the first term is significant, which
4827 in the end is all that matters. */
4828 max_10_exp = fmt->emax * log10_b;
4829 sprintf (name, "__%s_MAX_10_EXP__", name_prefix);
4830 builtin_define_with_int_value (name, max_10_exp);
4832 /* The number of decimal digits, n, such that any floating-point number
4833 can be rounded to n decimal digits and back again without change to
4836 p * log10(b) if b is a power of 10
4837 ceil(1 + p * log10(b)) otherwise
4839 The only macro we care about is this number for the widest supported
4840 floating type, but we want this value for rendering constants below. */
4842 double d_decimal_dig = 1 + fmt->p * log10_b;
4843 decimal_dig = d_decimal_dig;
4844 if (decimal_dig < d_decimal_dig)
4847 if (type == long_double_type_node)
4848 builtin_define_with_int_value ("__DECIMAL_DIG__", decimal_dig);
4850 /* Since, for the supported formats, B is always a power of 2, we
4851 construct the following numbers directly as a hexadecimal
4854 /* The maximum representable finite floating-point number,
4855 (1 - b**-p) * b**emax */
4860 strcpy (buf, "0x0.");
4861 n = fmt->p * fmt->log2_b;
4862 for (i = 0, p = buf + 4; i + 3 < n; i += 4)
4865 *p++ = "08ce"[n - i];
4866 sprintf (p, "p%d", fmt->emax * fmt->log2_b);
4868 sprintf (name, "__%s_MAX__", name_prefix);
4869 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix);
4871 /* The minimum normalized positive floating-point number,
4873 sprintf (name, "__%s_MIN__", name_prefix);
4874 sprintf (buf, "0x1p%d", (fmt->emin - 1) * fmt->log2_b);
4875 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix);
4877 /* The difference between 1 and the least value greater than 1 that is
4878 representable in the given floating point type, b**(1-p). */
4879 sprintf (name, "__%s_EPSILON__", name_prefix);
4880 sprintf (buf, "0x1p%d", (1 - fmt->p) * fmt->log2_b);
4881 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix);
4883 /* For C++ std::numeric_limits<T>::denorm_min. The minimum denormalized
4884 positive floating-point number, b**(emin-p). Zero for formats that
4885 don't support denormals. */
4886 sprintf (name, "__%s_DENORM_MIN__", name_prefix);
4887 if (fmt->has_denorm)
4889 sprintf (buf, "0x1p%d", (fmt->emin - fmt->p) * fmt->log2_b);
4890 builtin_define_with_hex_fp_value (name, type, decimal_dig,
4895 sprintf (buf, "0.0%s", fp_suffix);
4896 builtin_define_with_value (name, buf, 0);
4900 /* Hook that registers front end and target-specific built-ins. */
4902 cb_register_builtins (pfile)
4905 /* -undef turns off target-specific built-ins. */
4909 if (c_language == clk_cplusplus)
4911 if (SUPPORTS_ONE_ONLY)
4912 cpp_define (pfile, "__GXX_WEAK__=1");
4914 cpp_define (pfile, "__GXX_WEAK__=0");
4915 if (flag_exceptions)
4916 cpp_define (pfile, "__EXCEPTIONS");
4917 if (warn_deprecated)
4918 cpp_define (pfile, "__DEPRECATED");
4921 /* represents the C++ ABI version, always defined so it can be used while
4922 preprocessing C and assembler. */
4923 cpp_define (pfile, "__GXX_ABI_VERSION=102");
4925 /* libgcc needs to know this. */
4926 if (USING_SJLJ_EXCEPTIONS)
4927 cpp_define (pfile, "__USING_SJLJ_EXCEPTIONS__");
4929 /* stddef.h needs to know these. */
4930 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
4931 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
4932 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
4933 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
4935 /* limits.h needs to know these. */
4936 builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node, 0);
4937 builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node, 0);
4938 builtin_define_type_max ("__INT_MAX__", integer_type_node, 0);
4939 builtin_define_type_max ("__LONG_MAX__", long_integer_type_node, 1);
4940 builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node, 2);
4942 builtin_define_type_precision ("__CHAR_BIT__", char_type_node);
4943 builtin_define_type_precision ("__WCHAR_BIT__", wchar_type_node);
4944 builtin_define_type_precision ("__SHRT_BIT__", short_integer_type_node);
4945 builtin_define_type_precision ("__INT_BIT__", integer_type_node);
4946 builtin_define_type_precision ("__LONG_BIT__", long_integer_type_node);
4947 builtin_define_type_precision ("__LONG_LONG_BIT__",
4948 long_long_integer_type_node);
4949 builtin_define_type_precision ("__FLOAT_BIT__", float_type_node);
4950 builtin_define_type_precision ("__DOUBLE_BIT__", double_type_node);
4951 builtin_define_type_precision ("__LONG_DOUBLE_BIT__", long_double_type_node);
4953 /* float.h needs to know these. */
4955 builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
4956 TARGET_FLT_EVAL_METHOD);
4958 builtin_define_float_constants ("FLT", "F", float_type_node);
4959 builtin_define_float_constants ("DBL", "", double_type_node);
4960 builtin_define_float_constants ("LDBL", "L", long_double_type_node);
4962 /* For use in assembly language. */
4963 builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0);
4964 builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0);
4967 builtin_define_with_value ("__VERSION__", version_string, 1);
4969 /* Other target-independent built-ins determined by command-line
4972 cpp_define (pfile, "__OPTIMIZE_SIZE__");
4974 cpp_define (pfile, "__OPTIMIZE__");
4977 cpp_define (pfile, "__STDC_HOSTED__=1");
4979 cpp_define (pfile, "__STDC_HOSTED__=0");
4981 if (fast_math_flags_set_p ())
4982 cpp_define (pfile, "__FAST_MATH__");
4984 cpp_define (pfile, "__NO_INLINE__");
4985 if (flag_signaling_nans)
4986 cpp_define (pfile, "__SUPPORT_SNAN__");
4987 if (flag_finite_math_only)
4988 cpp_define (pfile, "__FINITE_MATH_ONLY__=1");
4990 cpp_define (pfile, "__FINITE_MATH_ONLY__=0");
4993 cpp_define (pfile, "__STRICT_ANSI__");
4995 if (!flag_signed_char)
4996 cpp_define (pfile, "__CHAR_UNSIGNED__");
4998 if (c_language == clk_cplusplus && TREE_UNSIGNED (wchar_type_node))
4999 cpp_define (pfile, "__WCHAR_UNSIGNED__");
5001 cpp_define_data_format (pfile);
5003 /* Make the choice of ObjC runtime visible to source code. */
5004 if (flag_objc && flag_next_runtime)
5005 cpp_define (pfile, "__NEXT_RUNTIME__");
5007 /* A straightforward target hook doesn't work, because of problems
5008 linking that hook's body when part of non-C front ends. */
5009 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
5010 # define builtin_define(TXT) cpp_define (pfile, TXT)
5011 # define builtin_assert(TXT) cpp_assert (pfile, TXT)
5012 TARGET_CPU_CPP_BUILTINS ();
5013 TARGET_OS_CPP_BUILTINS ();
5016 /* Pass an object-like macro. If it doesn't lie in the user's
5017 namespace, defines it unconditionally. Otherwise define a version
5018 with two leading underscores, and another version with two leading
5019 and trailing underscores, and define the original only if an ISO
5020 standard was not nominated.
5022 e.g. passing "unix" defines "__unix", "__unix__" and possibly
5023 "unix". Passing "_mips" defines "__mips", "__mips__" and possibly
5026 builtin_define_std (macro)
5029 size_t len = strlen (macro);
5030 char *buff = alloca (len + 5);
5034 /* prepend __ (or maybe just _) if in user's namespace. */
5035 memcpy (p, macro, len + 1);
5036 if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1]))))
5043 cpp_define (parse_in, p);
5045 /* If it was in user's namespace... */
5048 /* Define the macro with leading and following __. */
5054 cpp_define (parse_in, p);
5056 /* Finally, define the original macro if permitted. */
5058 cpp_define (parse_in, macro);
5062 /* Pass an object-like macro and a value to define it to. The third
5063 parameter says whether or not to turn the value into a string
5066 builtin_define_with_value (macro, expansion, is_str)
5068 const char *expansion;
5072 size_t mlen = strlen (macro);
5073 size_t elen = strlen (expansion);
5074 size_t extra = 2; /* space for an = and a NUL */
5077 extra += 2; /* space for two quote marks */
5079 buf = alloca (mlen + elen + extra);
5081 sprintf (buf, "%s=\"%s\"", macro, expansion);
5083 sprintf (buf, "%s=%s", macro, expansion);
5085 cpp_define (parse_in, buf);
5088 /* Pass an object-like macro and an integer value to define it to. */
5090 builtin_define_with_int_value (macro, value)
5092 HOST_WIDE_INT value;
5095 size_t mlen = strlen (macro);
5097 size_t extra = 2; /* space for = and NUL. */
5099 buf = alloca (mlen + vlen + extra);
5100 memcpy (buf, macro, mlen);
5102 sprintf (buf + mlen + 1, HOST_WIDE_INT_PRINT_DEC, value);
5104 cpp_define (parse_in, buf);
5107 /* Pass an object-like macro a hexadecimal floating-point value. */
5109 builtin_define_with_hex_fp_value (macro, type, digits, hex_str, fp_suffix)
5111 tree type ATTRIBUTE_UNUSED;
5113 const char *hex_str;
5114 const char *fp_suffix;
5116 REAL_VALUE_TYPE real;
5117 char dec_str[64], buf[256];
5119 /* Hex values are really cool and convenient, except that they're
5120 not supported in strict ISO C90 mode. First, the "p-" sequence
5121 is not valid as part of a preprocessor number. Second, we get a
5122 pedwarn from the preprocessor, which has no context, so we can't
5123 suppress the warning with __extension__.
5125 So instead what we do is construct the number in hex (because
5126 it's easy to get the exact correct value), parse it as a real,
5127 then print it back out as decimal. */
5129 real_from_string (&real, hex_str);
5130 real_to_decimal (dec_str, &real, digits);
5132 sprintf (buf, "%s=%s%s", macro, dec_str, fp_suffix);
5133 cpp_define (parse_in, buf);
5136 /* Define MAX for TYPE based on the precision of the type, which is assumed
5137 to be signed. IS_LONG is 1 for type "long" and 2 for "long long". */
5140 builtin_define_type_max (macro, type, is_long)
5147 size_t mlen, vlen, extra;
5149 /* Pre-rendering the values mean we don't have to futz with printing a
5150 multi-word decimal value. There are also a very limited number of
5151 precisions that we support, so it's really a waste of time. */
5152 switch (TYPE_PRECISION (type))
5161 value = "2147483647";
5164 value = "9223372036854775807";
5167 value = "170141183460469231731687303715884105727";
5173 mlen = strlen (macro);
5174 vlen = strlen (value);
5175 extra = 2 + is_long;
5176 buf = alloca (mlen + vlen + extra);
5178 sprintf (buf, "%s=%s%s", macro, value,
5179 (is_long == 1 ? "L" : is_long == 2 ? "LL" : ""));
5181 cpp_define (parse_in, buf);
5185 c_init_attributes ()
5187 /* Fill in the built_in_attributes array. */
5188 #define DEF_ATTR_NULL_TREE(ENUM) \
5189 built_in_attributes[(int) ENUM] = NULL_TREE;
5190 #define DEF_ATTR_INT(ENUM, VALUE) \
5191 built_in_attributes[(int) ENUM] = build_int_2 (VALUE, VALUE < 0 ? -1 : 0);
5192 #define DEF_ATTR_IDENT(ENUM, STRING) \
5193 built_in_attributes[(int) ENUM] = get_identifier (STRING);
5194 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
5195 built_in_attributes[(int) ENUM] \
5196 = tree_cons (built_in_attributes[(int) PURPOSE], \
5197 built_in_attributes[(int) VALUE], \
5198 built_in_attributes[(int) CHAIN]);
5199 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No initialization needed. */
5200 #include "builtin-attrs.def"
5201 #undef DEF_ATTR_NULL_TREE
5203 #undef DEF_ATTR_IDENT
5204 #undef DEF_ATTR_TREE_LIST
5206 c_attrs_initialized = true;
5209 /* Depending on the name of DECL, apply default attributes to it. */
5212 c_common_insert_default_attributes (decl)
5215 tree name = DECL_NAME (decl);
5217 if (!c_attrs_initialized)
5218 c_init_attributes ();
5220 #define DEF_ATTR_NULL_TREE(ENUM) /* Nothing needed after initialization. */
5221 #define DEF_ATTR_INT(ENUM, VALUE)
5222 #define DEF_ATTR_IDENT(ENUM, STRING)
5223 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN)
5224 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) \
5225 if ((PREDICATE) && name == built_in_attributes[(int) NAME]) \
5226 decl_attributes (&decl, built_in_attributes[(int) ATTRS], \
5227 ATTR_FLAG_BUILT_IN);
5228 #include "builtin-attrs.def"
5229 #undef DEF_ATTR_NULL_TREE
5231 #undef DEF_ATTR_IDENT
5232 #undef DEF_ATTR_TREE_LIST
5236 /* Output a -Wshadow warning MSGID about NAME, an IDENTIFIER_NODE, and
5237 additionally give the location of the previous declaration DECL. */
5239 shadow_warning (msgid, name, decl)
5243 warning ("declaration of `%s' shadows %s", IDENTIFIER_POINTER (name), msgid);
5244 warning_with_file_and_line (DECL_SOURCE_FILE (decl),
5245 DECL_SOURCE_LINE (decl),
5246 "shadowed declaration is here");
5249 /* Attribute handlers common to C front ends. */
5251 /* Handle a "packed" attribute; arguments as in
5252 struct attribute_spec.handler. */
5255 handle_packed_attribute (node, name, args, flags, no_add_attrs)
5258 tree args ATTRIBUTE_UNUSED;
5265 if (TREE_CODE (*node) == TYPE_DECL)
5266 type = &TREE_TYPE (*node);
5273 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5274 *type = build_type_copy (*type);
5275 TYPE_PACKED (*type) = 1;
5277 else if (TREE_CODE (*node) == FIELD_DECL)
5278 DECL_PACKED (*node) = 1;
5279 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
5280 used for DECL_REGISTER. It wouldn't mean anything anyway. */
5283 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5284 *no_add_attrs = true;
5290 /* Handle a "nocommon" attribute; arguments as in
5291 struct attribute_spec.handler. */
5294 handle_nocommon_attribute (node, name, args, flags, no_add_attrs)
5297 tree args ATTRIBUTE_UNUSED;
5298 int flags ATTRIBUTE_UNUSED;
5301 if (TREE_CODE (*node) == VAR_DECL)
5302 DECL_COMMON (*node) = 0;
5305 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5306 *no_add_attrs = true;
5312 /* Handle a "common" attribute; arguments as in
5313 struct attribute_spec.handler. */
5316 handle_common_attribute (node, name, args, flags, no_add_attrs)
5319 tree args ATTRIBUTE_UNUSED;
5320 int flags ATTRIBUTE_UNUSED;
5323 if (TREE_CODE (*node) == VAR_DECL)
5324 DECL_COMMON (*node) = 1;
5327 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5328 *no_add_attrs = true;
5334 /* Handle a "noreturn" attribute; arguments as in
5335 struct attribute_spec.handler. */
5338 handle_noreturn_attribute (node, name, args, flags, no_add_attrs)
5341 tree args ATTRIBUTE_UNUSED;
5342 int flags ATTRIBUTE_UNUSED;
5345 tree type = TREE_TYPE (*node);
5347 /* See FIXME comment in c_common_attribute_table. */
5348 if (TREE_CODE (*node) == FUNCTION_DECL)
5349 TREE_THIS_VOLATILE (*node) = 1;
5350 else if (TREE_CODE (type) == POINTER_TYPE
5351 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
5353 = build_pointer_type
5354 (build_type_variant (TREE_TYPE (type),
5355 TREE_READONLY (TREE_TYPE (type)), 1));
5358 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5359 *no_add_attrs = true;
5365 /* Handle a "noinline" attribute; arguments as in
5366 struct attribute_spec.handler. */
5369 handle_noinline_attribute (node, name, args, flags, no_add_attrs)
5372 tree args ATTRIBUTE_UNUSED;
5373 int flags ATTRIBUTE_UNUSED;
5376 if (TREE_CODE (*node) == FUNCTION_DECL)
5377 DECL_UNINLINABLE (*node) = 1;
5380 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5381 *no_add_attrs = true;
5387 /* Handle a "always_inline" attribute; arguments as in
5388 struct attribute_spec.handler. */
5391 handle_always_inline_attribute (node, name, args, flags, no_add_attrs)
5394 tree args ATTRIBUTE_UNUSED;
5395 int flags ATTRIBUTE_UNUSED;
5398 if (TREE_CODE (*node) == FUNCTION_DECL)
5400 /* Do nothing else, just set the attribute. We'll get at
5401 it later with lookup_attribute. */
5405 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5406 *no_add_attrs = true;
5412 /* Handle a "used" attribute; arguments as in
5413 struct attribute_spec.handler. */
5416 handle_used_attribute (node, name, args, flags, no_add_attrs)
5419 tree args ATTRIBUTE_UNUSED;
5420 int flags ATTRIBUTE_UNUSED;
5423 if (TREE_CODE (*node) == FUNCTION_DECL)
5424 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (*node))
5425 = TREE_USED (*node) = 1;
5428 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5429 *no_add_attrs = true;
5435 /* Handle a "unused" attribute; arguments as in
5436 struct attribute_spec.handler. */
5439 handle_unused_attribute (node, name, args, flags, no_add_attrs)
5442 tree args ATTRIBUTE_UNUSED;
5450 if (TREE_CODE (decl) == PARM_DECL
5451 || TREE_CODE (decl) == VAR_DECL
5452 || TREE_CODE (decl) == FUNCTION_DECL
5453 || TREE_CODE (decl) == LABEL_DECL
5454 || TREE_CODE (decl) == TYPE_DECL)
5455 TREE_USED (decl) = 1;
5458 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5459 *no_add_attrs = true;
5464 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5465 *node = build_type_copy (*node);
5466 TREE_USED (*node) = 1;
5472 /* Handle a "const" attribute; arguments as in
5473 struct attribute_spec.handler. */
5476 handle_const_attribute (node, name, args, flags, no_add_attrs)
5479 tree args ATTRIBUTE_UNUSED;
5480 int flags ATTRIBUTE_UNUSED;
5483 tree type = TREE_TYPE (*node);
5485 /* See FIXME comment on noreturn in c_common_attribute_table. */
5486 if (TREE_CODE (*node) == FUNCTION_DECL)
5487 TREE_READONLY (*node) = 1;
5488 else if (TREE_CODE (type) == POINTER_TYPE
5489 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
5491 = build_pointer_type
5492 (build_type_variant (TREE_TYPE (type), 1,
5493 TREE_THIS_VOLATILE (TREE_TYPE (type))));
5496 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5497 *no_add_attrs = true;
5503 /* Handle a "transparent_union" attribute; arguments as in
5504 struct attribute_spec.handler. */
5507 handle_transparent_union_attribute (node, name, args, flags, no_add_attrs)
5510 tree args ATTRIBUTE_UNUSED;
5514 tree decl = NULL_TREE;
5521 type = &TREE_TYPE (decl);
5522 is_type = TREE_CODE (*node) == TYPE_DECL;
5524 else if (TYPE_P (*node))
5525 type = node, is_type = 1;
5528 && TREE_CODE (*type) == UNION_TYPE
5530 || (TYPE_FIELDS (*type) != 0
5531 && TYPE_MODE (*type) == DECL_MODE (TYPE_FIELDS (*type)))))
5533 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5534 *type = build_type_copy (*type);
5535 TYPE_TRANSPARENT_UNION (*type) = 1;
5537 else if (decl != 0 && TREE_CODE (decl) == PARM_DECL
5538 && TREE_CODE (*type) == UNION_TYPE
5539 && TYPE_MODE (*type) == DECL_MODE (TYPE_FIELDS (*type)))
5540 DECL_TRANSPARENT_UNION (decl) = 1;
5543 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5544 *no_add_attrs = true;
5550 /* Handle a "constructor" attribute; arguments as in
5551 struct attribute_spec.handler. */
5554 handle_constructor_attribute (node, name, args, flags, no_add_attrs)
5557 tree args ATTRIBUTE_UNUSED;
5558 int flags ATTRIBUTE_UNUSED;
5562 tree type = TREE_TYPE (decl);
5564 if (TREE_CODE (decl) == FUNCTION_DECL
5565 && TREE_CODE (type) == FUNCTION_TYPE
5566 && decl_function_context (decl) == 0)
5568 DECL_STATIC_CONSTRUCTOR (decl) = 1;
5569 TREE_USED (decl) = 1;
5573 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5574 *no_add_attrs = true;
5580 /* Handle a "destructor" attribute; arguments as in
5581 struct attribute_spec.handler. */
5584 handle_destructor_attribute (node, name, args, flags, no_add_attrs)
5587 tree args ATTRIBUTE_UNUSED;
5588 int flags ATTRIBUTE_UNUSED;
5592 tree type = TREE_TYPE (decl);
5594 if (TREE_CODE (decl) == FUNCTION_DECL
5595 && TREE_CODE (type) == FUNCTION_TYPE
5596 && decl_function_context (decl) == 0)
5598 DECL_STATIC_DESTRUCTOR (decl) = 1;
5599 TREE_USED (decl) = 1;
5603 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5604 *no_add_attrs = true;
5610 /* Handle a "mode" attribute; arguments as in
5611 struct attribute_spec.handler. */
5614 handle_mode_attribute (node, name, args, flags, no_add_attrs)
5618 int flags ATTRIBUTE_UNUSED;
5623 *no_add_attrs = true;
5625 if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
5626 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5630 const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
5631 int len = strlen (p);
5632 enum machine_mode mode = VOIDmode;
5635 if (len > 4 && p[0] == '_' && p[1] == '_'
5636 && p[len - 1] == '_' && p[len - 2] == '_')
5638 char *newp = (char *) alloca (len - 1);
5640 strcpy (newp, &p[2]);
5641 newp[len - 4] = '\0';
5645 /* Change this type to have a type with the specified mode.
5646 First check for the special modes. */
5647 if (! strcmp (p, "byte"))
5649 else if (!strcmp (p, "word"))
5651 else if (! strcmp (p, "pointer"))
5654 for (j = 0; j < NUM_MACHINE_MODES; j++)
5655 if (!strcmp (p, GET_MODE_NAME (j)))
5656 mode = (enum machine_mode) j;
5658 if (mode == VOIDmode)
5659 error ("unknown machine mode `%s'", p);
5660 else if (0 == (typefm = (*lang_hooks.types.type_for_mode)
5661 (mode, TREE_UNSIGNED (type))))
5662 error ("no data type for mode `%s'", p);
5665 /* If this is a vector, make sure we either have hardware
5666 support, or we can emulate it. */
5667 if ((GET_MODE_CLASS (mode) == MODE_VECTOR_INT
5668 || GET_MODE_CLASS (mode) == MODE_VECTOR_FLOAT)
5669 && !vector_mode_valid_p (mode))
5671 error ("unable to emulate '%s'", GET_MODE_NAME (mode));
5676 /* No need to layout the type here. The caller should do this. */
5683 /* Handle a "section" attribute; arguments as in
5684 struct attribute_spec.handler. */
5687 handle_section_attribute (node, name, args, flags, no_add_attrs)
5689 tree name ATTRIBUTE_UNUSED;
5691 int flags ATTRIBUTE_UNUSED;
5696 if (targetm.have_named_sections)
5698 if ((TREE_CODE (decl) == FUNCTION_DECL
5699 || TREE_CODE (decl) == VAR_DECL)
5700 && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
5702 if (TREE_CODE (decl) == VAR_DECL
5703 && current_function_decl != NULL_TREE
5704 && ! TREE_STATIC (decl))
5706 error_with_decl (decl,
5707 "section attribute cannot be specified for local variables");
5708 *no_add_attrs = true;
5711 /* The decl may have already been given a section attribute
5712 from a previous declaration. Ensure they match. */
5713 else if (DECL_SECTION_NAME (decl) != NULL_TREE
5714 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
5715 TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
5717 error_with_decl (*node,
5718 "section of `%s' conflicts with previous declaration");
5719 *no_add_attrs = true;
5722 DECL_SECTION_NAME (decl) = TREE_VALUE (args);
5726 error_with_decl (*node,
5727 "section attribute not allowed for `%s'");
5728 *no_add_attrs = true;
5733 error_with_decl (*node,
5734 "section attributes are not supported for this target");
5735 *no_add_attrs = true;
5741 /* Handle a "aligned" attribute; arguments as in
5742 struct attribute_spec.handler. */
5745 handle_aligned_attribute (node, name, args, flags, no_add_attrs)
5747 tree name ATTRIBUTE_UNUSED;
5752 tree decl = NULL_TREE;
5755 tree align_expr = (args ? TREE_VALUE (args)
5756 : size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
5762 type = &TREE_TYPE (decl);
5763 is_type = TREE_CODE (*node) == TYPE_DECL;
5765 else if (TYPE_P (*node))
5766 type = node, is_type = 1;
5768 /* Strip any NOPs of any kind. */
5769 while (TREE_CODE (align_expr) == NOP_EXPR
5770 || TREE_CODE (align_expr) == CONVERT_EXPR
5771 || TREE_CODE (align_expr) == NON_LVALUE_EXPR)
5772 align_expr = TREE_OPERAND (align_expr, 0);
5774 if (TREE_CODE (align_expr) != INTEGER_CST)
5776 error ("requested alignment is not a constant");
5777 *no_add_attrs = true;
5779 else if ((i = tree_log2 (align_expr)) == -1)
5781 error ("requested alignment is not a power of 2");
5782 *no_add_attrs = true;
5784 else if (i > HOST_BITS_PER_INT - 2)
5786 error ("requested alignment is too large");
5787 *no_add_attrs = true;
5791 /* If we have a TYPE_DECL, then copy the type, so that we
5792 don't accidentally modify a builtin type. See pushdecl. */
5793 if (decl && TREE_TYPE (decl) != error_mark_node
5794 && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
5796 tree tt = TREE_TYPE (decl);
5797 *type = build_type_copy (*type);
5798 DECL_ORIGINAL_TYPE (decl) = tt;
5799 TYPE_NAME (*type) = decl;
5800 TREE_USED (*type) = TREE_USED (decl);
5801 TREE_TYPE (decl) = *type;
5803 else if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5804 *type = build_type_copy (*type);
5806 TYPE_ALIGN (*type) = (1 << i) * BITS_PER_UNIT;
5807 TYPE_USER_ALIGN (*type) = 1;
5809 else if (TREE_CODE (decl) != VAR_DECL
5810 && TREE_CODE (decl) != FIELD_DECL)
5812 error_with_decl (decl,
5813 "alignment may not be specified for `%s'");
5814 *no_add_attrs = true;
5818 DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
5819 DECL_USER_ALIGN (decl) = 1;
5825 /* Handle a "weak" attribute; arguments as in
5826 struct attribute_spec.handler. */
5829 handle_weak_attribute (node, name, args, flags, no_add_attrs)
5831 tree name ATTRIBUTE_UNUSED;
5832 tree args ATTRIBUTE_UNUSED;
5833 int flags ATTRIBUTE_UNUSED;
5834 bool *no_add_attrs ATTRIBUTE_UNUSED;
5836 declare_weak (*node);
5841 /* Handle an "alias" attribute; arguments as in
5842 struct attribute_spec.handler. */
5845 handle_alias_attribute (node, name, args, flags, no_add_attrs)
5849 int flags ATTRIBUTE_UNUSED;
5854 if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
5855 || (TREE_CODE (decl) != FUNCTION_DECL && ! DECL_EXTERNAL (decl)))
5857 error_with_decl (decl,
5858 "`%s' defined both normally and as an alias");
5859 *no_add_attrs = true;
5861 else if (decl_function_context (decl) == 0)
5865 id = TREE_VALUE (args);
5866 if (TREE_CODE (id) != STRING_CST)
5868 error ("alias arg not a string");
5869 *no_add_attrs = true;
5872 id = get_identifier (TREE_STRING_POINTER (id));
5873 /* This counts as a use of the object pointed to. */
5876 if (TREE_CODE (decl) == FUNCTION_DECL)
5877 DECL_INITIAL (decl) = error_mark_node;
5879 DECL_EXTERNAL (decl) = 0;
5883 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5884 *no_add_attrs = true;
5890 /* Handle an "visibility" attribute; arguments as in
5891 struct attribute_spec.handler. */
5894 handle_visibility_attribute (node, name, args, flags, no_add_attrs)
5898 int flags ATTRIBUTE_UNUSED;
5903 if (decl_function_context (decl) != 0 || ! TREE_PUBLIC (decl))
5905 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5906 *no_add_attrs = true;
5912 id = TREE_VALUE (args);
5913 if (TREE_CODE (id) != STRING_CST)
5915 error ("visibility arg not a string");
5916 *no_add_attrs = true;
5919 if (strcmp (TREE_STRING_POINTER (id), "hidden")
5920 && strcmp (TREE_STRING_POINTER (id), "protected")
5921 && strcmp (TREE_STRING_POINTER (id), "internal"))
5923 error ("visibility arg must be one of \"hidden\", \"protected\" or \"internal\"");
5924 *no_add_attrs = true;
5932 /* Handle a "no_instrument_function" attribute; arguments as in
5933 struct attribute_spec.handler. */
5936 handle_no_instrument_function_attribute (node, name, args, flags, no_add_attrs)
5939 tree args ATTRIBUTE_UNUSED;
5940 int flags ATTRIBUTE_UNUSED;
5945 if (TREE_CODE (decl) != FUNCTION_DECL)
5947 error_with_decl (decl,
5948 "`%s' attribute applies only to functions",
5949 IDENTIFIER_POINTER (name));
5950 *no_add_attrs = true;
5952 else if (DECL_INITIAL (decl))
5954 error_with_decl (decl,
5955 "can't set `%s' attribute after definition",
5956 IDENTIFIER_POINTER (name));
5957 *no_add_attrs = true;
5960 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
5965 /* Handle a "malloc" attribute; arguments as in
5966 struct attribute_spec.handler. */
5969 handle_malloc_attribute (node, name, args, flags, no_add_attrs)
5972 tree args ATTRIBUTE_UNUSED;
5973 int flags ATTRIBUTE_UNUSED;
5976 if (TREE_CODE (*node) == FUNCTION_DECL)
5977 DECL_IS_MALLOC (*node) = 1;
5978 /* ??? TODO: Support types. */
5981 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5982 *no_add_attrs = true;
5988 /* Handle a "no_limit_stack" attribute; arguments as in
5989 struct attribute_spec.handler. */
5992 handle_no_limit_stack_attribute (node, name, args, flags, no_add_attrs)
5995 tree args ATTRIBUTE_UNUSED;
5996 int flags ATTRIBUTE_UNUSED;
6001 if (TREE_CODE (decl) != FUNCTION_DECL)
6003 error_with_decl (decl,
6004 "`%s' attribute applies only to functions",
6005 IDENTIFIER_POINTER (name));
6006 *no_add_attrs = true;
6008 else if (DECL_INITIAL (decl))
6010 error_with_decl (decl,
6011 "can't set `%s' attribute after definition",
6012 IDENTIFIER_POINTER (name));
6013 *no_add_attrs = true;
6016 DECL_NO_LIMIT_STACK (decl) = 1;
6021 /* Handle a "pure" attribute; arguments as in
6022 struct attribute_spec.handler. */
6025 handle_pure_attribute (node, name, args, flags, no_add_attrs)
6028 tree args ATTRIBUTE_UNUSED;
6029 int flags ATTRIBUTE_UNUSED;
6032 if (TREE_CODE (*node) == FUNCTION_DECL)
6033 DECL_IS_PURE (*node) = 1;
6034 /* ??? TODO: Support types. */
6037 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
6038 *no_add_attrs = true;
6044 /* Handle a "deprecated" attribute; arguments as in
6045 struct attribute_spec.handler. */
6048 handle_deprecated_attribute (node, name, args, flags, no_add_attrs)
6051 tree args ATTRIBUTE_UNUSED;
6055 tree type = NULL_TREE;
6057 const char *what = NULL;
6062 type = TREE_TYPE (decl);
6064 if (TREE_CODE (decl) == TYPE_DECL
6065 || TREE_CODE (decl) == PARM_DECL
6066 || TREE_CODE (decl) == VAR_DECL
6067 || TREE_CODE (decl) == FUNCTION_DECL
6068 || TREE_CODE (decl) == FIELD_DECL)
6069 TREE_DEPRECATED (decl) = 1;
6073 else if (TYPE_P (*node))
6075 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
6076 *node = build_type_copy (*node);
6077 TREE_DEPRECATED (*node) = 1;
6085 *no_add_attrs = true;
6086 if (type && TYPE_NAME (type))
6088 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
6089 what = IDENTIFIER_POINTER (TYPE_NAME (*node));
6090 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
6091 && DECL_NAME (TYPE_NAME (type)))
6092 what = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
6095 warning ("`%s' attribute ignored for `%s'",
6096 IDENTIFIER_POINTER (name), what);
6098 warning ("`%s' attribute ignored",
6099 IDENTIFIER_POINTER (name));
6105 /* Keep a list of vector type nodes we created in handle_vector_size_attribute,
6106 to prevent us from duplicating type nodes unnecessarily.
6107 The normal mechanism to prevent duplicates is to use type_hash_canon, but
6108 since we want to distinguish types that are essentially identical (except
6109 for their debug representation), we use a local list here. */
6110 static tree vector_type_node_list = 0;
6112 /* Handle a "vector_size" attribute; arguments as in
6113 struct attribute_spec.handler. */
6116 handle_vector_size_attribute (node, name, args, flags, no_add_attrs)
6120 int flags ATTRIBUTE_UNUSED;
6123 unsigned HOST_WIDE_INT vecsize, nunits;
6124 enum machine_mode mode, orig_mode, new_mode;
6125 tree type = *node, new_type = NULL_TREE;
6126 tree type_list_node;
6128 *no_add_attrs = true;
6130 if (! host_integerp (TREE_VALUE (args), 1))
6132 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
6136 /* Get the vector size (in bytes). */
6137 vecsize = tree_low_cst (TREE_VALUE (args), 1);
6139 /* We need to provide for vector pointers, vector arrays, and
6140 functions returning vectors. For example:
6142 __attribute__((vector_size(16))) short *foo;
6144 In this case, the mode is SI, but the type being modified is
6145 HI, so we need to look further. */
6147 while (POINTER_TYPE_P (type)
6148 || TREE_CODE (type) == FUNCTION_TYPE
6149 || TREE_CODE (type) == ARRAY_TYPE)
6150 type = TREE_TYPE (type);
6152 /* Get the mode of the type being modified. */
6153 orig_mode = TYPE_MODE (type);
6155 if (TREE_CODE (type) == RECORD_TYPE
6156 || (GET_MODE_CLASS (orig_mode) != MODE_FLOAT
6157 && GET_MODE_CLASS (orig_mode) != MODE_INT)
6158 || ! host_integerp (TYPE_SIZE_UNIT (type), 1))
6160 error ("invalid vector type for attribute `%s'",
6161 IDENTIFIER_POINTER (name));
6165 /* Calculate how many units fit in the vector. */
6166 nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
6168 /* Find a suitably sized vector. */
6169 new_mode = VOIDmode;
6170 for (mode = GET_CLASS_NARROWEST_MODE (GET_MODE_CLASS (orig_mode) == MODE_INT
6172 : MODE_VECTOR_FLOAT);
6174 mode = GET_MODE_WIDER_MODE (mode))
6175 if (vecsize == GET_MODE_SIZE (mode)
6176 && nunits == (unsigned HOST_WIDE_INT) GET_MODE_NUNITS (mode))
6182 if (new_mode == VOIDmode)
6184 error ("no vector mode with the size and type specified could be found");
6188 for (type_list_node = vector_type_node_list; type_list_node;
6189 type_list_node = TREE_CHAIN (type_list_node))
6191 tree other_type = TREE_VALUE (type_list_node);
6192 tree record = TYPE_DEBUG_REPRESENTATION_TYPE (other_type);
6193 tree fields = TYPE_FIELDS (record);
6194 tree field_type = TREE_TYPE (fields);
6195 tree array_type = TREE_TYPE (field_type);
6196 if (TREE_CODE (fields) != FIELD_DECL
6197 || TREE_CODE (field_type) != ARRAY_TYPE)
6200 if (TYPE_MODE (other_type) == mode && type == array_type)
6202 new_type = other_type;
6207 if (new_type == NULL_TREE)
6209 tree index, array, rt, list_node;
6211 new_type = (*lang_hooks.types.type_for_mode) (new_mode,
6212 TREE_UNSIGNED (type));
6216 error ("no vector mode with the size and type specified could be found");
6220 new_type = build_type_copy (new_type);
6222 /* If this is a vector, make sure we either have hardware
6223 support, or we can emulate it. */
6224 if ((GET_MODE_CLASS (mode) == MODE_VECTOR_INT
6225 || GET_MODE_CLASS (mode) == MODE_VECTOR_FLOAT)
6226 && !vector_mode_valid_p (mode))
6228 error ("unable to emulate '%s'", GET_MODE_NAME (mode));
6232 /* Set the debug information here, because this is the only
6233 place where we know the underlying type for a vector made
6234 with vector_size. For debugging purposes we pretend a vector
6235 is an array within a structure. */
6236 index = build_int_2 (TYPE_VECTOR_SUBPARTS (new_type) - 1, 0);
6237 array = build_array_type (type, build_index_type (index));
6238 rt = make_node (RECORD_TYPE);
6240 TYPE_FIELDS (rt) = build_decl (FIELD_DECL, get_identifier ("f"), array);
6241 DECL_CONTEXT (TYPE_FIELDS (rt)) = rt;
6243 TYPE_DEBUG_REPRESENTATION_TYPE (new_type) = rt;
6245 list_node = build_tree_list (NULL, new_type);
6246 TREE_CHAIN (list_node) = vector_type_node_list;
6247 vector_type_node_list = list_node;
6250 /* Build back pointers if needed. */
6251 *node = vector_size_helper (*node, new_type);
6256 /* HACK. GROSS. This is absolutely disgusting. I wish there was a
6259 If we requested a pointer to a vector, build up the pointers that
6260 we stripped off while looking for the inner type. Similarly for
6261 return values from functions.
6263 The argument "type" is the top of the chain, and "bottom" is the
6264 new type which we will point to. */
6267 vector_size_helper (type, bottom)
6272 if (POINTER_TYPE_P (type))
6274 inner = vector_size_helper (TREE_TYPE (type), bottom);
6275 outer = build_pointer_type (inner);
6277 else if (TREE_CODE (type) == ARRAY_TYPE)
6279 inner = vector_size_helper (TREE_TYPE (type), bottom);
6280 outer = build_array_type (inner, TYPE_VALUES (type));
6282 else if (TREE_CODE (type) == FUNCTION_TYPE)
6284 inner = vector_size_helper (TREE_TYPE (type), bottom);
6285 outer = build_function_type (inner, TYPE_VALUES (type));
6290 TREE_READONLY (outer) = TREE_READONLY (type);
6291 TREE_THIS_VOLATILE (outer) = TREE_THIS_VOLATILE (type);
6296 /* Handle the "nonnull" attribute. */
6298 handle_nonnull_attribute (node, name, args, flags, no_add_attrs)
6300 tree name ATTRIBUTE_UNUSED;
6302 int flags ATTRIBUTE_UNUSED;
6306 unsigned HOST_WIDE_INT attr_arg_num;
6308 /* If no arguments are specified, all pointer arguments should be
6309 non-null. Veryify a full prototype is given so that the arguments
6310 will have the correct types when we actually check them later. */
6313 if (! TYPE_ARG_TYPES (type))
6315 error ("nonnull attribute without arguments on a non-prototype");
6316 *no_add_attrs = true;
6321 /* Argument list specified. Verify that each argument number references
6322 a pointer argument. */
6323 for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
6326 unsigned HOST_WIDE_INT arg_num, ck_num;
6328 if (! get_nonnull_operand (TREE_VALUE (args), &arg_num))
6330 error ("nonnull argument has invalid operand number (arg %lu)",
6331 (unsigned long) attr_arg_num);
6332 *no_add_attrs = true;
6336 argument = TYPE_ARG_TYPES (type);
6339 for (ck_num = 1; ; ck_num++)
6341 if (! argument || ck_num == arg_num)
6343 argument = TREE_CHAIN (argument);
6347 || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
6349 error ("nonnull argument with out-of-range operand number (arg %lu, operand %lu)",
6350 (unsigned long) attr_arg_num, (unsigned long) arg_num);
6351 *no_add_attrs = true;
6355 if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
6357 error ("nonnull argument references non-pointer operand (arg %lu, operand %lu)",
6358 (unsigned long) attr_arg_num, (unsigned long) arg_num);
6359 *no_add_attrs = true;
6368 /* Check the argument list of a function call for null in argument slots
6369 that are marked as requiring a non-null pointer argument. */
6372 check_function_nonnull (attrs, params)
6376 tree a, args, param;
6379 for (a = attrs; a; a = TREE_CHAIN (a))
6381 if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
6383 args = TREE_VALUE (a);
6385 /* Walk the argument list. If we encounter an argument number we
6386 should check for non-null, do it. If the attribute has no args,
6387 then every pointer argument is checked (in which case the check
6388 for pointer type is done in check_nonnull_arg). */
6389 for (param = params, param_num = 1; ;
6390 param_num++, param = TREE_CHAIN (param))
6394 if (! args || nonnull_check_p (args, param_num))
6395 check_function_arguments_recurse (check_nonnull_arg, NULL,
6403 /* Helper for check_function_nonnull; given a list of operands which
6404 must be non-null in ARGS, determine if operand PARAM_NUM should be
6408 nonnull_check_p (args, param_num)
6410 unsigned HOST_WIDE_INT param_num;
6412 unsigned HOST_WIDE_INT arg_num;
6414 for (; args; args = TREE_CHAIN (args))
6416 if (! get_nonnull_operand (TREE_VALUE (args), &arg_num))
6419 if (arg_num == param_num)
6425 /* Check that the function argument PARAM (which is operand number
6426 PARAM_NUM) is non-null. This is called by check_function_nonnull
6427 via check_function_arguments_recurse. */
6430 check_nonnull_arg (ctx, param, param_num)
6431 void *ctx ATTRIBUTE_UNUSED;
6433 unsigned HOST_WIDE_INT param_num;
6435 /* Just skip checking the argument if it's not a pointer. This can
6436 happen if the "nonnull" attribute was given without an operand
6437 list (which means to check every pointer argument). */
6439 if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
6442 if (integer_zerop (param))
6443 warning ("null argument where non-null required (arg %lu)",
6444 (unsigned long) param_num);
6447 /* Helper for nonnull attribute handling; fetch the operand number
6448 from the attribute argument list. */
6451 get_nonnull_operand (arg_num_expr, valp)
6453 unsigned HOST_WIDE_INT *valp;
6455 /* Strip any conversions from the arg number and verify they
6457 while (TREE_CODE (arg_num_expr) == NOP_EXPR
6458 || TREE_CODE (arg_num_expr) == CONVERT_EXPR
6459 || TREE_CODE (arg_num_expr) == NON_LVALUE_EXPR)
6460 arg_num_expr = TREE_OPERAND (arg_num_expr, 0);
6462 if (TREE_CODE (arg_num_expr) != INTEGER_CST
6463 || TREE_INT_CST_HIGH (arg_num_expr) != 0)
6466 *valp = TREE_INT_CST_LOW (arg_num_expr);
6470 /* Handle a "nothrow" attribute; arguments as in
6471 struct attribute_spec.handler. */
6474 handle_nothrow_attribute (node, name, args, flags, no_add_attrs)
6477 tree args ATTRIBUTE_UNUSED;
6478 int flags ATTRIBUTE_UNUSED;
6481 if (TREE_CODE (*node) == FUNCTION_DECL)
6482 TREE_NOTHROW (*node) = 1;
6483 /* ??? TODO: Support types. */
6486 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
6487 *no_add_attrs = true;
6493 /* Check for valid arguments being passed to a function. */
6495 check_function_arguments (attrs, params)
6499 /* Check for null being passed in a pointer argument that must be
6500 non-null. We also need to do this if format checking is enabled. */
6503 check_function_nonnull (attrs, params);
6505 /* Check for errors in format strings. */
6508 check_function_format (NULL, attrs, params);
6511 /* Generic argument checking recursion routine. PARAM is the argument to
6512 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
6513 once the argument is resolved. CTX is context for the callback. */
6515 check_function_arguments_recurse (callback, ctx, param, param_num)
6516 void (*callback) PARAMS ((void *, tree, unsigned HOST_WIDE_INT));
6519 unsigned HOST_WIDE_INT param_num;
6521 if (TREE_CODE (param) == NOP_EXPR)
6523 /* Strip coercion. */
6524 check_function_arguments_recurse (callback, ctx,
6525 TREE_OPERAND (param, 0), param_num);
6529 if (TREE_CODE (param) == CALL_EXPR)
6531 tree type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (param, 0)));
6533 bool found_format_arg = false;
6535 /* See if this is a call to a known internationalization function
6536 that modifies a format arg. Such a function may have multiple
6537 format_arg attributes (for example, ngettext). */
6539 for (attrs = TYPE_ATTRIBUTES (type);
6541 attrs = TREE_CHAIN (attrs))
6542 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
6545 tree format_num_expr;
6549 /* Extract the argument number, which was previously checked
6551 format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
6552 while (TREE_CODE (format_num_expr) == NOP_EXPR
6553 || TREE_CODE (format_num_expr) == CONVERT_EXPR
6554 || TREE_CODE (format_num_expr) == NON_LVALUE_EXPR)
6555 format_num_expr = TREE_OPERAND (format_num_expr, 0);
6557 if (TREE_CODE (format_num_expr) != INTEGER_CST
6558 || TREE_INT_CST_HIGH (format_num_expr) != 0)
6561 format_num = TREE_INT_CST_LOW (format_num_expr);
6563 for (inner_args = TREE_OPERAND (param, 1), i = 1;
6565 inner_args = TREE_CHAIN (inner_args), i++)
6566 if (i == format_num)
6568 check_function_arguments_recurse (callback, ctx,
6569 TREE_VALUE (inner_args),
6571 found_format_arg = true;
6576 /* If we found a format_arg attribute and did a recursive check,
6577 we are done with checking this argument. Otherwise, we continue
6578 and this will be considered a non-literal. */
6579 if (found_format_arg)
6583 if (TREE_CODE (param) == COND_EXPR)
6585 /* Check both halves of the conditional expression. */
6586 check_function_arguments_recurse (callback, ctx,
6587 TREE_OPERAND (param, 1), param_num);
6588 check_function_arguments_recurse (callback, ctx,
6589 TREE_OPERAND (param, 2), param_num);
6593 (*callback) (ctx, param, param_num);
6596 #include "gt-c-common.h"