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_type_max PARAMS ((const char *, tree, int));
768 static void cpp_define_data_format PARAMS ((cpp_reader *));
769 static void builtin_define_type_precision PARAMS ((const char *, tree));
770 static void builtin_define_float_constants PARAMS ((const char *,
771 const char *, tree));
773 /* Table of machine-independent attributes common to all C-like languages. */
774 const struct attribute_spec c_common_attribute_table[] =
776 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
777 { "packed", 0, 0, false, false, false,
778 handle_packed_attribute },
779 { "nocommon", 0, 0, true, false, false,
780 handle_nocommon_attribute },
781 { "common", 0, 0, true, false, false,
782 handle_common_attribute },
783 /* FIXME: logically, noreturn attributes should be listed as
784 "false, true, true" and apply to function types. But implementing this
785 would require all the places in the compiler that use TREE_THIS_VOLATILE
786 on a decl to identify non-returning functions to be located and fixed
787 to check the function type instead. */
788 { "noreturn", 0, 0, true, false, false,
789 handle_noreturn_attribute },
790 { "volatile", 0, 0, true, false, false,
791 handle_noreturn_attribute },
792 { "noinline", 0, 0, true, false, false,
793 handle_noinline_attribute },
794 { "always_inline", 0, 0, true, false, false,
795 handle_always_inline_attribute },
796 { "used", 0, 0, true, false, false,
797 handle_used_attribute },
798 { "unused", 0, 0, false, false, false,
799 handle_unused_attribute },
800 /* The same comments as for noreturn attributes apply to const ones. */
801 { "const", 0, 0, true, false, false,
802 handle_const_attribute },
803 { "transparent_union", 0, 0, false, false, false,
804 handle_transparent_union_attribute },
805 { "constructor", 0, 0, true, false, false,
806 handle_constructor_attribute },
807 { "destructor", 0, 0, true, false, false,
808 handle_destructor_attribute },
809 { "mode", 1, 1, false, true, false,
810 handle_mode_attribute },
811 { "section", 1, 1, true, false, false,
812 handle_section_attribute },
813 { "aligned", 0, 1, false, false, false,
814 handle_aligned_attribute },
815 { "weak", 0, 0, true, false, false,
816 handle_weak_attribute },
817 { "alias", 1, 1, true, false, false,
818 handle_alias_attribute },
819 { "no_instrument_function", 0, 0, true, false, false,
820 handle_no_instrument_function_attribute },
821 { "malloc", 0, 0, true, false, false,
822 handle_malloc_attribute },
823 { "no_stack_limit", 0, 0, true, false, false,
824 handle_no_limit_stack_attribute },
825 { "pure", 0, 0, true, false, false,
826 handle_pure_attribute },
827 { "deprecated", 0, 0, false, false, false,
828 handle_deprecated_attribute },
829 { "vector_size", 1, 1, false, true, false,
830 handle_vector_size_attribute },
831 { "visibility", 1, 1, true, false, false,
832 handle_visibility_attribute },
833 { "nonnull", 0, -1, false, true, true,
834 handle_nonnull_attribute },
835 { "nothrow", 0, 0, true, false, false,
836 handle_nothrow_attribute },
837 { "may_alias", 0, 0, false, true, false, NULL },
838 { NULL, 0, 0, false, false, false, NULL }
841 /* Give the specifications for the format attributes, used by C and all
844 const struct attribute_spec c_common_format_attribute_table[] =
846 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
847 { "format", 3, 3, false, true, true,
848 handle_format_attribute },
849 { "format_arg", 1, 1, false, true, true,
850 handle_format_arg_attribute },
851 { NULL, 0, 0, false, false, false, NULL }
854 /* Record the start of an if-then, and record the start of it
855 for ambiguous else detection.
857 COND is the condition for the if-then statement.
859 IF_STMT is the statement node that has already been created for
860 this if-then statement. It is created before parsing the
861 condition to keep line number information accurate. */
864 c_expand_start_cond (cond, compstmt_count, if_stmt)
869 /* Make sure there is enough space on the stack. */
870 if (if_stack_space == 0)
873 if_stack = (if_elt *) xmalloc (10 * sizeof (if_elt));
875 else if (if_stack_space == if_stack_pointer)
877 if_stack_space += 10;
878 if_stack = (if_elt *) xrealloc (if_stack, if_stack_space * sizeof (if_elt));
881 IF_COND (if_stmt) = cond;
884 /* Record this if statement. */
885 if_stack[if_stack_pointer].compstmt_count = compstmt_count;
886 if_stack[if_stack_pointer].file = input_filename;
887 if_stack[if_stack_pointer].line = lineno;
888 if_stack[if_stack_pointer].needs_warning = 0;
889 if_stack[if_stack_pointer].if_stmt = if_stmt;
893 /* Called after the then-clause for an if-statement is processed. */
898 tree if_stmt = if_stack[if_stack_pointer - 1].if_stmt;
899 RECHAIN_STMTS (if_stmt, THEN_CLAUSE (if_stmt));
902 /* Record the end of an if-then. Optionally warn if a nested
903 if statement had an ambiguous else clause. */
909 if (if_stack[if_stack_pointer].needs_warning)
910 warning_with_file_and_line (if_stack[if_stack_pointer].file,
911 if_stack[if_stack_pointer].line,
912 "suggest explicit braces to avoid ambiguous `else'");
913 last_expr_type = NULL_TREE;
916 /* Called between the then-clause and the else-clause
917 of an if-then-else. */
920 c_expand_start_else ()
922 /* An ambiguous else warning must be generated for the enclosing if
923 statement, unless we see an else branch for that one, too. */
925 && if_stack_pointer > 1
926 && (if_stack[if_stack_pointer - 1].compstmt_count
927 == if_stack[if_stack_pointer - 2].compstmt_count))
928 if_stack[if_stack_pointer - 2].needs_warning = 1;
930 /* Even if a nested if statement had an else branch, it can't be
931 ambiguous if this one also has an else. So don't warn in that
932 case. Also don't warn for any if statements nested in this else. */
933 if_stack[if_stack_pointer - 1].needs_warning = 0;
934 if_stack[if_stack_pointer - 1].compstmt_count--;
937 /* Called after the else-clause for an if-statement is processed. */
942 tree if_stmt = if_stack[if_stack_pointer - 1].if_stmt;
943 RECHAIN_STMTS (if_stmt, ELSE_CLAUSE (if_stmt));
946 /* Begin an if-statement. Returns a newly created IF_STMT if
949 Unlike the C++ front-end, we do not call add_stmt here; it is
950 probably safe to do so, but I am not very familiar with this
951 code so I am being extra careful not to change its behavior
952 beyond what is strictly necessary for correctness. */
958 r = build_stmt (IF_STMT, NULL_TREE, NULL_TREE, NULL_TREE);
962 /* Begin a while statement. Returns a newly created WHILE_STMT if
965 Unlike the C++ front-end, we do not call add_stmt here; it is
966 probably safe to do so, but I am not very familiar with this
967 code so I am being extra careful not to change its behavior
968 beyond what is strictly necessary for correctness. */
971 c_begin_while_stmt ()
974 r = build_stmt (WHILE_STMT, NULL_TREE, NULL_TREE);
979 c_finish_while_stmt_cond (cond, while_stmt)
983 WHILE_COND (while_stmt) = cond;
986 /* Push current bindings for the function name VAR_DECLS. */
992 tree saved = NULL_TREE;
994 for (ix = 0; fname_vars[ix].decl; ix++)
996 tree decl = *fname_vars[ix].decl;
1000 saved = tree_cons (decl, build_int_2 (ix, 0), saved);
1001 *fname_vars[ix].decl = NULL_TREE;
1004 if (saved || saved_function_name_decls)
1005 /* Normally they'll have been NULL, so only push if we've got a
1006 stack, or they are non-NULL. */
1007 saved_function_name_decls = tree_cons (saved, NULL_TREE,
1008 saved_function_name_decls);
1011 /* Finish up the current bindings, adding them into the
1012 current function's statement tree. This is done by wrapping the
1013 function's body in a COMPOUND_STMT containing these decls too. This
1014 must be done _before_ finish_stmt_tree is called. If there is no
1015 current function, we must be at file scope and no statements are
1016 involved. Pop the previous bindings. */
1019 finish_fname_decls ()
1022 tree body = NULL_TREE;
1023 tree stack = saved_function_name_decls;
1025 for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
1026 body = chainon (TREE_VALUE (stack), body);
1030 /* They were called into existence, so add to statement tree. */
1031 body = chainon (body,
1032 TREE_CHAIN (DECL_SAVED_TREE (current_function_decl)));
1033 body = build_stmt (COMPOUND_STMT, body);
1035 COMPOUND_STMT_NO_SCOPE (body) = 1;
1036 TREE_CHAIN (DECL_SAVED_TREE (current_function_decl)) = body;
1039 for (ix = 0; fname_vars[ix].decl; ix++)
1040 *fname_vars[ix].decl = NULL_TREE;
1044 /* We had saved values, restore them. */
1047 for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
1049 tree decl = TREE_PURPOSE (saved);
1050 unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
1052 *fname_vars[ix].decl = decl;
1054 stack = TREE_CHAIN (stack);
1056 saved_function_name_decls = stack;
1059 /* Return the text name of the current function, suitable prettified
1063 fname_as_string (pretty_p)
1066 const char *name = NULL;
1069 name = (current_function_decl
1070 ? (*lang_hooks.decl_printable_name) (current_function_decl, 2)
1072 else if (current_function_decl && DECL_NAME (current_function_decl))
1073 name = IDENTIFIER_POINTER (DECL_NAME (current_function_decl));
1079 /* Return the text name of the current function, formatted as
1080 required by the supplied RID value. */
1088 for (ix = 0; fname_vars[ix].decl; ix++)
1089 if (fname_vars[ix].rid == rid)
1091 return fname_as_string (fname_vars[ix].pretty);
1094 /* Return the VAR_DECL for a const char array naming the current
1095 function. If the VAR_DECL has not yet been created, create it
1096 now. RID indicates how it should be formatted and IDENTIFIER_NODE
1097 ID is its name (unfortunately C and C++ hold the RID values of
1098 keywords in different places, so we can't derive RID from ID in
1099 this language independent code. */
1102 fname_decl (rid, id)
1107 tree decl = NULL_TREE;
1109 for (ix = 0; fname_vars[ix].decl; ix++)
1110 if (fname_vars[ix].rid == rid)
1113 decl = *fname_vars[ix].decl;
1116 tree saved_last_tree = last_tree;
1117 /* If a tree is built here, it would normally have the lineno of
1118 the current statement. Later this tree will be moved to the
1119 beginning of the function and this line number will be wrong.
1120 To avoid this problem set the lineno to 0 here; that prevents
1121 it from appearing in the RTL. */
1122 int saved_lineno = lineno;
1125 decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
1126 if (last_tree != saved_last_tree)
1128 /* We created some statement tree for the decl. This belongs
1129 at the start of the function, so remove it now and reinsert
1130 it after the function is complete. */
1131 tree stmts = TREE_CHAIN (saved_last_tree);
1133 TREE_CHAIN (saved_last_tree) = NULL_TREE;
1134 last_tree = saved_last_tree;
1135 saved_function_name_decls = tree_cons (decl, stmts,
1136 saved_function_name_decls);
1138 *fname_vars[ix].decl = decl;
1139 lineno = saved_lineno;
1141 if (!ix && !current_function_decl)
1142 pedwarn_with_decl (decl, "`%s' is not defined outside of function scope");
1147 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
1150 fix_string_type (value)
1153 const int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
1154 const int wide_flag = TREE_TYPE (value) == wchar_array_type_node;
1155 const int nchars_max = flag_isoc99 ? 4095 : 509;
1156 int length = TREE_STRING_LENGTH (value);
1159 /* Compute the number of elements, for the array type. */
1160 nchars = wide_flag ? length / wchar_bytes : length;
1162 if (pedantic && nchars - 1 > nchars_max && c_language == clk_c)
1163 pedwarn ("string length `%d' is greater than the length `%d' ISO C%d compilers are required to support",
1164 nchars - 1, nchars_max, flag_isoc99 ? 99 : 89);
1166 /* Create the array type for the string constant.
1167 -Wwrite-strings says make the string constant an array of const char
1168 so that copying it to a non-const pointer will get a warning.
1169 For C++, this is the standard behavior. */
1170 if (flag_const_strings && ! flag_writable_strings)
1173 = build_type_variant (wide_flag ? wchar_type_node : char_type_node,
1176 = build_array_type (elements,
1177 build_index_type (build_int_2 (nchars - 1, 0)));
1181 = build_array_type (wide_flag ? wchar_type_node : char_type_node,
1182 build_index_type (build_int_2 (nchars - 1, 0)));
1184 TREE_CONSTANT (value) = 1;
1185 TREE_READONLY (value) = ! flag_writable_strings;
1186 TREE_STATIC (value) = 1;
1190 /* Given a VARRAY of STRING_CST nodes, concatenate them into one
1194 combine_strings (strings)
1195 varray_type strings;
1197 const int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
1198 const int nstrings = VARRAY_ACTIVE_SIZE (strings);
1201 int wide_length = 0;
1206 /* Don't include the \0 at the end of each substring. Count wide
1207 strings and ordinary strings separately. */
1208 for (i = 0; i < nstrings; ++i)
1210 t = VARRAY_TREE (strings, i);
1212 if (TREE_TYPE (t) == wchar_array_type_node)
1214 wide_length += TREE_STRING_LENGTH (t) - wchar_bytes;
1219 length += (TREE_STRING_LENGTH (t) - 1);
1220 if (C_ARTIFICIAL_STRING_P (t) && !in_system_header)
1221 warning ("concatenation of string literals with __FUNCTION__ is deprecated");
1225 /* If anything is wide, the non-wides will be converted,
1226 which makes them take more space. */
1228 length = length * wchar_bytes + wide_length;
1230 p = xmalloc (length);
1232 /* Copy the individual strings into the new combined string.
1233 If the combined string is wide, convert the chars to ints
1234 for any individual strings that are not wide. */
1237 for (i = 0; i < nstrings; ++i)
1241 t = VARRAY_TREE (strings, i);
1242 this_wide = TREE_TYPE (t) == wchar_array_type_node;
1243 len = TREE_STRING_LENGTH (t) - (this_wide ? wchar_bytes : 1);
1244 if (this_wide == wide_flag)
1246 memcpy (q, TREE_STRING_POINTER (t), len);
1251 const int nzeros = (TYPE_PRECISION (wchar_type_node)
1252 / BITS_PER_UNIT) - 1;
1255 if (BYTES_BIG_ENDIAN)
1257 for (k = 0; k < len; k++)
1259 for (j = 0; j < nzeros; j++)
1261 *q++ = TREE_STRING_POINTER (t)[k];
1266 for (k = 0; k < len; k++)
1268 *q++ = TREE_STRING_POINTER (t)[k];
1269 for (j = 0; j < nzeros; j++)
1276 /* Nul terminate the string. */
1279 for (i = 0; i < wchar_bytes; i++)
1285 value = build_string (length, p);
1289 TREE_TYPE (value) = wchar_array_type_node;
1291 TREE_TYPE (value) = char_array_type_node;
1296 static int is_valid_printf_arglist PARAMS ((tree));
1297 static rtx c_expand_builtin PARAMS ((tree, rtx, enum machine_mode, enum expand_modifier));
1298 static rtx c_expand_builtin_printf PARAMS ((tree, rtx, enum machine_mode,
1299 enum expand_modifier, int, int));
1300 static rtx c_expand_builtin_fprintf PARAMS ((tree, rtx, enum machine_mode,
1301 enum expand_modifier, int, int));
1303 /* Print a warning if a constant expression had overflow in folding.
1304 Invoke this function on every expression that the language
1305 requires to be a constant expression.
1306 Note the ANSI C standard says it is erroneous for a
1307 constant expression to overflow. */
1310 constant_expression_warning (value)
1313 if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
1314 || TREE_CODE (value) == VECTOR_CST
1315 || TREE_CODE (value) == COMPLEX_CST)
1316 && TREE_CONSTANT_OVERFLOW (value) && pedantic)
1317 pedwarn ("overflow in constant expression");
1320 /* Print a warning if an expression had overflow in folding.
1321 Invoke this function on every expression that
1322 (1) appears in the source code, and
1323 (2) might be a constant expression that overflowed, and
1324 (3) is not already checked by convert_and_check;
1325 however, do not invoke this function on operands of explicit casts. */
1328 overflow_warning (value)
1331 if ((TREE_CODE (value) == INTEGER_CST
1332 || (TREE_CODE (value) == COMPLEX_CST
1333 && TREE_CODE (TREE_REALPART (value)) == INTEGER_CST))
1334 && TREE_OVERFLOW (value))
1336 TREE_OVERFLOW (value) = 0;
1337 if (skip_evaluation == 0)
1338 warning ("integer overflow in expression");
1340 else if ((TREE_CODE (value) == REAL_CST
1341 || (TREE_CODE (value) == COMPLEX_CST
1342 && TREE_CODE (TREE_REALPART (value)) == REAL_CST))
1343 && TREE_OVERFLOW (value))
1345 TREE_OVERFLOW (value) = 0;
1346 if (skip_evaluation == 0)
1347 warning ("floating point overflow in expression");
1349 else if (TREE_CODE (value) == VECTOR_CST && TREE_OVERFLOW (value))
1351 TREE_OVERFLOW (value) = 0;
1352 if (skip_evaluation == 0)
1353 warning ("vector overflow in expression");
1357 /* Print a warning if a large constant is truncated to unsigned,
1358 or if -Wconversion is used and a constant < 0 is converted to unsigned.
1359 Invoke this function on every expression that might be implicitly
1360 converted to an unsigned type. */
1363 unsigned_conversion_warning (result, operand)
1364 tree result, operand;
1366 tree type = TREE_TYPE (result);
1368 if (TREE_CODE (operand) == INTEGER_CST
1369 && TREE_CODE (type) == INTEGER_TYPE
1370 && TREE_UNSIGNED (type)
1371 && skip_evaluation == 0
1372 && !int_fits_type_p (operand, type))
1374 if (!int_fits_type_p (operand, c_common_signed_type (type)))
1375 /* This detects cases like converting -129 or 256 to unsigned char. */
1376 warning ("large integer implicitly truncated to unsigned type");
1377 else if (warn_conversion)
1378 warning ("negative integer implicitly converted to unsigned type");
1382 /* Nonzero if constant C has a value that is permissible
1383 for type TYPE (an INTEGER_TYPE). */
1386 constant_fits_type_p (c, type)
1389 if (TREE_CODE (c) == INTEGER_CST)
1390 return int_fits_type_p (c, type);
1392 c = convert (type, c);
1393 return !TREE_OVERFLOW (c);
1396 /* Convert EXPR to TYPE, warning about conversion problems with constants.
1397 Invoke this function on every expression that is converted implicitly,
1398 i.e. because of language rules and not because of an explicit cast. */
1401 convert_and_check (type, expr)
1404 tree t = convert (type, expr);
1405 if (TREE_CODE (t) == INTEGER_CST)
1407 if (TREE_OVERFLOW (t))
1409 TREE_OVERFLOW (t) = 0;
1411 /* Do not diagnose overflow in a constant expression merely
1412 because a conversion overflowed. */
1413 TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (expr);
1415 /* No warning for converting 0x80000000 to int. */
1416 if (!(TREE_UNSIGNED (type) < TREE_UNSIGNED (TREE_TYPE (expr))
1417 && TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
1418 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr))))
1419 /* If EXPR fits in the unsigned version of TYPE,
1420 don't warn unless pedantic. */
1422 || TREE_UNSIGNED (type)
1423 || ! constant_fits_type_p (expr,
1424 c_common_unsigned_type (type)))
1425 && skip_evaluation == 0)
1426 warning ("overflow in implicit constant conversion");
1429 unsigned_conversion_warning (t, expr);
1434 /* A node in a list that describes references to variables (EXPR), which are
1435 either read accesses if WRITER is zero, or write accesses, in which case
1436 WRITER is the parent of EXPR. */
1443 /* Used to implement a cache the results of a call to verify_tree. We only
1444 use this for SAVE_EXPRs. */
1447 struct tlist_cache *next;
1448 struct tlist *cache_before_sp;
1449 struct tlist *cache_after_sp;
1453 /* Obstack to use when allocating tlist structures, and corresponding
1455 static struct obstack tlist_obstack;
1456 static char *tlist_firstobj = 0;
1458 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
1460 static struct tlist *warned_ids;
1461 /* SAVE_EXPRs need special treatment. We process them only once and then
1462 cache the results. */
1463 static struct tlist_cache *save_expr_cache;
1465 static void add_tlist PARAMS ((struct tlist **, struct tlist *, tree, int));
1466 static void merge_tlist PARAMS ((struct tlist **, struct tlist *, int));
1467 static void verify_tree PARAMS ((tree, struct tlist **, struct tlist **, tree));
1468 static int warning_candidate_p PARAMS ((tree));
1469 static void warn_for_collisions PARAMS ((struct tlist *));
1470 static void warn_for_collisions_1 PARAMS ((tree, tree, struct tlist *, int));
1471 static struct tlist *new_tlist PARAMS ((struct tlist *, tree, tree));
1472 static void verify_sequence_points PARAMS ((tree));
1474 /* Create a new struct tlist and fill in its fields. */
1475 static struct tlist *
1476 new_tlist (next, t, writer)
1482 l = (struct tlist *) obstack_alloc (&tlist_obstack, sizeof *l);
1489 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
1490 is nonnull, we ignore any node we find which has a writer equal to it. */
1493 add_tlist (to, add, exclude_writer, copy)
1496 tree exclude_writer;
1501 struct tlist *next = add->next;
1504 if (! exclude_writer || add->writer != exclude_writer)
1505 *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
1510 /* Merge the nodes of ADD into TO. This merging process is done so that for
1511 each variable that already exists in TO, no new node is added; however if
1512 there is a write access recorded in ADD, and an occurrence on TO is only
1513 a read access, then the occurrence in TO will be modified to record the
1517 merge_tlist (to, add, copy)
1522 struct tlist **end = to;
1525 end = &(*end)->next;
1531 struct tlist *next = add->next;
1533 for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
1534 if (tmp2->expr == add->expr)
1538 tmp2->writer = add->writer;
1542 *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
1543 end = &(*end)->next;
1550 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
1551 references in list LIST conflict with it, excluding reads if ONLY writers
1555 warn_for_collisions_1 (written, writer, list, only_writes)
1556 tree written, writer;
1562 /* Avoid duplicate warnings. */
1563 for (tmp = warned_ids; tmp; tmp = tmp->next)
1564 if (tmp->expr == written)
1569 if (list->expr == written
1570 && list->writer != writer
1571 && (! only_writes || list->writer))
1573 warned_ids = new_tlist (warned_ids, written, NULL_TREE);
1574 warning ("operation on `%s' may be undefined",
1575 IDENTIFIER_POINTER (DECL_NAME (list->expr)));
1581 /* Given a list LIST of references to variables, find whether any of these
1582 can cause conflicts due to missing sequence points. */
1585 warn_for_collisions (list)
1590 for (tmp = list; tmp; tmp = tmp->next)
1593 warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
1597 /* Return nonzero if X is a tree that can be verified by the sequence point
1600 warning_candidate_p (x)
1603 return TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == PARM_DECL;
1606 /* Walk the tree X, and record accesses to variables. If X is written by the
1607 parent tree, WRITER is the parent.
1608 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
1609 expression or its only operand forces a sequence point, then everything up
1610 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
1612 Once we return, we will have emitted warnings if any subexpression before
1613 such a sequence point could be undefined. On a higher level, however, the
1614 sequence point may not be relevant, and we'll merge the two lists.
1616 Example: (b++, a) + b;
1617 The call that processes the COMPOUND_EXPR will store the increment of B
1618 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
1619 processes the PLUS_EXPR will need to merge the two lists so that
1620 eventually, all accesses end up on the same list (and we'll warn about the
1621 unordered subexpressions b++ and b.
1623 A note on merging. If we modify the former example so that our expression
1626 care must be taken not simply to add all three expressions into the final
1627 PNO_SP list. The function merge_tlist takes care of that by merging the
1628 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1629 way, so that no more than one access to B is recorded. */
1632 verify_tree (x, pbefore_sp, pno_sp, writer)
1634 struct tlist **pbefore_sp, **pno_sp;
1637 struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
1638 enum tree_code code;
1641 /* X may be NULL if it is the operand of an empty statement expression
1647 code = TREE_CODE (x);
1648 class = TREE_CODE_CLASS (code);
1650 if (warning_candidate_p (x))
1652 *pno_sp = new_tlist (*pno_sp, x, writer);
1662 case TRUTH_ANDIF_EXPR:
1663 case TRUTH_ORIF_EXPR:
1664 tmp_before = tmp_nosp = tmp_list3 = 0;
1665 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1666 warn_for_collisions (tmp_nosp);
1667 merge_tlist (pbefore_sp, tmp_before, 0);
1668 merge_tlist (pbefore_sp, tmp_nosp, 0);
1669 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
1670 merge_tlist (pbefore_sp, tmp_list3, 0);
1674 tmp_before = tmp_list2 = 0;
1675 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
1676 warn_for_collisions (tmp_list2);
1677 merge_tlist (pbefore_sp, tmp_before, 0);
1678 merge_tlist (pbefore_sp, tmp_list2, 1);
1680 tmp_list3 = tmp_nosp = 0;
1681 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
1682 warn_for_collisions (tmp_nosp);
1683 merge_tlist (pbefore_sp, tmp_list3, 0);
1685 tmp_list3 = tmp_list2 = 0;
1686 verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
1687 warn_for_collisions (tmp_list2);
1688 merge_tlist (pbefore_sp, tmp_list3, 0);
1689 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1690 two first, to avoid warning for (a ? b++ : b++). */
1691 merge_tlist (&tmp_nosp, tmp_list2, 0);
1692 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1695 case PREDECREMENT_EXPR:
1696 case PREINCREMENT_EXPR:
1697 case POSTDECREMENT_EXPR:
1698 case POSTINCREMENT_EXPR:
1699 verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
1703 tmp_before = tmp_nosp = tmp_list3 = 0;
1704 verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
1705 verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
1706 /* Expressions inside the LHS are not ordered wrt. the sequence points
1707 in the RHS. Example:
1709 Despite the fact that the modification of "a" is in the before_sp
1710 list (tmp_before), it conflicts with the use of "a" in the LHS.
1711 We can handle this by adding the contents of tmp_list3
1712 to those of tmp_before, and redoing the collision warnings for that
1714 add_tlist (&tmp_before, tmp_list3, x, 1);
1715 warn_for_collisions (tmp_before);
1716 /* Exclude the LHS itself here; we first have to merge it into the
1717 tmp_nosp list. This is done to avoid warning for "a = a"; if we
1718 didn't exclude the LHS, we'd get it twice, once as a read and once
1720 add_tlist (pno_sp, tmp_list3, x, 0);
1721 warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
1723 merge_tlist (pbefore_sp, tmp_before, 0);
1724 if (warning_candidate_p (TREE_OPERAND (x, 0)))
1725 merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
1726 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
1730 /* We need to warn about conflicts among arguments and conflicts between
1731 args and the function address. Side effects of the function address,
1732 however, are not ordered by the sequence point of the call. */
1733 tmp_before = tmp_nosp = tmp_list2 = tmp_list3 = 0;
1734 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1735 if (TREE_OPERAND (x, 1))
1736 verify_tree (TREE_OPERAND (x, 1), &tmp_list2, &tmp_list3, NULL_TREE);
1737 merge_tlist (&tmp_list3, tmp_list2, 0);
1738 add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
1739 add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
1740 warn_for_collisions (tmp_before);
1741 add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
1745 /* Scan all the list, e.g. indices of multi dimensional array. */
1748 tmp_before = tmp_nosp = 0;
1749 verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
1750 merge_tlist (&tmp_nosp, tmp_before, 0);
1751 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1758 struct tlist_cache *t;
1759 for (t = save_expr_cache; t; t = t->next)
1765 t = (struct tlist_cache *) obstack_alloc (&tlist_obstack,
1767 t->next = save_expr_cache;
1769 save_expr_cache = t;
1771 tmp_before = tmp_nosp = 0;
1772 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1773 warn_for_collisions (tmp_nosp);
1778 struct tlist *t = tmp_nosp;
1780 merge_tlist (&tmp_list3, t, 0);
1782 t->cache_before_sp = tmp_before;
1783 t->cache_after_sp = tmp_list3;
1785 merge_tlist (pbefore_sp, t->cache_before_sp, 1);
1786 add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
1795 if (first_rtl_op (code) == 0)
1797 x = TREE_OPERAND (x, 0);
1813 int max = first_rtl_op (TREE_CODE (x));
1814 for (lp = 0; lp < max; lp++)
1816 tmp_before = tmp_nosp = 0;
1817 verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, NULL_TREE);
1818 merge_tlist (&tmp_nosp, tmp_before, 0);
1819 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1826 /* Try to warn for undefined behaviour in EXPR due to missing sequence
1830 verify_sequence_points (expr)
1833 struct tlist *before_sp = 0, *after_sp = 0;
1836 save_expr_cache = 0;
1837 if (tlist_firstobj == 0)
1839 gcc_obstack_init (&tlist_obstack);
1840 tlist_firstobj = obstack_alloc (&tlist_obstack, 0);
1843 verify_tree (expr, &before_sp, &after_sp, 0);
1844 warn_for_collisions (after_sp);
1845 obstack_free (&tlist_obstack, tlist_firstobj);
1849 c_expand_expr_stmt (expr)
1852 /* Do default conversion if safe and possibly important,
1853 in case within ({...}). */
1854 if ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE
1855 && (flag_isoc99 || lvalue_p (expr)))
1856 || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE)
1857 expr = default_conversion (expr);
1859 if (warn_sequence_point)
1860 verify_sequence_points (expr);
1862 if (TREE_TYPE (expr) != error_mark_node
1863 && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr))
1864 && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
1865 error ("expression statement has incomplete type");
1867 last_expr_type = TREE_TYPE (expr);
1868 return add_stmt (build_stmt (EXPR_STMT, expr));
1871 /* Validate the expression after `case' and apply default promotions. */
1874 check_case_value (value)
1877 if (value == NULL_TREE)
1880 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
1881 STRIP_TYPE_NOPS (value);
1882 /* In C++, the following is allowed:
1885 switch (...) { case i: ... }
1887 So, we try to reduce the VALUE to a constant that way. */
1888 if (c_language == clk_cplusplus)
1890 value = decl_constant_value (value);
1891 STRIP_TYPE_NOPS (value);
1892 value = fold (value);
1895 if (TREE_CODE (value) != INTEGER_CST
1896 && value != error_mark_node)
1898 error ("case label does not reduce to an integer constant");
1899 value = error_mark_node;
1902 /* Promote char or short to int. */
1903 value = default_conversion (value);
1905 constant_expression_warning (value);
1910 /* Return an integer type with BITS bits of precision,
1911 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1914 c_common_type_for_size (bits, unsignedp)
1918 if (bits == TYPE_PRECISION (integer_type_node))
1919 return unsignedp ? unsigned_type_node : integer_type_node;
1921 if (bits == TYPE_PRECISION (signed_char_type_node))
1922 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1924 if (bits == TYPE_PRECISION (short_integer_type_node))
1925 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1927 if (bits == TYPE_PRECISION (long_integer_type_node))
1928 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1930 if (bits == TYPE_PRECISION (long_long_integer_type_node))
1931 return (unsignedp ? long_long_unsigned_type_node
1932 : long_long_integer_type_node);
1934 if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
1935 return (unsignedp ? widest_unsigned_literal_type_node
1936 : widest_integer_literal_type_node);
1938 if (bits <= TYPE_PRECISION (intQI_type_node))
1939 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1941 if (bits <= TYPE_PRECISION (intHI_type_node))
1942 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1944 if (bits <= TYPE_PRECISION (intSI_type_node))
1945 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1947 if (bits <= TYPE_PRECISION (intDI_type_node))
1948 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1953 /* Return a data type that has machine mode MODE.
1954 If the mode is an integer,
1955 then UNSIGNEDP selects between signed and unsigned types. */
1958 c_common_type_for_mode (mode, unsignedp)
1959 enum machine_mode mode;
1962 if (mode == TYPE_MODE (integer_type_node))
1963 return unsignedp ? unsigned_type_node : integer_type_node;
1965 if (mode == TYPE_MODE (signed_char_type_node))
1966 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1968 if (mode == TYPE_MODE (short_integer_type_node))
1969 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1971 if (mode == TYPE_MODE (long_integer_type_node))
1972 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1974 if (mode == TYPE_MODE (long_long_integer_type_node))
1975 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
1977 if (mode == TYPE_MODE (widest_integer_literal_type_node))
1978 return unsignedp ? widest_unsigned_literal_type_node
1979 : widest_integer_literal_type_node;
1982 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1985 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1988 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1991 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1993 #if HOST_BITS_PER_WIDE_INT >= 64
1994 if (mode == TYPE_MODE (intTI_type_node))
1995 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1998 if (mode == TYPE_MODE (float_type_node))
1999 return float_type_node;
2001 if (mode == TYPE_MODE (double_type_node))
2002 return double_type_node;
2004 if (mode == TYPE_MODE (long_double_type_node))
2005 return long_double_type_node;
2007 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
2008 return build_pointer_type (char_type_node);
2010 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
2011 return build_pointer_type (integer_type_node);
2016 return unsignedp ? unsigned_V16QI_type_node : V16QI_type_node;
2018 return unsignedp ? unsigned_V8HI_type_node : V8HI_type_node;
2020 return unsignedp ? unsigned_V4SI_type_node : V4SI_type_node;
2022 return unsignedp ? unsigned_V2DI_type_node : V2DI_type_node;
2024 return unsignedp ? unsigned_V2SI_type_node : V2SI_type_node;
2026 return unsignedp ? unsigned_V4HI_type_node : V4HI_type_node;
2028 return unsignedp ? unsigned_V8QI_type_node : V8QI_type_node;
2030 return V16SF_type_node;
2032 return V4SF_type_node;
2034 return V2SF_type_node;
2036 return V2DF_type_node;
2044 /* Return an unsigned type the same as TYPE in other respects. */
2046 c_common_unsigned_type (type)
2049 tree type1 = TYPE_MAIN_VARIANT (type);
2050 if (type1 == signed_char_type_node || type1 == char_type_node)
2051 return unsigned_char_type_node;
2052 if (type1 == integer_type_node)
2053 return unsigned_type_node;
2054 if (type1 == short_integer_type_node)
2055 return short_unsigned_type_node;
2056 if (type1 == long_integer_type_node)
2057 return long_unsigned_type_node;
2058 if (type1 == long_long_integer_type_node)
2059 return long_long_unsigned_type_node;
2060 if (type1 == widest_integer_literal_type_node)
2061 return widest_unsigned_literal_type_node;
2062 #if HOST_BITS_PER_WIDE_INT >= 64
2063 if (type1 == intTI_type_node)
2064 return unsigned_intTI_type_node;
2066 if (type1 == intDI_type_node)
2067 return unsigned_intDI_type_node;
2068 if (type1 == intSI_type_node)
2069 return unsigned_intSI_type_node;
2070 if (type1 == intHI_type_node)
2071 return unsigned_intHI_type_node;
2072 if (type1 == intQI_type_node)
2073 return unsigned_intQI_type_node;
2075 return c_common_signed_or_unsigned_type (1, type);
2078 /* Return a signed type the same as TYPE in other respects. */
2081 c_common_signed_type (type)
2084 tree type1 = TYPE_MAIN_VARIANT (type);
2085 if (type1 == unsigned_char_type_node || type1 == char_type_node)
2086 return signed_char_type_node;
2087 if (type1 == unsigned_type_node)
2088 return integer_type_node;
2089 if (type1 == short_unsigned_type_node)
2090 return short_integer_type_node;
2091 if (type1 == long_unsigned_type_node)
2092 return long_integer_type_node;
2093 if (type1 == long_long_unsigned_type_node)
2094 return long_long_integer_type_node;
2095 if (type1 == widest_unsigned_literal_type_node)
2096 return widest_integer_literal_type_node;
2097 #if HOST_BITS_PER_WIDE_INT >= 64
2098 if (type1 == unsigned_intTI_type_node)
2099 return intTI_type_node;
2101 if (type1 == unsigned_intDI_type_node)
2102 return intDI_type_node;
2103 if (type1 == unsigned_intSI_type_node)
2104 return intSI_type_node;
2105 if (type1 == unsigned_intHI_type_node)
2106 return intHI_type_node;
2107 if (type1 == unsigned_intQI_type_node)
2108 return intQI_type_node;
2110 return c_common_signed_or_unsigned_type (0, type);
2113 /* Return a type the same as TYPE except unsigned or
2114 signed according to UNSIGNEDP. */
2117 c_common_signed_or_unsigned_type (unsignedp, type)
2121 if (! INTEGRAL_TYPE_P (type)
2122 || TREE_UNSIGNED (type) == unsignedp)
2125 if (TYPE_PRECISION (type) == TYPE_PRECISION (signed_char_type_node))
2126 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2127 if (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
2128 return unsignedp ? unsigned_type_node : integer_type_node;
2129 if (TYPE_PRECISION (type) == TYPE_PRECISION (short_integer_type_node))
2130 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2131 if (TYPE_PRECISION (type) == TYPE_PRECISION (long_integer_type_node))
2132 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2133 if (TYPE_PRECISION (type) == TYPE_PRECISION (long_long_integer_type_node))
2134 return (unsignedp ? long_long_unsigned_type_node
2135 : long_long_integer_type_node);
2136 if (TYPE_PRECISION (type) == TYPE_PRECISION (widest_integer_literal_type_node))
2137 return (unsignedp ? widest_unsigned_literal_type_node
2138 : widest_integer_literal_type_node);
2140 #if HOST_BITS_PER_WIDE_INT >= 64
2141 if (TYPE_PRECISION (type) == TYPE_PRECISION (intTI_type_node))
2142 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2144 if (TYPE_PRECISION (type) == TYPE_PRECISION (intDI_type_node))
2145 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2146 if (TYPE_PRECISION (type) == TYPE_PRECISION (intSI_type_node))
2147 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2148 if (TYPE_PRECISION (type) == TYPE_PRECISION (intHI_type_node))
2149 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2150 if (TYPE_PRECISION (type) == TYPE_PRECISION (intQI_type_node))
2151 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2156 /* Return the minimum number of bits needed to represent VALUE in a
2157 signed or unsigned type, UNSIGNEDP says which. */
2160 min_precision (value, unsignedp)
2166 /* If the value is negative, compute its negative minus 1. The latter
2167 adjustment is because the absolute value of the largest negative value
2168 is one larger than the largest positive value. This is equivalent to
2169 a bit-wise negation, so use that operation instead. */
2171 if (tree_int_cst_sgn (value) < 0)
2172 value = fold (build1 (BIT_NOT_EXPR, TREE_TYPE (value), value));
2174 /* Return the number of bits needed, taking into account the fact
2175 that we need one more bit for a signed than unsigned type. */
2177 if (integer_zerop (value))
2180 log = tree_floor_log2 (value);
2182 return log + 1 + ! unsignedp;
2185 /* Print an error message for invalid operands to arith operation
2186 CODE. NOP_EXPR is used as a special case (see
2187 c_common_truthvalue_conversion). */
2190 binary_op_error (code)
2191 enum tree_code code;
2198 error ("invalid truth-value expression");
2202 opname = "+"; break;
2204 opname = "-"; break;
2206 opname = "*"; break;
2208 opname = "max"; break;
2210 opname = "min"; break;
2212 opname = "=="; break;
2214 opname = "!="; break;
2216 opname = "<="; break;
2218 opname = ">="; break;
2220 opname = "<"; break;
2222 opname = ">"; break;
2224 opname = "<<"; break;
2226 opname = ">>"; break;
2227 case TRUNC_MOD_EXPR:
2228 case FLOOR_MOD_EXPR:
2229 opname = "%"; break;
2230 case TRUNC_DIV_EXPR:
2231 case FLOOR_DIV_EXPR:
2232 opname = "/"; break;
2234 opname = "&"; break;
2236 opname = "|"; break;
2237 case TRUTH_ANDIF_EXPR:
2238 opname = "&&"; break;
2239 case TRUTH_ORIF_EXPR:
2240 opname = "||"; break;
2242 opname = "^"; break;
2245 opname = "rotate"; break;
2247 opname = "unknown"; break;
2249 error ("invalid operands to binary %s", opname);
2252 /* Subroutine of build_binary_op, used for comparison operations.
2253 See if the operands have both been converted from subword integer types
2254 and, if so, perhaps change them both back to their original type.
2255 This function is also responsible for converting the two operands
2256 to the proper common type for comparison.
2258 The arguments of this function are all pointers to local variables
2259 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2260 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2262 If this function returns nonzero, it means that the comparison has
2263 a constant value. What this function returns is an expression for
2267 shorten_compare (op0_ptr, op1_ptr, restype_ptr, rescode_ptr)
2268 tree *op0_ptr, *op1_ptr;
2270 enum tree_code *rescode_ptr;
2273 tree op0 = *op0_ptr;
2274 tree op1 = *op1_ptr;
2275 int unsignedp0, unsignedp1;
2277 tree primop0, primop1;
2278 enum tree_code code = *rescode_ptr;
2280 /* Throw away any conversions to wider types
2281 already present in the operands. */
2283 primop0 = get_narrower (op0, &unsignedp0);
2284 primop1 = get_narrower (op1, &unsignedp1);
2286 /* Handle the case that OP0 does not *contain* a conversion
2287 but it *requires* conversion to FINAL_TYPE. */
2289 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
2290 unsignedp0 = TREE_UNSIGNED (TREE_TYPE (op0));
2291 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
2292 unsignedp1 = TREE_UNSIGNED (TREE_TYPE (op1));
2294 /* If one of the operands must be floated, we cannot optimize. */
2295 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
2296 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
2298 /* If first arg is constant, swap the args (changing operation
2299 so value is preserved), for canonicalization. Don't do this if
2300 the second arg is 0. */
2302 if (TREE_CONSTANT (primop0)
2303 && ! integer_zerop (primop1) && ! real_zerop (primop1))
2306 int temi = unsignedp0;
2314 unsignedp0 = unsignedp1;
2337 *rescode_ptr = code;
2340 /* If comparing an integer against a constant more bits wide,
2341 maybe we can deduce a value of 1 or 0 independent of the data.
2342 Or else truncate the constant now
2343 rather than extend the variable at run time.
2345 This is only interesting if the constant is the wider arg.
2346 Also, it is not safe if the constant is unsigned and the
2347 variable arg is signed, since in this case the variable
2348 would be sign-extended and then regarded as unsigned.
2349 Our technique fails in this case because the lowest/highest
2350 possible unsigned results don't follow naturally from the
2351 lowest/highest possible values of the variable operand.
2352 For just EQ_EXPR and NE_EXPR there is another technique that
2353 could be used: see if the constant can be faithfully represented
2354 in the other operand's type, by truncating it and reextending it
2355 and see if that preserves the constant's value. */
2357 if (!real1 && !real2
2358 && TREE_CODE (primop1) == INTEGER_CST
2359 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
2361 int min_gt, max_gt, min_lt, max_lt;
2362 tree maxval, minval;
2363 /* 1 if comparison is nominally unsigned. */
2364 int unsignedp = TREE_UNSIGNED (*restype_ptr);
2367 type = c_common_signed_or_unsigned_type (unsignedp0,
2368 TREE_TYPE (primop0));
2370 /* If TYPE is an enumeration, then we need to get its min/max
2371 values from it's underlying integral type, not the enumerated
2373 if (TREE_CODE (type) == ENUMERAL_TYPE)
2374 type = c_common_type_for_size (TYPE_PRECISION (type), unsignedp0);
2376 maxval = TYPE_MAX_VALUE (type);
2377 minval = TYPE_MIN_VALUE (type);
2379 if (unsignedp && !unsignedp0)
2380 *restype_ptr = c_common_signed_type (*restype_ptr);
2382 if (TREE_TYPE (primop1) != *restype_ptr)
2383 primop1 = convert (*restype_ptr, primop1);
2384 if (type != *restype_ptr)
2386 minval = convert (*restype_ptr, minval);
2387 maxval = convert (*restype_ptr, maxval);
2390 if (unsignedp && unsignedp0)
2392 min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
2393 max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
2394 min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
2395 max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
2399 min_gt = INT_CST_LT (primop1, minval);
2400 max_gt = INT_CST_LT (primop1, maxval);
2401 min_lt = INT_CST_LT (minval, primop1);
2402 max_lt = INT_CST_LT (maxval, primop1);
2406 /* This used to be a switch, but Genix compiler can't handle that. */
2407 if (code == NE_EXPR)
2409 if (max_lt || min_gt)
2410 val = boolean_true_node;
2412 else if (code == EQ_EXPR)
2414 if (max_lt || min_gt)
2415 val = boolean_false_node;
2417 else if (code == LT_EXPR)
2420 val = boolean_true_node;
2422 val = boolean_false_node;
2424 else if (code == GT_EXPR)
2427 val = boolean_true_node;
2429 val = boolean_false_node;
2431 else if (code == LE_EXPR)
2434 val = boolean_true_node;
2436 val = boolean_false_node;
2438 else if (code == GE_EXPR)
2441 val = boolean_true_node;
2443 val = boolean_false_node;
2446 /* If primop0 was sign-extended and unsigned comparison specd,
2447 we did a signed comparison above using the signed type bounds.
2448 But the comparison we output must be unsigned.
2450 Also, for inequalities, VAL is no good; but if the signed
2451 comparison had *any* fixed result, it follows that the
2452 unsigned comparison just tests the sign in reverse
2453 (positive values are LE, negative ones GE).
2454 So we can generate an unsigned comparison
2455 against an extreme value of the signed type. */
2457 if (unsignedp && !unsignedp0)
2464 primop1 = TYPE_MIN_VALUE (type);
2470 primop1 = TYPE_MAX_VALUE (type);
2477 type = c_common_unsigned_type (type);
2480 if (TREE_CODE (primop0) != INTEGER_CST)
2482 if (val == boolean_false_node)
2483 warning ("comparison is always false due to limited range of data type");
2484 if (val == boolean_true_node)
2485 warning ("comparison is always true due to limited range of data type");
2490 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2491 if (TREE_SIDE_EFFECTS (primop0))
2492 return build (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
2496 /* Value is not predetermined, but do the comparison
2497 in the type of the operand that is not constant.
2498 TYPE is already properly set. */
2500 else if (real1 && real2
2501 && (TYPE_PRECISION (TREE_TYPE (primop0))
2502 == TYPE_PRECISION (TREE_TYPE (primop1))))
2503 type = TREE_TYPE (primop0);
2505 /* If args' natural types are both narrower than nominal type
2506 and both extend in the same manner, compare them
2507 in the type of the wider arg.
2508 Otherwise must actually extend both to the nominal
2509 common type lest different ways of extending
2511 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
2513 else if (unsignedp0 == unsignedp1 && real1 == real2
2514 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
2515 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
2517 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2518 type = c_common_signed_or_unsigned_type (unsignedp0
2519 || TREE_UNSIGNED (*restype_ptr),
2521 /* Make sure shorter operand is extended the right way
2522 to match the longer operand. */
2524 = convert (c_common_signed_or_unsigned_type (unsignedp0,
2525 TREE_TYPE (primop0)),
2528 = convert (c_common_signed_or_unsigned_type (unsignedp1,
2529 TREE_TYPE (primop1)),
2534 /* Here we must do the comparison on the nominal type
2535 using the args exactly as we received them. */
2536 type = *restype_ptr;
2540 if (!real1 && !real2 && integer_zerop (primop1)
2541 && TREE_UNSIGNED (*restype_ptr))
2547 /* All unsigned values are >= 0, so we warn if extra warnings
2548 are requested. However, if OP0 is a constant that is
2549 >= 0, the signedness of the comparison isn't an issue,
2550 so suppress the warning. */
2551 if (extra_warnings && !in_system_header
2552 && ! (TREE_CODE (primop0) == INTEGER_CST
2553 && ! TREE_OVERFLOW (convert (c_common_signed_type (type),
2555 warning ("comparison of unsigned expression >= 0 is always true");
2556 value = boolean_true_node;
2560 if (extra_warnings && !in_system_header
2561 && ! (TREE_CODE (primop0) == INTEGER_CST
2562 && ! TREE_OVERFLOW (convert (c_common_signed_type (type),
2564 warning ("comparison of unsigned expression < 0 is always false");
2565 value = boolean_false_node;
2574 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2575 if (TREE_SIDE_EFFECTS (primop0))
2576 return build (COMPOUND_EXPR, TREE_TYPE (value),
2583 *op0_ptr = convert (type, primop0);
2584 *op1_ptr = convert (type, primop1);
2586 *restype_ptr = boolean_type_node;
2591 /* Return a tree for the sum or difference (RESULTCODE says which)
2592 of pointer PTROP and integer INTOP. */
2595 pointer_int_sum (resultcode, ptrop, intop)
2596 enum tree_code resultcode;
2604 /* The result is a pointer of the same type that is being added. */
2606 tree result_type = TREE_TYPE (ptrop);
2608 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
2610 if (pedantic || warn_pointer_arith)
2611 pedwarn ("pointer of type `void *' used in arithmetic");
2612 size_exp = integer_one_node;
2614 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
2616 if (pedantic || warn_pointer_arith)
2617 pedwarn ("pointer to a function used in arithmetic");
2618 size_exp = integer_one_node;
2620 else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
2622 if (pedantic || warn_pointer_arith)
2623 pedwarn ("pointer to member function used in arithmetic");
2624 size_exp = integer_one_node;
2626 else if (TREE_CODE (TREE_TYPE (result_type)) == OFFSET_TYPE)
2628 if (pedantic || warn_pointer_arith)
2629 pedwarn ("pointer to a member used in arithmetic");
2630 size_exp = integer_one_node;
2633 size_exp = size_in_bytes (TREE_TYPE (result_type));
2635 /* If what we are about to multiply by the size of the elements
2636 contains a constant term, apply distributive law
2637 and multiply that constant term separately.
2638 This helps produce common subexpressions. */
2640 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
2641 && ! TREE_CONSTANT (intop)
2642 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
2643 && TREE_CONSTANT (size_exp)
2644 /* If the constant comes from pointer subtraction,
2645 skip this optimization--it would cause an error. */
2646 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
2647 /* If the constant is unsigned, and smaller than the pointer size,
2648 then we must skip this optimization. This is because it could cause
2649 an overflow error if the constant is negative but INTOP is not. */
2650 && (! TREE_UNSIGNED (TREE_TYPE (intop))
2651 || (TYPE_PRECISION (TREE_TYPE (intop))
2652 == TYPE_PRECISION (TREE_TYPE (ptrop)))))
2654 enum tree_code subcode = resultcode;
2655 tree int_type = TREE_TYPE (intop);
2656 if (TREE_CODE (intop) == MINUS_EXPR)
2657 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
2658 /* Convert both subexpression types to the type of intop,
2659 because weird cases involving pointer arithmetic
2660 can result in a sum or difference with different type args. */
2661 ptrop = build_binary_op (subcode, ptrop,
2662 convert (int_type, TREE_OPERAND (intop, 1)), 1);
2663 intop = convert (int_type, TREE_OPERAND (intop, 0));
2666 /* Convert the integer argument to a type the same size as sizetype
2667 so the multiply won't overflow spuriously. */
2669 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
2670 || TREE_UNSIGNED (TREE_TYPE (intop)) != TREE_UNSIGNED (sizetype))
2671 intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
2672 TREE_UNSIGNED (sizetype)), intop);
2674 /* Replace the integer argument with a suitable product by the object size.
2675 Do this multiplication as signed, then convert to the appropriate
2676 pointer type (actually unsigned integral). */
2678 intop = convert (result_type,
2679 build_binary_op (MULT_EXPR, intop,
2680 convert (TREE_TYPE (intop), size_exp), 1));
2682 /* Create the sum or difference. */
2684 result = build (resultcode, result_type, ptrop, intop);
2686 folded = fold (result);
2687 if (folded == result)
2688 TREE_CONSTANT (folded) = TREE_CONSTANT (ptrop) & TREE_CONSTANT (intop);
2692 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2693 or validate its data type for an `if' or `while' statement or ?..: exp.
2695 This preparation consists of taking the ordinary
2696 representation of an expression expr and producing a valid tree
2697 boolean expression describing whether expr is nonzero. We could
2698 simply always do build_binary_op (NE_EXPR, expr, boolean_false_node, 1),
2699 but we optimize comparisons, &&, ||, and !.
2701 The resulting type should always be `boolean_type_node'. */
2704 c_common_truthvalue_conversion (expr)
2707 if (TREE_CODE (expr) == ERROR_MARK)
2710 #if 0 /* This appears to be wrong for C++. */
2711 /* These really should return error_mark_node after 2.4 is stable.
2712 But not all callers handle ERROR_MARK properly. */
2713 switch (TREE_CODE (TREE_TYPE (expr)))
2716 error ("struct type value used where scalar is required");
2717 return boolean_false_node;
2720 error ("union type value used where scalar is required");
2721 return boolean_false_node;
2724 error ("array type value used where scalar is required");
2725 return boolean_false_node;
2732 switch (TREE_CODE (expr))
2735 case NE_EXPR: case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
2736 case TRUTH_ANDIF_EXPR:
2737 case TRUTH_ORIF_EXPR:
2738 case TRUTH_AND_EXPR:
2740 case TRUTH_XOR_EXPR:
2741 case TRUTH_NOT_EXPR:
2742 TREE_TYPE (expr) = boolean_type_node;
2749 return integer_zerop (expr) ? boolean_false_node : boolean_true_node;
2752 return real_zerop (expr) ? boolean_false_node : boolean_true_node;
2755 /* If we are taking the address of an external decl, it might be zero
2756 if it is weak, so we cannot optimize. */
2757 if (DECL_P (TREE_OPERAND (expr, 0))
2758 && DECL_EXTERNAL (TREE_OPERAND (expr, 0)))
2761 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 0)))
2762 return build (COMPOUND_EXPR, boolean_type_node,
2763 TREE_OPERAND (expr, 0), boolean_true_node);
2765 return boolean_true_node;
2768 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
2769 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2770 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)),
2771 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2778 /* These don't change whether an object is non-zero or zero. */
2779 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2783 /* These don't change whether an object is zero or non-zero, but
2784 we can't ignore them if their second arg has side-effects. */
2785 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2786 return build (COMPOUND_EXPR, boolean_type_node, TREE_OPERAND (expr, 1),
2787 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)));
2789 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2792 /* Distribute the conversion into the arms of a COND_EXPR. */
2793 return fold (build (COND_EXPR, boolean_type_node, TREE_OPERAND (expr, 0),
2794 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2795 c_common_truthvalue_conversion (TREE_OPERAND (expr, 2))));
2798 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2799 since that affects how `default_conversion' will behave. */
2800 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
2801 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2803 /* fall through... */
2805 /* If this is widening the argument, we can ignore it. */
2806 if (TYPE_PRECISION (TREE_TYPE (expr))
2807 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2808 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2812 /* Perhaps reduce (x - y) != 0 to (x != y). The expressions
2813 aren't guaranteed to the be same for modes that can represent
2814 infinity, since if x and y are both +infinity, or both
2815 -infinity, then x - y is not a number.
2817 Note that this transformation is safe when x or y is NaN.
2818 (x - y) is then NaN, and both (x - y) != 0 and x != y will
2820 if (HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr, 0)))))
2822 /* fall through... */
2824 /* This and MINUS_EXPR can be changed into a comparison of the
2826 if (TREE_TYPE (TREE_OPERAND (expr, 0))
2827 == TREE_TYPE (TREE_OPERAND (expr, 1)))
2828 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2829 TREE_OPERAND (expr, 1), 1);
2830 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2831 fold (build1 (NOP_EXPR,
2832 TREE_TYPE (TREE_OPERAND (expr, 0)),
2833 TREE_OPERAND (expr, 1))), 1);
2836 if (integer_onep (TREE_OPERAND (expr, 1))
2837 && TREE_TYPE (expr) != boolean_type_node)
2838 /* Using convert here would cause infinite recursion. */
2839 return build1 (NOP_EXPR, boolean_type_node, expr);
2843 if (warn_parentheses && C_EXP_ORIGINAL_CODE (expr) == MODIFY_EXPR)
2844 warning ("suggest parentheses around assignment used as truth value");
2851 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
2853 tree t = save_expr (expr);
2854 return (build_binary_op
2855 ((TREE_SIDE_EFFECTS (expr)
2856 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2857 c_common_truthvalue_conversion (build_unary_op (REALPART_EXPR, t, 0)),
2858 c_common_truthvalue_conversion (build_unary_op (IMAGPART_EXPR, t, 0)),
2862 return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
2865 static tree builtin_function_2 PARAMS ((const char *, const char *, tree, tree,
2866 int, enum built_in_class, int, int,
2869 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2870 down to the element type of an array. */
2873 c_build_qualified_type (type, type_quals)
2877 /* A restrict-qualified pointer type must be a pointer to object or
2878 incomplete type. Note that the use of POINTER_TYPE_P also allows
2879 REFERENCE_TYPEs, which is appropriate for C++. Unfortunately,
2880 the C++ front-end also use POINTER_TYPE for pointer-to-member
2881 values, so even though it should be illegal to use `restrict'
2882 with such an entity we don't flag that here. Thus, special case
2883 code for that case is required in the C++ front-end. */
2884 if ((type_quals & TYPE_QUAL_RESTRICT)
2885 && (!POINTER_TYPE_P (type)
2886 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
2888 error ("invalid use of `restrict'");
2889 type_quals &= ~TYPE_QUAL_RESTRICT;
2892 if (TREE_CODE (type) == ARRAY_TYPE)
2893 return build_array_type (c_build_qualified_type (TREE_TYPE (type),
2895 TYPE_DOMAIN (type));
2896 return build_qualified_type (type, type_quals);
2899 /* Apply the TYPE_QUALS to the new DECL. */
2902 c_apply_type_quals_to_decl (type_quals, decl)
2906 if ((type_quals & TYPE_QUAL_CONST)
2907 || (TREE_TYPE (decl)
2908 && TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE))
2909 TREE_READONLY (decl) = 1;
2910 if (type_quals & TYPE_QUAL_VOLATILE)
2912 TREE_SIDE_EFFECTS (decl) = 1;
2913 TREE_THIS_VOLATILE (decl) = 1;
2915 if (type_quals & TYPE_QUAL_RESTRICT)
2917 if (!TREE_TYPE (decl)
2918 || !POINTER_TYPE_P (TREE_TYPE (decl))
2919 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (TREE_TYPE (decl))))
2920 error ("invalid use of `restrict'");
2921 else if (flag_strict_aliasing)
2922 /* Indicate we need to make a unique alias set for this pointer.
2923 We can't do it here because it might be pointing to an
2925 DECL_POINTER_ALIAS_SET (decl) = -2;
2929 /* Return the typed-based alias set for T, which may be an expression
2930 or a type. Return -1 if we don't do anything special. */
2933 c_common_get_alias_set (t)
2938 /* Permit type-punning when accessing a union, provided the access
2939 is directly through the union. For example, this code does not
2940 permit taking the address of a union member and then storing
2941 through it. Even the type-punning allowed here is a GCC
2942 extension, albeit a common and useful one; the C standard says
2943 that such accesses have implementation-defined behavior. */
2945 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
2946 u = TREE_OPERAND (u, 0))
2947 if (TREE_CODE (u) == COMPONENT_REF
2948 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
2951 /* That's all the expressions we handle specially. */
2955 /* The C standard guarantess that any object may be accessed via an
2956 lvalue that has character type. */
2957 if (t == char_type_node
2958 || t == signed_char_type_node
2959 || t == unsigned_char_type_node)
2962 /* If it has the may_alias attribute, it can alias anything. */
2963 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (t)))
2966 /* The C standard specifically allows aliasing between signed and
2967 unsigned variants of the same type. We treat the signed
2968 variant as canonical. */
2969 if (TREE_CODE (t) == INTEGER_TYPE && TREE_UNSIGNED (t))
2971 tree t1 = c_common_signed_type (t);
2973 /* t1 == t can happen for boolean nodes which are always unsigned. */
2975 return get_alias_set (t1);
2977 else if (POINTER_TYPE_P (t))
2981 /* Unfortunately, there is no canonical form of a pointer type.
2982 In particular, if we have `typedef int I', then `int *', and
2983 `I *' are different types. So, we have to pick a canonical
2984 representative. We do this below.
2986 Technically, this approach is actually more conservative that
2987 it needs to be. In particular, `const int *' and `int *'
2988 should be in different alias sets, according to the C and C++
2989 standard, since their types are not the same, and so,
2990 technically, an `int **' and `const int **' cannot point at
2993 But, the standard is wrong. In particular, this code is
2998 const int* const* cipp = &ipp;
3000 And, it doesn't make sense for that to be legal unless you
3001 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
3002 the pointed-to types. This issue has been reported to the
3004 t1 = build_type_no_quals (t);
3006 return get_alias_set (t1);
3012 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
3013 second parameter indicates which OPERATOR is being applied. The COMPLAIN
3014 flag controls whether we should diagnose possibly ill-formed
3015 constructs or not. */
3017 c_sizeof_or_alignof_type (type, op, complain)
3022 const char *op_name;
3024 enum tree_code type_code = TREE_CODE (type);
3026 my_friendly_assert (op == SIZEOF_EXPR || op == ALIGNOF_EXPR, 20020720);
3027 op_name = op == SIZEOF_EXPR ? "sizeof" : "__alignof__";
3029 if (type_code == FUNCTION_TYPE)
3031 if (op == SIZEOF_EXPR)
3033 if (complain && (pedantic || warn_pointer_arith))
3034 pedwarn ("invalid application of `sizeof' to a function type");
3035 value = size_one_node;
3038 value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
3040 else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
3042 if (type_code == VOID_TYPE
3043 && complain && (pedantic || warn_pointer_arith))
3044 pedwarn ("invalid application of `%s' to a void type", op_name);
3045 value = size_one_node;
3047 else if (!COMPLETE_TYPE_P (type))
3050 error ("invalid application of `%s' to an incomplete type", op_name);
3051 value = size_zero_node;
3055 if (op == SIZEOF_EXPR)
3056 /* Convert in case a char is more than one unit. */
3057 value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
3058 size_int (TYPE_PRECISION (char_type_node)
3061 value = size_int (TYPE_ALIGN (type) / BITS_PER_UNIT);
3064 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
3065 TYPE_IS_SIZETYPE means that certain things (like overflow) will
3066 never happen. However, this node should really have type
3067 `size_t', which is just a typedef for an ordinary integer type. */
3068 value = fold (build1 (NOP_EXPR, c_size_type_node, value));
3069 my_friendly_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)), 20001021);
3074 /* Implement the __alignof keyword: Return the minimum required
3075 alignment of EXPR, measured in bytes. For VAR_DECL's and
3076 FIELD_DECL's return DECL_ALIGN (which can be set from an
3077 "aligned" __attribute__ specification). */
3080 c_alignof_expr (expr)
3085 if (TREE_CODE (expr) == VAR_DECL)
3086 t = size_int (DECL_ALIGN (expr) / BITS_PER_UNIT);
3088 else if (TREE_CODE (expr) == COMPONENT_REF
3089 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
3091 error ("`__alignof' applied to a bit-field");
3094 else if (TREE_CODE (expr) == COMPONENT_REF
3095 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
3096 t = size_int (DECL_ALIGN (TREE_OPERAND (expr, 1)) / BITS_PER_UNIT);
3098 else if (TREE_CODE (expr) == INDIRECT_REF)
3100 tree t = TREE_OPERAND (expr, 0);
3102 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3104 while (TREE_CODE (t) == NOP_EXPR
3105 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
3109 t = TREE_OPERAND (t, 0);
3110 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3111 if (thisalign > bestalign)
3112 best = t, bestalign = thisalign;
3114 return c_alignof (TREE_TYPE (TREE_TYPE (best)));
3117 return c_alignof (TREE_TYPE (expr));
3119 return fold (build1 (NOP_EXPR, c_size_type_node, t));
3122 /* Handle C and C++ default attributes. */
3124 enum built_in_attribute
3126 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
3127 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
3128 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
3129 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
3130 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No entry needed in enum. */
3131 #include "builtin-attrs.def"
3132 #undef DEF_ATTR_NULL_TREE
3134 #undef DEF_ATTR_IDENT
3135 #undef DEF_ATTR_TREE_LIST
3140 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
3142 static bool c_attrs_initialized = false;
3144 static void c_init_attributes PARAMS ((void));
3146 /* Build tree nodes and builtin functions common to both C and C++ language
3150 c_common_nodes_and_builtins ()
3154 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
3155 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
3156 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
3157 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
3158 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3159 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3160 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
3161 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
3162 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
3163 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
3164 #include "builtin-types.def"
3165 #undef DEF_PRIMITIVE_TYPE
3166 #undef DEF_FUNCTION_TYPE_0
3167 #undef DEF_FUNCTION_TYPE_1
3168 #undef DEF_FUNCTION_TYPE_2
3169 #undef DEF_FUNCTION_TYPE_3
3170 #undef DEF_FUNCTION_TYPE_4
3171 #undef DEF_FUNCTION_TYPE_VAR_0
3172 #undef DEF_FUNCTION_TYPE_VAR_1
3173 #undef DEF_FUNCTION_TYPE_VAR_2
3174 #undef DEF_POINTER_TYPE
3178 typedef enum builtin_type builtin_type;
3180 tree builtin_types[(int) BT_LAST];
3181 int wchar_type_size;
3182 tree array_domain_type;
3183 tree va_list_ref_type_node;
3184 tree va_list_arg_type_node;
3186 /* Define `int' and `char' first so that dbx will output them first. */
3187 record_builtin_type (RID_INT, NULL, integer_type_node);
3188 record_builtin_type (RID_CHAR, "char", char_type_node);
3190 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
3191 "unsigned long", "long long unsigned" and "unsigned short" were in C++
3192 but not C. Are the conditionals here needed? */
3193 if (c_language == clk_cplusplus)
3194 record_builtin_type (RID_SIGNED, NULL, integer_type_node);
3195 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
3196 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
3197 record_builtin_type (RID_MAX, "long unsigned int",
3198 long_unsigned_type_node);
3199 if (c_language == clk_cplusplus)
3200 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
3201 record_builtin_type (RID_MAX, "long long int",
3202 long_long_integer_type_node);
3203 record_builtin_type (RID_MAX, "long long unsigned int",
3204 long_long_unsigned_type_node);
3205 if (c_language == clk_cplusplus)
3206 record_builtin_type (RID_MAX, "long long unsigned",
3207 long_long_unsigned_type_node);
3208 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
3209 record_builtin_type (RID_MAX, "short unsigned int",
3210 short_unsigned_type_node);
3211 if (c_language == clk_cplusplus)
3212 record_builtin_type (RID_MAX, "unsigned short",
3213 short_unsigned_type_node);
3215 /* Define both `signed char' and `unsigned char'. */
3216 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
3217 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
3219 /* These are types that c_common_type_for_size and
3220 c_common_type_for_mode use. */
3221 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3223 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3225 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3227 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3229 #if HOST_BITS_PER_WIDE_INT >= 64
3230 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3231 get_identifier ("__int128_t"),
3234 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3235 unsigned_intQI_type_node));
3236 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3237 unsigned_intHI_type_node));
3238 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3239 unsigned_intSI_type_node));
3240 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3241 unsigned_intDI_type_node));
3242 #if HOST_BITS_PER_WIDE_INT >= 64
3243 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3244 get_identifier ("__uint128_t"),
3245 unsigned_intTI_type_node));
3248 /* Create the widest literal types. */
3249 widest_integer_literal_type_node
3250 = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
3251 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3252 widest_integer_literal_type_node));
3254 widest_unsigned_literal_type_node
3255 = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
3256 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3257 widest_unsigned_literal_type_node));
3259 /* `unsigned long' is the standard type for sizeof.
3260 Note that stddef.h uses `unsigned long',
3261 and this must agree, even if long and int are the same size. */
3263 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
3264 signed_size_type_node = c_common_signed_type (c_size_type_node);
3265 set_sizetype (c_size_type_node);
3267 build_common_tree_nodes_2 (flag_short_double);
3269 record_builtin_type (RID_FLOAT, NULL, float_type_node);
3270 record_builtin_type (RID_DOUBLE, NULL, double_type_node);
3271 record_builtin_type (RID_MAX, "long double", long_double_type_node);
3273 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3274 get_identifier ("complex int"),
3275 complex_integer_type_node));
3276 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3277 get_identifier ("complex float"),
3278 complex_float_type_node));
3279 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3280 get_identifier ("complex double"),
3281 complex_double_type_node));
3282 (*lang_hooks.decls.pushdecl)
3283 (build_decl (TYPE_DECL, get_identifier ("complex long double"),
3284 complex_long_double_type_node));
3286 /* Types which are common to the fortran compiler and libf2c. When
3287 changing these, you also need to be concerned with f/com.h. */
3289 if (TYPE_PRECISION (float_type_node)
3290 == TYPE_PRECISION (long_integer_type_node))
3292 g77_integer_type_node = long_integer_type_node;
3293 g77_uinteger_type_node = long_unsigned_type_node;
3295 else if (TYPE_PRECISION (float_type_node)
3296 == TYPE_PRECISION (integer_type_node))
3298 g77_integer_type_node = integer_type_node;
3299 g77_uinteger_type_node = unsigned_type_node;
3302 g77_integer_type_node = g77_uinteger_type_node = NULL_TREE;
3304 if (g77_integer_type_node != NULL_TREE)
3306 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3307 get_identifier ("__g77_integer"),
3308 g77_integer_type_node));
3309 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3310 get_identifier ("__g77_uinteger"),
3311 g77_uinteger_type_node));
3314 if (TYPE_PRECISION (float_type_node) * 2
3315 == TYPE_PRECISION (long_integer_type_node))
3317 g77_longint_type_node = long_integer_type_node;
3318 g77_ulongint_type_node = long_unsigned_type_node;
3320 else if (TYPE_PRECISION (float_type_node) * 2
3321 == TYPE_PRECISION (long_long_integer_type_node))
3323 g77_longint_type_node = long_long_integer_type_node;
3324 g77_ulongint_type_node = long_long_unsigned_type_node;
3327 g77_longint_type_node = g77_ulongint_type_node = NULL_TREE;
3329 if (g77_longint_type_node != NULL_TREE)
3331 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3332 get_identifier ("__g77_longint"),
3333 g77_longint_type_node));
3334 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3335 get_identifier ("__g77_ulongint"),
3336 g77_ulongint_type_node));
3339 record_builtin_type (RID_VOID, NULL, void_type_node);
3341 void_zero_node = build_int_2 (0, 0);
3342 TREE_TYPE (void_zero_node) = void_type_node;
3344 void_list_node = build_void_list_node ();
3346 /* Make a type to be the domain of a few array types
3347 whose domains don't really matter.
3348 200 is small enough that it always fits in size_t
3349 and large enough that it can hold most function names for the
3350 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
3351 array_domain_type = build_index_type (size_int (200));
3353 /* Make a type for arrays of characters.
3354 With luck nothing will ever really depend on the length of this
3356 char_array_type_node
3357 = build_array_type (char_type_node, array_domain_type);
3359 /* Likewise for arrays of ints. */
3361 = build_array_type (integer_type_node, array_domain_type);
3363 string_type_node = build_pointer_type (char_type_node);
3364 const_string_type_node
3365 = build_pointer_type (build_qualified_type
3366 (char_type_node, TYPE_QUAL_CONST));
3368 (*targetm.init_builtins) ();
3370 /* This is special for C++ so functions can be overloaded. */
3371 wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
3372 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
3373 wchar_type_size = TYPE_PRECISION (wchar_type_node);
3374 if (c_language == clk_cplusplus)
3376 if (TREE_UNSIGNED (wchar_type_node))
3377 wchar_type_node = make_unsigned_type (wchar_type_size);
3379 wchar_type_node = make_signed_type (wchar_type_size);
3380 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
3384 signed_wchar_type_node = c_common_signed_type (wchar_type_node);
3385 unsigned_wchar_type_node = c_common_unsigned_type (wchar_type_node);
3388 /* This is for wide string constants. */
3389 wchar_array_type_node
3390 = build_array_type (wchar_type_node, array_domain_type);
3393 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
3396 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
3398 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
3400 default_function_type = build_function_type (integer_type_node, NULL_TREE);
3402 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
3403 unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
3405 (*lang_hooks.decls.pushdecl)
3406 (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
3407 va_list_type_node));
3409 (*lang_hooks.decls.pushdecl)
3410 (build_decl (TYPE_DECL, get_identifier ("__builtin_ptrdiff_t"),
3411 ptrdiff_type_node));
3413 (*lang_hooks.decls.pushdecl)
3414 (build_decl (TYPE_DECL, get_identifier ("__builtin_size_t"),
3417 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
3419 va_list_arg_type_node = va_list_ref_type_node =
3420 build_pointer_type (TREE_TYPE (va_list_type_node));
3424 va_list_arg_type_node = va_list_type_node;
3425 va_list_ref_type_node = build_reference_type (va_list_type_node);
3428 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3429 builtin_types[(int) ENUM] = VALUE;
3430 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
3431 builtin_types[(int) ENUM] \
3432 = build_function_type (builtin_types[(int) RETURN], \
3434 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
3435 builtin_types[(int) ENUM] \
3436 = build_function_type (builtin_types[(int) RETURN], \
3437 tree_cons (NULL_TREE, \
3438 builtin_types[(int) ARG1], \
3440 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
3441 builtin_types[(int) ENUM] \
3442 = build_function_type \
3443 (builtin_types[(int) RETURN], \
3444 tree_cons (NULL_TREE, \
3445 builtin_types[(int) ARG1], \
3446 tree_cons (NULL_TREE, \
3447 builtin_types[(int) ARG2], \
3449 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3450 builtin_types[(int) ENUM] \
3451 = build_function_type \
3452 (builtin_types[(int) RETURN], \
3453 tree_cons (NULL_TREE, \
3454 builtin_types[(int) ARG1], \
3455 tree_cons (NULL_TREE, \
3456 builtin_types[(int) ARG2], \
3457 tree_cons (NULL_TREE, \
3458 builtin_types[(int) ARG3], \
3460 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3461 builtin_types[(int) ENUM] \
3462 = build_function_type \
3463 (builtin_types[(int) RETURN], \
3464 tree_cons (NULL_TREE, \
3465 builtin_types[(int) ARG1], \
3466 tree_cons (NULL_TREE, \
3467 builtin_types[(int) ARG2], \
3470 builtin_types[(int) ARG3], \
3471 tree_cons (NULL_TREE, \
3472 builtin_types[(int) ARG4], \
3473 void_list_node)))));
3474 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
3475 builtin_types[(int) ENUM] \
3476 = build_function_type (builtin_types[(int) RETURN], NULL_TREE);
3477 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
3478 builtin_types[(int) ENUM] \
3479 = build_function_type (builtin_types[(int) RETURN], \
3480 tree_cons (NULL_TREE, \
3481 builtin_types[(int) ARG1], \
3484 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
3485 builtin_types[(int) ENUM] \
3486 = build_function_type \
3487 (builtin_types[(int) RETURN], \
3488 tree_cons (NULL_TREE, \
3489 builtin_types[(int) ARG1], \
3490 tree_cons (NULL_TREE, \
3491 builtin_types[(int) ARG2], \
3493 #define DEF_POINTER_TYPE(ENUM, TYPE) \
3494 builtin_types[(int) ENUM] \
3495 = build_pointer_type (builtin_types[(int) TYPE]);
3496 #include "builtin-types.def"
3497 #undef DEF_PRIMITIVE_TYPE
3498 #undef DEF_FUNCTION_TYPE_1
3499 #undef DEF_FUNCTION_TYPE_2
3500 #undef DEF_FUNCTION_TYPE_3
3501 #undef DEF_FUNCTION_TYPE_4
3502 #undef DEF_FUNCTION_TYPE_VAR_0
3503 #undef DEF_FUNCTION_TYPE_VAR_1
3504 #undef DEF_POINTER_TYPE
3506 if (!c_attrs_initialized)
3507 c_init_attributes ();
3509 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, \
3510 BOTH_P, FALLBACK_P, NONANSI_P, ATTRS) \
3515 if (strncmp (NAME, "__builtin_", strlen ("__builtin_")) != 0) \
3519 decl = builtin_function (NAME, builtin_types[TYPE], ENUM, \
3522 ? (NAME + strlen ("__builtin_")) \
3524 built_in_attributes[(int) ATTRS]); \
3526 decl = builtin_function_2 (NAME, \
3527 NAME + strlen ("__builtin_"), \
3528 builtin_types[TYPE], \
3529 builtin_types[LIBTYPE], \
3534 built_in_attributes[(int) ATTRS]); \
3536 built_in_decls[(int) ENUM] = decl; \
3538 #include "builtins.def"
3541 main_identifier_node = get_identifier ("main");
3545 build_va_arg (expr, type)
3548 return build1 (VA_ARG_EXPR, type, expr);
3552 /* Linked list of disabled built-in functions. */
3554 typedef struct disabled_builtin
3557 struct disabled_builtin *next;
3559 static disabled_builtin *disabled_builtins = NULL;
3561 static bool builtin_function_disabled_p PARAMS ((const char *));
3563 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
3564 begins with "__builtin_", give an error. */
3567 disable_builtin_function (name)
3570 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
3571 error ("cannot disable built-in function `%s'", name);
3574 disabled_builtin *new = xmalloc (sizeof (disabled_builtin));
3576 new->next = disabled_builtins;
3577 disabled_builtins = new;
3582 /* Return true if the built-in function NAME has been disabled, false
3586 builtin_function_disabled_p (name)
3589 disabled_builtin *p;
3590 for (p = disabled_builtins; p != NULL; p = p->next)
3592 if (strcmp (name, p->name) == 0)
3599 /* Possibly define a builtin function with one or two names. BUILTIN_NAME
3600 is an __builtin_-prefixed name; NAME is the ordinary name; one or both
3601 of these may be NULL (though both being NULL is useless).
3602 BUILTIN_TYPE is the type of the __builtin_-prefixed function;
3603 TYPE is the type of the function with the ordinary name. These
3604 may differ if the ordinary name is declared with a looser type to avoid
3605 conflicts with headers. FUNCTION_CODE and CLASS are as for
3606 builtin_function. If LIBRARY_NAME_P is nonzero, NAME is passed as
3607 the LIBRARY_NAME parameter to builtin_function when declaring BUILTIN_NAME.
3608 If NONANSI_P is nonzero, the name NAME is treated as a non-ANSI name;
3609 ATTRS is the tree list representing the builtin's function attributes.
3610 Returns the declaration of BUILTIN_NAME, if any, otherwise
3611 the declaration of NAME. Does not declare NAME if flag_no_builtin,
3612 or if NONANSI_P and flag_no_nonansi_builtin. */
3615 builtin_function_2 (builtin_name, name, builtin_type, type, function_code,
3616 class, library_name_p, nonansi_p, attrs)
3617 const char *builtin_name;
3622 enum built_in_class class;
3627 tree bdecl = NULL_TREE;
3628 tree decl = NULL_TREE;
3629 if (builtin_name != 0)
3631 bdecl = builtin_function (builtin_name, builtin_type, function_code,
3632 class, library_name_p ? name : NULL,
3635 if (name != 0 && !flag_no_builtin && !builtin_function_disabled_p (name)
3636 && !(nonansi_p && flag_no_nonansi_builtin))
3638 decl = builtin_function (name, type, function_code, class, NULL,
3641 DECL_BUILT_IN_NONANSI (decl) = 1;
3643 return (bdecl != 0 ? bdecl : decl);
3646 /* Nonzero if the type T promotes to int. This is (nearly) the
3647 integral promotions defined in ISO C99 6.3.1.1/2. */
3650 c_promoting_integer_type_p (t)
3653 switch (TREE_CODE (t))
3656 return (TYPE_MAIN_VARIANT (t) == char_type_node
3657 || TYPE_MAIN_VARIANT (t) == signed_char_type_node
3658 || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
3659 || TYPE_MAIN_VARIANT (t) == short_integer_type_node
3660 || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
3661 || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
3664 /* ??? Technically all enumerations not larger than an int
3665 promote to an int. But this is used along code paths
3666 that only want to notice a size change. */
3667 return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
3677 /* Return 1 if PARMS specifies a fixed number of parameters
3678 and none of their types is affected by default promotions. */
3681 self_promoting_args_p (parms)
3685 for (t = parms; t; t = TREE_CHAIN (t))
3687 tree type = TREE_VALUE (t);
3689 if (TREE_CHAIN (t) == 0 && type != void_type_node)
3695 if (TYPE_MAIN_VARIANT (type) == float_type_node)
3698 if (c_promoting_integer_type_p (type))
3704 /* Recursively examines the array elements of TYPE, until a non-array
3705 element type is found. */
3708 strip_array_types (type)
3711 while (TREE_CODE (type) == ARRAY_TYPE)
3712 type = TREE_TYPE (type);
3717 static tree expand_unordered_cmp PARAMS ((tree, tree, enum tree_code,
3720 /* Expand a call to an unordered comparison function such as
3721 __builtin_isgreater(). FUNCTION is the function's declaration and
3722 PARAMS a list of the values passed. For __builtin_isunordered(),
3723 UNORDERED_CODE is UNORDERED_EXPR and ORDERED_CODE is NOP_EXPR. In
3724 other cases, UNORDERED_CODE and ORDERED_CODE are comparison codes
3725 that give the opposite of the desired result. UNORDERED_CODE is
3726 used for modes that can hold NaNs and ORDERED_CODE is used for the
3730 expand_unordered_cmp (function, params, unordered_code, ordered_code)
3731 tree function, params;
3732 enum tree_code unordered_code, ordered_code;
3734 tree arg0, arg1, type;
3735 enum tree_code code0, code1;
3737 /* Check that we have exactly two arguments. */
3738 if (params == 0 || TREE_CHAIN (params) == 0)
3740 error ("too few arguments to function `%s'",
3741 IDENTIFIER_POINTER (DECL_NAME (function)));
3742 return error_mark_node;
3744 else if (TREE_CHAIN (TREE_CHAIN (params)) != 0)
3746 error ("too many arguments to function `%s'",
3747 IDENTIFIER_POINTER (DECL_NAME (function)));
3748 return error_mark_node;
3751 arg0 = TREE_VALUE (params);
3752 arg1 = TREE_VALUE (TREE_CHAIN (params));
3754 code0 = TREE_CODE (TREE_TYPE (arg0));
3755 code1 = TREE_CODE (TREE_TYPE (arg1));
3757 /* Make sure that the arguments have a common type of REAL. */
3759 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
3760 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
3761 type = common_type (TREE_TYPE (arg0), TREE_TYPE (arg1));
3763 if (type == 0 || TREE_CODE (type) != REAL_TYPE)
3765 error ("non-floating-point argument to function `%s'",
3766 IDENTIFIER_POINTER (DECL_NAME (function)));
3767 return error_mark_node;
3770 if (unordered_code == UNORDERED_EXPR)
3772 if (MODE_HAS_NANS (TYPE_MODE (type)))
3773 return build_binary_op (unordered_code,
3774 convert (type, arg0),
3775 convert (type, arg1),
3778 return integer_zero_node;
3781 return build_unary_op (TRUTH_NOT_EXPR,
3782 build_binary_op (MODE_HAS_NANS (TYPE_MODE (type))
3785 convert (type, arg0),
3786 convert (type, arg1),
3792 /* Recognize certain built-in functions so we can make tree-codes
3793 other than CALL_EXPR. We do this when it enables fold-const.c
3794 to do something useful. */
3795 /* ??? By rights this should go in builtins.c, but only C and C++
3796 implement build_{binary,unary}_op. Not exactly sure what bits
3797 of functionality are actually needed from those functions, or
3798 where the similar functionality exists in the other front ends. */
3801 expand_tree_builtin (function, params, coerced_params)
3802 tree function, params, coerced_params;
3804 if (DECL_BUILT_IN_CLASS (function) != BUILT_IN_NORMAL)
3807 switch (DECL_FUNCTION_CODE (function))
3811 case BUILT_IN_LLABS:
3812 case BUILT_IN_IMAXABS:
3814 case BUILT_IN_FABSL:
3815 case BUILT_IN_FABSF:
3816 if (coerced_params == 0)
3817 return integer_zero_node;
3818 return build_unary_op (ABS_EXPR, TREE_VALUE (coerced_params), 0);
3821 case BUILT_IN_CONJF:
3822 case BUILT_IN_CONJL:
3823 if (coerced_params == 0)
3824 return integer_zero_node;
3825 return build_unary_op (CONJ_EXPR, TREE_VALUE (coerced_params), 0);
3827 case BUILT_IN_CREAL:
3828 case BUILT_IN_CREALF:
3829 case BUILT_IN_CREALL:
3830 if (coerced_params == 0)
3831 return integer_zero_node;
3832 return build_unary_op (REALPART_EXPR, TREE_VALUE (coerced_params), 0);
3834 case BUILT_IN_CIMAG:
3835 case BUILT_IN_CIMAGF:
3836 case BUILT_IN_CIMAGL:
3837 if (coerced_params == 0)
3838 return integer_zero_node;
3839 return build_unary_op (IMAGPART_EXPR, TREE_VALUE (coerced_params), 0);
3841 case BUILT_IN_ISGREATER:
3842 return expand_unordered_cmp (function, params, UNLE_EXPR, LE_EXPR);
3844 case BUILT_IN_ISGREATEREQUAL:
3845 return expand_unordered_cmp (function, params, UNLT_EXPR, LT_EXPR);
3847 case BUILT_IN_ISLESS:
3848 return expand_unordered_cmp (function, params, UNGE_EXPR, GE_EXPR);
3850 case BUILT_IN_ISLESSEQUAL:
3851 return expand_unordered_cmp (function, params, UNGT_EXPR, GT_EXPR);
3853 case BUILT_IN_ISLESSGREATER:
3854 return expand_unordered_cmp (function, params, UNEQ_EXPR, EQ_EXPR);
3856 case BUILT_IN_ISUNORDERED:
3857 return expand_unordered_cmp (function, params, UNORDERED_EXPR, NOP_EXPR);
3866 /* Returns non-zero if CODE is the code for a statement. */
3869 statement_code_p (code)
3870 enum tree_code code;
3895 if (lang_statement_code_p)
3896 return (*lang_statement_code_p) (code);
3901 /* Walk the statement tree, rooted at *tp. Apply FUNC to all the
3902 sub-trees of *TP in a pre-order traversal. FUNC is called with the
3903 DATA and the address of each sub-tree. If FUNC returns a non-NULL
3904 value, the traversal is aborted, and the value returned by FUNC is
3905 returned. If FUNC sets WALK_SUBTREES to zero, then the subtrees of
3906 the node being visited are not walked.
3908 We don't need a without_duplicates variant of this one because the
3909 statement tree is a tree, not a graph. */
3912 walk_stmt_tree (tp, func, data)
3917 enum tree_code code;
3922 #define WALK_SUBTREE(NODE) \
3925 result = walk_stmt_tree (&(NODE), func, data); \
3931 /* Skip empty subtrees. */
3935 /* Skip subtrees below non-statement nodes. */
3936 if (!statement_code_p (TREE_CODE (*tp)))
3939 /* Call the function. */
3941 result = (*func) (tp, &walk_subtrees, data);
3943 /* If we found something, return it. */
3947 /* FUNC may have modified the tree, recheck that we're looking at a
3949 code = TREE_CODE (*tp);
3950 if (!statement_code_p (code))
3953 /* Visit the subtrees unless FUNC decided that there was nothing
3954 interesting below this point in the tree. */
3957 /* Walk over all the sub-trees of this operand. Statement nodes
3958 never contain RTL, and we needn't worry about TARGET_EXPRs. */
3959 len = TREE_CODE_LENGTH (code);
3961 /* Go through the subtrees. We need to do this in forward order so
3962 that the scope of a FOR_EXPR is handled properly. */
3963 for (i = 0; i < len; ++i)
3964 WALK_SUBTREE (TREE_OPERAND (*tp, i));
3967 /* Finally visit the chain. This can be tail-recursion optimized if
3968 we write it this way. */
3969 return walk_stmt_tree (&TREE_CHAIN (*tp), func, data);
3974 /* Used to compare case labels. K1 and K2 are actually tree nodes
3975 representing case labels, or NULL_TREE for a `default' label.
3976 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3977 K2, and 0 if K1 and K2 are equal. */
3980 case_compare (k1, k2)
3984 /* Consider a NULL key (such as arises with a `default' label) to be
3985 smaller than anything else. */
3991 return tree_int_cst_compare ((tree) k1, (tree) k2);
3994 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
3995 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3996 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
3997 case label was declared using the usual C/C++ syntax, rather than
3998 the GNU case range extension. CASES is a tree containing all the
3999 case ranges processed so far; COND is the condition for the
4000 switch-statement itself. Returns the CASE_LABEL created, or
4001 ERROR_MARK_NODE if no CASE_LABEL is created. */
4004 c_add_case_label (cases, cond, low_value, high_value)
4013 splay_tree_node node;
4015 /* Create the LABEL_DECL itself. */
4016 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
4017 DECL_CONTEXT (label) = current_function_decl;
4019 /* If there was an error processing the switch condition, bail now
4020 before we get more confused. */
4021 if (!cond || cond == error_mark_node)
4023 /* Add a label anyhow so that the back-end doesn't think that
4024 the beginning of the switch is unreachable. */
4026 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
4027 return error_mark_node;
4030 if ((low_value && TREE_TYPE (low_value)
4031 && POINTER_TYPE_P (TREE_TYPE (low_value)))
4032 || (high_value && TREE_TYPE (high_value)
4033 && POINTER_TYPE_P (TREE_TYPE (high_value))))
4034 error ("pointers are not permitted as case values");
4036 /* Case ranges are a GNU extension. */
4037 if (high_value && pedantic)
4039 if (c_language == clk_cplusplus)
4040 pedwarn ("ISO C++ forbids range expressions in switch statements");
4042 pedwarn ("ISO C forbids range expressions in switch statements");
4045 type = TREE_TYPE (cond);
4048 low_value = check_case_value (low_value);
4049 low_value = convert_and_check (type, low_value);
4053 high_value = check_case_value (high_value);
4054 high_value = convert_and_check (type, high_value);
4057 /* If an error has occurred, bail out now. */
4058 if (low_value == error_mark_node || high_value == error_mark_node)
4061 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
4062 return error_mark_node;
4065 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
4066 really a case range, even though it was written that way. Remove
4067 the HIGH_VALUE to simplify later processing. */
4068 if (tree_int_cst_equal (low_value, high_value))
4069 high_value = NULL_TREE;
4070 if (low_value && high_value
4071 && !tree_int_cst_lt (low_value, high_value))
4072 warning ("empty range specified");
4074 /* Look up the LOW_VALUE in the table of case labels we already
4076 node = splay_tree_lookup (cases, (splay_tree_key) low_value);
4077 /* If there was not an exact match, check for overlapping ranges.
4078 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
4079 that's a `default' label and the only overlap is an exact match. */
4080 if (!node && (low_value || high_value))
4082 splay_tree_node low_bound;
4083 splay_tree_node high_bound;
4085 /* Even though there wasn't an exact match, there might be an
4086 overlap between this case range and another case range.
4087 Since we've (inductively) not allowed any overlapping case
4088 ranges, we simply need to find the greatest low case label
4089 that is smaller that LOW_VALUE, and the smallest low case
4090 label that is greater than LOW_VALUE. If there is an overlap
4091 it will occur in one of these two ranges. */
4092 low_bound = splay_tree_predecessor (cases,
4093 (splay_tree_key) low_value);
4094 high_bound = splay_tree_successor (cases,
4095 (splay_tree_key) low_value);
4097 /* Check to see if the LOW_BOUND overlaps. It is smaller than
4098 the LOW_VALUE, so there is no need to check unless the
4099 LOW_BOUND is in fact itself a case range. */
4101 && CASE_HIGH ((tree) low_bound->value)
4102 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
4105 /* Check to see if the HIGH_BOUND overlaps. The low end of that
4106 range is bigger than the low end of the current range, so we
4107 are only interested if the current range is a real range, and
4108 not an ordinary case label. */
4111 && (tree_int_cst_compare ((tree) high_bound->key,
4116 /* If there was an overlap, issue an error. */
4119 tree duplicate = CASE_LABEL_DECL ((tree) node->value);
4123 error ("duplicate (or overlapping) case value");
4124 error_with_decl (duplicate,
4125 "this is the first entry overlapping that value");
4129 error ("duplicate case value") ;
4130 error_with_decl (duplicate, "previously used here");
4134 error ("multiple default labels in one switch");
4135 error_with_decl (duplicate, "this is the first default label");
4138 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
4141 /* Add a CASE_LABEL to the statement-tree. */
4142 case_label = add_stmt (build_case_label (low_value, high_value, label));
4143 /* Register this case label in the splay tree. */
4144 splay_tree_insert (cases,
4145 (splay_tree_key) low_value,
4146 (splay_tree_value) case_label);
4151 /* Finish an expression taking the address of LABEL. Returns an
4152 expression for the address. */
4155 finish_label_address_expr (label)
4162 if (c_language == clk_cplusplus)
4163 pedwarn ("ISO C++ forbids taking the address of a label");
4165 pedwarn ("ISO C forbids taking the address of a label");
4168 label = lookup_label (label);
4169 if (label == NULL_TREE)
4170 result = null_pointer_node;
4173 TREE_USED (label) = 1;
4174 result = build1 (ADDR_EXPR, ptr_type_node, label);
4175 TREE_CONSTANT (result) = 1;
4176 /* The current function in not necessarily uninlinable.
4177 Computed gotos are incompatible with inlining, but the value
4178 here could be used only in a diagnostic, for example. */
4184 /* Hook used by expand_expr to expand language-specific tree codes. */
4187 c_expand_expr (exp, target, tmode, modifier)
4190 enum machine_mode tmode;
4191 int modifier; /* Actually enum_modifier. */
4193 switch (TREE_CODE (exp))
4199 bool preserve_result = false;
4200 bool return_target = false;
4202 /* Since expand_expr_stmt calls free_temp_slots after every
4203 expression statement, we must call push_temp_slots here.
4204 Otherwise, any temporaries in use now would be considered
4205 out-of-scope after the first EXPR_STMT from within the
4208 rtl_expr = expand_start_stmt_expr (!STMT_EXPR_NO_SCOPE (exp));
4210 /* If we want the result of this expression, find the last
4211 EXPR_STMT in the COMPOUND_STMT and mark it as addressable. */
4212 if (target != const0_rtx
4213 && TREE_CODE (STMT_EXPR_STMT (exp)) == COMPOUND_STMT
4214 && TREE_CODE (COMPOUND_BODY (STMT_EXPR_STMT (exp))) == SCOPE_STMT)
4216 tree expr = COMPOUND_BODY (STMT_EXPR_STMT (exp));
4217 tree last = TREE_CHAIN (expr);
4219 while (TREE_CHAIN (last))
4222 last = TREE_CHAIN (last);
4225 if (TREE_CODE (last) == SCOPE_STMT
4226 && TREE_CODE (expr) == EXPR_STMT)
4228 if (target && TREE_CODE (EXPR_STMT_EXPR (expr)) == VAR_DECL
4229 && DECL_RTL_IF_SET (EXPR_STMT_EXPR (expr)) == target)
4230 /* If the last expression is a variable whose RTL is the
4231 same as our target, just return the target; if it
4232 isn't valid expanding the decl would produce different
4233 RTL, and store_expr would try to do a copy. */
4234 return_target = true;
4237 /* Otherwise, note that we want the value from the last
4239 TREE_ADDRESSABLE (expr) = 1;
4240 preserve_result = true;
4245 expand_stmt (STMT_EXPR_STMT (exp));
4246 expand_end_stmt_expr (rtl_expr);
4248 result = expand_expr (rtl_expr, target, tmode, modifier);
4251 else if (preserve_result && GET_CODE (result) == MEM)
4253 if (GET_MODE (result) != BLKmode)
4254 result = copy_to_reg (result);
4256 preserve_temp_slots (result);
4259 /* If the statment-expression does not have a scope, then the
4260 new temporaries we created within it must live beyond the
4261 statement-expression. */
4262 if (STMT_EXPR_NO_SCOPE (exp))
4263 preserve_temp_slots (NULL_RTX);
4272 if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
4273 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
4275 && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
4276 && (DECL_BUILT_IN_CLASS (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
4277 == BUILT_IN_FRONTEND))
4278 return c_expand_builtin (exp, target, tmode, modifier);
4284 case COMPOUND_LITERAL_EXPR:
4286 /* Initialize the anonymous variable declared in the compound
4287 literal, then return the variable. */
4288 tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
4289 emit_local_var (decl);
4290 return expand_expr (decl, target, tmode, modifier);
4301 /* Hook used by safe_from_p to handle language-specific tree codes. */
4304 c_safe_from_p (target, exp)
4308 /* We can see statements here when processing the body of a
4309 statement-expression. For a declaration statement declaring a
4310 variable, look at the variable's initializer. */
4311 if (TREE_CODE (exp) == DECL_STMT)
4313 tree decl = DECL_STMT_DECL (exp);
4315 if (TREE_CODE (decl) == VAR_DECL
4316 && DECL_INITIAL (decl)
4317 && !safe_from_p (target, DECL_INITIAL (decl), /*top_p=*/0))
4321 /* For any statement, we must follow the statement-chain. */
4322 if (statement_code_p (TREE_CODE (exp)) && TREE_CHAIN (exp))
4323 return safe_from_p (target, TREE_CHAIN (exp), /*top_p=*/0);
4325 /* Assume everything else is safe. */
4329 /* Hook used by unsafe_for_reeval to handle language-specific tree codes. */
4332 c_common_unsafe_for_reeval (exp)
4335 /* Statement expressions may not be reevaluated, likewise compound
4337 if (TREE_CODE (exp) == STMT_EXPR
4338 || TREE_CODE (exp) == COMPOUND_LITERAL_EXPR)
4341 /* Walk all other expressions. */
4345 /* Hook used by staticp to handle language-specific tree codes. */
4351 if (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR
4352 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp)))
4357 #define CALLED_AS_BUILT_IN(NODE) \
4358 (!strncmp (IDENTIFIER_POINTER (DECL_NAME (NODE)), "__builtin_", 10))
4361 c_expand_builtin (exp, target, tmode, modifier)
4364 enum machine_mode tmode;
4365 enum expand_modifier modifier;
4367 tree type = TREE_TYPE (exp);
4368 tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
4369 tree arglist = TREE_OPERAND (exp, 1);
4370 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
4371 enum tree_code code = TREE_CODE (exp);
4372 const int ignore = (target == const0_rtx
4373 || ((code == NON_LVALUE_EXPR || code == NOP_EXPR
4374 || code == CONVERT_EXPR || code == REFERENCE_EXPR
4375 || code == COND_EXPR)
4376 && TREE_CODE (type) == VOID_TYPE));
4378 if (! optimize && ! CALLED_AS_BUILT_IN (fndecl))
4379 return expand_call (exp, target, ignore);
4383 case BUILT_IN_PRINTF:
4384 target = c_expand_builtin_printf (arglist, target, tmode,
4385 modifier, ignore, /*unlocked=*/ 0);
4390 case BUILT_IN_PRINTF_UNLOCKED:
4391 target = c_expand_builtin_printf (arglist, target, tmode,
4392 modifier, ignore, /*unlocked=*/ 1);
4397 case BUILT_IN_FPRINTF:
4398 target = c_expand_builtin_fprintf (arglist, target, tmode,
4399 modifier, ignore, /*unlocked=*/ 0);
4404 case BUILT_IN_FPRINTF_UNLOCKED:
4405 target = c_expand_builtin_fprintf (arglist, target, tmode,
4406 modifier, ignore, /*unlocked=*/ 1);
4411 default: /* just do library call, if unknown builtin */
4412 error ("built-in function `%s' not currently supported",
4413 IDENTIFIER_POINTER (DECL_NAME (fndecl)));
4416 /* The switch statement above can drop through to cause the function
4417 to be called normally. */
4418 return expand_call (exp, target, ignore);
4421 /* Check an arglist to *printf for problems. The arglist should start
4422 at the format specifier, with the remaining arguments immediately
4425 is_valid_printf_arglist (arglist)
4428 /* Save this value so we can restore it later. */
4429 const int SAVE_pedantic = pedantic;
4430 int diagnostic_occurred = 0;
4433 /* Set this to a known value so the user setting won't affect code
4436 /* Check to make sure there are no format specifier errors. */
4437 attrs = tree_cons (get_identifier ("format"),
4438 tree_cons (NULL_TREE,
4439 get_identifier ("printf"),
4440 tree_cons (NULL_TREE,
4442 tree_cons (NULL_TREE,
4446 check_function_format (&diagnostic_occurred, attrs, arglist);
4448 /* Restore the value of `pedantic'. */
4449 pedantic = SAVE_pedantic;
4451 /* If calling `check_function_format_ptr' produces a warning, we
4452 return false, otherwise we return true. */
4453 return ! diagnostic_occurred;
4456 /* If the arguments passed to printf are suitable for optimizations,
4457 we attempt to transform the call. */
4459 c_expand_builtin_printf (arglist, target, tmode, modifier, ignore, unlocked)
4462 enum machine_mode tmode;
4463 enum expand_modifier modifier;
4467 tree fn_putchar = unlocked ?
4468 built_in_decls[BUILT_IN_PUTCHAR_UNLOCKED] : built_in_decls[BUILT_IN_PUTCHAR];
4469 tree fn_puts = unlocked ?
4470 built_in_decls[BUILT_IN_PUTS_UNLOCKED] : built_in_decls[BUILT_IN_PUTS];
4471 tree fn, format_arg, stripped_string;
4473 /* If the return value is used, or the replacement _DECL isn't
4474 initialized, don't do the transformation. */
4475 if (!ignore || !fn_putchar || !fn_puts)
4478 /* Verify the required arguments in the original call. */
4480 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE))
4483 /* Check the specifier vs. the parameters. */
4484 if (!is_valid_printf_arglist (arglist))
4487 format_arg = TREE_VALUE (arglist);
4488 stripped_string = format_arg;
4489 STRIP_NOPS (stripped_string);
4490 if (stripped_string && TREE_CODE (stripped_string) == ADDR_EXPR)
4491 stripped_string = TREE_OPERAND (stripped_string, 0);
4493 /* If the format specifier isn't a STRING_CST, punt. */
4494 if (TREE_CODE (stripped_string) != STRING_CST)
4497 /* OK! We can attempt optimization. */
4499 /* If the format specifier was "%s\n", call __builtin_puts(arg2). */
4500 if (strcmp (TREE_STRING_POINTER (stripped_string), "%s\n") == 0)
4502 arglist = TREE_CHAIN (arglist);
4505 /* If the format specifier was "%c", call __builtin_putchar (arg2). */
4506 else if (strcmp (TREE_STRING_POINTER (stripped_string), "%c") == 0)
4508 arglist = TREE_CHAIN (arglist);
4513 /* We can't handle anything else with % args or %% ... yet. */
4514 if (strchr (TREE_STRING_POINTER (stripped_string), '%'))
4517 /* If the resulting constant string has a length of 1, call
4518 putchar. Note, TREE_STRING_LENGTH includes the terminating
4519 NULL in its count. */
4520 if (TREE_STRING_LENGTH (stripped_string) == 2)
4522 /* Given printf("c"), (where c is any one character,)
4523 convert "c"[0] to an int and pass that to the replacement
4525 arglist = build_int_2 (TREE_STRING_POINTER (stripped_string)[0], 0);
4526 arglist = build_tree_list (NULL_TREE, arglist);
4530 /* If the resulting constant was "string\n", call
4531 __builtin_puts("string"). Ensure "string" has at least one
4532 character besides the trailing \n. Note, TREE_STRING_LENGTH
4533 includes the terminating NULL in its count. */
4534 else if (TREE_STRING_LENGTH (stripped_string) > 2
4535 && TREE_STRING_POINTER (stripped_string)
4536 [TREE_STRING_LENGTH (stripped_string) - 2] == '\n')
4538 /* Create a NULL-terminated string that's one char shorter
4539 than the original, stripping off the trailing '\n'. */
4540 const int newlen = TREE_STRING_LENGTH (stripped_string) - 1;
4541 char *newstr = (char *) alloca (newlen);
4542 memcpy (newstr, TREE_STRING_POINTER (stripped_string), newlen - 1);
4543 newstr[newlen - 1] = 0;
4545 arglist = fix_string_type (build_string (newlen, newstr));
4546 arglist = build_tree_list (NULL_TREE, arglist);
4550 /* We'd like to arrange to call fputs(string) here, but we
4551 need stdout and don't have a way to get it ... yet. */
4555 return expand_expr (build_function_call (fn, arglist),
4556 (ignore ? const0_rtx : target),
4560 /* If the arguments passed to fprintf are suitable for optimizations,
4561 we attempt to transform the call. */
4563 c_expand_builtin_fprintf (arglist, target, tmode, modifier, ignore, unlocked)
4566 enum machine_mode tmode;
4567 enum expand_modifier modifier;
4571 tree fn_fputc = unlocked ?
4572 built_in_decls[BUILT_IN_FPUTC_UNLOCKED] : built_in_decls[BUILT_IN_FPUTC];
4573 tree fn_fputs = unlocked ?
4574 built_in_decls[BUILT_IN_FPUTS_UNLOCKED] : built_in_decls[BUILT_IN_FPUTS];
4575 tree fn, format_arg, stripped_string;
4577 /* If the return value is used, or the replacement _DECL isn't
4578 initialized, don't do the transformation. */
4579 if (!ignore || !fn_fputc || !fn_fputs)
4582 /* Verify the required arguments in the original call. */
4584 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE)
4585 || (TREE_CHAIN (arglist) == 0)
4586 || (TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist)))) !=
4590 /* Check the specifier vs. the parameters. */
4591 if (!is_valid_printf_arglist (TREE_CHAIN (arglist)))
4594 format_arg = TREE_VALUE (TREE_CHAIN (arglist));
4595 stripped_string = format_arg;
4596 STRIP_NOPS (stripped_string);
4597 if (stripped_string && TREE_CODE (stripped_string) == ADDR_EXPR)
4598 stripped_string = TREE_OPERAND (stripped_string, 0);
4600 /* If the format specifier isn't a STRING_CST, punt. */
4601 if (TREE_CODE (stripped_string) != STRING_CST)
4604 /* OK! We can attempt optimization. */
4606 /* If the format specifier was "%s", call __builtin_fputs(arg3, arg1). */
4607 if (strcmp (TREE_STRING_POINTER (stripped_string), "%s") == 0)
4609 tree newarglist = build_tree_list (NULL_TREE, TREE_VALUE (arglist));
4610 arglist = tree_cons (NULL_TREE,
4611 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))),
4615 /* If the format specifier was "%c", call __builtin_fputc (arg3, arg1). */
4616 else if (strcmp (TREE_STRING_POINTER (stripped_string), "%c") == 0)
4618 tree newarglist = build_tree_list (NULL_TREE, TREE_VALUE (arglist));
4619 arglist = tree_cons (NULL_TREE,
4620 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))),
4626 /* We can't handle anything else with % args or %% ... yet. */
4627 if (strchr (TREE_STRING_POINTER (stripped_string), '%'))
4630 /* When "string" doesn't contain %, replace all cases of
4631 fprintf(stream,string) with fputs(string,stream). The fputs
4632 builtin will take take of special cases like length==1. */
4633 arglist = tree_cons (NULL_TREE, TREE_VALUE (TREE_CHAIN (arglist)),
4634 build_tree_list (NULL_TREE, TREE_VALUE (arglist)));
4638 return expand_expr (build_function_call (fn, arglist),
4639 (ignore ? const0_rtx : target),
4644 /* Given a boolean expression ARG, return a tree representing an increment
4645 or decrement (as indicated by CODE) of ARG. The front end must check for
4646 invalid cases (e.g., decrement in C++). */
4648 boolean_increment (code, arg)
4649 enum tree_code code;
4653 tree true_res = (c_language == clk_cplusplus
4655 : c_bool_true_node);
4656 arg = stabilize_reference (arg);
4659 case PREINCREMENT_EXPR:
4660 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4662 case POSTINCREMENT_EXPR:
4663 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4664 arg = save_expr (arg);
4665 val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4666 val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4668 case PREDECREMENT_EXPR:
4669 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
4671 case POSTDECREMENT_EXPR:
4672 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
4673 arg = save_expr (arg);
4674 val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4675 val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4680 TREE_SIDE_EFFECTS (val) = 1;
4684 /* Define macros necessary to describe fundamental data type formats. */
4686 cpp_define_data_format (pfile)
4691 /* Define endianness enumeration values. */
4692 cpp_define (pfile, "__GCC_LITTLE_ENDIAN__=0");
4693 cpp_define (pfile, "__GCC_BIG_ENDIAN__=1");
4695 /* Define supported floating-point format enumeration values. */
4696 cpp_define (pfile, "__UNKNOWN_FORMAT__=0");
4697 cpp_define (pfile, "__IEEE_FORMAT__=1");
4698 cpp_define (pfile, "__IBM_FORMAT__=2");
4699 cpp_define (pfile, "__C4X_FORMAT__=3");
4700 cpp_define (pfile, "__VAX_FORMAT__=4");
4702 /* Define target endianness:
4705 - word order in an integer that spans a multi-word
4706 - word order in a floating-poing that spans a multi-word */
4707 if (BITS_BIG_ENDIAN)
4708 cpp_define (pfile, "__TARGET_BITS_ORDER__=__GCC_BIG_ENDIAN__");
4710 cpp_define (pfile, "__TARGET_BITS_ORDER__=__GCC_BIG_ENDIAN__");
4711 if (BYTES_BIG_ENDIAN)
4712 cpp_define (pfile, "__TARGET_BYTES_ORDER__=__GCC_BIG_ENDIAN__");
4714 cpp_define (pfile, "__TARGET_BYTES_ORDER__=__GCC_LITTLE_ENDIAN__");
4715 /* Define words order in a multi-word integer. */
4716 if (WORDS_BIG_ENDIAN)
4717 cpp_define (pfile, "__TARGET_INT_WORDS_ORDER__=__GCC_BIG_ENDIAN__");
4719 cpp_define (pfile, "__TARGET_INT_WORDS_ORDER__=__GCC_LITTLE_ENDIAN__");
4720 /* Define words order in a multi-word floating point. */
4721 if (FLOAT_WORDS_BIG_ENDIAN)
4722 cpp_define (pfile, "__TARGET_FLOAT_WORDS_ORDER__=__GCC_BIG_ENDIAN__");
4724 cpp_define (pfile, "__TARGET_FLOAT_WORDS_ORDER__=__GCC_LITTLE_ENDIAN__");
4726 switch (TARGET_FLOAT_FORMAT)
4728 case UNKNOWN_FLOAT_FORMAT:
4729 format = "__UNKNOWN_FORMAT__";
4732 case IEEE_FLOAT_FORMAT:
4733 format = "__IEEE_FORMAT__";
4736 case VAX_FLOAT_FORMAT:
4737 format = "__VAX_FORMAT__";
4738 cpp_define (pfile, "__TARGET_USES_VAX_F_FLOAT__=1");
4739 #ifdef TARGET_G_FLOAT
4742 cpp_define (pfile, "__TARGET_USES_VAX_D_FLOAT__=0");
4743 cpp_define (pfile, "__TARGET_USES_VAX_G_FLOAT__=1");
4747 cpp_define (pfile, "__TARGET_USES_VAX_D_FLOAT__=1");
4748 cpp_define (pfile, "__TARGET_USES_VAX_G_FLOAT__=0");
4751 cpp_define (pfile, "__TARGET_USES_VAX_H_FLOAT__=1");
4754 case IBM_FLOAT_FORMAT:
4755 format = "__IBM_FORMAT__";
4758 case C4X_FLOAT_FORMAT:
4759 format = "__C4X_FORMAT__";
4765 if (TARGET_FLOAT_FORMAT != VAX_FLOAT_FORMAT)
4767 cpp_define (pfile, "__TARGET_USES_VAX_F_FLOAT__=0");
4768 cpp_define (pfile, "__TARGET_USES_VAX_D_FLOAT__=0");
4769 cpp_define (pfile, "__TARGET_USES_VAX_G_FLOAT__=0");
4770 cpp_define (pfile, "__TARGET_USES_VAX_H_FLOAT__=0");
4772 builtin_define_with_value ("__GCC_FLOAT_FORMAT__", format, 0);
4775 /* Define NAME with value TYPE precision. */
4777 builtin_define_type_precision (name, type)
4781 builtin_define_with_int_value (name, TYPE_PRECISION (type));
4784 /* Define the float.h constants for TYPE using NAME_PREFIX and FP_SUFFIX. */
4786 builtin_define_float_constants (name_prefix, fp_suffix, type)
4787 const char *name_prefix;
4788 const char *fp_suffix;
4791 /* Used to convert radix-based values to base 10 values in several cases.
4793 In the max_exp -> max_10_exp conversion for 128-bit IEEE, we need at
4794 least 6 significant digits for correct results. Using the fraction
4795 formed by (log(2)*1e6)/(log(10)*1e6) overflows a 32-bit integer as an
4796 intermediate; perhaps someone can find a better approximation, in the
4797 mean time, I suspect using doubles won't harm the bootstrap here. */
4799 const double log10_2 = .30102999566398119521;
4800 const double log10_16 = 1.20411998265592478085;
4801 const double log10_b
4802 = TARGET_FLOAT_FORMAT == IBM_FLOAT_FORMAT ? log10_16 : log10_2;
4804 const int log2_b = TARGET_FLOAT_FORMAT == IBM_FLOAT_FORMAT ? 4 : 1;
4806 char name[64], buf[128];
4807 int mant_dig, max_exp, min_exp;
4808 int dig, min_10_exp, max_10_exp;
4810 /* ??? This information should be shared with real.c. */
4812 #ifndef INTEL_EXTENDED_IEEE_FORMAT
4813 #define INTEL_EXTENDED_IEEE_FORMAT 0
4815 #ifndef TARGET_G_FLOAT
4816 #define TARGET_G_FLOAT 0
4819 switch (TARGET_FLOAT_FORMAT)
4821 case IEEE_FLOAT_FORMAT:
4822 switch (TYPE_PRECISION (type))
4825 /* ??? Handle MIPS r5900, which doesn't implement Inf or NaN,
4826 but rather reuses the largest exponent as a normal number. */
4837 if (!INTEL_EXTENDED_IEEE_FORMAT)
4848 if (INTEL_EXTENDED_IEEE_FORMAT)
4851 /* ??? Otherwise assume m68k. */
4859 case VAX_FLOAT_FORMAT:
4860 switch (TYPE_PRECISION (type))
4862 case 32: /* F_FLOAT */
4867 case 64: /* G_FLOAT or D_FLOAT */
4881 case 128: /* H_FLOAT */
4891 case IBM_FLOAT_FORMAT:
4892 switch (TYPE_PRECISION (type))
4909 case C4X_FLOAT_FORMAT:
4910 switch (TYPE_PRECISION (type))
4931 /* The number of radix digits, p, in the floating-point significand. */
4932 sprintf (name, "__%s_MANT_DIG__", name_prefix);
4933 builtin_define_with_int_value (name, mant_dig);
4935 /* The number of decimal digits, q, such that any floating-point number
4936 with q decimal digits can be rounded into a floating-point number with
4937 p radix b digits and back again without change to the q decimal digits,
4939 p log10 b if b is a power of 10
4940 floor((p - 1) log10 b) otherwise
4942 dig = (mant_dig - 1) * log10_b;
4943 sprintf (name, "__%s_DIG__", name_prefix);
4944 builtin_define_with_int_value (name, dig);
4946 /* The minimum negative int x such that b**(x-1) is a normalised float. */
4947 sprintf (name, "__%s_MIN_EXP__", name_prefix);
4948 sprintf (buf, "(%d)", min_exp);
4949 builtin_define_with_value (name, buf, 0);
4951 /* The minimum negative int x such that 10**x is a normalized float,
4953 ceil (log10 (b ** (min_exp - 1)))
4954 = ceil (log10 (b) * (min_exp - 1))
4956 Recall that min_exp is negative, so the integer truncation calculates
4957 the ceiling, not the floor, in this case. */
4958 min_10_exp = (min_exp - 1) * log10_b;
4959 sprintf (name, "__%s_MIN_10_EXP__", name_prefix);
4960 sprintf (buf, "(%d)", min_10_exp);
4961 builtin_define_with_value (name, buf, 0);
4963 /* The maximum int x such that b**(x-1) is a representable float. */
4964 sprintf (name, "__%s_MAX_EXP__", name_prefix);
4965 builtin_define_with_int_value (name, max_exp);
4967 /* The maximum int x such that 10**x is in the range of representable
4968 finite floating-point numbers,
4970 floor (log10((1 - b**-p) * b**max_exp))
4971 = floor (log10(1 - b**-p) + log10(b**max_exp))
4972 = floor (log10(1 - b**-p) + log10(b)*max_exp)
4974 The safest thing to do here is to just compute this number. But since
4975 we don't link cc1 with libm, we cannot. We could implement log10 here
4976 a series expansion, but that seems too much effort because:
4978 Note that the first term, for all extant p, is a number exceedingly close
4979 to zero, but slightly negative. Note that the second term is an integer
4980 scaling an irrational number, and that because of the floor we are only
4981 interested in its integral portion.
4983 In order for the first term to have any effect on the integral portion
4984 of the second term, the second term has to be exceedingly close to an
4985 integer itself (e.g. 123.000000000001 or something). Getting a result
4986 that close to an integer requires that the irrational multiplicand have
4987 a long series of zeros in its expansion, which doesn't occur in the
4988 first 20 digits or so of log10(b).
4990 Hand-waving aside, crunching all of the sets of constants above by hand
4991 does not yield a case for which the first term is significant, which
4992 in the end is all that matters. */
4993 max_10_exp = max_exp * log10_b;
4994 sprintf (name, "__%s_MAX_10_EXP__", name_prefix);
4995 builtin_define_with_int_value (name, max_10_exp);
4997 /* Since, for the supported formats, B is always a power of 2, we
4998 construct the following numbers directly as a hexadecimal constants. */
5000 /* The maximum representable finite floating-point number,
5001 (1 - b**-p) * b**max_exp */
5005 sprintf (name, "__%s_MAX__", name_prefix);
5007 strcpy (buf, "0x0.");
5009 n = mant_dig * log2_b;
5010 for (i = 0, p = buf + 4; i + 3 < n; i += 4)
5013 *p++ = "08ce"[n - i];
5014 sprintf (p, "p%d%s", max_exp * log2_b, fp_suffix);
5015 builtin_define_with_value (name, buf, 0);
5018 /* The minimum normalized positive floating-point number, b**(min_exp-1). */
5019 sprintf (name, "__%s_MIN__", name_prefix);
5020 sprintf (buf, "0x1p%d%s", (min_exp - 1) * log2_b, fp_suffix);
5021 builtin_define_with_value (name, buf, 0);
5023 /* The difference between 1 and the least value greater than 1 that is
5024 representable in the given floating point type, b**(1-p). */
5025 sprintf (name, "__%s_EPSILON__", name_prefix);
5026 sprintf (buf, "0x1p%d%s", (1 - mant_dig) * log2_b, fp_suffix);
5027 builtin_define_with_value (name, buf, 0);
5029 if (type == long_double_type_node)
5031 /* The number of decimal digits, n, such that any floating-point number
5032 in the widest supported floating type with pmax radix b digits can be
5033 rounded to a floating-point number with n decimal digits and back
5034 again without change to the value,
5036 pmax log10(b) if b is a power of 10
5037 ceil(1 + pmax * log10(b)) otherwise
5039 double d_decimal_dig = 1 + mant_dig * log10_b;
5040 int decimal_dig = d_decimal_dig;
5041 if (decimal_dig < d_decimal_dig)
5043 builtin_define_with_int_value ("__DECIMAL_DIG__", decimal_dig);
5047 /* Hook that registers front end and target-specific built-ins. */
5049 cb_register_builtins (pfile)
5052 /* -undef turns off target-specific built-ins. */
5056 if (c_language == clk_cplusplus)
5058 if (SUPPORTS_ONE_ONLY)
5059 cpp_define (pfile, "__GXX_WEAK__=1");
5061 cpp_define (pfile, "__GXX_WEAK__=0");
5062 if (flag_exceptions)
5063 cpp_define (pfile, "__EXCEPTIONS");
5064 if (warn_deprecated)
5065 cpp_define (pfile, "__DEPRECATED");
5068 /* represents the C++ ABI version, always defined so it can be used while
5069 preprocessing C and assembler. */
5070 cpp_define (pfile, "__GXX_ABI_VERSION=102");
5072 /* libgcc needs to know this. */
5073 if (USING_SJLJ_EXCEPTIONS)
5074 cpp_define (pfile, "__USING_SJLJ_EXCEPTIONS__");
5076 /* stddef.h needs to know these. */
5077 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
5078 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
5079 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
5080 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
5082 /* limits.h needs to know these. */
5083 builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node, 0);
5084 builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node, 0);
5085 builtin_define_type_max ("__INT_MAX__", integer_type_node, 0);
5086 builtin_define_type_max ("__LONG_MAX__", long_integer_type_node, 1);
5087 builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node, 2);
5089 builtin_define_type_precision ("__CHAR_BIT__", char_type_node);
5090 builtin_define_type_precision ("__WCHAR_BIT__", wchar_type_node);
5091 builtin_define_type_precision ("__SHRT_BIT__", short_integer_type_node);
5092 builtin_define_type_precision ("__INT_BIT__", integer_type_node);
5093 builtin_define_type_precision ("__LONG_BIT__", long_integer_type_node);
5094 builtin_define_type_precision ("__LONG_LONG_BIT__",
5095 long_long_integer_type_node);
5096 builtin_define_type_precision ("__FLOAT_BIT__", float_type_node);
5097 builtin_define_type_precision ("__DOUBLE_BIT__", double_type_node);
5098 builtin_define_type_precision ("__LONG_DOUBLE_BIT__", long_double_type_node);
5100 /* float.h needs to know these. */
5102 /* The radix of the exponent representation. */
5103 builtin_define_with_int_value ("__FLT_RADIX__",
5104 (TARGET_FLOAT_FORMAT == IBM_FLOAT_FORMAT
5107 builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
5108 TARGET_FLT_EVAL_METHOD);
5110 builtin_define_float_constants ("FLT", "F", float_type_node);
5111 builtin_define_float_constants ("DBL", "", double_type_node);
5112 builtin_define_float_constants ("LDBL", "L", long_double_type_node);
5114 /* For use in assembly language. */
5115 builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0);
5116 builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0);
5119 builtin_define_with_value ("__VERSION__", version_string, 1);
5121 /* Other target-independent built-ins determined by command-line
5124 cpp_define (pfile, "__OPTIMIZE_SIZE__");
5126 cpp_define (pfile, "__OPTIMIZE__");
5129 cpp_define (pfile, "__STDC_HOSTED__=1");
5131 cpp_define (pfile, "__STDC_HOSTED__=0");
5133 if (fast_math_flags_set_p ())
5134 cpp_define (pfile, "__FAST_MATH__");
5136 cpp_define (pfile, "__NO_INLINE__");
5137 if (flag_signaling_nans)
5138 cpp_define (pfile, "__SUPPORT_SNAN__");
5139 if (flag_finite_math_only)
5140 cpp_define (pfile, "__FINITE_MATH_ONLY__=1");
5142 cpp_define (pfile, "__FINITE_MATH_ONLY__=0");
5145 cpp_define (pfile, "__STRICT_ANSI__");
5147 if (!flag_signed_char)
5148 cpp_define (pfile, "__CHAR_UNSIGNED__");
5150 if (c_language == clk_cplusplus && TREE_UNSIGNED (wchar_type_node))
5151 cpp_define (pfile, "__WCHAR_UNSIGNED__");
5153 cpp_define_data_format (pfile);
5155 /* Make the choice of ObjC runtime visible to source code. */
5156 if (flag_objc && flag_next_runtime)
5157 cpp_define (pfile, "__NEXT_RUNTIME__");
5159 /* A straightforward target hook doesn't work, because of problems
5160 linking that hook's body when part of non-C front ends. */
5161 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
5162 # define builtin_define(TXT) cpp_define (pfile, TXT)
5163 # define builtin_assert(TXT) cpp_assert (pfile, TXT)
5164 TARGET_CPU_CPP_BUILTINS ();
5165 TARGET_OS_CPP_BUILTINS ();
5168 /* Pass an object-like macro. If it doesn't lie in the user's
5169 namespace, defines it unconditionally. Otherwise define a version
5170 with two leading underscores, and another version with two leading
5171 and trailing underscores, and define the original only if an ISO
5172 standard was not nominated.
5174 e.g. passing "unix" defines "__unix", "__unix__" and possibly
5175 "unix". Passing "_mips" defines "__mips", "__mips__" and possibly
5178 builtin_define_std (macro)
5181 size_t len = strlen (macro);
5182 char *buff = alloca (len + 5);
5186 /* prepend __ (or maybe just _) if in user's namespace. */
5187 memcpy (p, macro, len + 1);
5188 if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1]))))
5195 cpp_define (parse_in, p);
5197 /* If it was in user's namespace... */
5200 /* Define the macro with leading and following __. */
5206 cpp_define (parse_in, p);
5208 /* Finally, define the original macro if permitted. */
5210 cpp_define (parse_in, macro);
5214 /* Pass an object-like macro and a value to define it to. The third
5215 parameter says whether or not to turn the value into a string
5218 builtin_define_with_value (macro, expansion, is_str)
5220 const char *expansion;
5224 size_t mlen = strlen (macro);
5225 size_t elen = strlen (expansion);
5226 size_t extra = 2; /* space for an = and a NUL */
5229 extra += 2; /* space for two quote marks */
5231 buf = alloca (mlen + elen + extra);
5233 sprintf (buf, "%s=\"%s\"", macro, expansion);
5235 sprintf (buf, "%s=%s", macro, expansion);
5237 cpp_define (parse_in, buf);
5240 /* Pass an object-like macro and an integer value to define it to. */
5242 builtin_define_with_int_value (macro, value)
5244 HOST_WIDE_INT value;
5247 size_t mlen = strlen (macro);
5249 size_t extra = 2; /* space for = and NUL. */
5251 buf = alloca (mlen + vlen + extra);
5252 memcpy (buf, macro, mlen);
5254 sprintf (buf + mlen + 1, HOST_WIDE_INT_PRINT_DEC, value);
5256 cpp_define (parse_in, buf);
5259 /* Define MAX for TYPE based on the precision of the type, which is assumed
5260 to be signed. IS_LONG is 1 for type "long" and 2 for "long long". */
5263 builtin_define_type_max (macro, type, is_long)
5270 size_t mlen, vlen, extra;
5272 /* Pre-rendering the values mean we don't have to futz with printing a
5273 multi-word decimal value. There are also a very limited number of
5274 precisions that we support, so it's really a waste of time. */
5275 switch (TYPE_PRECISION (type))
5284 value = "2147483647";
5287 value = "9223372036854775807";
5290 value = "170141183460469231731687303715884105727";
5296 mlen = strlen (macro);
5297 vlen = strlen (value);
5298 extra = 2 + is_long;
5299 buf = alloca (mlen + vlen + extra);
5301 sprintf (buf, "%s=%s%s", macro, value,
5302 (is_long == 1 ? "L" : is_long == 2 ? "LL" : ""));
5304 cpp_define (parse_in, buf);
5308 c_init_attributes ()
5310 /* Fill in the built_in_attributes array. */
5311 #define DEF_ATTR_NULL_TREE(ENUM) \
5312 built_in_attributes[(int) ENUM] = NULL_TREE;
5313 #define DEF_ATTR_INT(ENUM, VALUE) \
5314 built_in_attributes[(int) ENUM] = build_int_2 (VALUE, VALUE < 0 ? -1 : 0);
5315 #define DEF_ATTR_IDENT(ENUM, STRING) \
5316 built_in_attributes[(int) ENUM] = get_identifier (STRING);
5317 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
5318 built_in_attributes[(int) ENUM] \
5319 = tree_cons (built_in_attributes[(int) PURPOSE], \
5320 built_in_attributes[(int) VALUE], \
5321 built_in_attributes[(int) CHAIN]);
5322 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No initialization needed. */
5323 #include "builtin-attrs.def"
5324 #undef DEF_ATTR_NULL_TREE
5326 #undef DEF_ATTR_IDENT
5327 #undef DEF_ATTR_TREE_LIST
5329 c_attrs_initialized = true;
5332 /* Depending on the name of DECL, apply default attributes to it. */
5335 c_common_insert_default_attributes (decl)
5338 tree name = DECL_NAME (decl);
5340 if (!c_attrs_initialized)
5341 c_init_attributes ();
5343 #define DEF_ATTR_NULL_TREE(ENUM) /* Nothing needed after initialization. */
5344 #define DEF_ATTR_INT(ENUM, VALUE)
5345 #define DEF_ATTR_IDENT(ENUM, STRING)
5346 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN)
5347 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) \
5348 if ((PREDICATE) && name == built_in_attributes[(int) NAME]) \
5349 decl_attributes (&decl, built_in_attributes[(int) ATTRS], \
5350 ATTR_FLAG_BUILT_IN);
5351 #include "builtin-attrs.def"
5352 #undef DEF_ATTR_NULL_TREE
5354 #undef DEF_ATTR_IDENT
5355 #undef DEF_ATTR_TREE_LIST
5359 /* Output a -Wshadow warning MSGID about NAME, an IDENTIFIER_NODE, and
5360 additionally give the location of the previous declaration DECL. */
5362 shadow_warning (msgid, name, decl)
5366 warning ("declaration of `%s' shadows %s", IDENTIFIER_POINTER (name), msgid);
5367 warning_with_file_and_line (DECL_SOURCE_FILE (decl),
5368 DECL_SOURCE_LINE (decl),
5369 "shadowed declaration is here");
5372 /* Attribute handlers common to C front ends. */
5374 /* Handle a "packed" attribute; arguments as in
5375 struct attribute_spec.handler. */
5378 handle_packed_attribute (node, name, args, flags, no_add_attrs)
5381 tree args ATTRIBUTE_UNUSED;
5388 if (TREE_CODE (*node) == TYPE_DECL)
5389 type = &TREE_TYPE (*node);
5396 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5397 *type = build_type_copy (*type);
5398 TYPE_PACKED (*type) = 1;
5400 else if (TREE_CODE (*node) == FIELD_DECL)
5401 DECL_PACKED (*node) = 1;
5402 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
5403 used for DECL_REGISTER. It wouldn't mean anything anyway. */
5406 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5407 *no_add_attrs = true;
5413 /* Handle a "nocommon" attribute; arguments as in
5414 struct attribute_spec.handler. */
5417 handle_nocommon_attribute (node, name, args, flags, no_add_attrs)
5420 tree args ATTRIBUTE_UNUSED;
5421 int flags ATTRIBUTE_UNUSED;
5424 if (TREE_CODE (*node) == VAR_DECL)
5425 DECL_COMMON (*node) = 0;
5428 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5429 *no_add_attrs = true;
5435 /* Handle a "common" attribute; arguments as in
5436 struct attribute_spec.handler. */
5439 handle_common_attribute (node, name, args, flags, no_add_attrs)
5442 tree args ATTRIBUTE_UNUSED;
5443 int flags ATTRIBUTE_UNUSED;
5446 if (TREE_CODE (*node) == VAR_DECL)
5447 DECL_COMMON (*node) = 1;
5450 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5451 *no_add_attrs = true;
5457 /* Handle a "noreturn" attribute; arguments as in
5458 struct attribute_spec.handler. */
5461 handle_noreturn_attribute (node, name, args, flags, no_add_attrs)
5464 tree args ATTRIBUTE_UNUSED;
5465 int flags ATTRIBUTE_UNUSED;
5468 tree type = TREE_TYPE (*node);
5470 /* See FIXME comment in c_common_attribute_table. */
5471 if (TREE_CODE (*node) == FUNCTION_DECL)
5472 TREE_THIS_VOLATILE (*node) = 1;
5473 else if (TREE_CODE (type) == POINTER_TYPE
5474 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
5476 = build_pointer_type
5477 (build_type_variant (TREE_TYPE (type),
5478 TREE_READONLY (TREE_TYPE (type)), 1));
5481 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5482 *no_add_attrs = true;
5488 /* Handle a "noinline" attribute; arguments as in
5489 struct attribute_spec.handler. */
5492 handle_noinline_attribute (node, name, args, flags, no_add_attrs)
5495 tree args ATTRIBUTE_UNUSED;
5496 int flags ATTRIBUTE_UNUSED;
5499 if (TREE_CODE (*node) == FUNCTION_DECL)
5500 DECL_UNINLINABLE (*node) = 1;
5503 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5504 *no_add_attrs = true;
5510 /* Handle a "always_inline" attribute; arguments as in
5511 struct attribute_spec.handler. */
5514 handle_always_inline_attribute (node, name, args, flags, no_add_attrs)
5517 tree args ATTRIBUTE_UNUSED;
5518 int flags ATTRIBUTE_UNUSED;
5521 if (TREE_CODE (*node) == FUNCTION_DECL)
5523 /* Do nothing else, just set the attribute. We'll get at
5524 it later with lookup_attribute. */
5528 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5529 *no_add_attrs = true;
5535 /* Handle a "used" attribute; arguments as in
5536 struct attribute_spec.handler. */
5539 handle_used_attribute (node, name, args, flags, no_add_attrs)
5542 tree args ATTRIBUTE_UNUSED;
5543 int flags ATTRIBUTE_UNUSED;
5546 if (TREE_CODE (*node) == FUNCTION_DECL)
5547 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (*node))
5548 = TREE_USED (*node) = 1;
5551 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5552 *no_add_attrs = true;
5558 /* Handle a "unused" attribute; arguments as in
5559 struct attribute_spec.handler. */
5562 handle_unused_attribute (node, name, args, flags, no_add_attrs)
5565 tree args ATTRIBUTE_UNUSED;
5573 if (TREE_CODE (decl) == PARM_DECL
5574 || TREE_CODE (decl) == VAR_DECL
5575 || TREE_CODE (decl) == FUNCTION_DECL
5576 || TREE_CODE (decl) == LABEL_DECL
5577 || TREE_CODE (decl) == TYPE_DECL)
5578 TREE_USED (decl) = 1;
5581 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5582 *no_add_attrs = true;
5587 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5588 *node = build_type_copy (*node);
5589 TREE_USED (*node) = 1;
5595 /* Handle a "const" attribute; arguments as in
5596 struct attribute_spec.handler. */
5599 handle_const_attribute (node, name, args, flags, no_add_attrs)
5602 tree args ATTRIBUTE_UNUSED;
5603 int flags ATTRIBUTE_UNUSED;
5606 tree type = TREE_TYPE (*node);
5608 /* See FIXME comment on noreturn in c_common_attribute_table. */
5609 if (TREE_CODE (*node) == FUNCTION_DECL)
5610 TREE_READONLY (*node) = 1;
5611 else if (TREE_CODE (type) == POINTER_TYPE
5612 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
5614 = build_pointer_type
5615 (build_type_variant (TREE_TYPE (type), 1,
5616 TREE_THIS_VOLATILE (TREE_TYPE (type))));
5619 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5620 *no_add_attrs = true;
5626 /* Handle a "transparent_union" attribute; arguments as in
5627 struct attribute_spec.handler. */
5630 handle_transparent_union_attribute (node, name, args, flags, no_add_attrs)
5633 tree args ATTRIBUTE_UNUSED;
5637 tree decl = NULL_TREE;
5644 type = &TREE_TYPE (decl);
5645 is_type = TREE_CODE (*node) == TYPE_DECL;
5647 else if (TYPE_P (*node))
5648 type = node, is_type = 1;
5651 && TREE_CODE (*type) == UNION_TYPE
5653 || (TYPE_FIELDS (*type) != 0
5654 && TYPE_MODE (*type) == DECL_MODE (TYPE_FIELDS (*type)))))
5656 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5657 *type = build_type_copy (*type);
5658 TYPE_TRANSPARENT_UNION (*type) = 1;
5660 else if (decl != 0 && TREE_CODE (decl) == PARM_DECL
5661 && TREE_CODE (*type) == UNION_TYPE
5662 && TYPE_MODE (*type) == DECL_MODE (TYPE_FIELDS (*type)))
5663 DECL_TRANSPARENT_UNION (decl) = 1;
5666 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5667 *no_add_attrs = true;
5673 /* Handle a "constructor" attribute; arguments as in
5674 struct attribute_spec.handler. */
5677 handle_constructor_attribute (node, name, args, flags, no_add_attrs)
5680 tree args ATTRIBUTE_UNUSED;
5681 int flags ATTRIBUTE_UNUSED;
5685 tree type = TREE_TYPE (decl);
5687 if (TREE_CODE (decl) == FUNCTION_DECL
5688 && TREE_CODE (type) == FUNCTION_TYPE
5689 && decl_function_context (decl) == 0)
5691 DECL_STATIC_CONSTRUCTOR (decl) = 1;
5692 TREE_USED (decl) = 1;
5696 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5697 *no_add_attrs = true;
5703 /* Handle a "destructor" attribute; arguments as in
5704 struct attribute_spec.handler. */
5707 handle_destructor_attribute (node, name, args, flags, no_add_attrs)
5710 tree args ATTRIBUTE_UNUSED;
5711 int flags ATTRIBUTE_UNUSED;
5715 tree type = TREE_TYPE (decl);
5717 if (TREE_CODE (decl) == FUNCTION_DECL
5718 && TREE_CODE (type) == FUNCTION_TYPE
5719 && decl_function_context (decl) == 0)
5721 DECL_STATIC_DESTRUCTOR (decl) = 1;
5722 TREE_USED (decl) = 1;
5726 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5727 *no_add_attrs = true;
5733 /* Handle a "mode" attribute; arguments as in
5734 struct attribute_spec.handler. */
5737 handle_mode_attribute (node, name, args, flags, no_add_attrs)
5741 int flags ATTRIBUTE_UNUSED;
5746 *no_add_attrs = true;
5748 if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
5749 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5753 const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
5754 int len = strlen (p);
5755 enum machine_mode mode = VOIDmode;
5758 if (len > 4 && p[0] == '_' && p[1] == '_'
5759 && p[len - 1] == '_' && p[len - 2] == '_')
5761 char *newp = (char *) alloca (len - 1);
5763 strcpy (newp, &p[2]);
5764 newp[len - 4] = '\0';
5768 /* Change this type to have a type with the specified mode.
5769 First check for the special modes. */
5770 if (! strcmp (p, "byte"))
5772 else if (!strcmp (p, "word"))
5774 else if (! strcmp (p, "pointer"))
5777 for (j = 0; j < NUM_MACHINE_MODES; j++)
5778 if (!strcmp (p, GET_MODE_NAME (j)))
5779 mode = (enum machine_mode) j;
5781 if (mode == VOIDmode)
5782 error ("unknown machine mode `%s'", p);
5783 else if (0 == (typefm = (*lang_hooks.types.type_for_mode)
5784 (mode, TREE_UNSIGNED (type))))
5785 error ("no data type for mode `%s'", p);
5788 /* If this is a vector, make sure we either have hardware
5789 support, or we can emulate it. */
5790 if ((GET_MODE_CLASS (mode) == MODE_VECTOR_INT
5791 || GET_MODE_CLASS (mode) == MODE_VECTOR_FLOAT)
5792 && !vector_mode_valid_p (mode))
5794 error ("unable to emulate '%s'", GET_MODE_NAME (mode));
5799 /* No need to layout the type here. The caller should do this. */
5806 /* Handle a "section" attribute; arguments as in
5807 struct attribute_spec.handler. */
5810 handle_section_attribute (node, name, args, flags, no_add_attrs)
5812 tree name ATTRIBUTE_UNUSED;
5814 int flags ATTRIBUTE_UNUSED;
5819 if (targetm.have_named_sections)
5821 if ((TREE_CODE (decl) == FUNCTION_DECL
5822 || TREE_CODE (decl) == VAR_DECL)
5823 && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
5825 if (TREE_CODE (decl) == VAR_DECL
5826 && current_function_decl != NULL_TREE
5827 && ! TREE_STATIC (decl))
5829 error_with_decl (decl,
5830 "section attribute cannot be specified for local variables");
5831 *no_add_attrs = true;
5834 /* The decl may have already been given a section attribute
5835 from a previous declaration. Ensure they match. */
5836 else if (DECL_SECTION_NAME (decl) != NULL_TREE
5837 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
5838 TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
5840 error_with_decl (*node,
5841 "section of `%s' conflicts with previous declaration");
5842 *no_add_attrs = true;
5845 DECL_SECTION_NAME (decl) = TREE_VALUE (args);
5849 error_with_decl (*node,
5850 "section attribute not allowed for `%s'");
5851 *no_add_attrs = true;
5856 error_with_decl (*node,
5857 "section attributes are not supported for this target");
5858 *no_add_attrs = true;
5864 /* Handle a "aligned" attribute; arguments as in
5865 struct attribute_spec.handler. */
5868 handle_aligned_attribute (node, name, args, flags, no_add_attrs)
5870 tree name ATTRIBUTE_UNUSED;
5875 tree decl = NULL_TREE;
5878 tree align_expr = (args ? TREE_VALUE (args)
5879 : size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
5885 type = &TREE_TYPE (decl);
5886 is_type = TREE_CODE (*node) == TYPE_DECL;
5888 else if (TYPE_P (*node))
5889 type = node, is_type = 1;
5891 /* Strip any NOPs of any kind. */
5892 while (TREE_CODE (align_expr) == NOP_EXPR
5893 || TREE_CODE (align_expr) == CONVERT_EXPR
5894 || TREE_CODE (align_expr) == NON_LVALUE_EXPR)
5895 align_expr = TREE_OPERAND (align_expr, 0);
5897 if (TREE_CODE (align_expr) != INTEGER_CST)
5899 error ("requested alignment is not a constant");
5900 *no_add_attrs = true;
5902 else if ((i = tree_log2 (align_expr)) == -1)
5904 error ("requested alignment is not a power of 2");
5905 *no_add_attrs = true;
5907 else if (i > HOST_BITS_PER_INT - 2)
5909 error ("requested alignment is too large");
5910 *no_add_attrs = true;
5914 /* If we have a TYPE_DECL, then copy the type, so that we
5915 don't accidentally modify a builtin type. See pushdecl. */
5916 if (decl && TREE_TYPE (decl) != error_mark_node
5917 && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
5919 tree tt = TREE_TYPE (decl);
5920 *type = build_type_copy (*type);
5921 DECL_ORIGINAL_TYPE (decl) = tt;
5922 TYPE_NAME (*type) = decl;
5923 TREE_USED (*type) = TREE_USED (decl);
5924 TREE_TYPE (decl) = *type;
5926 else if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5927 *type = build_type_copy (*type);
5929 TYPE_ALIGN (*type) = (1 << i) * BITS_PER_UNIT;
5930 TYPE_USER_ALIGN (*type) = 1;
5932 else if (TREE_CODE (decl) != VAR_DECL
5933 && TREE_CODE (decl) != FIELD_DECL)
5935 error_with_decl (decl,
5936 "alignment may not be specified for `%s'");
5937 *no_add_attrs = true;
5941 DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
5942 DECL_USER_ALIGN (decl) = 1;
5948 /* Handle a "weak" attribute; arguments as in
5949 struct attribute_spec.handler. */
5952 handle_weak_attribute (node, name, args, flags, no_add_attrs)
5954 tree name ATTRIBUTE_UNUSED;
5955 tree args ATTRIBUTE_UNUSED;
5956 int flags ATTRIBUTE_UNUSED;
5957 bool *no_add_attrs ATTRIBUTE_UNUSED;
5959 declare_weak (*node);
5964 /* Handle an "alias" attribute; arguments as in
5965 struct attribute_spec.handler. */
5968 handle_alias_attribute (node, name, args, flags, no_add_attrs)
5972 int flags ATTRIBUTE_UNUSED;
5977 if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
5978 || (TREE_CODE (decl) != FUNCTION_DECL && ! DECL_EXTERNAL (decl)))
5980 error_with_decl (decl,
5981 "`%s' defined both normally and as an alias");
5982 *no_add_attrs = true;
5984 else if (decl_function_context (decl) == 0)
5988 id = TREE_VALUE (args);
5989 if (TREE_CODE (id) != STRING_CST)
5991 error ("alias arg not a string");
5992 *no_add_attrs = true;
5995 id = get_identifier (TREE_STRING_POINTER (id));
5996 /* This counts as a use of the object pointed to. */
5999 if (TREE_CODE (decl) == FUNCTION_DECL)
6000 DECL_INITIAL (decl) = error_mark_node;
6002 DECL_EXTERNAL (decl) = 0;
6006 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
6007 *no_add_attrs = true;
6013 /* Handle an "visibility" attribute; arguments as in
6014 struct attribute_spec.handler. */
6017 handle_visibility_attribute (node, name, args, flags, no_add_attrs)
6021 int flags ATTRIBUTE_UNUSED;
6026 if (decl_function_context (decl) != 0 || ! TREE_PUBLIC (decl))
6028 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
6029 *no_add_attrs = true;
6035 id = TREE_VALUE (args);
6036 if (TREE_CODE (id) != STRING_CST)
6038 error ("visibility arg not a string");
6039 *no_add_attrs = true;
6042 if (strcmp (TREE_STRING_POINTER (id), "hidden")
6043 && strcmp (TREE_STRING_POINTER (id), "protected")
6044 && strcmp (TREE_STRING_POINTER (id), "internal"))
6046 error ("visibility arg must be one of \"hidden\", \"protected\" or \"internal\"");
6047 *no_add_attrs = true;
6055 /* Handle a "no_instrument_function" attribute; arguments as in
6056 struct attribute_spec.handler. */
6059 handle_no_instrument_function_attribute (node, name, args, flags, no_add_attrs)
6062 tree args ATTRIBUTE_UNUSED;
6063 int flags ATTRIBUTE_UNUSED;
6068 if (TREE_CODE (decl) != FUNCTION_DECL)
6070 error_with_decl (decl,
6071 "`%s' attribute applies only to functions",
6072 IDENTIFIER_POINTER (name));
6073 *no_add_attrs = true;
6075 else if (DECL_INITIAL (decl))
6077 error_with_decl (decl,
6078 "can't set `%s' attribute after definition",
6079 IDENTIFIER_POINTER (name));
6080 *no_add_attrs = true;
6083 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
6088 /* Handle a "malloc" attribute; arguments as in
6089 struct attribute_spec.handler. */
6092 handle_malloc_attribute (node, name, args, flags, no_add_attrs)
6095 tree args ATTRIBUTE_UNUSED;
6096 int flags ATTRIBUTE_UNUSED;
6099 if (TREE_CODE (*node) == FUNCTION_DECL)
6100 DECL_IS_MALLOC (*node) = 1;
6101 /* ??? TODO: Support types. */
6104 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
6105 *no_add_attrs = true;
6111 /* Handle a "no_limit_stack" attribute; arguments as in
6112 struct attribute_spec.handler. */
6115 handle_no_limit_stack_attribute (node, name, args, flags, no_add_attrs)
6118 tree args ATTRIBUTE_UNUSED;
6119 int flags ATTRIBUTE_UNUSED;
6124 if (TREE_CODE (decl) != FUNCTION_DECL)
6126 error_with_decl (decl,
6127 "`%s' attribute applies only to functions",
6128 IDENTIFIER_POINTER (name));
6129 *no_add_attrs = true;
6131 else if (DECL_INITIAL (decl))
6133 error_with_decl (decl,
6134 "can't set `%s' attribute after definition",
6135 IDENTIFIER_POINTER (name));
6136 *no_add_attrs = true;
6139 DECL_NO_LIMIT_STACK (decl) = 1;
6144 /* Handle a "pure" attribute; arguments as in
6145 struct attribute_spec.handler. */
6148 handle_pure_attribute (node, name, args, flags, no_add_attrs)
6151 tree args ATTRIBUTE_UNUSED;
6152 int flags ATTRIBUTE_UNUSED;
6155 if (TREE_CODE (*node) == FUNCTION_DECL)
6156 DECL_IS_PURE (*node) = 1;
6157 /* ??? TODO: Support types. */
6160 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
6161 *no_add_attrs = true;
6167 /* Handle a "deprecated" attribute; arguments as in
6168 struct attribute_spec.handler. */
6171 handle_deprecated_attribute (node, name, args, flags, no_add_attrs)
6174 tree args ATTRIBUTE_UNUSED;
6178 tree type = NULL_TREE;
6180 const char *what = NULL;
6185 type = TREE_TYPE (decl);
6187 if (TREE_CODE (decl) == TYPE_DECL
6188 || TREE_CODE (decl) == PARM_DECL
6189 || TREE_CODE (decl) == VAR_DECL
6190 || TREE_CODE (decl) == FUNCTION_DECL
6191 || TREE_CODE (decl) == FIELD_DECL)
6192 TREE_DEPRECATED (decl) = 1;
6196 else if (TYPE_P (*node))
6198 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
6199 *node = build_type_copy (*node);
6200 TREE_DEPRECATED (*node) = 1;
6208 *no_add_attrs = true;
6209 if (type && TYPE_NAME (type))
6211 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
6212 what = IDENTIFIER_POINTER (TYPE_NAME (*node));
6213 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
6214 && DECL_NAME (TYPE_NAME (type)))
6215 what = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
6218 warning ("`%s' attribute ignored for `%s'",
6219 IDENTIFIER_POINTER (name), what);
6221 warning ("`%s' attribute ignored",
6222 IDENTIFIER_POINTER (name));
6228 /* Keep a list of vector type nodes we created in handle_vector_size_attribute,
6229 to prevent us from duplicating type nodes unnecessarily.
6230 The normal mechanism to prevent duplicates is to use type_hash_canon, but
6231 since we want to distinguish types that are essentially identical (except
6232 for their debug representation), we use a local list here. */
6233 static tree vector_type_node_list = 0;
6235 /* Handle a "vector_size" attribute; arguments as in
6236 struct attribute_spec.handler. */
6239 handle_vector_size_attribute (node, name, args, flags, no_add_attrs)
6243 int flags ATTRIBUTE_UNUSED;
6246 unsigned HOST_WIDE_INT vecsize, nunits;
6247 enum machine_mode mode, orig_mode, new_mode;
6248 tree type = *node, new_type = NULL_TREE;
6249 tree type_list_node;
6251 *no_add_attrs = true;
6253 if (! host_integerp (TREE_VALUE (args), 1))
6255 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
6259 /* Get the vector size (in bytes). */
6260 vecsize = tree_low_cst (TREE_VALUE (args), 1);
6262 /* We need to provide for vector pointers, vector arrays, and
6263 functions returning vectors. For example:
6265 __attribute__((vector_size(16))) short *foo;
6267 In this case, the mode is SI, but the type being modified is
6268 HI, so we need to look further. */
6270 while (POINTER_TYPE_P (type)
6271 || TREE_CODE (type) == FUNCTION_TYPE
6272 || TREE_CODE (type) == ARRAY_TYPE)
6273 type = TREE_TYPE (type);
6275 /* Get the mode of the type being modified. */
6276 orig_mode = TYPE_MODE (type);
6278 if (TREE_CODE (type) == RECORD_TYPE
6279 || (GET_MODE_CLASS (orig_mode) != MODE_FLOAT
6280 && GET_MODE_CLASS (orig_mode) != MODE_INT)
6281 || ! host_integerp (TYPE_SIZE_UNIT (type), 1))
6283 error ("invalid vector type for attribute `%s'",
6284 IDENTIFIER_POINTER (name));
6288 /* Calculate how many units fit in the vector. */
6289 nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
6291 /* Find a suitably sized vector. */
6292 new_mode = VOIDmode;
6293 for (mode = GET_CLASS_NARROWEST_MODE (GET_MODE_CLASS (orig_mode) == MODE_INT
6295 : MODE_VECTOR_FLOAT);
6297 mode = GET_MODE_WIDER_MODE (mode))
6298 if (vecsize == GET_MODE_SIZE (mode)
6299 && nunits == (unsigned HOST_WIDE_INT) GET_MODE_NUNITS (mode))
6305 if (new_mode == VOIDmode)
6307 error ("no vector mode with the size and type specified could be found");
6311 for (type_list_node = vector_type_node_list; type_list_node;
6312 type_list_node = TREE_CHAIN (type_list_node))
6314 tree other_type = TREE_VALUE (type_list_node);
6315 tree record = TYPE_DEBUG_REPRESENTATION_TYPE (other_type);
6316 tree fields = TYPE_FIELDS (record);
6317 tree field_type = TREE_TYPE (fields);
6318 tree array_type = TREE_TYPE (field_type);
6319 if (TREE_CODE (fields) != FIELD_DECL
6320 || TREE_CODE (field_type) != ARRAY_TYPE)
6323 if (TYPE_MODE (other_type) == mode && type == array_type)
6325 new_type = other_type;
6330 if (new_type == NULL_TREE)
6332 tree index, array, rt, list_node;
6334 new_type = (*lang_hooks.types.type_for_mode) (new_mode,
6335 TREE_UNSIGNED (type));
6339 error ("no vector mode with the size and type specified could be found");
6343 new_type = build_type_copy (new_type);
6345 /* If this is a vector, make sure we either have hardware
6346 support, or we can emulate it. */
6347 if ((GET_MODE_CLASS (mode) == MODE_VECTOR_INT
6348 || GET_MODE_CLASS (mode) == MODE_VECTOR_FLOAT)
6349 && !vector_mode_valid_p (mode))
6351 error ("unable to emulate '%s'", GET_MODE_NAME (mode));
6355 /* Set the debug information here, because this is the only
6356 place where we know the underlying type for a vector made
6357 with vector_size. For debugging purposes we pretend a vector
6358 is an array within a structure. */
6359 index = build_int_2 (TYPE_VECTOR_SUBPARTS (new_type) - 1, 0);
6360 array = build_array_type (type, build_index_type (index));
6361 rt = make_node (RECORD_TYPE);
6363 TYPE_FIELDS (rt) = build_decl (FIELD_DECL, get_identifier ("f"), array);
6364 DECL_CONTEXT (TYPE_FIELDS (rt)) = rt;
6366 TYPE_DEBUG_REPRESENTATION_TYPE (new_type) = rt;
6368 list_node = build_tree_list (NULL, new_type);
6369 TREE_CHAIN (list_node) = vector_type_node_list;
6370 vector_type_node_list = list_node;
6373 /* Build back pointers if needed. */
6374 *node = vector_size_helper (*node, new_type);
6379 /* HACK. GROSS. This is absolutely disgusting. I wish there was a
6382 If we requested a pointer to a vector, build up the pointers that
6383 we stripped off while looking for the inner type. Similarly for
6384 return values from functions.
6386 The argument "type" is the top of the chain, and "bottom" is the
6387 new type which we will point to. */
6390 vector_size_helper (type, bottom)
6395 if (POINTER_TYPE_P (type))
6397 inner = vector_size_helper (TREE_TYPE (type), bottom);
6398 outer = build_pointer_type (inner);
6400 else if (TREE_CODE (type) == ARRAY_TYPE)
6402 inner = vector_size_helper (TREE_TYPE (type), bottom);
6403 outer = build_array_type (inner, TYPE_VALUES (type));
6405 else if (TREE_CODE (type) == FUNCTION_TYPE)
6407 inner = vector_size_helper (TREE_TYPE (type), bottom);
6408 outer = build_function_type (inner, TYPE_VALUES (type));
6413 TREE_READONLY (outer) = TREE_READONLY (type);
6414 TREE_THIS_VOLATILE (outer) = TREE_THIS_VOLATILE (type);
6419 /* Handle the "nonnull" attribute. */
6421 handle_nonnull_attribute (node, name, args, flags, no_add_attrs)
6423 tree name ATTRIBUTE_UNUSED;
6425 int flags ATTRIBUTE_UNUSED;
6429 unsigned HOST_WIDE_INT attr_arg_num;
6431 /* If no arguments are specified, all pointer arguments should be
6432 non-null. Veryify a full prototype is given so that the arguments
6433 will have the correct types when we actually check them later. */
6436 if (! TYPE_ARG_TYPES (type))
6438 error ("nonnull attribute without arguments on a non-prototype");
6439 *no_add_attrs = true;
6444 /* Argument list specified. Verify that each argument number references
6445 a pointer argument. */
6446 for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
6449 unsigned HOST_WIDE_INT arg_num, ck_num;
6451 if (! get_nonnull_operand (TREE_VALUE (args), &arg_num))
6453 error ("nonnull argument has invalid operand number (arg %lu)",
6454 (unsigned long) attr_arg_num);
6455 *no_add_attrs = true;
6459 argument = TYPE_ARG_TYPES (type);
6462 for (ck_num = 1; ; ck_num++)
6464 if (! argument || ck_num == arg_num)
6466 argument = TREE_CHAIN (argument);
6470 || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
6472 error ("nonnull argument with out-of-range operand number (arg %lu, operand %lu)",
6473 (unsigned long) attr_arg_num, (unsigned long) arg_num);
6474 *no_add_attrs = true;
6478 if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
6480 error ("nonnull argument references non-pointer operand (arg %lu, operand %lu)",
6481 (unsigned long) attr_arg_num, (unsigned long) arg_num);
6482 *no_add_attrs = true;
6491 /* Check the argument list of a function call for null in argument slots
6492 that are marked as requiring a non-null pointer argument. */
6495 check_function_nonnull (attrs, params)
6499 tree a, args, param;
6502 for (a = attrs; a; a = TREE_CHAIN (a))
6504 if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
6506 args = TREE_VALUE (a);
6508 /* Walk the argument list. If we encounter an argument number we
6509 should check for non-null, do it. If the attribute has no args,
6510 then every pointer argument is checked (in which case the check
6511 for pointer type is done in check_nonnull_arg). */
6512 for (param = params, param_num = 1; ;
6513 param_num++, param = TREE_CHAIN (param))
6517 if (! args || nonnull_check_p (args, param_num))
6518 check_function_arguments_recurse (check_nonnull_arg, NULL,
6526 /* Helper for check_function_nonnull; given a list of operands which
6527 must be non-null in ARGS, determine if operand PARAM_NUM should be
6531 nonnull_check_p (args, param_num)
6533 unsigned HOST_WIDE_INT param_num;
6535 unsigned HOST_WIDE_INT arg_num;
6537 for (; args; args = TREE_CHAIN (args))
6539 if (! get_nonnull_operand (TREE_VALUE (args), &arg_num))
6542 if (arg_num == param_num)
6548 /* Check that the function argument PARAM (which is operand number
6549 PARAM_NUM) is non-null. This is called by check_function_nonnull
6550 via check_function_arguments_recurse. */
6553 check_nonnull_arg (ctx, param, param_num)
6554 void *ctx ATTRIBUTE_UNUSED;
6556 unsigned HOST_WIDE_INT param_num;
6558 /* Just skip checking the argument if it's not a pointer. This can
6559 happen if the "nonnull" attribute was given without an operand
6560 list (which means to check every pointer argument). */
6562 if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
6565 if (integer_zerop (param))
6566 warning ("null argument where non-null required (arg %lu)",
6567 (unsigned long) param_num);
6570 /* Helper for nonnull attribute handling; fetch the operand number
6571 from the attribute argument list. */
6574 get_nonnull_operand (arg_num_expr, valp)
6576 unsigned HOST_WIDE_INT *valp;
6578 /* Strip any conversions from the arg number and verify they
6580 while (TREE_CODE (arg_num_expr) == NOP_EXPR
6581 || TREE_CODE (arg_num_expr) == CONVERT_EXPR
6582 || TREE_CODE (arg_num_expr) == NON_LVALUE_EXPR)
6583 arg_num_expr = TREE_OPERAND (arg_num_expr, 0);
6585 if (TREE_CODE (arg_num_expr) != INTEGER_CST
6586 || TREE_INT_CST_HIGH (arg_num_expr) != 0)
6589 *valp = TREE_INT_CST_LOW (arg_num_expr);
6593 /* Handle a "nothrow" attribute; arguments as in
6594 struct attribute_spec.handler. */
6597 handle_nothrow_attribute (node, name, args, flags, no_add_attrs)
6600 tree args ATTRIBUTE_UNUSED;
6601 int flags ATTRIBUTE_UNUSED;
6604 if (TREE_CODE (*node) == FUNCTION_DECL)
6605 TREE_NOTHROW (*node) = 1;
6606 /* ??? TODO: Support types. */
6609 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
6610 *no_add_attrs = true;
6616 /* Check for valid arguments being passed to a function. */
6618 check_function_arguments (attrs, params)
6622 /* Check for null being passed in a pointer argument that must be
6623 non-null. We also need to do this if format checking is enabled. */
6626 check_function_nonnull (attrs, params);
6628 /* Check for errors in format strings. */
6631 check_function_format (NULL, attrs, params);
6634 /* Generic argument checking recursion routine. PARAM is the argument to
6635 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
6636 once the argument is resolved. CTX is context for the callback. */
6638 check_function_arguments_recurse (callback, ctx, param, param_num)
6639 void (*callback) PARAMS ((void *, tree, unsigned HOST_WIDE_INT));
6642 unsigned HOST_WIDE_INT param_num;
6644 if (TREE_CODE (param) == NOP_EXPR)
6646 /* Strip coercion. */
6647 check_function_arguments_recurse (callback, ctx,
6648 TREE_OPERAND (param, 0), param_num);
6652 if (TREE_CODE (param) == CALL_EXPR)
6654 tree type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (param, 0)));
6656 bool found_format_arg = false;
6658 /* See if this is a call to a known internationalization function
6659 that modifies a format arg. Such a function may have multiple
6660 format_arg attributes (for example, ngettext). */
6662 for (attrs = TYPE_ATTRIBUTES (type);
6664 attrs = TREE_CHAIN (attrs))
6665 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
6668 tree format_num_expr;
6672 /* Extract the argument number, which was previously checked
6674 format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
6675 while (TREE_CODE (format_num_expr) == NOP_EXPR
6676 || TREE_CODE (format_num_expr) == CONVERT_EXPR
6677 || TREE_CODE (format_num_expr) == NON_LVALUE_EXPR)
6678 format_num_expr = TREE_OPERAND (format_num_expr, 0);
6680 if (TREE_CODE (format_num_expr) != INTEGER_CST
6681 || TREE_INT_CST_HIGH (format_num_expr) != 0)
6684 format_num = TREE_INT_CST_LOW (format_num_expr);
6686 for (inner_args = TREE_OPERAND (param, 1), i = 1;
6688 inner_args = TREE_CHAIN (inner_args), i++)
6689 if (i == format_num)
6691 check_function_arguments_recurse (callback, ctx,
6692 TREE_VALUE (inner_args),
6694 found_format_arg = true;
6699 /* If we found a format_arg attribute and did a recursive check,
6700 we are done with checking this argument. Otherwise, we continue
6701 and this will be considered a non-literal. */
6702 if (found_format_arg)
6706 if (TREE_CODE (param) == COND_EXPR)
6708 /* Check both halves of the conditional expression. */
6709 check_function_arguments_recurse (callback, ctx,
6710 TREE_OPERAND (param, 1), param_num);
6711 check_function_arguments_recurse (callback, ctx,
6712 TREE_OPERAND (param, 2), param_num);
6716 (*callback) (ctx, param, param_num);
6719 #include "gt-c-common.h"