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 recognised. */
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 /* Non-zero 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 /* Non-zero means warn when declaring a class that has a non virtual
591 destructor, when it really ought to have a virtual one. */
595 /* Non-zero means warn when the compiler will reorder code. */
599 /* Non-zero means warn when synthesis behavior differs from Cfront's. */
603 /* Non-zero 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 behaviour 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 V16SF_type_node;
2035 return V4SF_type_node;
2037 return V2SF_type_node;
2039 return V2DF_type_node;
2047 /* Return an unsigned type the same as TYPE in other respects. */
2049 c_common_unsigned_type (type)
2052 tree type1 = TYPE_MAIN_VARIANT (type);
2053 if (type1 == signed_char_type_node || type1 == char_type_node)
2054 return unsigned_char_type_node;
2055 if (type1 == integer_type_node)
2056 return unsigned_type_node;
2057 if (type1 == short_integer_type_node)
2058 return short_unsigned_type_node;
2059 if (type1 == long_integer_type_node)
2060 return long_unsigned_type_node;
2061 if (type1 == long_long_integer_type_node)
2062 return long_long_unsigned_type_node;
2063 if (type1 == widest_integer_literal_type_node)
2064 return widest_unsigned_literal_type_node;
2065 #if HOST_BITS_PER_WIDE_INT >= 64
2066 if (type1 == intTI_type_node)
2067 return unsigned_intTI_type_node;
2069 if (type1 == intDI_type_node)
2070 return unsigned_intDI_type_node;
2071 if (type1 == intSI_type_node)
2072 return unsigned_intSI_type_node;
2073 if (type1 == intHI_type_node)
2074 return unsigned_intHI_type_node;
2075 if (type1 == intQI_type_node)
2076 return unsigned_intQI_type_node;
2078 return c_common_signed_or_unsigned_type (1, type);
2081 /* Return a signed type the same as TYPE in other respects. */
2084 c_common_signed_type (type)
2087 tree type1 = TYPE_MAIN_VARIANT (type);
2088 if (type1 == unsigned_char_type_node || type1 == char_type_node)
2089 return signed_char_type_node;
2090 if (type1 == unsigned_type_node)
2091 return integer_type_node;
2092 if (type1 == short_unsigned_type_node)
2093 return short_integer_type_node;
2094 if (type1 == long_unsigned_type_node)
2095 return long_integer_type_node;
2096 if (type1 == long_long_unsigned_type_node)
2097 return long_long_integer_type_node;
2098 if (type1 == widest_unsigned_literal_type_node)
2099 return widest_integer_literal_type_node;
2100 #if HOST_BITS_PER_WIDE_INT >= 64
2101 if (type1 == unsigned_intTI_type_node)
2102 return intTI_type_node;
2104 if (type1 == unsigned_intDI_type_node)
2105 return intDI_type_node;
2106 if (type1 == unsigned_intSI_type_node)
2107 return intSI_type_node;
2108 if (type1 == unsigned_intHI_type_node)
2109 return intHI_type_node;
2110 if (type1 == unsigned_intQI_type_node)
2111 return intQI_type_node;
2113 return c_common_signed_or_unsigned_type (0, type);
2116 /* Return a type the same as TYPE except unsigned or
2117 signed according to UNSIGNEDP. */
2120 c_common_signed_or_unsigned_type (unsignedp, type)
2124 if (! INTEGRAL_TYPE_P (type)
2125 || TREE_UNSIGNED (type) == unsignedp)
2128 if (TYPE_PRECISION (type) == TYPE_PRECISION (signed_char_type_node))
2129 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2130 if (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
2131 return unsignedp ? unsigned_type_node : integer_type_node;
2132 if (TYPE_PRECISION (type) == TYPE_PRECISION (short_integer_type_node))
2133 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2134 if (TYPE_PRECISION (type) == TYPE_PRECISION (long_integer_type_node))
2135 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2136 if (TYPE_PRECISION (type) == TYPE_PRECISION (long_long_integer_type_node))
2137 return (unsignedp ? long_long_unsigned_type_node
2138 : long_long_integer_type_node);
2139 if (TYPE_PRECISION (type) == TYPE_PRECISION (widest_integer_literal_type_node))
2140 return (unsignedp ? widest_unsigned_literal_type_node
2141 : widest_integer_literal_type_node);
2143 #if HOST_BITS_PER_WIDE_INT >= 64
2144 if (TYPE_PRECISION (type) == TYPE_PRECISION (intTI_type_node))
2145 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2147 if (TYPE_PRECISION (type) == TYPE_PRECISION (intDI_type_node))
2148 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2149 if (TYPE_PRECISION (type) == TYPE_PRECISION (intSI_type_node))
2150 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2151 if (TYPE_PRECISION (type) == TYPE_PRECISION (intHI_type_node))
2152 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2153 if (TYPE_PRECISION (type) == TYPE_PRECISION (intQI_type_node))
2154 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2159 /* Return the minimum number of bits needed to represent VALUE in a
2160 signed or unsigned type, UNSIGNEDP says which. */
2163 min_precision (value, unsignedp)
2169 /* If the value is negative, compute its negative minus 1. The latter
2170 adjustment is because the absolute value of the largest negative value
2171 is one larger than the largest positive value. This is equivalent to
2172 a bit-wise negation, so use that operation instead. */
2174 if (tree_int_cst_sgn (value) < 0)
2175 value = fold (build1 (BIT_NOT_EXPR, TREE_TYPE (value), value));
2177 /* Return the number of bits needed, taking into account the fact
2178 that we need one more bit for a signed than unsigned type. */
2180 if (integer_zerop (value))
2183 log = tree_floor_log2 (value);
2185 return log + 1 + ! unsignedp;
2188 /* Print an error message for invalid operands to arith operation
2189 CODE. NOP_EXPR is used as a special case (see
2190 c_common_truthvalue_conversion). */
2193 binary_op_error (code)
2194 enum tree_code code;
2201 error ("invalid truth-value expression");
2205 opname = "+"; break;
2207 opname = "-"; break;
2209 opname = "*"; break;
2211 opname = "max"; break;
2213 opname = "min"; break;
2215 opname = "=="; break;
2217 opname = "!="; break;
2219 opname = "<="; break;
2221 opname = ">="; break;
2223 opname = "<"; break;
2225 opname = ">"; break;
2227 opname = "<<"; break;
2229 opname = ">>"; break;
2230 case TRUNC_MOD_EXPR:
2231 case FLOOR_MOD_EXPR:
2232 opname = "%"; break;
2233 case TRUNC_DIV_EXPR:
2234 case FLOOR_DIV_EXPR:
2235 opname = "/"; break;
2237 opname = "&"; break;
2239 opname = "|"; break;
2240 case TRUTH_ANDIF_EXPR:
2241 opname = "&&"; break;
2242 case TRUTH_ORIF_EXPR:
2243 opname = "||"; break;
2245 opname = "^"; break;
2248 opname = "rotate"; break;
2250 opname = "unknown"; break;
2252 error ("invalid operands to binary %s", opname);
2255 /* Subroutine of build_binary_op, used for comparison operations.
2256 See if the operands have both been converted from subword integer types
2257 and, if so, perhaps change them both back to their original type.
2258 This function is also responsible for converting the two operands
2259 to the proper common type for comparison.
2261 The arguments of this function are all pointers to local variables
2262 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2263 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2265 If this function returns nonzero, it means that the comparison has
2266 a constant value. What this function returns is an expression for
2270 shorten_compare (op0_ptr, op1_ptr, restype_ptr, rescode_ptr)
2271 tree *op0_ptr, *op1_ptr;
2273 enum tree_code *rescode_ptr;
2276 tree op0 = *op0_ptr;
2277 tree op1 = *op1_ptr;
2278 int unsignedp0, unsignedp1;
2280 tree primop0, primop1;
2281 enum tree_code code = *rescode_ptr;
2283 /* Throw away any conversions to wider types
2284 already present in the operands. */
2286 primop0 = get_narrower (op0, &unsignedp0);
2287 primop1 = get_narrower (op1, &unsignedp1);
2289 /* Handle the case that OP0 does not *contain* a conversion
2290 but it *requires* conversion to FINAL_TYPE. */
2292 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
2293 unsignedp0 = TREE_UNSIGNED (TREE_TYPE (op0));
2294 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
2295 unsignedp1 = TREE_UNSIGNED (TREE_TYPE (op1));
2297 /* If one of the operands must be floated, we cannot optimize. */
2298 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
2299 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
2301 /* If first arg is constant, swap the args (changing operation
2302 so value is preserved), for canonicalization. Don't do this if
2303 the second arg is 0. */
2305 if (TREE_CONSTANT (primop0)
2306 && ! integer_zerop (primop1) && ! real_zerop (primop1))
2309 int temi = unsignedp0;
2317 unsignedp0 = unsignedp1;
2340 *rescode_ptr = code;
2343 /* If comparing an integer against a constant more bits wide,
2344 maybe we can deduce a value of 1 or 0 independent of the data.
2345 Or else truncate the constant now
2346 rather than extend the variable at run time.
2348 This is only interesting if the constant is the wider arg.
2349 Also, it is not safe if the constant is unsigned and the
2350 variable arg is signed, since in this case the variable
2351 would be sign-extended and then regarded as unsigned.
2352 Our technique fails in this case because the lowest/highest
2353 possible unsigned results don't follow naturally from the
2354 lowest/highest possible values of the variable operand.
2355 For just EQ_EXPR and NE_EXPR there is another technique that
2356 could be used: see if the constant can be faithfully represented
2357 in the other operand's type, by truncating it and reextending it
2358 and see if that preserves the constant's value. */
2360 if (!real1 && !real2
2361 && TREE_CODE (primop1) == INTEGER_CST
2362 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
2364 int min_gt, max_gt, min_lt, max_lt;
2365 tree maxval, minval;
2366 /* 1 if comparison is nominally unsigned. */
2367 int unsignedp = TREE_UNSIGNED (*restype_ptr);
2370 type = c_common_signed_or_unsigned_type (unsignedp0,
2371 TREE_TYPE (primop0));
2373 /* If TYPE is an enumeration, then we need to get its min/max
2374 values from it's underlying integral type, not the enumerated
2376 if (TREE_CODE (type) == ENUMERAL_TYPE)
2377 type = c_common_type_for_size (TYPE_PRECISION (type), unsignedp0);
2379 maxval = TYPE_MAX_VALUE (type);
2380 minval = TYPE_MIN_VALUE (type);
2382 if (unsignedp && !unsignedp0)
2383 *restype_ptr = c_common_signed_type (*restype_ptr);
2385 if (TREE_TYPE (primop1) != *restype_ptr)
2386 primop1 = convert (*restype_ptr, primop1);
2387 if (type != *restype_ptr)
2389 minval = convert (*restype_ptr, minval);
2390 maxval = convert (*restype_ptr, maxval);
2393 if (unsignedp && unsignedp0)
2395 min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
2396 max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
2397 min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
2398 max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
2402 min_gt = INT_CST_LT (primop1, minval);
2403 max_gt = INT_CST_LT (primop1, maxval);
2404 min_lt = INT_CST_LT (minval, primop1);
2405 max_lt = INT_CST_LT (maxval, primop1);
2409 /* This used to be a switch, but Genix compiler can't handle that. */
2410 if (code == NE_EXPR)
2412 if (max_lt || min_gt)
2413 val = boolean_true_node;
2415 else if (code == EQ_EXPR)
2417 if (max_lt || min_gt)
2418 val = boolean_false_node;
2420 else if (code == LT_EXPR)
2423 val = boolean_true_node;
2425 val = boolean_false_node;
2427 else if (code == GT_EXPR)
2430 val = boolean_true_node;
2432 val = boolean_false_node;
2434 else if (code == LE_EXPR)
2437 val = boolean_true_node;
2439 val = boolean_false_node;
2441 else if (code == GE_EXPR)
2444 val = boolean_true_node;
2446 val = boolean_false_node;
2449 /* If primop0 was sign-extended and unsigned comparison specd,
2450 we did a signed comparison above using the signed type bounds.
2451 But the comparison we output must be unsigned.
2453 Also, for inequalities, VAL is no good; but if the signed
2454 comparison had *any* fixed result, it follows that the
2455 unsigned comparison just tests the sign in reverse
2456 (positive values are LE, negative ones GE).
2457 So we can generate an unsigned comparison
2458 against an extreme value of the signed type. */
2460 if (unsignedp && !unsignedp0)
2467 primop1 = TYPE_MIN_VALUE (type);
2473 primop1 = TYPE_MAX_VALUE (type);
2480 type = c_common_unsigned_type (type);
2483 if (TREE_CODE (primop0) != INTEGER_CST)
2485 if (val == boolean_false_node)
2486 warning ("comparison is always false due to limited range of data type");
2487 if (val == boolean_true_node)
2488 warning ("comparison is always true due to limited range of data type");
2493 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2494 if (TREE_SIDE_EFFECTS (primop0))
2495 return build (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
2499 /* Value is not predetermined, but do the comparison
2500 in the type of the operand that is not constant.
2501 TYPE is already properly set. */
2503 else if (real1 && real2
2504 && (TYPE_PRECISION (TREE_TYPE (primop0))
2505 == TYPE_PRECISION (TREE_TYPE (primop1))))
2506 type = TREE_TYPE (primop0);
2508 /* If args' natural types are both narrower than nominal type
2509 and both extend in the same manner, compare them
2510 in the type of the wider arg.
2511 Otherwise must actually extend both to the nominal
2512 common type lest different ways of extending
2514 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
2516 else if (unsignedp0 == unsignedp1 && real1 == real2
2517 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
2518 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
2520 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2521 type = c_common_signed_or_unsigned_type (unsignedp0
2522 || TREE_UNSIGNED (*restype_ptr),
2524 /* Make sure shorter operand is extended the right way
2525 to match the longer operand. */
2527 = convert (c_common_signed_or_unsigned_type (unsignedp0,
2528 TREE_TYPE (primop0)),
2531 = convert (c_common_signed_or_unsigned_type (unsignedp1,
2532 TREE_TYPE (primop1)),
2537 /* Here we must do the comparison on the nominal type
2538 using the args exactly as we received them. */
2539 type = *restype_ptr;
2543 if (!real1 && !real2 && integer_zerop (primop1)
2544 && TREE_UNSIGNED (*restype_ptr))
2550 /* All unsigned values are >= 0, so we warn if extra warnings
2551 are requested. However, if OP0 is a constant that is
2552 >= 0, the signedness of the comparison isn't an issue,
2553 so suppress the warning. */
2554 if (extra_warnings && !in_system_header
2555 && ! (TREE_CODE (primop0) == INTEGER_CST
2556 && ! TREE_OVERFLOW (convert (c_common_signed_type (type),
2558 warning ("comparison of unsigned expression >= 0 is always true");
2559 value = boolean_true_node;
2563 if (extra_warnings && !in_system_header
2564 && ! (TREE_CODE (primop0) == INTEGER_CST
2565 && ! TREE_OVERFLOW (convert (c_common_signed_type (type),
2567 warning ("comparison of unsigned expression < 0 is always false");
2568 value = boolean_false_node;
2577 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2578 if (TREE_SIDE_EFFECTS (primop0))
2579 return build (COMPOUND_EXPR, TREE_TYPE (value),
2586 *op0_ptr = convert (type, primop0);
2587 *op1_ptr = convert (type, primop1);
2589 *restype_ptr = boolean_type_node;
2594 /* Return a tree for the sum or difference (RESULTCODE says which)
2595 of pointer PTROP and integer INTOP. */
2598 pointer_int_sum (resultcode, ptrop, intop)
2599 enum tree_code resultcode;
2607 /* The result is a pointer of the same type that is being added. */
2609 tree result_type = TREE_TYPE (ptrop);
2611 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
2613 if (pedantic || warn_pointer_arith)
2614 pedwarn ("pointer of type `void *' used in arithmetic");
2615 size_exp = integer_one_node;
2617 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
2619 if (pedantic || warn_pointer_arith)
2620 pedwarn ("pointer to a function used in arithmetic");
2621 size_exp = integer_one_node;
2623 else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
2625 if (pedantic || warn_pointer_arith)
2626 pedwarn ("pointer to member function used in arithmetic");
2627 size_exp = integer_one_node;
2629 else if (TREE_CODE (TREE_TYPE (result_type)) == OFFSET_TYPE)
2631 if (pedantic || warn_pointer_arith)
2632 pedwarn ("pointer to a member used in arithmetic");
2633 size_exp = integer_one_node;
2636 size_exp = size_in_bytes (TREE_TYPE (result_type));
2638 /* If what we are about to multiply by the size of the elements
2639 contains a constant term, apply distributive law
2640 and multiply that constant term separately.
2641 This helps produce common subexpressions. */
2643 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
2644 && ! TREE_CONSTANT (intop)
2645 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
2646 && TREE_CONSTANT (size_exp)
2647 /* If the constant comes from pointer subtraction,
2648 skip this optimization--it would cause an error. */
2649 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
2650 /* If the constant is unsigned, and smaller than the pointer size,
2651 then we must skip this optimization. This is because it could cause
2652 an overflow error if the constant is negative but INTOP is not. */
2653 && (! TREE_UNSIGNED (TREE_TYPE (intop))
2654 || (TYPE_PRECISION (TREE_TYPE (intop))
2655 == TYPE_PRECISION (TREE_TYPE (ptrop)))))
2657 enum tree_code subcode = resultcode;
2658 tree int_type = TREE_TYPE (intop);
2659 if (TREE_CODE (intop) == MINUS_EXPR)
2660 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
2661 /* Convert both subexpression types to the type of intop,
2662 because weird cases involving pointer arithmetic
2663 can result in a sum or difference with different type args. */
2664 ptrop = build_binary_op (subcode, ptrop,
2665 convert (int_type, TREE_OPERAND (intop, 1)), 1);
2666 intop = convert (int_type, TREE_OPERAND (intop, 0));
2669 /* Convert the integer argument to a type the same size as sizetype
2670 so the multiply won't overflow spuriously. */
2672 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
2673 || TREE_UNSIGNED (TREE_TYPE (intop)) != TREE_UNSIGNED (sizetype))
2674 intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
2675 TREE_UNSIGNED (sizetype)), intop);
2677 /* Replace the integer argument with a suitable product by the object size.
2678 Do this multiplication as signed, then convert to the appropriate
2679 pointer type (actually unsigned integral). */
2681 intop = convert (result_type,
2682 build_binary_op (MULT_EXPR, intop,
2683 convert (TREE_TYPE (intop), size_exp), 1));
2685 /* Create the sum or difference. */
2687 result = build (resultcode, result_type, ptrop, intop);
2689 folded = fold (result);
2690 if (folded == result)
2691 TREE_CONSTANT (folded) = TREE_CONSTANT (ptrop) & TREE_CONSTANT (intop);
2695 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2696 or validate its data type for an `if' or `while' statement or ?..: exp.
2698 This preparation consists of taking the ordinary
2699 representation of an expression expr and producing a valid tree
2700 boolean expression describing whether expr is nonzero. We could
2701 simply always do build_binary_op (NE_EXPR, expr, boolean_false_node, 1),
2702 but we optimize comparisons, &&, ||, and !.
2704 The resulting type should always be `boolean_type_node'. */
2707 c_common_truthvalue_conversion (expr)
2710 if (TREE_CODE (expr) == ERROR_MARK)
2713 #if 0 /* This appears to be wrong for C++. */
2714 /* These really should return error_mark_node after 2.4 is stable.
2715 But not all callers handle ERROR_MARK properly. */
2716 switch (TREE_CODE (TREE_TYPE (expr)))
2719 error ("struct type value used where scalar is required");
2720 return boolean_false_node;
2723 error ("union type value used where scalar is required");
2724 return boolean_false_node;
2727 error ("array type value used where scalar is required");
2728 return boolean_false_node;
2735 switch (TREE_CODE (expr))
2738 case NE_EXPR: case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
2739 case TRUTH_ANDIF_EXPR:
2740 case TRUTH_ORIF_EXPR:
2741 case TRUTH_AND_EXPR:
2743 case TRUTH_XOR_EXPR:
2744 case TRUTH_NOT_EXPR:
2745 TREE_TYPE (expr) = boolean_type_node;
2752 return integer_zerop (expr) ? boolean_false_node : boolean_true_node;
2755 return real_zerop (expr) ? boolean_false_node : boolean_true_node;
2758 /* If we are taking the address of an external decl, it might be zero
2759 if it is weak, so we cannot optimize. */
2760 if (DECL_P (TREE_OPERAND (expr, 0))
2761 && DECL_EXTERNAL (TREE_OPERAND (expr, 0)))
2764 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 0)))
2765 return build (COMPOUND_EXPR, boolean_type_node,
2766 TREE_OPERAND (expr, 0), boolean_true_node);
2768 return boolean_true_node;
2771 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
2772 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2773 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)),
2774 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2781 /* These don't change whether an object is non-zero or zero. */
2782 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2786 /* These don't change whether an object is zero or non-zero, but
2787 we can't ignore them if their second arg has side-effects. */
2788 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2789 return build (COMPOUND_EXPR, boolean_type_node, TREE_OPERAND (expr, 1),
2790 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)));
2792 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2795 /* Distribute the conversion into the arms of a COND_EXPR. */
2796 return fold (build (COND_EXPR, boolean_type_node, TREE_OPERAND (expr, 0),
2797 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2798 c_common_truthvalue_conversion (TREE_OPERAND (expr, 2))));
2801 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2802 since that affects how `default_conversion' will behave. */
2803 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
2804 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2806 /* fall through... */
2808 /* If this is widening the argument, we can ignore it. */
2809 if (TYPE_PRECISION (TREE_TYPE (expr))
2810 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2811 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2815 /* Perhaps reduce (x - y) != 0 to (x != y). The expressions
2816 aren't guaranteed to the be same for modes that can represent
2817 infinity, since if x and y are both +infinity, or both
2818 -infinity, then x - y is not a number.
2820 Note that this transformation is safe when x or y is NaN.
2821 (x - y) is then NaN, and both (x - y) != 0 and x != y will
2823 if (HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr, 0)))))
2825 /* fall through... */
2827 /* This and MINUS_EXPR can be changed into a comparison of the
2829 if (TREE_TYPE (TREE_OPERAND (expr, 0))
2830 == TREE_TYPE (TREE_OPERAND (expr, 1)))
2831 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2832 TREE_OPERAND (expr, 1), 1);
2833 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2834 fold (build1 (NOP_EXPR,
2835 TREE_TYPE (TREE_OPERAND (expr, 0)),
2836 TREE_OPERAND (expr, 1))), 1);
2839 if (integer_onep (TREE_OPERAND (expr, 1))
2840 && TREE_TYPE (expr) != boolean_type_node)
2841 /* Using convert here would cause infinite recursion. */
2842 return build1 (NOP_EXPR, boolean_type_node, expr);
2846 if (warn_parentheses && C_EXP_ORIGINAL_CODE (expr) == MODIFY_EXPR)
2847 warning ("suggest parentheses around assignment used as truth value");
2854 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
2856 tree t = save_expr (expr);
2857 return (build_binary_op
2858 ((TREE_SIDE_EFFECTS (expr)
2859 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2860 c_common_truthvalue_conversion (build_unary_op (REALPART_EXPR, t, 0)),
2861 c_common_truthvalue_conversion (build_unary_op (IMAGPART_EXPR, t, 0)),
2865 return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
2868 static tree builtin_function_2 PARAMS ((const char *, const char *, tree, tree,
2869 int, enum built_in_class, int, int,
2872 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2873 down to the element type of an array. */
2876 c_build_qualified_type (type, type_quals)
2880 /* A restrict-qualified pointer type must be a pointer to object or
2881 incomplete type. Note that the use of POINTER_TYPE_P also allows
2882 REFERENCE_TYPEs, which is appropriate for C++. Unfortunately,
2883 the C++ front-end also use POINTER_TYPE for pointer-to-member
2884 values, so even though it should be illegal to use `restrict'
2885 with such an entity we don't flag that here. Thus, special case
2886 code for that case is required in the C++ front-end. */
2887 if ((type_quals & TYPE_QUAL_RESTRICT)
2888 && (!POINTER_TYPE_P (type)
2889 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
2891 error ("invalid use of `restrict'");
2892 type_quals &= ~TYPE_QUAL_RESTRICT;
2895 if (TREE_CODE (type) == ARRAY_TYPE)
2896 return build_array_type (c_build_qualified_type (TREE_TYPE (type),
2898 TYPE_DOMAIN (type));
2899 return build_qualified_type (type, type_quals);
2902 /* Apply the TYPE_QUALS to the new DECL. */
2905 c_apply_type_quals_to_decl (type_quals, decl)
2909 if ((type_quals & TYPE_QUAL_CONST)
2910 || (TREE_TYPE (decl)
2911 && TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE))
2912 TREE_READONLY (decl) = 1;
2913 if (type_quals & TYPE_QUAL_VOLATILE)
2915 TREE_SIDE_EFFECTS (decl) = 1;
2916 TREE_THIS_VOLATILE (decl) = 1;
2918 if (type_quals & TYPE_QUAL_RESTRICT)
2920 if (!TREE_TYPE (decl)
2921 || !POINTER_TYPE_P (TREE_TYPE (decl))
2922 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (TREE_TYPE (decl))))
2923 error ("invalid use of `restrict'");
2924 else if (flag_strict_aliasing)
2925 /* Indicate we need to make a unique alias set for this pointer.
2926 We can't do it here because it might be pointing to an
2928 DECL_POINTER_ALIAS_SET (decl) = -2;
2932 /* Return the typed-based alias set for T, which may be an expression
2933 or a type. Return -1 if we don't do anything special. */
2936 c_common_get_alias_set (t)
2941 /* Permit type-punning when accessing a union, provided the access
2942 is directly through the union. For example, this code does not
2943 permit taking the address of a union member and then storing
2944 through it. Even the type-punning allowed here is a GCC
2945 extension, albeit a common and useful one; the C standard says
2946 that such accesses have implementation-defined behavior. */
2948 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
2949 u = TREE_OPERAND (u, 0))
2950 if (TREE_CODE (u) == COMPONENT_REF
2951 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
2954 /* That's all the expressions we handle specially. */
2958 /* The C standard guarantess that any object may be accessed via an
2959 lvalue that has character type. */
2960 if (t == char_type_node
2961 || t == signed_char_type_node
2962 || t == unsigned_char_type_node)
2965 /* If it has the may_alias attribute, it can alias anything. */
2966 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (t)))
2969 /* The C standard specifically allows aliasing between signed and
2970 unsigned variants of the same type. We treat the signed
2971 variant as canonical. */
2972 if (TREE_CODE (t) == INTEGER_TYPE && TREE_UNSIGNED (t))
2974 tree t1 = c_common_signed_type (t);
2976 /* t1 == t can happen for boolean nodes which are always unsigned. */
2978 return get_alias_set (t1);
2980 else if (POINTER_TYPE_P (t))
2984 /* Unfortunately, there is no canonical form of a pointer type.
2985 In particular, if we have `typedef int I', then `int *', and
2986 `I *' are different types. So, we have to pick a canonical
2987 representative. We do this below.
2989 Technically, this approach is actually more conservative that
2990 it needs to be. In particular, `const int *' and `int *'
2991 should be in different alias sets, according to the C and C++
2992 standard, since their types are not the same, and so,
2993 technically, an `int **' and `const int **' cannot point at
2996 But, the standard is wrong. In particular, this code is
3001 const int* const* cipp = &ipp;
3003 And, it doesn't make sense for that to be legal unless you
3004 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
3005 the pointed-to types. This issue has been reported to the
3007 t1 = build_type_no_quals (t);
3009 return get_alias_set (t1);
3015 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
3016 second parameter indicates which OPERATOR is being applied. The COMPLAIN
3017 flag controls whether we should diagnose possibly ill-formed
3018 constructs or not. */
3020 c_sizeof_or_alignof_type (type, op, complain)
3025 const char *op_name;
3027 enum tree_code type_code = TREE_CODE (type);
3029 my_friendly_assert (op == SIZEOF_EXPR || op == ALIGNOF_EXPR, 20020720);
3030 op_name = op == SIZEOF_EXPR ? "sizeof" : "__alignof__";
3032 if (type_code == FUNCTION_TYPE)
3034 if (op == SIZEOF_EXPR)
3036 if (complain && (pedantic || warn_pointer_arith))
3037 pedwarn ("invalid application of `sizeof' to a function type");
3038 value = size_one_node;
3041 value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
3043 else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
3045 if (type_code == VOID_TYPE
3046 && complain && (pedantic || warn_pointer_arith))
3047 pedwarn ("invalid application of `%s' to a void type", op_name);
3048 value = size_one_node;
3050 else if (!COMPLETE_TYPE_P (type))
3053 error ("invalid application of `%s' to an incomplete type", op_name);
3054 value = size_zero_node;
3058 if (op == SIZEOF_EXPR)
3059 /* Convert in case a char is more than one unit. */
3060 value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
3061 size_int (TYPE_PRECISION (char_type_node)
3064 value = size_int (TYPE_ALIGN (type) / BITS_PER_UNIT);
3067 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
3068 TYPE_IS_SIZETYPE means that certain things (like overflow) will
3069 never happen. However, this node should really have type
3070 `size_t', which is just a typedef for an ordinary integer type. */
3071 value = fold (build1 (NOP_EXPR, c_size_type_node, value));
3072 my_friendly_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)), 20001021);
3077 /* Implement the __alignof keyword: Return the minimum required
3078 alignment of EXPR, measured in bytes. For VAR_DECL's and
3079 FIELD_DECL's return DECL_ALIGN (which can be set from an
3080 "aligned" __attribute__ specification). */
3083 c_alignof_expr (expr)
3088 if (TREE_CODE (expr) == VAR_DECL)
3089 t = size_int (DECL_ALIGN (expr) / BITS_PER_UNIT);
3091 else if (TREE_CODE (expr) == COMPONENT_REF
3092 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
3094 error ("`__alignof' applied to a bit-field");
3097 else if (TREE_CODE (expr) == COMPONENT_REF
3098 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
3099 t = size_int (DECL_ALIGN (TREE_OPERAND (expr, 1)) / BITS_PER_UNIT);
3101 else if (TREE_CODE (expr) == INDIRECT_REF)
3103 tree t = TREE_OPERAND (expr, 0);
3105 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3107 while (TREE_CODE (t) == NOP_EXPR
3108 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
3112 t = TREE_OPERAND (t, 0);
3113 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3114 if (thisalign > bestalign)
3115 best = t, bestalign = thisalign;
3117 return c_alignof (TREE_TYPE (TREE_TYPE (best)));
3120 return c_alignof (TREE_TYPE (expr));
3122 return fold (build1 (NOP_EXPR, c_size_type_node, t));
3125 /* Handle C and C++ default attributes. */
3127 enum built_in_attribute
3129 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
3130 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
3131 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
3132 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
3133 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No entry needed in enum. */
3134 #include "builtin-attrs.def"
3135 #undef DEF_ATTR_NULL_TREE
3137 #undef DEF_ATTR_IDENT
3138 #undef DEF_ATTR_TREE_LIST
3143 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
3145 static bool c_attrs_initialized = false;
3147 static void c_init_attributes PARAMS ((void));
3149 /* Build tree nodes and builtin functions common to both C and C++ language
3153 c_common_nodes_and_builtins ()
3157 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
3158 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
3159 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
3160 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
3161 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3162 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3163 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
3164 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
3165 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
3166 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
3167 #include "builtin-types.def"
3168 #undef DEF_PRIMITIVE_TYPE
3169 #undef DEF_FUNCTION_TYPE_0
3170 #undef DEF_FUNCTION_TYPE_1
3171 #undef DEF_FUNCTION_TYPE_2
3172 #undef DEF_FUNCTION_TYPE_3
3173 #undef DEF_FUNCTION_TYPE_4
3174 #undef DEF_FUNCTION_TYPE_VAR_0
3175 #undef DEF_FUNCTION_TYPE_VAR_1
3176 #undef DEF_FUNCTION_TYPE_VAR_2
3177 #undef DEF_POINTER_TYPE
3181 typedef enum builtin_type builtin_type;
3183 tree builtin_types[(int) BT_LAST];
3184 int wchar_type_size;
3185 tree array_domain_type;
3186 tree va_list_ref_type_node;
3187 tree va_list_arg_type_node;
3189 /* Define `int' and `char' first so that dbx will output them first. */
3190 record_builtin_type (RID_INT, NULL, integer_type_node);
3191 record_builtin_type (RID_CHAR, "char", char_type_node);
3193 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
3194 "unsigned long", "long long unsigned" and "unsigned short" were in C++
3195 but not C. Are the conditionals here needed? */
3196 if (c_language == clk_cplusplus)
3197 record_builtin_type (RID_SIGNED, NULL, integer_type_node);
3198 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
3199 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
3200 record_builtin_type (RID_MAX, "long unsigned int",
3201 long_unsigned_type_node);
3202 if (c_language == clk_cplusplus)
3203 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
3204 record_builtin_type (RID_MAX, "long long int",
3205 long_long_integer_type_node);
3206 record_builtin_type (RID_MAX, "long long unsigned int",
3207 long_long_unsigned_type_node);
3208 if (c_language == clk_cplusplus)
3209 record_builtin_type (RID_MAX, "long long unsigned",
3210 long_long_unsigned_type_node);
3211 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
3212 record_builtin_type (RID_MAX, "short unsigned int",
3213 short_unsigned_type_node);
3214 if (c_language == clk_cplusplus)
3215 record_builtin_type (RID_MAX, "unsigned short",
3216 short_unsigned_type_node);
3218 /* Define both `signed char' and `unsigned char'. */
3219 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
3220 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
3222 /* These are types that c_common_type_for_size and
3223 c_common_type_for_mode use. */
3224 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
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 #if HOST_BITS_PER_WIDE_INT >= 64
3233 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3234 get_identifier ("__int128_t"),
3237 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3238 unsigned_intQI_type_node));
3239 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3240 unsigned_intHI_type_node));
3241 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3242 unsigned_intSI_type_node));
3243 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3244 unsigned_intDI_type_node));
3245 #if HOST_BITS_PER_WIDE_INT >= 64
3246 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3247 get_identifier ("__uint128_t"),
3248 unsigned_intTI_type_node));
3251 /* Create the widest literal types. */
3252 widest_integer_literal_type_node
3253 = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
3254 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3255 widest_integer_literal_type_node));
3257 widest_unsigned_literal_type_node
3258 = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
3259 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3260 widest_unsigned_literal_type_node));
3262 /* `unsigned long' is the standard type for sizeof.
3263 Note that stddef.h uses `unsigned long',
3264 and this must agree, even if long and int are the same size. */
3266 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
3267 signed_size_type_node = c_common_signed_type (c_size_type_node);
3268 set_sizetype (c_size_type_node);
3270 build_common_tree_nodes_2 (flag_short_double);
3272 record_builtin_type (RID_FLOAT, NULL, float_type_node);
3273 record_builtin_type (RID_DOUBLE, NULL, double_type_node);
3274 record_builtin_type (RID_MAX, "long double", long_double_type_node);
3276 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3277 get_identifier ("complex int"),
3278 complex_integer_type_node));
3279 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3280 get_identifier ("complex float"),
3281 complex_float_type_node));
3282 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3283 get_identifier ("complex double"),
3284 complex_double_type_node));
3285 (*lang_hooks.decls.pushdecl)
3286 (build_decl (TYPE_DECL, get_identifier ("complex long double"),
3287 complex_long_double_type_node));
3289 /* Types which are common to the fortran compiler and libf2c. When
3290 changing these, you also need to be concerned with f/com.h. */
3292 if (TYPE_PRECISION (float_type_node)
3293 == TYPE_PRECISION (long_integer_type_node))
3295 g77_integer_type_node = long_integer_type_node;
3296 g77_uinteger_type_node = long_unsigned_type_node;
3298 else if (TYPE_PRECISION (float_type_node)
3299 == TYPE_PRECISION (integer_type_node))
3301 g77_integer_type_node = integer_type_node;
3302 g77_uinteger_type_node = unsigned_type_node;
3305 g77_integer_type_node = g77_uinteger_type_node = NULL_TREE;
3307 if (g77_integer_type_node != NULL_TREE)
3309 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3310 get_identifier ("__g77_integer"),
3311 g77_integer_type_node));
3312 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3313 get_identifier ("__g77_uinteger"),
3314 g77_uinteger_type_node));
3317 if (TYPE_PRECISION (float_type_node) * 2
3318 == TYPE_PRECISION (long_integer_type_node))
3320 g77_longint_type_node = long_integer_type_node;
3321 g77_ulongint_type_node = long_unsigned_type_node;
3323 else if (TYPE_PRECISION (float_type_node) * 2
3324 == TYPE_PRECISION (long_long_integer_type_node))
3326 g77_longint_type_node = long_long_integer_type_node;
3327 g77_ulongint_type_node = long_long_unsigned_type_node;
3330 g77_longint_type_node = g77_ulongint_type_node = NULL_TREE;
3332 if (g77_longint_type_node != NULL_TREE)
3334 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3335 get_identifier ("__g77_longint"),
3336 g77_longint_type_node));
3337 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3338 get_identifier ("__g77_ulongint"),
3339 g77_ulongint_type_node));
3342 record_builtin_type (RID_VOID, NULL, void_type_node);
3344 void_zero_node = build_int_2 (0, 0);
3345 TREE_TYPE (void_zero_node) = void_type_node;
3347 void_list_node = build_void_list_node ();
3349 /* Make a type to be the domain of a few array types
3350 whose domains don't really matter.
3351 200 is small enough that it always fits in size_t
3352 and large enough that it can hold most function names for the
3353 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
3354 array_domain_type = build_index_type (size_int (200));
3356 /* Make a type for arrays of characters.
3357 With luck nothing will ever really depend on the length of this
3359 char_array_type_node
3360 = build_array_type (char_type_node, array_domain_type);
3362 /* Likewise for arrays of ints. */
3364 = build_array_type (integer_type_node, array_domain_type);
3366 string_type_node = build_pointer_type (char_type_node);
3367 const_string_type_node
3368 = build_pointer_type (build_qualified_type
3369 (char_type_node, TYPE_QUAL_CONST));
3371 (*targetm.init_builtins) ();
3373 /* This is special for C++ so functions can be overloaded. */
3374 wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
3375 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
3376 wchar_type_size = TYPE_PRECISION (wchar_type_node);
3377 if (c_language == clk_cplusplus)
3379 if (TREE_UNSIGNED (wchar_type_node))
3380 wchar_type_node = make_unsigned_type (wchar_type_size);
3382 wchar_type_node = make_signed_type (wchar_type_size);
3383 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
3387 signed_wchar_type_node = c_common_signed_type (wchar_type_node);
3388 unsigned_wchar_type_node = c_common_unsigned_type (wchar_type_node);
3391 /* This is for wide string constants. */
3392 wchar_array_type_node
3393 = build_array_type (wchar_type_node, array_domain_type);
3396 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
3399 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
3401 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
3403 default_function_type = build_function_type (integer_type_node, NULL_TREE);
3405 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
3406 unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
3408 (*lang_hooks.decls.pushdecl)
3409 (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
3410 va_list_type_node));
3412 (*lang_hooks.decls.pushdecl)
3413 (build_decl (TYPE_DECL, get_identifier ("__builtin_ptrdiff_t"),
3414 ptrdiff_type_node));
3416 (*lang_hooks.decls.pushdecl)
3417 (build_decl (TYPE_DECL, get_identifier ("__builtin_size_t"),
3420 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
3422 va_list_arg_type_node = va_list_ref_type_node =
3423 build_pointer_type (TREE_TYPE (va_list_type_node));
3427 va_list_arg_type_node = va_list_type_node;
3428 va_list_ref_type_node = build_reference_type (va_list_type_node);
3431 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3432 builtin_types[(int) ENUM] = VALUE;
3433 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
3434 builtin_types[(int) ENUM] \
3435 = build_function_type (builtin_types[(int) RETURN], \
3437 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
3438 builtin_types[(int) ENUM] \
3439 = build_function_type (builtin_types[(int) RETURN], \
3440 tree_cons (NULL_TREE, \
3441 builtin_types[(int) ARG1], \
3443 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
3444 builtin_types[(int) ENUM] \
3445 = build_function_type \
3446 (builtin_types[(int) RETURN], \
3447 tree_cons (NULL_TREE, \
3448 builtin_types[(int) ARG1], \
3449 tree_cons (NULL_TREE, \
3450 builtin_types[(int) ARG2], \
3452 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3453 builtin_types[(int) ENUM] \
3454 = build_function_type \
3455 (builtin_types[(int) RETURN], \
3456 tree_cons (NULL_TREE, \
3457 builtin_types[(int) ARG1], \
3458 tree_cons (NULL_TREE, \
3459 builtin_types[(int) ARG2], \
3460 tree_cons (NULL_TREE, \
3461 builtin_types[(int) ARG3], \
3463 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3464 builtin_types[(int) ENUM] \
3465 = build_function_type \
3466 (builtin_types[(int) RETURN], \
3467 tree_cons (NULL_TREE, \
3468 builtin_types[(int) ARG1], \
3469 tree_cons (NULL_TREE, \
3470 builtin_types[(int) ARG2], \
3473 builtin_types[(int) ARG3], \
3474 tree_cons (NULL_TREE, \
3475 builtin_types[(int) ARG4], \
3476 void_list_node)))));
3477 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
3478 builtin_types[(int) ENUM] \
3479 = build_function_type (builtin_types[(int) RETURN], NULL_TREE);
3480 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
3481 builtin_types[(int) ENUM] \
3482 = build_function_type (builtin_types[(int) RETURN], \
3483 tree_cons (NULL_TREE, \
3484 builtin_types[(int) ARG1], \
3487 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
3488 builtin_types[(int) ENUM] \
3489 = build_function_type \
3490 (builtin_types[(int) RETURN], \
3491 tree_cons (NULL_TREE, \
3492 builtin_types[(int) ARG1], \
3493 tree_cons (NULL_TREE, \
3494 builtin_types[(int) ARG2], \
3496 #define DEF_POINTER_TYPE(ENUM, TYPE) \
3497 builtin_types[(int) ENUM] \
3498 = build_pointer_type (builtin_types[(int) TYPE]);
3499 #include "builtin-types.def"
3500 #undef DEF_PRIMITIVE_TYPE
3501 #undef DEF_FUNCTION_TYPE_1
3502 #undef DEF_FUNCTION_TYPE_2
3503 #undef DEF_FUNCTION_TYPE_3
3504 #undef DEF_FUNCTION_TYPE_4
3505 #undef DEF_FUNCTION_TYPE_VAR_0
3506 #undef DEF_FUNCTION_TYPE_VAR_1
3507 #undef DEF_POINTER_TYPE
3509 if (!c_attrs_initialized)
3510 c_init_attributes ();
3512 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, \
3513 BOTH_P, FALLBACK_P, NONANSI_P, ATTRS) \
3518 if (strncmp (NAME, "__builtin_", strlen ("__builtin_")) != 0) \
3522 decl = builtin_function (NAME, builtin_types[TYPE], ENUM, \
3525 ? (NAME + strlen ("__builtin_")) \
3527 built_in_attributes[(int) ATTRS]); \
3529 decl = builtin_function_2 (NAME, \
3530 NAME + strlen ("__builtin_"), \
3531 builtin_types[TYPE], \
3532 builtin_types[LIBTYPE], \
3537 built_in_attributes[(int) ATTRS]); \
3539 built_in_decls[(int) ENUM] = decl; \
3541 #include "builtins.def"
3544 main_identifier_node = get_identifier ("main");
3548 build_va_arg (expr, type)
3551 return build1 (VA_ARG_EXPR, type, expr);
3555 /* Linked list of disabled built-in functions. */
3557 typedef struct disabled_builtin
3560 struct disabled_builtin *next;
3562 static disabled_builtin *disabled_builtins = NULL;
3564 static bool builtin_function_disabled_p PARAMS ((const char *));
3566 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
3567 begins with "__builtin_", give an error. */
3570 disable_builtin_function (name)
3573 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
3574 error ("cannot disable built-in function `%s'", name);
3577 disabled_builtin *new = xmalloc (sizeof (disabled_builtin));
3579 new->next = disabled_builtins;
3580 disabled_builtins = new;
3585 /* Return true if the built-in function NAME has been disabled, false
3589 builtin_function_disabled_p (name)
3592 disabled_builtin *p;
3593 for (p = disabled_builtins; p != NULL; p = p->next)
3595 if (strcmp (name, p->name) == 0)
3602 /* Possibly define a builtin function with one or two names. BUILTIN_NAME
3603 is an __builtin_-prefixed name; NAME is the ordinary name; one or both
3604 of these may be NULL (though both being NULL is useless).
3605 BUILTIN_TYPE is the type of the __builtin_-prefixed function;
3606 TYPE is the type of the function with the ordinary name. These
3607 may differ if the ordinary name is declared with a looser type to avoid
3608 conflicts with headers. FUNCTION_CODE and CLASS are as for
3609 builtin_function. If LIBRARY_NAME_P is nonzero, NAME is passed as
3610 the LIBRARY_NAME parameter to builtin_function when declaring BUILTIN_NAME.
3611 If NONANSI_P is nonzero, the name NAME is treated as a non-ANSI name;
3612 ATTRS is the tree list representing the builtin's function attributes.
3613 Returns the declaration of BUILTIN_NAME, if any, otherwise
3614 the declaration of NAME. Does not declare NAME if flag_no_builtin,
3615 or if NONANSI_P and flag_no_nonansi_builtin. */
3618 builtin_function_2 (builtin_name, name, builtin_type, type, function_code,
3619 class, library_name_p, nonansi_p, attrs)
3620 const char *builtin_name;
3625 enum built_in_class class;
3630 tree bdecl = NULL_TREE;
3631 tree decl = NULL_TREE;
3632 if (builtin_name != 0)
3634 bdecl = builtin_function (builtin_name, builtin_type, function_code,
3635 class, library_name_p ? name : NULL,
3638 if (name != 0 && !flag_no_builtin && !builtin_function_disabled_p (name)
3639 && !(nonansi_p && flag_no_nonansi_builtin))
3641 decl = builtin_function (name, type, function_code, class, NULL,
3644 DECL_BUILT_IN_NONANSI (decl) = 1;
3646 return (bdecl != 0 ? bdecl : decl);
3649 /* Nonzero if the type T promotes to int. This is (nearly) the
3650 integral promotions defined in ISO C99 6.3.1.1/2. */
3653 c_promoting_integer_type_p (t)
3656 switch (TREE_CODE (t))
3659 return (TYPE_MAIN_VARIANT (t) == char_type_node
3660 || TYPE_MAIN_VARIANT (t) == signed_char_type_node
3661 || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
3662 || TYPE_MAIN_VARIANT (t) == short_integer_type_node
3663 || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
3664 || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
3667 /* ??? Technically all enumerations not larger than an int
3668 promote to an int. But this is used along code paths
3669 that only want to notice a size change. */
3670 return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
3680 /* Return 1 if PARMS specifies a fixed number of parameters
3681 and none of their types is affected by default promotions. */
3684 self_promoting_args_p (parms)
3688 for (t = parms; t; t = TREE_CHAIN (t))
3690 tree type = TREE_VALUE (t);
3692 if (TREE_CHAIN (t) == 0 && type != void_type_node)
3698 if (TYPE_MAIN_VARIANT (type) == float_type_node)
3701 if (c_promoting_integer_type_p (type))
3707 /* Recursively examines the array elements of TYPE, until a non-array
3708 element type is found. */
3711 strip_array_types (type)
3714 while (TREE_CODE (type) == ARRAY_TYPE)
3715 type = TREE_TYPE (type);
3720 static tree expand_unordered_cmp PARAMS ((tree, tree, enum tree_code,
3723 /* Expand a call to an unordered comparison function such as
3724 __builtin_isgreater(). FUNCTION is the function's declaration and
3725 PARAMS a list of the values passed. For __builtin_isunordered(),
3726 UNORDERED_CODE is UNORDERED_EXPR and ORDERED_CODE is NOP_EXPR. In
3727 other cases, UNORDERED_CODE and ORDERED_CODE are comparison codes
3728 that give the opposite of the desired result. UNORDERED_CODE is
3729 used for modes that can hold NaNs and ORDERED_CODE is used for the
3733 expand_unordered_cmp (function, params, unordered_code, ordered_code)
3734 tree function, params;
3735 enum tree_code unordered_code, ordered_code;
3737 tree arg0, arg1, type;
3738 enum tree_code code0, code1;
3740 /* Check that we have exactly two arguments. */
3741 if (params == 0 || TREE_CHAIN (params) == 0)
3743 error ("too few arguments to function `%s'",
3744 IDENTIFIER_POINTER (DECL_NAME (function)));
3745 return error_mark_node;
3747 else if (TREE_CHAIN (TREE_CHAIN (params)) != 0)
3749 error ("too many arguments to function `%s'",
3750 IDENTIFIER_POINTER (DECL_NAME (function)));
3751 return error_mark_node;
3754 arg0 = TREE_VALUE (params);
3755 arg1 = TREE_VALUE (TREE_CHAIN (params));
3757 code0 = TREE_CODE (TREE_TYPE (arg0));
3758 code1 = TREE_CODE (TREE_TYPE (arg1));
3760 /* Make sure that the arguments have a common type of REAL. */
3762 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
3763 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
3764 type = common_type (TREE_TYPE (arg0), TREE_TYPE (arg1));
3766 if (type == 0 || TREE_CODE (type) != REAL_TYPE)
3768 error ("non-floating-point argument to function `%s'",
3769 IDENTIFIER_POINTER (DECL_NAME (function)));
3770 return error_mark_node;
3773 if (unordered_code == UNORDERED_EXPR)
3775 if (MODE_HAS_NANS (TYPE_MODE (type)))
3776 return build_binary_op (unordered_code,
3777 convert (type, arg0),
3778 convert (type, arg1),
3781 return integer_zero_node;
3784 return build_unary_op (TRUTH_NOT_EXPR,
3785 build_binary_op (MODE_HAS_NANS (TYPE_MODE (type))
3788 convert (type, arg0),
3789 convert (type, arg1),
3795 /* Recognize certain built-in functions so we can make tree-codes
3796 other than CALL_EXPR. We do this when it enables fold-const.c
3797 to do something useful. */
3798 /* ??? By rights this should go in builtins.c, but only C and C++
3799 implement build_{binary,unary}_op. Not exactly sure what bits
3800 of functionality are actually needed from those functions, or
3801 where the similar functionality exists in the other front ends. */
3804 expand_tree_builtin (function, params, coerced_params)
3805 tree function, params, coerced_params;
3807 if (DECL_BUILT_IN_CLASS (function) != BUILT_IN_NORMAL)
3810 switch (DECL_FUNCTION_CODE (function))
3814 case BUILT_IN_LLABS:
3815 case BUILT_IN_IMAXABS:
3817 case BUILT_IN_FABSL:
3818 case BUILT_IN_FABSF:
3819 if (coerced_params == 0)
3820 return integer_zero_node;
3821 return build_unary_op (ABS_EXPR, TREE_VALUE (coerced_params), 0);
3824 case BUILT_IN_CONJF:
3825 case BUILT_IN_CONJL:
3826 if (coerced_params == 0)
3827 return integer_zero_node;
3828 return build_unary_op (CONJ_EXPR, TREE_VALUE (coerced_params), 0);
3830 case BUILT_IN_CREAL:
3831 case BUILT_IN_CREALF:
3832 case BUILT_IN_CREALL:
3833 if (coerced_params == 0)
3834 return integer_zero_node;
3835 return build_unary_op (REALPART_EXPR, TREE_VALUE (coerced_params), 0);
3837 case BUILT_IN_CIMAG:
3838 case BUILT_IN_CIMAGF:
3839 case BUILT_IN_CIMAGL:
3840 if (coerced_params == 0)
3841 return integer_zero_node;
3842 return build_unary_op (IMAGPART_EXPR, TREE_VALUE (coerced_params), 0);
3844 case BUILT_IN_ISGREATER:
3845 return expand_unordered_cmp (function, params, UNLE_EXPR, LE_EXPR);
3847 case BUILT_IN_ISGREATEREQUAL:
3848 return expand_unordered_cmp (function, params, UNLT_EXPR, LT_EXPR);
3850 case BUILT_IN_ISLESS:
3851 return expand_unordered_cmp (function, params, UNGE_EXPR, GE_EXPR);
3853 case BUILT_IN_ISLESSEQUAL:
3854 return expand_unordered_cmp (function, params, UNGT_EXPR, GT_EXPR);
3856 case BUILT_IN_ISLESSGREATER:
3857 return expand_unordered_cmp (function, params, UNEQ_EXPR, EQ_EXPR);
3859 case BUILT_IN_ISUNORDERED:
3860 return expand_unordered_cmp (function, params, UNORDERED_EXPR, NOP_EXPR);
3869 /* Returns non-zero if CODE is the code for a statement. */
3872 statement_code_p (code)
3873 enum tree_code code;
3898 if (lang_statement_code_p)
3899 return (*lang_statement_code_p) (code);
3904 /* Walk the statement tree, rooted at *tp. Apply FUNC to all the
3905 sub-trees of *TP in a pre-order traversal. FUNC is called with the
3906 DATA and the address of each sub-tree. If FUNC returns a non-NULL
3907 value, the traversal is aborted, and the value returned by FUNC is
3908 returned. If FUNC sets WALK_SUBTREES to zero, then the subtrees of
3909 the node being visited are not walked.
3911 We don't need a without_duplicates variant of this one because the
3912 statement tree is a tree, not a graph. */
3915 walk_stmt_tree (tp, func, data)
3920 enum tree_code code;
3925 #define WALK_SUBTREE(NODE) \
3928 result = walk_stmt_tree (&(NODE), func, data); \
3934 /* Skip empty subtrees. */
3938 /* Skip subtrees below non-statement nodes. */
3939 if (!statement_code_p (TREE_CODE (*tp)))
3942 /* Call the function. */
3944 result = (*func) (tp, &walk_subtrees, data);
3946 /* If we found something, return it. */
3950 /* FUNC may have modified the tree, recheck that we're looking at a
3952 code = TREE_CODE (*tp);
3953 if (!statement_code_p (code))
3956 /* Visit the subtrees unless FUNC decided that there was nothing
3957 interesting below this point in the tree. */
3960 /* Walk over all the sub-trees of this operand. Statement nodes
3961 never contain RTL, and we needn't worry about TARGET_EXPRs. */
3962 len = TREE_CODE_LENGTH (code);
3964 /* Go through the subtrees. We need to do this in forward order so
3965 that the scope of a FOR_EXPR is handled properly. */
3966 for (i = 0; i < len; ++i)
3967 WALK_SUBTREE (TREE_OPERAND (*tp, i));
3970 /* Finally visit the chain. This can be tail-recursion optimized if
3971 we write it this way. */
3972 return walk_stmt_tree (&TREE_CHAIN (*tp), func, data);
3977 /* Used to compare case labels. K1 and K2 are actually tree nodes
3978 representing case labels, or NULL_TREE for a `default' label.
3979 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3980 K2, and 0 if K1 and K2 are equal. */
3983 case_compare (k1, k2)
3987 /* Consider a NULL key (such as arises with a `default' label) to be
3988 smaller than anything else. */
3994 return tree_int_cst_compare ((tree) k1, (tree) k2);
3997 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
3998 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3999 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
4000 case label was declared using the usual C/C++ syntax, rather than
4001 the GNU case range extension. CASES is a tree containing all the
4002 case ranges processed so far; COND is the condition for the
4003 switch-statement itself. Returns the CASE_LABEL created, or
4004 ERROR_MARK_NODE if no CASE_LABEL is created. */
4007 c_add_case_label (cases, cond, low_value, high_value)
4016 splay_tree_node node;
4018 /* Create the LABEL_DECL itself. */
4019 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
4020 DECL_CONTEXT (label) = current_function_decl;
4022 /* If there was an error processing the switch condition, bail now
4023 before we get more confused. */
4024 if (!cond || cond == error_mark_node)
4026 /* Add a label anyhow so that the back-end doesn't think that
4027 the beginning of the switch is unreachable. */
4029 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
4030 return error_mark_node;
4033 if ((low_value && TREE_TYPE (low_value)
4034 && POINTER_TYPE_P (TREE_TYPE (low_value)))
4035 || (high_value && TREE_TYPE (high_value)
4036 && POINTER_TYPE_P (TREE_TYPE (high_value))))
4037 error ("pointers are not permitted as case values");
4039 /* Case ranges are a GNU extension. */
4040 if (high_value && pedantic)
4042 if (c_language == clk_cplusplus)
4043 pedwarn ("ISO C++ forbids range expressions in switch statements");
4045 pedwarn ("ISO C forbids range expressions in switch statements");
4048 type = TREE_TYPE (cond);
4051 low_value = check_case_value (low_value);
4052 low_value = convert_and_check (type, low_value);
4056 high_value = check_case_value (high_value);
4057 high_value = convert_and_check (type, high_value);
4060 /* If an error has occurred, bail out now. */
4061 if (low_value == error_mark_node || high_value == error_mark_node)
4064 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
4065 return error_mark_node;
4068 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
4069 really a case range, even though it was written that way. Remove
4070 the HIGH_VALUE to simplify later processing. */
4071 if (tree_int_cst_equal (low_value, high_value))
4072 high_value = NULL_TREE;
4073 if (low_value && high_value
4074 && !tree_int_cst_lt (low_value, high_value))
4075 warning ("empty range specified");
4077 /* Look up the LOW_VALUE in the table of case labels we already
4079 node = splay_tree_lookup (cases, (splay_tree_key) low_value);
4080 /* If there was not an exact match, check for overlapping ranges.
4081 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
4082 that's a `default' label and the only overlap is an exact match. */
4083 if (!node && (low_value || high_value))
4085 splay_tree_node low_bound;
4086 splay_tree_node high_bound;
4088 /* Even though there wasn't an exact match, there might be an
4089 overlap between this case range and another case range.
4090 Since we've (inductively) not allowed any overlapping case
4091 ranges, we simply need to find the greatest low case label
4092 that is smaller that LOW_VALUE, and the smallest low case
4093 label that is greater than LOW_VALUE. If there is an overlap
4094 it will occur in one of these two ranges. */
4095 low_bound = splay_tree_predecessor (cases,
4096 (splay_tree_key) low_value);
4097 high_bound = splay_tree_successor (cases,
4098 (splay_tree_key) low_value);
4100 /* Check to see if the LOW_BOUND overlaps. It is smaller than
4101 the LOW_VALUE, so there is no need to check unless the
4102 LOW_BOUND is in fact itself a case range. */
4104 && CASE_HIGH ((tree) low_bound->value)
4105 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
4108 /* Check to see if the HIGH_BOUND overlaps. The low end of that
4109 range is bigger than the low end of the current range, so we
4110 are only interested if the current range is a real range, and
4111 not an ordinary case label. */
4114 && (tree_int_cst_compare ((tree) high_bound->key,
4119 /* If there was an overlap, issue an error. */
4122 tree duplicate = CASE_LABEL_DECL ((tree) node->value);
4126 error ("duplicate (or overlapping) case value");
4127 error_with_decl (duplicate,
4128 "this is the first entry overlapping that value");
4132 error ("duplicate case value") ;
4133 error_with_decl (duplicate, "previously used here");
4137 error ("multiple default labels in one switch");
4138 error_with_decl (duplicate, "this is the first default label");
4141 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
4144 /* Add a CASE_LABEL to the statement-tree. */
4145 case_label = add_stmt (build_case_label (low_value, high_value, label));
4146 /* Register this case label in the splay tree. */
4147 splay_tree_insert (cases,
4148 (splay_tree_key) low_value,
4149 (splay_tree_value) case_label);
4154 /* Finish an expression taking the address of LABEL. Returns an
4155 expression for the address. */
4158 finish_label_address_expr (label)
4165 if (c_language == clk_cplusplus)
4166 pedwarn ("ISO C++ forbids taking the address of a label");
4168 pedwarn ("ISO C forbids taking the address of a label");
4171 label = lookup_label (label);
4172 if (label == NULL_TREE)
4173 result = null_pointer_node;
4176 TREE_USED (label) = 1;
4177 result = build1 (ADDR_EXPR, ptr_type_node, label);
4178 TREE_CONSTANT (result) = 1;
4179 /* The current function in not necessarily uninlinable.
4180 Computed gotos are incompatible with inlining, but the value
4181 here could be used only in a diagnostic, for example. */
4187 /* Hook used by expand_expr to expand language-specific tree codes. */
4190 c_expand_expr (exp, target, tmode, modifier)
4193 enum machine_mode tmode;
4194 int modifier; /* Actually enum_modifier. */
4196 switch (TREE_CODE (exp))
4202 bool preserve_result = false;
4203 bool return_target = false;
4205 /* Since expand_expr_stmt calls free_temp_slots after every
4206 expression statement, we must call push_temp_slots here.
4207 Otherwise, any temporaries in use now would be considered
4208 out-of-scope after the first EXPR_STMT from within the
4211 rtl_expr = expand_start_stmt_expr (!STMT_EXPR_NO_SCOPE (exp));
4213 /* If we want the result of this expression, find the last
4214 EXPR_STMT in the COMPOUND_STMT and mark it as addressable. */
4215 if (target != const0_rtx
4216 && TREE_CODE (STMT_EXPR_STMT (exp)) == COMPOUND_STMT
4217 && TREE_CODE (COMPOUND_BODY (STMT_EXPR_STMT (exp))) == SCOPE_STMT)
4219 tree expr = COMPOUND_BODY (STMT_EXPR_STMT (exp));
4220 tree last = TREE_CHAIN (expr);
4222 while (TREE_CHAIN (last))
4225 last = TREE_CHAIN (last);
4228 if (TREE_CODE (last) == SCOPE_STMT
4229 && TREE_CODE (expr) == EXPR_STMT)
4231 if (target && TREE_CODE (EXPR_STMT_EXPR (expr)) == VAR_DECL
4232 && DECL_RTL_IF_SET (EXPR_STMT_EXPR (expr)) == target)
4233 /* If the last expression is a variable whose RTL is the
4234 same as our target, just return the target; if it
4235 isn't valid expanding the decl would produce different
4236 RTL, and store_expr would try to do a copy. */
4237 return_target = true;
4240 /* Otherwise, note that we want the value from the last
4242 TREE_ADDRESSABLE (expr) = 1;
4243 preserve_result = true;
4248 expand_stmt (STMT_EXPR_STMT (exp));
4249 expand_end_stmt_expr (rtl_expr);
4251 result = expand_expr (rtl_expr, target, tmode, modifier);
4254 else if (preserve_result && GET_CODE (result) == MEM)
4256 if (GET_MODE (result) != BLKmode)
4257 result = copy_to_reg (result);
4259 preserve_temp_slots (result);
4262 /* If the statment-expression does not have a scope, then the
4263 new temporaries we created within it must live beyond the
4264 statement-expression. */
4265 if (STMT_EXPR_NO_SCOPE (exp))
4266 preserve_temp_slots (NULL_RTX);
4275 if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
4276 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
4278 && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
4279 && (DECL_BUILT_IN_CLASS (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
4280 == BUILT_IN_FRONTEND))
4281 return c_expand_builtin (exp, target, tmode, modifier);
4287 case COMPOUND_LITERAL_EXPR:
4289 /* Initialize the anonymous variable declared in the compound
4290 literal, then return the variable. */
4291 tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
4292 emit_local_var (decl);
4293 return expand_expr (decl, target, tmode, modifier);
4304 /* Hook used by safe_from_p to handle language-specific tree codes. */
4307 c_safe_from_p (target, exp)
4311 /* We can see statements here when processing the body of a
4312 statement-expression. For a declaration statement declaring a
4313 variable, look at the variable's initializer. */
4314 if (TREE_CODE (exp) == DECL_STMT)
4316 tree decl = DECL_STMT_DECL (exp);
4318 if (TREE_CODE (decl) == VAR_DECL
4319 && DECL_INITIAL (decl)
4320 && !safe_from_p (target, DECL_INITIAL (decl), /*top_p=*/0))
4324 /* For any statement, we must follow the statement-chain. */
4325 if (statement_code_p (TREE_CODE (exp)) && TREE_CHAIN (exp))
4326 return safe_from_p (target, TREE_CHAIN (exp), /*top_p=*/0);
4328 /* Assume everything else is safe. */
4332 /* Hook used by unsafe_for_reeval to handle language-specific tree codes. */
4335 c_common_unsafe_for_reeval (exp)
4338 /* Statement expressions may not be reevaluated, likewise compound
4340 if (TREE_CODE (exp) == STMT_EXPR
4341 || TREE_CODE (exp) == COMPOUND_LITERAL_EXPR)
4344 /* Walk all other expressions. */
4348 /* Hook used by staticp to handle language-specific tree codes. */
4354 if (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR
4355 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp)))
4360 #define CALLED_AS_BUILT_IN(NODE) \
4361 (!strncmp (IDENTIFIER_POINTER (DECL_NAME (NODE)), "__builtin_", 10))
4364 c_expand_builtin (exp, target, tmode, modifier)
4367 enum machine_mode tmode;
4368 enum expand_modifier modifier;
4370 tree type = TREE_TYPE (exp);
4371 tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
4372 tree arglist = TREE_OPERAND (exp, 1);
4373 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
4374 enum tree_code code = TREE_CODE (exp);
4375 const int ignore = (target == const0_rtx
4376 || ((code == NON_LVALUE_EXPR || code == NOP_EXPR
4377 || code == CONVERT_EXPR || code == REFERENCE_EXPR
4378 || code == COND_EXPR)
4379 && TREE_CODE (type) == VOID_TYPE));
4381 if (! optimize && ! CALLED_AS_BUILT_IN (fndecl))
4382 return expand_call (exp, target, ignore);
4386 case BUILT_IN_PRINTF:
4387 target = c_expand_builtin_printf (arglist, target, tmode,
4388 modifier, ignore, /*unlocked=*/ 0);
4393 case BUILT_IN_PRINTF_UNLOCKED:
4394 target = c_expand_builtin_printf (arglist, target, tmode,
4395 modifier, ignore, /*unlocked=*/ 1);
4400 case BUILT_IN_FPRINTF:
4401 target = c_expand_builtin_fprintf (arglist, target, tmode,
4402 modifier, ignore, /*unlocked=*/ 0);
4407 case BUILT_IN_FPRINTF_UNLOCKED:
4408 target = c_expand_builtin_fprintf (arglist, target, tmode,
4409 modifier, ignore, /*unlocked=*/ 1);
4414 default: /* just do library call, if unknown builtin */
4415 error ("built-in function `%s' not currently supported",
4416 IDENTIFIER_POINTER (DECL_NAME (fndecl)));
4419 /* The switch statement above can drop through to cause the function
4420 to be called normally. */
4421 return expand_call (exp, target, ignore);
4424 /* Check an arglist to *printf for problems. The arglist should start
4425 at the format specifier, with the remaining arguments immediately
4428 is_valid_printf_arglist (arglist)
4431 /* Save this value so we can restore it later. */
4432 const int SAVE_pedantic = pedantic;
4433 int diagnostic_occurred = 0;
4436 /* Set this to a known value so the user setting won't affect code
4439 /* Check to make sure there are no format specifier errors. */
4440 attrs = tree_cons (get_identifier ("format"),
4441 tree_cons (NULL_TREE,
4442 get_identifier ("printf"),
4443 tree_cons (NULL_TREE,
4445 tree_cons (NULL_TREE,
4449 check_function_format (&diagnostic_occurred, attrs, arglist);
4451 /* Restore the value of `pedantic'. */
4452 pedantic = SAVE_pedantic;
4454 /* If calling `check_function_format_ptr' produces a warning, we
4455 return false, otherwise we return true. */
4456 return ! diagnostic_occurred;
4459 /* If the arguments passed to printf are suitable for optimizations,
4460 we attempt to transform the call. */
4462 c_expand_builtin_printf (arglist, target, tmode, modifier, ignore, unlocked)
4465 enum machine_mode tmode;
4466 enum expand_modifier modifier;
4470 tree fn_putchar = unlocked ?
4471 built_in_decls[BUILT_IN_PUTCHAR_UNLOCKED] : built_in_decls[BUILT_IN_PUTCHAR];
4472 tree fn_puts = unlocked ?
4473 built_in_decls[BUILT_IN_PUTS_UNLOCKED] : built_in_decls[BUILT_IN_PUTS];
4474 tree fn, format_arg, stripped_string;
4476 /* If the return value is used, or the replacement _DECL isn't
4477 initialized, don't do the transformation. */
4478 if (!ignore || !fn_putchar || !fn_puts)
4481 /* Verify the required arguments in the original call. */
4483 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE))
4486 /* Check the specifier vs. the parameters. */
4487 if (!is_valid_printf_arglist (arglist))
4490 format_arg = TREE_VALUE (arglist);
4491 stripped_string = format_arg;
4492 STRIP_NOPS (stripped_string);
4493 if (stripped_string && TREE_CODE (stripped_string) == ADDR_EXPR)
4494 stripped_string = TREE_OPERAND (stripped_string, 0);
4496 /* If the format specifier isn't a STRING_CST, punt. */
4497 if (TREE_CODE (stripped_string) != STRING_CST)
4500 /* OK! We can attempt optimization. */
4502 /* If the format specifier was "%s\n", call __builtin_puts(arg2). */
4503 if (strcmp (TREE_STRING_POINTER (stripped_string), "%s\n") == 0)
4505 arglist = TREE_CHAIN (arglist);
4508 /* If the format specifier was "%c", call __builtin_putchar (arg2). */
4509 else if (strcmp (TREE_STRING_POINTER (stripped_string), "%c") == 0)
4511 arglist = TREE_CHAIN (arglist);
4516 /* We can't handle anything else with % args or %% ... yet. */
4517 if (strchr (TREE_STRING_POINTER (stripped_string), '%'))
4520 /* If the resulting constant string has a length of 1, call
4521 putchar. Note, TREE_STRING_LENGTH includes the terminating
4522 NULL in its count. */
4523 if (TREE_STRING_LENGTH (stripped_string) == 2)
4525 /* Given printf("c"), (where c is any one character,)
4526 convert "c"[0] to an int and pass that to the replacement
4528 arglist = build_int_2 (TREE_STRING_POINTER (stripped_string)[0], 0);
4529 arglist = build_tree_list (NULL_TREE, arglist);
4533 /* If the resulting constant was "string\n", call
4534 __builtin_puts("string"). Ensure "string" has at least one
4535 character besides the trailing \n. Note, TREE_STRING_LENGTH
4536 includes the terminating NULL in its count. */
4537 else if (TREE_STRING_LENGTH (stripped_string) > 2
4538 && TREE_STRING_POINTER (stripped_string)
4539 [TREE_STRING_LENGTH (stripped_string) - 2] == '\n')
4541 /* Create a NULL-terminated string that's one char shorter
4542 than the original, stripping off the trailing '\n'. */
4543 const int newlen = TREE_STRING_LENGTH (stripped_string) - 1;
4544 char *newstr = (char *) alloca (newlen);
4545 memcpy (newstr, TREE_STRING_POINTER (stripped_string), newlen - 1);
4546 newstr[newlen - 1] = 0;
4548 arglist = fix_string_type (build_string (newlen, newstr));
4549 arglist = build_tree_list (NULL_TREE, arglist);
4553 /* We'd like to arrange to call fputs(string) here, but we
4554 need stdout and don't have a way to get it ... yet. */
4558 return expand_expr (build_function_call (fn, arglist),
4559 (ignore ? const0_rtx : target),
4563 /* If the arguments passed to fprintf are suitable for optimizations,
4564 we attempt to transform the call. */
4566 c_expand_builtin_fprintf (arglist, target, tmode, modifier, ignore, unlocked)
4569 enum machine_mode tmode;
4570 enum expand_modifier modifier;
4574 tree fn_fputc = unlocked ?
4575 built_in_decls[BUILT_IN_FPUTC_UNLOCKED] : built_in_decls[BUILT_IN_FPUTC];
4576 tree fn_fputs = unlocked ?
4577 built_in_decls[BUILT_IN_FPUTS_UNLOCKED] : built_in_decls[BUILT_IN_FPUTS];
4578 tree fn, format_arg, stripped_string;
4580 /* If the return value is used, or the replacement _DECL isn't
4581 initialized, don't do the transformation. */
4582 if (!ignore || !fn_fputc || !fn_fputs)
4585 /* Verify the required arguments in the original call. */
4587 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE)
4588 || (TREE_CHAIN (arglist) == 0)
4589 || (TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist)))) !=
4593 /* Check the specifier vs. the parameters. */
4594 if (!is_valid_printf_arglist (TREE_CHAIN (arglist)))
4597 format_arg = TREE_VALUE (TREE_CHAIN (arglist));
4598 stripped_string = format_arg;
4599 STRIP_NOPS (stripped_string);
4600 if (stripped_string && TREE_CODE (stripped_string) == ADDR_EXPR)
4601 stripped_string = TREE_OPERAND (stripped_string, 0);
4603 /* If the format specifier isn't a STRING_CST, punt. */
4604 if (TREE_CODE (stripped_string) != STRING_CST)
4607 /* OK! We can attempt optimization. */
4609 /* If the format specifier was "%s", call __builtin_fputs(arg3, arg1). */
4610 if (strcmp (TREE_STRING_POINTER (stripped_string), "%s") == 0)
4612 tree newarglist = build_tree_list (NULL_TREE, TREE_VALUE (arglist));
4613 arglist = tree_cons (NULL_TREE,
4614 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))),
4618 /* If the format specifier was "%c", call __builtin_fputc (arg3, arg1). */
4619 else if (strcmp (TREE_STRING_POINTER (stripped_string), "%c") == 0)
4621 tree newarglist = build_tree_list (NULL_TREE, TREE_VALUE (arglist));
4622 arglist = tree_cons (NULL_TREE,
4623 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))),
4629 /* We can't handle anything else with % args or %% ... yet. */
4630 if (strchr (TREE_STRING_POINTER (stripped_string), '%'))
4633 /* When "string" doesn't contain %, replace all cases of
4634 fprintf(stream,string) with fputs(string,stream). The fputs
4635 builtin will take take of special cases like length==1. */
4636 arglist = tree_cons (NULL_TREE, TREE_VALUE (TREE_CHAIN (arglist)),
4637 build_tree_list (NULL_TREE, TREE_VALUE (arglist)));
4641 return expand_expr (build_function_call (fn, arglist),
4642 (ignore ? const0_rtx : target),
4647 /* Given a boolean expression ARG, return a tree representing an increment
4648 or decrement (as indicated by CODE) of ARG. The front end must check for
4649 invalid cases (e.g., decrement in C++). */
4651 boolean_increment (code, arg)
4652 enum tree_code code;
4656 tree true_res = (c_language == clk_cplusplus
4658 : c_bool_true_node);
4659 arg = stabilize_reference (arg);
4662 case PREINCREMENT_EXPR:
4663 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4665 case POSTINCREMENT_EXPR:
4666 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4667 arg = save_expr (arg);
4668 val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4669 val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4671 case PREDECREMENT_EXPR:
4672 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
4674 case POSTDECREMENT_EXPR:
4675 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
4676 arg = save_expr (arg);
4677 val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4678 val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4683 TREE_SIDE_EFFECTS (val) = 1;
4687 /* Define macros necessary to describe fundamental data type formats. */
4689 cpp_define_data_format (pfile)
4694 /* Define endianness enumeration values. */
4695 cpp_define (pfile, "__GCC_LITTLE_ENDIAN__=0");
4696 cpp_define (pfile, "__GCC_BIG_ENDIAN__=1");
4698 /* Define supported floating-point format enumeration values. */
4699 cpp_define (pfile, "__UNKNOWN_FORMAT__=0");
4700 cpp_define (pfile, "__IEEE_FORMAT__=1");
4701 cpp_define (pfile, "__IBM_FORMAT__=2");
4702 cpp_define (pfile, "__C4X_FORMAT__=3");
4703 cpp_define (pfile, "__VAX_FORMAT__=4");
4705 /* Define target endianness:
4708 - word order in an integer that spans a multi-word
4709 - word order in a floating-poing that spans a multi-word */
4710 if (BITS_BIG_ENDIAN)
4711 cpp_define (pfile, "__TARGET_BITS_ORDER__=__GCC_BIG_ENDIAN__");
4713 cpp_define (pfile, "__TARGET_BITS_ORDER__=__GCC_BIG_ENDIAN__");
4714 if (BYTES_BIG_ENDIAN)
4715 cpp_define (pfile, "__TARGET_BYTES_ORDER__=__GCC_BIG_ENDIAN__");
4717 cpp_define (pfile, "__TARGET_BYTES_ORDER__=__GCC_LITTLE_ENDIAN__");
4718 /* Define words order in a multi-word integer. */
4719 if (WORDS_BIG_ENDIAN)
4720 cpp_define (pfile, "__TARGET_INT_WORDS_ORDER__=__GCC_BIG_ENDIAN__");
4722 cpp_define (pfile, "__TARGET_INT_WORDS_ORDER__=__GCC_LITTLE_ENDIAN__");
4723 /* Define words order in a multi-word floating point. */
4724 if (FLOAT_WORDS_BIG_ENDIAN)
4725 cpp_define (pfile, "__TARGET_FLOAT_WORDS_ORDER__=__GCC_BIG_ENDIAN__");
4727 cpp_define (pfile, "__TARGET_FLOAT_WORDS_ORDER__=__GCC_LITTLE_ENDIAN__");
4729 switch (TARGET_FLOAT_FORMAT)
4731 case UNKNOWN_FLOAT_FORMAT:
4732 format = "__UNKNOWN_FORMAT__";
4735 case IEEE_FLOAT_FORMAT:
4736 format = "__IEEE_FORMAT__";
4739 case VAX_FLOAT_FORMAT:
4740 format = "__VAX_FORMAT__";
4741 cpp_define (pfile, "__TARGET_USES_VAX_F_FLOAT__=1");
4742 #ifdef TARGET_G_FLOAT
4745 cpp_define (pfile, "__TARGET_USES_VAX_D_FLOAT__=0");
4746 cpp_define (pfile, "__TARGET_USES_VAX_G_FLOAT__=1");
4750 cpp_define (pfile, "__TARGET_USES_VAX_D_FLOAT__=1");
4751 cpp_define (pfile, "__TARGET_USES_VAX_G_FLOAT__=0");
4754 cpp_define (pfile, "__TARGET_USES_VAX_H_FLOAT__=1");
4757 case IBM_FLOAT_FORMAT:
4758 format = "__IBM_FORMAT__";
4761 case C4X_FLOAT_FORMAT:
4762 format = "__C4X_FORMAT__";
4768 if (TARGET_FLOAT_FORMAT != VAX_FLOAT_FORMAT)
4770 cpp_define (pfile, "__TARGET_USES_VAX_F_FLOAT__=0");
4771 cpp_define (pfile, "__TARGET_USES_VAX_D_FLOAT__=0");
4772 cpp_define (pfile, "__TARGET_USES_VAX_G_FLOAT__=0");
4773 cpp_define (pfile, "__TARGET_USES_VAX_H_FLOAT__=0");
4775 builtin_define_with_value ("__GCC_FLOAT_FORMAT__", format, 0);
4778 /* Define NAME with value TYPE precision. */
4780 builtin_define_type_precision (name, type)
4784 builtin_define_with_int_value (name, TYPE_PRECISION (type));
4787 /* Define the float.h constants for TYPE using NAME_PREFIX and FP_SUFFIX. */
4789 builtin_define_float_constants (name_prefix, fp_suffix, type)
4790 const char *name_prefix;
4791 const char *fp_suffix;
4794 /* Used to convert radix-based values to base 10 values in several cases.
4796 In the max_exp -> max_10_exp conversion for 128-bit IEEE, we need at
4797 least 6 significant digits for correct results. Using the fraction
4798 formed by (log(2)*1e6)/(log(10)*1e6) overflows a 32-bit integer as an
4799 intermediate; perhaps someone can find a better approximation, in the
4800 mean time, I suspect using doubles won't harm the bootstrap here. */
4802 const double log10_2 = .30102999566398119521;
4803 const double log10_16 = 1.20411998265592478085;
4804 const double log10_b
4805 = TARGET_FLOAT_FORMAT == IBM_FLOAT_FORMAT ? log10_16 : log10_2;
4807 const int log2_b = TARGET_FLOAT_FORMAT == IBM_FLOAT_FORMAT ? 4 : 1;
4809 char name[64], buf[128];
4810 int mant_dig, max_exp, min_exp;
4811 int dig, min_10_exp, max_10_exp;
4814 /* ??? This information should be shared with real.c. */
4816 #ifndef INTEL_EXTENDED_IEEE_FORMAT
4817 #define INTEL_EXTENDED_IEEE_FORMAT 0
4819 #ifndef TARGET_G_FLOAT
4820 #define TARGET_G_FLOAT 0
4823 switch (TARGET_FLOAT_FORMAT)
4825 case IEEE_FLOAT_FORMAT:
4826 switch (TYPE_PRECISION (type))
4829 /* ??? Handle MIPS r5900, which doesn't implement Inf or NaN,
4830 but rather reuses the largest exponent as a normal number. */
4841 if (!INTEL_EXTENDED_IEEE_FORMAT)
4852 if (INTEL_EXTENDED_IEEE_FORMAT)
4855 /* ??? Otherwise assume m68k. */
4863 case VAX_FLOAT_FORMAT:
4864 switch (TYPE_PRECISION (type))
4866 case 32: /* F_FLOAT */
4871 case 64: /* G_FLOAT or D_FLOAT */
4885 case 128: /* H_FLOAT */
4895 case IBM_FLOAT_FORMAT:
4896 switch (TYPE_PRECISION (type))
4913 case C4X_FLOAT_FORMAT:
4914 switch (TYPE_PRECISION (type))
4935 /* The number of radix digits, p, in the floating-point significand. */
4936 sprintf (name, "__%s_MANT_DIG__", name_prefix);
4937 builtin_define_with_int_value (name, mant_dig);
4939 /* The number of decimal digits, q, such that any floating-point number
4940 with q decimal digits can be rounded into a floating-point number with
4941 p radix b digits and back again without change to the q decimal digits,
4943 p log10 b if b is a power of 10
4944 floor((p - 1) log10 b) otherwise
4946 dig = (mant_dig - 1) * log10_b;
4947 sprintf (name, "__%s_DIG__", name_prefix);
4948 builtin_define_with_int_value (name, dig);
4950 /* The minimum negative int x such that b**(x-1) is a normalised float. */
4951 sprintf (name, "__%s_MIN_EXP__", name_prefix);
4952 sprintf (buf, "(%d)", min_exp);
4953 builtin_define_with_value (name, buf, 0);
4955 /* The minimum negative int x such that 10**x is a normalized float,
4957 ceil (log10 (b ** (min_exp - 1)))
4958 = ceil (log10 (b) * (min_exp - 1))
4960 Recall that min_exp is negative, so the integer truncation calculates
4961 the ceiling, not the floor, in this case. */
4962 min_10_exp = (min_exp - 1) * log10_b;
4963 sprintf (name, "__%s_MIN_10_EXP__", name_prefix);
4964 sprintf (buf, "(%d)", min_10_exp);
4965 builtin_define_with_value (name, buf, 0);
4967 /* The maximum int x such that b**(x-1) is a representable float. */
4968 sprintf (name, "__%s_MAX_EXP__", name_prefix);
4969 builtin_define_with_int_value (name, max_exp);
4971 /* The maximum int x such that 10**x is in the range of representable
4972 finite floating-point numbers,
4974 floor (log10((1 - b**-p) * b**max_exp))
4975 = floor (log10(1 - b**-p) + log10(b**max_exp))
4976 = floor (log10(1 - b**-p) + log10(b)*max_exp)
4978 The safest thing to do here is to just compute this number. But since
4979 we don't link cc1 with libm, we cannot. We could implement log10 here
4980 a series expansion, but that seems too much effort because:
4982 Note that the first term, for all extant p, is a number exceedingly close
4983 to zero, but slightly negative. Note that the second term is an integer
4984 scaling an irrational number, and that because of the floor we are only
4985 interested in its integral portion.
4987 In order for the first term to have any effect on the integral portion
4988 of the second term, the second term has to be exceedingly close to an
4989 integer itself (e.g. 123.000000000001 or something). Getting a result
4990 that close to an integer requires that the irrational multiplicand have
4991 a long series of zeros in its expansion, which doesn't occur in the
4992 first 20 digits or so of log10(b).
4994 Hand-waving aside, crunching all of the sets of constants above by hand
4995 does not yield a case for which the first term is significant, which
4996 in the end is all that matters. */
4997 max_10_exp = max_exp * log10_b;
4998 sprintf (name, "__%s_MAX_10_EXP__", name_prefix);
4999 builtin_define_with_int_value (name, max_10_exp);
5001 /* The number of decimal digits, n, such that any floating-point number
5002 can be rounded to n decimal digits and back again without change to
5005 p * log10(b) if b is a power of 10
5006 ceil(1 + p * log10(b)) otherwise
5008 The only macro we care about is this number for the widest supported
5009 floating type, but we want this value for rendering constants below. */
5011 double d_decimal_dig = 1 + mant_dig * log10_b;
5012 decimal_dig = d_decimal_dig;
5013 if (decimal_dig < d_decimal_dig)
5016 if (type == long_double_type_node)
5017 builtin_define_with_int_value ("__DECIMAL_DIG__", decimal_dig);
5019 /* Since, for the supported formats, B is always a power of 2, we
5020 construct the following numbers directly as a hexadecimal
5023 /* The maximum representable finite floating-point number,
5024 (1 - b**-p) * b**max_exp */
5029 strcpy (buf, "0x0.");
5030 n = mant_dig * log2_b;
5031 for (i = 0, p = buf + 4; i + 3 < n; i += 4)
5034 *p++ = "08ce"[n - i];
5035 sprintf (p, "p%d", max_exp * log2_b);
5037 sprintf (name, "__%s_MAX__", name_prefix);
5038 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix);
5040 /* The minimum normalized positive floating-point number,
5042 sprintf (name, "__%s_MIN__", name_prefix);
5043 sprintf (buf, "0x1p%d", (min_exp - 1) * log2_b);
5044 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix);
5046 /* The difference between 1 and the least value greater than 1 that is
5047 representable in the given floating point type, b**(1-p). */
5048 sprintf (name, "__%s_EPSILON__", name_prefix);
5049 sprintf (buf, "0x1p%d", (1 - mant_dig) * log2_b);
5050 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix);
5053 /* Hook that registers front end and target-specific built-ins. */
5055 cb_register_builtins (pfile)
5058 /* -undef turns off target-specific built-ins. */
5062 if (c_language == clk_cplusplus)
5064 if (SUPPORTS_ONE_ONLY)
5065 cpp_define (pfile, "__GXX_WEAK__=1");
5067 cpp_define (pfile, "__GXX_WEAK__=0");
5068 if (flag_exceptions)
5069 cpp_define (pfile, "__EXCEPTIONS");
5070 if (warn_deprecated)
5071 cpp_define (pfile, "__DEPRECATED");
5074 /* represents the C++ ABI version, always defined so it can be used while
5075 preprocessing C and assembler. */
5076 cpp_define (pfile, "__GXX_ABI_VERSION=102");
5078 /* libgcc needs to know this. */
5079 if (USING_SJLJ_EXCEPTIONS)
5080 cpp_define (pfile, "__USING_SJLJ_EXCEPTIONS__");
5082 /* stddef.h needs to know these. */
5083 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
5084 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
5085 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
5086 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
5088 /* limits.h needs to know these. */
5089 builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node, 0);
5090 builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node, 0);
5091 builtin_define_type_max ("__INT_MAX__", integer_type_node, 0);
5092 builtin_define_type_max ("__LONG_MAX__", long_integer_type_node, 1);
5093 builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node, 2);
5095 builtin_define_type_precision ("__CHAR_BIT__", char_type_node);
5096 builtin_define_type_precision ("__WCHAR_BIT__", wchar_type_node);
5097 builtin_define_type_precision ("__SHRT_BIT__", short_integer_type_node);
5098 builtin_define_type_precision ("__INT_BIT__", integer_type_node);
5099 builtin_define_type_precision ("__LONG_BIT__", long_integer_type_node);
5100 builtin_define_type_precision ("__LONG_LONG_BIT__",
5101 long_long_integer_type_node);
5102 builtin_define_type_precision ("__FLOAT_BIT__", float_type_node);
5103 builtin_define_type_precision ("__DOUBLE_BIT__", double_type_node);
5104 builtin_define_type_precision ("__LONG_DOUBLE_BIT__", long_double_type_node);
5106 /* float.h needs to know these. */
5108 /* The radix of the exponent representation. */
5109 builtin_define_with_int_value ("__FLT_RADIX__",
5110 (TARGET_FLOAT_FORMAT == IBM_FLOAT_FORMAT
5113 builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
5114 TARGET_FLT_EVAL_METHOD);
5116 builtin_define_float_constants ("FLT", "F", float_type_node);
5117 builtin_define_float_constants ("DBL", "", double_type_node);
5118 builtin_define_float_constants ("LDBL", "L", long_double_type_node);
5120 /* For use in assembly language. */
5121 builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0);
5122 builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0);
5125 builtin_define_with_value ("__VERSION__", version_string, 1);
5127 /* Other target-independent built-ins determined by command-line
5130 cpp_define (pfile, "__OPTIMIZE_SIZE__");
5132 cpp_define (pfile, "__OPTIMIZE__");
5135 cpp_define (pfile, "__STDC_HOSTED__=1");
5137 cpp_define (pfile, "__STDC_HOSTED__=0");
5139 if (fast_math_flags_set_p ())
5140 cpp_define (pfile, "__FAST_MATH__");
5142 cpp_define (pfile, "__NO_INLINE__");
5143 if (flag_signaling_nans)
5144 cpp_define (pfile, "__SUPPORT_SNAN__");
5145 if (flag_finite_math_only)
5146 cpp_define (pfile, "__FINITE_MATH_ONLY__=1");
5148 cpp_define (pfile, "__FINITE_MATH_ONLY__=0");
5151 cpp_define (pfile, "__STRICT_ANSI__");
5153 if (!flag_signed_char)
5154 cpp_define (pfile, "__CHAR_UNSIGNED__");
5156 if (c_language == clk_cplusplus && TREE_UNSIGNED (wchar_type_node))
5157 cpp_define (pfile, "__WCHAR_UNSIGNED__");
5159 cpp_define_data_format (pfile);
5161 /* Make the choice of ObjC runtime visible to source code. */
5162 if (flag_objc && flag_next_runtime)
5163 cpp_define (pfile, "__NEXT_RUNTIME__");
5165 /* A straightforward target hook doesn't work, because of problems
5166 linking that hook's body when part of non-C front ends. */
5167 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
5168 # define builtin_define(TXT) cpp_define (pfile, TXT)
5169 # define builtin_assert(TXT) cpp_assert (pfile, TXT)
5170 TARGET_CPU_CPP_BUILTINS ();
5171 TARGET_OS_CPP_BUILTINS ();
5174 /* Pass an object-like macro. If it doesn't lie in the user's
5175 namespace, defines it unconditionally. Otherwise define a version
5176 with two leading underscores, and another version with two leading
5177 and trailing underscores, and define the original only if an ISO
5178 standard was not nominated.
5180 e.g. passing "unix" defines "__unix", "__unix__" and possibly
5181 "unix". Passing "_mips" defines "__mips", "__mips__" and possibly
5184 builtin_define_std (macro)
5187 size_t len = strlen (macro);
5188 char *buff = alloca (len + 5);
5192 /* prepend __ (or maybe just _) if in user's namespace. */
5193 memcpy (p, macro, len + 1);
5194 if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1]))))
5201 cpp_define (parse_in, p);
5203 /* If it was in user's namespace... */
5206 /* Define the macro with leading and following __. */
5212 cpp_define (parse_in, p);
5214 /* Finally, define the original macro if permitted. */
5216 cpp_define (parse_in, macro);
5220 /* Pass an object-like macro and a value to define it to. The third
5221 parameter says whether or not to turn the value into a string
5224 builtin_define_with_value (macro, expansion, is_str)
5226 const char *expansion;
5230 size_t mlen = strlen (macro);
5231 size_t elen = strlen (expansion);
5232 size_t extra = 2; /* space for an = and a NUL */
5235 extra += 2; /* space for two quote marks */
5237 buf = alloca (mlen + elen + extra);
5239 sprintf (buf, "%s=\"%s\"", macro, expansion);
5241 sprintf (buf, "%s=%s", macro, expansion);
5243 cpp_define (parse_in, buf);
5246 /* Pass an object-like macro and an integer value to define it to. */
5248 builtin_define_with_int_value (macro, value)
5250 HOST_WIDE_INT value;
5253 size_t mlen = strlen (macro);
5255 size_t extra = 2; /* space for = and NUL. */
5257 buf = alloca (mlen + vlen + extra);
5258 memcpy (buf, macro, mlen);
5260 sprintf (buf + mlen + 1, HOST_WIDE_INT_PRINT_DEC, value);
5262 cpp_define (parse_in, buf);
5265 /* Pass an object-like macro a hexadecimal floating-point value. */
5267 builtin_define_with_hex_fp_value (macro, type, digits, hex_str, fp_suffix)
5271 const char *hex_str;
5272 const char *fp_suffix;
5274 REAL_VALUE_TYPE real;
5275 char dec_str[64], buf[256];
5277 /* Hex values are really cool and convenient, except that they're
5278 not supported in strict ISO C90 mode. First, the "p-" sequence
5279 is not valid as part of a preprocessor number. Second, we get a
5280 pedwarn from the preprocessor, which has no context, so we can't
5281 suppress the warning with __extension__.
5283 So instead what we do is construct the number in hex (because
5284 it's easy to get the exact correct value), parse it as a real,
5285 then print it back out as decimal. */
5287 real = REAL_VALUE_HTOF (hex_str, TYPE_MODE (type));
5288 REAL_VALUE_TO_DECIMAL (real, dec_str, digits);
5290 sprintf (buf, "%s=%s%s", macro, dec_str, fp_suffix);
5291 cpp_define (parse_in, buf);
5294 /* Define MAX for TYPE based on the precision of the type, which is assumed
5295 to be signed. IS_LONG is 1 for type "long" and 2 for "long long". */
5298 builtin_define_type_max (macro, type, is_long)
5305 size_t mlen, vlen, extra;
5307 /* Pre-rendering the values mean we don't have to futz with printing a
5308 multi-word decimal value. There are also a very limited number of
5309 precisions that we support, so it's really a waste of time. */
5310 switch (TYPE_PRECISION (type))
5319 value = "2147483647";
5322 value = "9223372036854775807";
5325 value = "170141183460469231731687303715884105727";
5331 mlen = strlen (macro);
5332 vlen = strlen (value);
5333 extra = 2 + is_long;
5334 buf = alloca (mlen + vlen + extra);
5336 sprintf (buf, "%s=%s%s", macro, value,
5337 (is_long == 1 ? "L" : is_long == 2 ? "LL" : ""));
5339 cpp_define (parse_in, buf);
5343 c_init_attributes ()
5345 /* Fill in the built_in_attributes array. */
5346 #define DEF_ATTR_NULL_TREE(ENUM) \
5347 built_in_attributes[(int) ENUM] = NULL_TREE;
5348 #define DEF_ATTR_INT(ENUM, VALUE) \
5349 built_in_attributes[(int) ENUM] = build_int_2 (VALUE, VALUE < 0 ? -1 : 0);
5350 #define DEF_ATTR_IDENT(ENUM, STRING) \
5351 built_in_attributes[(int) ENUM] = get_identifier (STRING);
5352 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
5353 built_in_attributes[(int) ENUM] \
5354 = tree_cons (built_in_attributes[(int) PURPOSE], \
5355 built_in_attributes[(int) VALUE], \
5356 built_in_attributes[(int) CHAIN]);
5357 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No initialization needed. */
5358 #include "builtin-attrs.def"
5359 #undef DEF_ATTR_NULL_TREE
5361 #undef DEF_ATTR_IDENT
5362 #undef DEF_ATTR_TREE_LIST
5364 c_attrs_initialized = true;
5367 /* Depending on the name of DECL, apply default attributes to it. */
5370 c_common_insert_default_attributes (decl)
5373 tree name = DECL_NAME (decl);
5375 if (!c_attrs_initialized)
5376 c_init_attributes ();
5378 #define DEF_ATTR_NULL_TREE(ENUM) /* Nothing needed after initialization. */
5379 #define DEF_ATTR_INT(ENUM, VALUE)
5380 #define DEF_ATTR_IDENT(ENUM, STRING)
5381 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN)
5382 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) \
5383 if ((PREDICATE) && name == built_in_attributes[(int) NAME]) \
5384 decl_attributes (&decl, built_in_attributes[(int) ATTRS], \
5385 ATTR_FLAG_BUILT_IN);
5386 #include "builtin-attrs.def"
5387 #undef DEF_ATTR_NULL_TREE
5389 #undef DEF_ATTR_IDENT
5390 #undef DEF_ATTR_TREE_LIST
5394 /* Output a -Wshadow warning MSGID about NAME, an IDENTIFIER_NODE, and
5395 additionally give the location of the previous declaration DECL. */
5397 shadow_warning (msgid, name, decl)
5401 warning ("declaration of `%s' shadows %s", IDENTIFIER_POINTER (name), msgid);
5402 warning_with_file_and_line (DECL_SOURCE_FILE (decl),
5403 DECL_SOURCE_LINE (decl),
5404 "shadowed declaration is here");
5407 /* Attribute handlers common to C front ends. */
5409 /* Handle a "packed" attribute; arguments as in
5410 struct attribute_spec.handler. */
5413 handle_packed_attribute (node, name, args, flags, no_add_attrs)
5416 tree args ATTRIBUTE_UNUSED;
5423 if (TREE_CODE (*node) == TYPE_DECL)
5424 type = &TREE_TYPE (*node);
5431 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5432 *type = build_type_copy (*type);
5433 TYPE_PACKED (*type) = 1;
5435 else if (TREE_CODE (*node) == FIELD_DECL)
5436 DECL_PACKED (*node) = 1;
5437 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
5438 used for DECL_REGISTER. It wouldn't mean anything anyway. */
5441 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5442 *no_add_attrs = true;
5448 /* Handle a "nocommon" attribute; arguments as in
5449 struct attribute_spec.handler. */
5452 handle_nocommon_attribute (node, name, args, flags, no_add_attrs)
5455 tree args ATTRIBUTE_UNUSED;
5456 int flags ATTRIBUTE_UNUSED;
5459 if (TREE_CODE (*node) == VAR_DECL)
5460 DECL_COMMON (*node) = 0;
5463 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5464 *no_add_attrs = true;
5470 /* Handle a "common" attribute; arguments as in
5471 struct attribute_spec.handler. */
5474 handle_common_attribute (node, name, args, flags, no_add_attrs)
5477 tree args ATTRIBUTE_UNUSED;
5478 int flags ATTRIBUTE_UNUSED;
5481 if (TREE_CODE (*node) == VAR_DECL)
5482 DECL_COMMON (*node) = 1;
5485 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5486 *no_add_attrs = true;
5492 /* Handle a "noreturn" attribute; arguments as in
5493 struct attribute_spec.handler. */
5496 handle_noreturn_attribute (node, name, args, flags, no_add_attrs)
5499 tree args ATTRIBUTE_UNUSED;
5500 int flags ATTRIBUTE_UNUSED;
5503 tree type = TREE_TYPE (*node);
5505 /* See FIXME comment in c_common_attribute_table. */
5506 if (TREE_CODE (*node) == FUNCTION_DECL)
5507 TREE_THIS_VOLATILE (*node) = 1;
5508 else if (TREE_CODE (type) == POINTER_TYPE
5509 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
5511 = build_pointer_type
5512 (build_type_variant (TREE_TYPE (type),
5513 TREE_READONLY (TREE_TYPE (type)), 1));
5516 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5517 *no_add_attrs = true;
5523 /* Handle a "noinline" attribute; arguments as in
5524 struct attribute_spec.handler. */
5527 handle_noinline_attribute (node, name, args, flags, no_add_attrs)
5530 tree args ATTRIBUTE_UNUSED;
5531 int flags ATTRIBUTE_UNUSED;
5534 if (TREE_CODE (*node) == FUNCTION_DECL)
5535 DECL_UNINLINABLE (*node) = 1;
5538 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5539 *no_add_attrs = true;
5545 /* Handle a "always_inline" attribute; arguments as in
5546 struct attribute_spec.handler. */
5549 handle_always_inline_attribute (node, name, args, flags, no_add_attrs)
5552 tree args ATTRIBUTE_UNUSED;
5553 int flags ATTRIBUTE_UNUSED;
5556 if (TREE_CODE (*node) == FUNCTION_DECL)
5558 /* Do nothing else, just set the attribute. We'll get at
5559 it later with lookup_attribute. */
5563 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5564 *no_add_attrs = true;
5570 /* Handle a "used" attribute; arguments as in
5571 struct attribute_spec.handler. */
5574 handle_used_attribute (node, name, args, flags, no_add_attrs)
5577 tree args ATTRIBUTE_UNUSED;
5578 int flags ATTRIBUTE_UNUSED;
5581 if (TREE_CODE (*node) == FUNCTION_DECL)
5582 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (*node))
5583 = TREE_USED (*node) = 1;
5586 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5587 *no_add_attrs = true;
5593 /* Handle a "unused" attribute; arguments as in
5594 struct attribute_spec.handler. */
5597 handle_unused_attribute (node, name, args, flags, no_add_attrs)
5600 tree args ATTRIBUTE_UNUSED;
5608 if (TREE_CODE (decl) == PARM_DECL
5609 || TREE_CODE (decl) == VAR_DECL
5610 || TREE_CODE (decl) == FUNCTION_DECL
5611 || TREE_CODE (decl) == LABEL_DECL
5612 || TREE_CODE (decl) == TYPE_DECL)
5613 TREE_USED (decl) = 1;
5616 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5617 *no_add_attrs = true;
5622 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5623 *node = build_type_copy (*node);
5624 TREE_USED (*node) = 1;
5630 /* Handle a "const" attribute; arguments as in
5631 struct attribute_spec.handler. */
5634 handle_const_attribute (node, name, args, flags, no_add_attrs)
5637 tree args ATTRIBUTE_UNUSED;
5638 int flags ATTRIBUTE_UNUSED;
5641 tree type = TREE_TYPE (*node);
5643 /* See FIXME comment on noreturn in c_common_attribute_table. */
5644 if (TREE_CODE (*node) == FUNCTION_DECL)
5645 TREE_READONLY (*node) = 1;
5646 else if (TREE_CODE (type) == POINTER_TYPE
5647 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
5649 = build_pointer_type
5650 (build_type_variant (TREE_TYPE (type), 1,
5651 TREE_THIS_VOLATILE (TREE_TYPE (type))));
5654 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5655 *no_add_attrs = true;
5661 /* Handle a "transparent_union" attribute; arguments as in
5662 struct attribute_spec.handler. */
5665 handle_transparent_union_attribute (node, name, args, flags, no_add_attrs)
5668 tree args ATTRIBUTE_UNUSED;
5672 tree decl = NULL_TREE;
5679 type = &TREE_TYPE (decl);
5680 is_type = TREE_CODE (*node) == TYPE_DECL;
5682 else if (TYPE_P (*node))
5683 type = node, is_type = 1;
5686 && TREE_CODE (*type) == UNION_TYPE
5688 || (TYPE_FIELDS (*type) != 0
5689 && TYPE_MODE (*type) == DECL_MODE (TYPE_FIELDS (*type)))))
5691 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5692 *type = build_type_copy (*type);
5693 TYPE_TRANSPARENT_UNION (*type) = 1;
5695 else if (decl != 0 && TREE_CODE (decl) == PARM_DECL
5696 && TREE_CODE (*type) == UNION_TYPE
5697 && TYPE_MODE (*type) == DECL_MODE (TYPE_FIELDS (*type)))
5698 DECL_TRANSPARENT_UNION (decl) = 1;
5701 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5702 *no_add_attrs = true;
5708 /* Handle a "constructor" attribute; arguments as in
5709 struct attribute_spec.handler. */
5712 handle_constructor_attribute (node, name, args, flags, no_add_attrs)
5715 tree args ATTRIBUTE_UNUSED;
5716 int flags ATTRIBUTE_UNUSED;
5720 tree type = TREE_TYPE (decl);
5722 if (TREE_CODE (decl) == FUNCTION_DECL
5723 && TREE_CODE (type) == FUNCTION_TYPE
5724 && decl_function_context (decl) == 0)
5726 DECL_STATIC_CONSTRUCTOR (decl) = 1;
5727 TREE_USED (decl) = 1;
5731 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5732 *no_add_attrs = true;
5738 /* Handle a "destructor" attribute; arguments as in
5739 struct attribute_spec.handler. */
5742 handle_destructor_attribute (node, name, args, flags, no_add_attrs)
5745 tree args ATTRIBUTE_UNUSED;
5746 int flags ATTRIBUTE_UNUSED;
5750 tree type = TREE_TYPE (decl);
5752 if (TREE_CODE (decl) == FUNCTION_DECL
5753 && TREE_CODE (type) == FUNCTION_TYPE
5754 && decl_function_context (decl) == 0)
5756 DECL_STATIC_DESTRUCTOR (decl) = 1;
5757 TREE_USED (decl) = 1;
5761 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5762 *no_add_attrs = true;
5768 /* Handle a "mode" attribute; arguments as in
5769 struct attribute_spec.handler. */
5772 handle_mode_attribute (node, name, args, flags, no_add_attrs)
5776 int flags ATTRIBUTE_UNUSED;
5781 *no_add_attrs = true;
5783 if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
5784 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5788 const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
5789 int len = strlen (p);
5790 enum machine_mode mode = VOIDmode;
5793 if (len > 4 && p[0] == '_' && p[1] == '_'
5794 && p[len - 1] == '_' && p[len - 2] == '_')
5796 char *newp = (char *) alloca (len - 1);
5798 strcpy (newp, &p[2]);
5799 newp[len - 4] = '\0';
5803 /* Change this type to have a type with the specified mode.
5804 First check for the special modes. */
5805 if (! strcmp (p, "byte"))
5807 else if (!strcmp (p, "word"))
5809 else if (! strcmp (p, "pointer"))
5812 for (j = 0; j < NUM_MACHINE_MODES; j++)
5813 if (!strcmp (p, GET_MODE_NAME (j)))
5814 mode = (enum machine_mode) j;
5816 if (mode == VOIDmode)
5817 error ("unknown machine mode `%s'", p);
5818 else if (0 == (typefm = (*lang_hooks.types.type_for_mode)
5819 (mode, TREE_UNSIGNED (type))))
5820 error ("no data type for mode `%s'", p);
5823 /* If this is a vector, make sure we either have hardware
5824 support, or we can emulate it. */
5825 if ((GET_MODE_CLASS (mode) == MODE_VECTOR_INT
5826 || GET_MODE_CLASS (mode) == MODE_VECTOR_FLOAT)
5827 && !vector_mode_valid_p (mode))
5829 error ("unable to emulate '%s'", GET_MODE_NAME (mode));
5834 /* No need to layout the type here. The caller should do this. */
5841 /* Handle a "section" attribute; arguments as in
5842 struct attribute_spec.handler. */
5845 handle_section_attribute (node, name, args, flags, no_add_attrs)
5847 tree name ATTRIBUTE_UNUSED;
5849 int flags ATTRIBUTE_UNUSED;
5854 if (targetm.have_named_sections)
5856 if ((TREE_CODE (decl) == FUNCTION_DECL
5857 || TREE_CODE (decl) == VAR_DECL)
5858 && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
5860 if (TREE_CODE (decl) == VAR_DECL
5861 && current_function_decl != NULL_TREE
5862 && ! TREE_STATIC (decl))
5864 error_with_decl (decl,
5865 "section attribute cannot be specified for local variables");
5866 *no_add_attrs = true;
5869 /* The decl may have already been given a section attribute
5870 from a previous declaration. Ensure they match. */
5871 else if (DECL_SECTION_NAME (decl) != NULL_TREE
5872 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
5873 TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
5875 error_with_decl (*node,
5876 "section of `%s' conflicts with previous declaration");
5877 *no_add_attrs = true;
5880 DECL_SECTION_NAME (decl) = TREE_VALUE (args);
5884 error_with_decl (*node,
5885 "section attribute not allowed for `%s'");
5886 *no_add_attrs = true;
5891 error_with_decl (*node,
5892 "section attributes are not supported for this target");
5893 *no_add_attrs = true;
5899 /* Handle a "aligned" attribute; arguments as in
5900 struct attribute_spec.handler. */
5903 handle_aligned_attribute (node, name, args, flags, no_add_attrs)
5905 tree name ATTRIBUTE_UNUSED;
5910 tree decl = NULL_TREE;
5913 tree align_expr = (args ? TREE_VALUE (args)
5914 : size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
5920 type = &TREE_TYPE (decl);
5921 is_type = TREE_CODE (*node) == TYPE_DECL;
5923 else if (TYPE_P (*node))
5924 type = node, is_type = 1;
5926 /* Strip any NOPs of any kind. */
5927 while (TREE_CODE (align_expr) == NOP_EXPR
5928 || TREE_CODE (align_expr) == CONVERT_EXPR
5929 || TREE_CODE (align_expr) == NON_LVALUE_EXPR)
5930 align_expr = TREE_OPERAND (align_expr, 0);
5932 if (TREE_CODE (align_expr) != INTEGER_CST)
5934 error ("requested alignment is not a constant");
5935 *no_add_attrs = true;
5937 else if ((i = tree_log2 (align_expr)) == -1)
5939 error ("requested alignment is not a power of 2");
5940 *no_add_attrs = true;
5942 else if (i > HOST_BITS_PER_INT - 2)
5944 error ("requested alignment is too large");
5945 *no_add_attrs = true;
5949 /* If we have a TYPE_DECL, then copy the type, so that we
5950 don't accidentally modify a builtin type. See pushdecl. */
5951 if (decl && TREE_TYPE (decl) != error_mark_node
5952 && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
5954 tree tt = TREE_TYPE (decl);
5955 *type = build_type_copy (*type);
5956 DECL_ORIGINAL_TYPE (decl) = tt;
5957 TYPE_NAME (*type) = decl;
5958 TREE_USED (*type) = TREE_USED (decl);
5959 TREE_TYPE (decl) = *type;
5961 else if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5962 *type = build_type_copy (*type);
5964 TYPE_ALIGN (*type) = (1 << i) * BITS_PER_UNIT;
5965 TYPE_USER_ALIGN (*type) = 1;
5967 else if (TREE_CODE (decl) != VAR_DECL
5968 && TREE_CODE (decl) != FIELD_DECL)
5970 error_with_decl (decl,
5971 "alignment may not be specified for `%s'");
5972 *no_add_attrs = true;
5976 DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
5977 DECL_USER_ALIGN (decl) = 1;
5983 /* Handle a "weak" attribute; arguments as in
5984 struct attribute_spec.handler. */
5987 handle_weak_attribute (node, name, args, flags, no_add_attrs)
5989 tree name ATTRIBUTE_UNUSED;
5990 tree args ATTRIBUTE_UNUSED;
5991 int flags ATTRIBUTE_UNUSED;
5992 bool *no_add_attrs ATTRIBUTE_UNUSED;
5994 declare_weak (*node);
5999 /* Handle an "alias" attribute; arguments as in
6000 struct attribute_spec.handler. */
6003 handle_alias_attribute (node, name, args, flags, no_add_attrs)
6007 int flags ATTRIBUTE_UNUSED;
6012 if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
6013 || (TREE_CODE (decl) != FUNCTION_DECL && ! DECL_EXTERNAL (decl)))
6015 error_with_decl (decl,
6016 "`%s' defined both normally and as an alias");
6017 *no_add_attrs = true;
6019 else if (decl_function_context (decl) == 0)
6023 id = TREE_VALUE (args);
6024 if (TREE_CODE (id) != STRING_CST)
6026 error ("alias arg not a string");
6027 *no_add_attrs = true;
6030 id = get_identifier (TREE_STRING_POINTER (id));
6031 /* This counts as a use of the object pointed to. */
6034 if (TREE_CODE (decl) == FUNCTION_DECL)
6035 DECL_INITIAL (decl) = error_mark_node;
6037 DECL_EXTERNAL (decl) = 0;
6041 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
6042 *no_add_attrs = true;
6048 /* Handle an "visibility" attribute; arguments as in
6049 struct attribute_spec.handler. */
6052 handle_visibility_attribute (node, name, args, flags, no_add_attrs)
6056 int flags ATTRIBUTE_UNUSED;
6061 if (decl_function_context (decl) != 0 || ! TREE_PUBLIC (decl))
6063 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
6064 *no_add_attrs = true;
6070 id = TREE_VALUE (args);
6071 if (TREE_CODE (id) != STRING_CST)
6073 error ("visibility arg not a string");
6074 *no_add_attrs = true;
6077 if (strcmp (TREE_STRING_POINTER (id), "hidden")
6078 && strcmp (TREE_STRING_POINTER (id), "protected")
6079 && strcmp (TREE_STRING_POINTER (id), "internal"))
6081 error ("visibility arg must be one of \"hidden\", \"protected\" or \"internal\"");
6082 *no_add_attrs = true;
6090 /* Handle a "no_instrument_function" attribute; arguments as in
6091 struct attribute_spec.handler. */
6094 handle_no_instrument_function_attribute (node, name, args, flags, no_add_attrs)
6097 tree args ATTRIBUTE_UNUSED;
6098 int flags ATTRIBUTE_UNUSED;
6103 if (TREE_CODE (decl) != FUNCTION_DECL)
6105 error_with_decl (decl,
6106 "`%s' attribute applies only to functions",
6107 IDENTIFIER_POINTER (name));
6108 *no_add_attrs = true;
6110 else if (DECL_INITIAL (decl))
6112 error_with_decl (decl,
6113 "can't set `%s' attribute after definition",
6114 IDENTIFIER_POINTER (name));
6115 *no_add_attrs = true;
6118 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
6123 /* Handle a "malloc" attribute; arguments as in
6124 struct attribute_spec.handler. */
6127 handle_malloc_attribute (node, name, args, flags, no_add_attrs)
6130 tree args ATTRIBUTE_UNUSED;
6131 int flags ATTRIBUTE_UNUSED;
6134 if (TREE_CODE (*node) == FUNCTION_DECL)
6135 DECL_IS_MALLOC (*node) = 1;
6136 /* ??? TODO: Support types. */
6139 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
6140 *no_add_attrs = true;
6146 /* Handle a "no_limit_stack" attribute; arguments as in
6147 struct attribute_spec.handler. */
6150 handle_no_limit_stack_attribute (node, name, args, flags, no_add_attrs)
6153 tree args ATTRIBUTE_UNUSED;
6154 int flags ATTRIBUTE_UNUSED;
6159 if (TREE_CODE (decl) != FUNCTION_DECL)
6161 error_with_decl (decl,
6162 "`%s' attribute applies only to functions",
6163 IDENTIFIER_POINTER (name));
6164 *no_add_attrs = true;
6166 else if (DECL_INITIAL (decl))
6168 error_with_decl (decl,
6169 "can't set `%s' attribute after definition",
6170 IDENTIFIER_POINTER (name));
6171 *no_add_attrs = true;
6174 DECL_NO_LIMIT_STACK (decl) = 1;
6179 /* Handle a "pure" attribute; arguments as in
6180 struct attribute_spec.handler. */
6183 handle_pure_attribute (node, name, args, flags, no_add_attrs)
6186 tree args ATTRIBUTE_UNUSED;
6187 int flags ATTRIBUTE_UNUSED;
6190 if (TREE_CODE (*node) == FUNCTION_DECL)
6191 DECL_IS_PURE (*node) = 1;
6192 /* ??? TODO: Support types. */
6195 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
6196 *no_add_attrs = true;
6202 /* Handle a "deprecated" attribute; arguments as in
6203 struct attribute_spec.handler. */
6206 handle_deprecated_attribute (node, name, args, flags, no_add_attrs)
6209 tree args ATTRIBUTE_UNUSED;
6213 tree type = NULL_TREE;
6215 const char *what = NULL;
6220 type = TREE_TYPE (decl);
6222 if (TREE_CODE (decl) == TYPE_DECL
6223 || TREE_CODE (decl) == PARM_DECL
6224 || TREE_CODE (decl) == VAR_DECL
6225 || TREE_CODE (decl) == FUNCTION_DECL
6226 || TREE_CODE (decl) == FIELD_DECL)
6227 TREE_DEPRECATED (decl) = 1;
6231 else if (TYPE_P (*node))
6233 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
6234 *node = build_type_copy (*node);
6235 TREE_DEPRECATED (*node) = 1;
6243 *no_add_attrs = true;
6244 if (type && TYPE_NAME (type))
6246 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
6247 what = IDENTIFIER_POINTER (TYPE_NAME (*node));
6248 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
6249 && DECL_NAME (TYPE_NAME (type)))
6250 what = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
6253 warning ("`%s' attribute ignored for `%s'",
6254 IDENTIFIER_POINTER (name), what);
6256 warning ("`%s' attribute ignored",
6257 IDENTIFIER_POINTER (name));
6263 /* Keep a list of vector type nodes we created in handle_vector_size_attribute,
6264 to prevent us from duplicating type nodes unnecessarily.
6265 The normal mechanism to prevent duplicates is to use type_hash_canon, but
6266 since we want to distinguish types that are essentially identical (except
6267 for their debug representation), we use a local list here. */
6268 static tree vector_type_node_list = 0;
6270 /* Handle a "vector_size" attribute; arguments as in
6271 struct attribute_spec.handler. */
6274 handle_vector_size_attribute (node, name, args, flags, no_add_attrs)
6278 int flags ATTRIBUTE_UNUSED;
6281 unsigned HOST_WIDE_INT vecsize, nunits;
6282 enum machine_mode mode, orig_mode, new_mode;
6283 tree type = *node, new_type = NULL_TREE;
6284 tree type_list_node;
6286 *no_add_attrs = true;
6288 if (! host_integerp (TREE_VALUE (args), 1))
6290 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
6294 /* Get the vector size (in bytes). */
6295 vecsize = tree_low_cst (TREE_VALUE (args), 1);
6297 /* We need to provide for vector pointers, vector arrays, and
6298 functions returning vectors. For example:
6300 __attribute__((vector_size(16))) short *foo;
6302 In this case, the mode is SI, but the type being modified is
6303 HI, so we need to look further. */
6305 while (POINTER_TYPE_P (type)
6306 || TREE_CODE (type) == FUNCTION_TYPE
6307 || TREE_CODE (type) == ARRAY_TYPE)
6308 type = TREE_TYPE (type);
6310 /* Get the mode of the type being modified. */
6311 orig_mode = TYPE_MODE (type);
6313 if (TREE_CODE (type) == RECORD_TYPE
6314 || (GET_MODE_CLASS (orig_mode) != MODE_FLOAT
6315 && GET_MODE_CLASS (orig_mode) != MODE_INT)
6316 || ! host_integerp (TYPE_SIZE_UNIT (type), 1))
6318 error ("invalid vector type for attribute `%s'",
6319 IDENTIFIER_POINTER (name));
6323 /* Calculate how many units fit in the vector. */
6324 nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
6326 /* Find a suitably sized vector. */
6327 new_mode = VOIDmode;
6328 for (mode = GET_CLASS_NARROWEST_MODE (GET_MODE_CLASS (orig_mode) == MODE_INT
6330 : MODE_VECTOR_FLOAT);
6332 mode = GET_MODE_WIDER_MODE (mode))
6333 if (vecsize == GET_MODE_SIZE (mode)
6334 && nunits == (unsigned HOST_WIDE_INT) GET_MODE_NUNITS (mode))
6340 if (new_mode == VOIDmode)
6342 error ("no vector mode with the size and type specified could be found");
6346 for (type_list_node = vector_type_node_list; type_list_node;
6347 type_list_node = TREE_CHAIN (type_list_node))
6349 tree other_type = TREE_VALUE (type_list_node);
6350 tree record = TYPE_DEBUG_REPRESENTATION_TYPE (other_type);
6351 tree fields = TYPE_FIELDS (record);
6352 tree field_type = TREE_TYPE (fields);
6353 tree array_type = TREE_TYPE (field_type);
6354 if (TREE_CODE (fields) != FIELD_DECL
6355 || TREE_CODE (field_type) != ARRAY_TYPE)
6358 if (TYPE_MODE (other_type) == mode && type == array_type)
6360 new_type = other_type;
6365 if (new_type == NULL_TREE)
6367 tree index, array, rt, list_node;
6369 new_type = (*lang_hooks.types.type_for_mode) (new_mode,
6370 TREE_UNSIGNED (type));
6374 error ("no vector mode with the size and type specified could be found");
6378 new_type = build_type_copy (new_type);
6380 /* If this is a vector, make sure we either have hardware
6381 support, or we can emulate it. */
6382 if ((GET_MODE_CLASS (mode) == MODE_VECTOR_INT
6383 || GET_MODE_CLASS (mode) == MODE_VECTOR_FLOAT)
6384 && !vector_mode_valid_p (mode))
6386 error ("unable to emulate '%s'", GET_MODE_NAME (mode));
6390 /* Set the debug information here, because this is the only
6391 place where we know the underlying type for a vector made
6392 with vector_size. For debugging purposes we pretend a vector
6393 is an array within a structure. */
6394 index = build_int_2 (TYPE_VECTOR_SUBPARTS (new_type) - 1, 0);
6395 array = build_array_type (type, build_index_type (index));
6396 rt = make_node (RECORD_TYPE);
6398 TYPE_FIELDS (rt) = build_decl (FIELD_DECL, get_identifier ("f"), array);
6399 DECL_CONTEXT (TYPE_FIELDS (rt)) = rt;
6401 TYPE_DEBUG_REPRESENTATION_TYPE (new_type) = rt;
6403 list_node = build_tree_list (NULL, new_type);
6404 TREE_CHAIN (list_node) = vector_type_node_list;
6405 vector_type_node_list = list_node;
6408 /* Build back pointers if needed. */
6409 *node = vector_size_helper (*node, new_type);
6414 /* HACK. GROSS. This is absolutely disgusting. I wish there was a
6417 If we requested a pointer to a vector, build up the pointers that
6418 we stripped off while looking for the inner type. Similarly for
6419 return values from functions.
6421 The argument "type" is the top of the chain, and "bottom" is the
6422 new type which we will point to. */
6425 vector_size_helper (type, bottom)
6430 if (POINTER_TYPE_P (type))
6432 inner = vector_size_helper (TREE_TYPE (type), bottom);
6433 outer = build_pointer_type (inner);
6435 else if (TREE_CODE (type) == ARRAY_TYPE)
6437 inner = vector_size_helper (TREE_TYPE (type), bottom);
6438 outer = build_array_type (inner, TYPE_VALUES (type));
6440 else if (TREE_CODE (type) == FUNCTION_TYPE)
6442 inner = vector_size_helper (TREE_TYPE (type), bottom);
6443 outer = build_function_type (inner, TYPE_VALUES (type));
6448 TREE_READONLY (outer) = TREE_READONLY (type);
6449 TREE_THIS_VOLATILE (outer) = TREE_THIS_VOLATILE (type);
6454 /* Handle the "nonnull" attribute. */
6456 handle_nonnull_attribute (node, name, args, flags, no_add_attrs)
6458 tree name ATTRIBUTE_UNUSED;
6460 int flags ATTRIBUTE_UNUSED;
6464 unsigned HOST_WIDE_INT attr_arg_num;
6466 /* If no arguments are specified, all pointer arguments should be
6467 non-null. Veryify a full prototype is given so that the arguments
6468 will have the correct types when we actually check them later. */
6471 if (! TYPE_ARG_TYPES (type))
6473 error ("nonnull attribute without arguments on a non-prototype");
6474 *no_add_attrs = true;
6479 /* Argument list specified. Verify that each argument number references
6480 a pointer argument. */
6481 for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
6484 unsigned HOST_WIDE_INT arg_num, ck_num;
6486 if (! get_nonnull_operand (TREE_VALUE (args), &arg_num))
6488 error ("nonnull argument has invalid operand number (arg %lu)",
6489 (unsigned long) attr_arg_num);
6490 *no_add_attrs = true;
6494 argument = TYPE_ARG_TYPES (type);
6497 for (ck_num = 1; ; ck_num++)
6499 if (! argument || ck_num == arg_num)
6501 argument = TREE_CHAIN (argument);
6505 || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
6507 error ("nonnull argument with out-of-range operand number (arg %lu, operand %lu)",
6508 (unsigned long) attr_arg_num, (unsigned long) arg_num);
6509 *no_add_attrs = true;
6513 if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
6515 error ("nonnull argument references non-pointer operand (arg %lu, operand %lu)",
6516 (unsigned long) attr_arg_num, (unsigned long) arg_num);
6517 *no_add_attrs = true;
6526 /* Check the argument list of a function call for null in argument slots
6527 that are marked as requiring a non-null pointer argument. */
6530 check_function_nonnull (attrs, params)
6534 tree a, args, param;
6537 for (a = attrs; a; a = TREE_CHAIN (a))
6539 if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
6541 args = TREE_VALUE (a);
6543 /* Walk the argument list. If we encounter an argument number we
6544 should check for non-null, do it. If the attribute has no args,
6545 then every pointer argument is checked (in which case the check
6546 for pointer type is done in check_nonnull_arg). */
6547 for (param = params, param_num = 1; ;
6548 param_num++, param = TREE_CHAIN (param))
6552 if (! args || nonnull_check_p (args, param_num))
6553 check_function_arguments_recurse (check_nonnull_arg, NULL,
6561 /* Helper for check_function_nonnull; given a list of operands which
6562 must be non-null in ARGS, determine if operand PARAM_NUM should be
6566 nonnull_check_p (args, param_num)
6568 unsigned HOST_WIDE_INT param_num;
6570 unsigned HOST_WIDE_INT arg_num;
6572 for (; args; args = TREE_CHAIN (args))
6574 if (! get_nonnull_operand (TREE_VALUE (args), &arg_num))
6577 if (arg_num == param_num)
6583 /* Check that the function argument PARAM (which is operand number
6584 PARAM_NUM) is non-null. This is called by check_function_nonnull
6585 via check_function_arguments_recurse. */
6588 check_nonnull_arg (ctx, param, param_num)
6589 void *ctx ATTRIBUTE_UNUSED;
6591 unsigned HOST_WIDE_INT param_num;
6593 /* Just skip checking the argument if it's not a pointer. This can
6594 happen if the "nonnull" attribute was given without an operand
6595 list (which means to check every pointer argument). */
6597 if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
6600 if (integer_zerop (param))
6601 warning ("null argument where non-null required (arg %lu)",
6602 (unsigned long) param_num);
6605 /* Helper for nonnull attribute handling; fetch the operand number
6606 from the attribute argument list. */
6609 get_nonnull_operand (arg_num_expr, valp)
6611 unsigned HOST_WIDE_INT *valp;
6613 /* Strip any conversions from the arg number and verify they
6615 while (TREE_CODE (arg_num_expr) == NOP_EXPR
6616 || TREE_CODE (arg_num_expr) == CONVERT_EXPR
6617 || TREE_CODE (arg_num_expr) == NON_LVALUE_EXPR)
6618 arg_num_expr = TREE_OPERAND (arg_num_expr, 0);
6620 if (TREE_CODE (arg_num_expr) != INTEGER_CST
6621 || TREE_INT_CST_HIGH (arg_num_expr) != 0)
6624 *valp = TREE_INT_CST_LOW (arg_num_expr);
6628 /* Handle a "nothrow" attribute; arguments as in
6629 struct attribute_spec.handler. */
6632 handle_nothrow_attribute (node, name, args, flags, no_add_attrs)
6635 tree args ATTRIBUTE_UNUSED;
6636 int flags ATTRIBUTE_UNUSED;
6639 if (TREE_CODE (*node) == FUNCTION_DECL)
6640 TREE_NOTHROW (*node) = 1;
6641 /* ??? TODO: Support types. */
6644 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
6645 *no_add_attrs = true;
6651 /* Check for valid arguments being passed to a function. */
6653 check_function_arguments (attrs, params)
6657 /* Check for null being passed in a pointer argument that must be
6658 non-null. We also need to do this if format checking is enabled. */
6661 check_function_nonnull (attrs, params);
6663 /* Check for errors in format strings. */
6666 check_function_format (NULL, attrs, params);
6669 /* Generic argument checking recursion routine. PARAM is the argument to
6670 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
6671 once the argument is resolved. CTX is context for the callback. */
6673 check_function_arguments_recurse (callback, ctx, param, param_num)
6674 void (*callback) PARAMS ((void *, tree, unsigned HOST_WIDE_INT));
6677 unsigned HOST_WIDE_INT param_num;
6679 if (TREE_CODE (param) == NOP_EXPR)
6681 /* Strip coercion. */
6682 check_function_arguments_recurse (callback, ctx,
6683 TREE_OPERAND (param, 0), param_num);
6687 if (TREE_CODE (param) == CALL_EXPR)
6689 tree type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (param, 0)));
6691 bool found_format_arg = false;
6693 /* See if this is a call to a known internationalization function
6694 that modifies a format arg. Such a function may have multiple
6695 format_arg attributes (for example, ngettext). */
6697 for (attrs = TYPE_ATTRIBUTES (type);
6699 attrs = TREE_CHAIN (attrs))
6700 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
6703 tree format_num_expr;
6707 /* Extract the argument number, which was previously checked
6709 format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
6710 while (TREE_CODE (format_num_expr) == NOP_EXPR
6711 || TREE_CODE (format_num_expr) == CONVERT_EXPR
6712 || TREE_CODE (format_num_expr) == NON_LVALUE_EXPR)
6713 format_num_expr = TREE_OPERAND (format_num_expr, 0);
6715 if (TREE_CODE (format_num_expr) != INTEGER_CST
6716 || TREE_INT_CST_HIGH (format_num_expr) != 0)
6719 format_num = TREE_INT_CST_LOW (format_num_expr);
6721 for (inner_args = TREE_OPERAND (param, 1), i = 1;
6723 inner_args = TREE_CHAIN (inner_args), i++)
6724 if (i == format_num)
6726 check_function_arguments_recurse (callback, ctx,
6727 TREE_VALUE (inner_args),
6729 found_format_arg = true;
6734 /* If we found a format_arg attribute and did a recursive check,
6735 we are done with checking this argument. Otherwise, we continue
6736 and this will be considered a non-literal. */
6737 if (found_format_arg)
6741 if (TREE_CODE (param) == COND_EXPR)
6743 /* Check both halves of the conditional expression. */
6744 check_function_arguments_recurse (callback, ctx,
6745 TREE_OPERAND (param, 1), param_num);
6746 check_function_arguments_recurse (callback, ctx,
6747 TREE_OPERAND (param, 2), param_num);
6751 (*callback) (ctx, param, param_num);
6754 #include "gt-c-common.h"