1 /* Subroutines shared by all languages that are variants of C.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005 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, 51 Franklin Street, Fifth Floor, Boston, MA
24 #include "coretypes.h"
36 #include "diagnostic.h"
41 #include "langhooks.h"
42 #include "tree-inline.h"
45 #include "tree-iterator.h"
47 #include "tree-mudflap.h"
52 cpp_reader *parse_in; /* Declared in c-pragma.h. */
54 /* We let tm.h override the types used here, to handle trivial differences
55 such as the choice of unsigned int or long unsigned int for size_t.
56 When machines start needing nontrivial differences in the size type,
57 it would be best to do something here to figure out automatically
58 from other information what type to use. */
61 #define SIZE_TYPE "long unsigned int"
65 #define PID_TYPE "int"
69 #define WCHAR_TYPE "int"
72 /* WCHAR_TYPE gets overridden by -fshort-wchar. */
73 #define MODIFIED_WCHAR_TYPE \
74 (flag_short_wchar ? "short unsigned int" : WCHAR_TYPE)
77 #define PTRDIFF_TYPE "long int"
81 #define WINT_TYPE "unsigned int"
85 #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
87 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
93 #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
95 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
96 ? "long unsigned int" \
97 : "long long unsigned int"))
100 /* The following symbols are subsumed in the c_global_trees array, and
101 listed here individually for documentation purposes.
103 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
105 tree short_integer_type_node;
106 tree long_integer_type_node;
107 tree long_long_integer_type_node;
109 tree short_unsigned_type_node;
110 tree long_unsigned_type_node;
111 tree long_long_unsigned_type_node;
113 tree truthvalue_type_node;
114 tree truthvalue_false_node;
115 tree truthvalue_true_node;
117 tree ptrdiff_type_node;
119 tree unsigned_char_type_node;
120 tree signed_char_type_node;
121 tree wchar_type_node;
122 tree signed_wchar_type_node;
123 tree unsigned_wchar_type_node;
125 tree float_type_node;
126 tree double_type_node;
127 tree long_double_type_node;
129 tree complex_integer_type_node;
130 tree complex_float_type_node;
131 tree complex_double_type_node;
132 tree complex_long_double_type_node;
134 tree dfloat32_type_node;
135 tree dfloat64_type_node;
136 tree_dfloat128_type_node;
138 tree intQI_type_node;
139 tree intHI_type_node;
140 tree intSI_type_node;
141 tree intDI_type_node;
142 tree intTI_type_node;
144 tree unsigned_intQI_type_node;
145 tree unsigned_intHI_type_node;
146 tree unsigned_intSI_type_node;
147 tree unsigned_intDI_type_node;
148 tree unsigned_intTI_type_node;
150 tree widest_integer_literal_type_node;
151 tree widest_unsigned_literal_type_node;
153 Nodes for types `void *' and `const void *'.
155 tree ptr_type_node, const_ptr_type_node;
157 Nodes for types `char *' and `const char *'.
159 tree string_type_node, const_string_type_node;
161 Type `char[SOMENUMBER]'.
162 Used when an array of char is needed and the size is irrelevant.
164 tree char_array_type_node;
166 Type `int[SOMENUMBER]' or something like it.
167 Used when an array of int needed and the size is irrelevant.
169 tree int_array_type_node;
171 Type `wchar_t[SOMENUMBER]' or something like it.
172 Used when a wide string literal is created.
174 tree wchar_array_type_node;
176 Type `int ()' -- used for implicit declaration of functions.
178 tree default_function_type;
180 A VOID_TYPE node, packaged in a TREE_LIST.
184 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
185 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
186 VAR_DECLS, but C++ does.)
188 tree function_name_decl_node;
189 tree pretty_function_name_decl_node;
190 tree c99_function_name_decl_node;
192 Stack of nested function name VAR_DECLs.
194 tree saved_function_name_decls;
198 tree c_global_trees[CTI_MAX];
200 /* Switches common to the C front ends. */
202 /* Nonzero if prepreprocessing only. */
204 int flag_preprocess_only;
206 /* Nonzero means don't output line number information. */
208 char flag_no_line_commands;
210 /* Nonzero causes -E output not to be done, but directives such as
211 #define that have side effects are still obeyed. */
215 /* Nonzero means dump macros in some fashion. */
217 char flag_dump_macros;
219 /* Nonzero means pass #include lines through to the output. */
221 char flag_dump_includes;
223 /* Nonzero means process PCH files while preprocessing. */
225 bool flag_pch_preprocess;
227 /* The file name to which we should write a precompiled header, or
228 NULL if no header will be written in this compile. */
230 const char *pch_file;
232 /* Nonzero if an ISO standard was selected. It rejects macros in the
236 /* Nonzero if -undef was given. It suppresses target built-in macros
240 /* Nonzero means don't recognize the non-ANSI builtin functions. */
244 /* Nonzero means don't recognize the non-ANSI builtin functions.
247 int flag_no_nonansi_builtin;
249 /* Nonzero means give `double' the same size as `float'. */
251 int flag_short_double;
253 /* Nonzero means give `wchar_t' the same size as `short'. */
255 int flag_short_wchar;
257 /* Nonzero means allow Microsoft extensions without warnings or errors. */
258 int flag_ms_extensions;
260 /* Nonzero means don't recognize the keyword `asm'. */
264 /* Nonzero means to treat bitfields as signed unless they say `unsigned'. */
266 int flag_signed_bitfields = 1;
268 /* Nonzero means warn about deprecated conversion from string constant to
271 int warn_write_strings;
273 /* Warn about #pragma directives that are not recognized. */
275 int warn_unknown_pragmas; /* Tri state variable. */
277 /* Warn about format/argument anomalies in calls to formatted I/O functions
278 (*printf, *scanf, strftime, strfmon, etc.). */
282 /* Warn about using __null (as NULL in C++) as sentinel. For code compiled
283 with GCC this doesn't matter as __null is guaranteed to have the right
286 int warn_strict_null_sentinel;
288 /* Zero means that faster, ...NonNil variants of objc_msgSend...
289 calls will be used in ObjC; passing nil receivers to such calls
290 will most likely result in crashes. */
291 int flag_nil_receivers = 1;
293 /* Nonzero means that code generation will be altered to support
294 "zero-link" execution. This currently affects ObjC only, but may
295 affect other languages in the future. */
296 int flag_zero_link = 0;
298 /* Nonzero means emit an '__OBJC, __image_info' for the current translation
299 unit. It will inform the ObjC runtime that class definition(s) herein
300 contained are to replace one(s) previously loaded. */
301 int flag_replace_objc_classes = 0;
303 /* C/ObjC language option variables. */
306 /* Nonzero means allow type mismatches in conditional expressions;
307 just make their values `void'. */
309 int flag_cond_mismatch;
311 /* Nonzero means enable C89 Amendment 1 features. */
315 /* Nonzero means use the ISO C99 dialect of C. */
319 /* Nonzero means that we have builtin functions, and main is an int. */
323 /* Warn if main is suspicious. */
328 /* ObjC language option variables. */
331 /* Open and close the file for outputting class declarations, if
334 int flag_gen_declaration;
336 /* Tells the compiler that this is a special run. Do not perform any
337 compiling, instead we are to test some platform dependent features
338 and output a C header file with appropriate definitions. */
340 int print_struct_values;
342 /* Tells the compiler what is the constant string class for Objc. */
344 const char *constant_string_class_name;
347 /* C++ language option variables. */
350 /* Nonzero means don't recognize any extension keywords. */
352 int flag_no_gnu_keywords;
354 /* Nonzero means do emit exported implementations of functions even if
355 they can be inlined. */
357 int flag_implement_inlines = 1;
359 /* Nonzero means that implicit instantiations will be emitted if needed. */
361 int flag_implicit_templates = 1;
363 /* Nonzero means that implicit instantiations of inline templates will be
364 emitted if needed, even if instantiations of non-inline templates
367 int flag_implicit_inline_templates = 1;
369 /* Nonzero means generate separate instantiation control files and
370 juggle them at link time. */
372 int flag_use_repository;
374 /* Nonzero if we want to issue diagnostics that the standard says are not
377 int flag_optional_diags = 1;
379 /* Nonzero means we should attempt to elide constructors when possible. */
381 int flag_elide_constructors = 1;
383 /* Nonzero means that member functions defined in class scope are
384 inline by default. */
386 int flag_default_inline = 1;
388 /* Controls whether compiler generates 'type descriptor' that give
389 run-time type information. */
393 /* Nonzero if we want to conserve space in the .o files. We do this
394 by putting uninitialized data and runtime initialized data into
395 .common instead of .data at the expense of not flagging multiple
398 int flag_conserve_space;
400 /* Nonzero if we want to obey access control semantics. */
402 int flag_access_control = 1;
404 /* Nonzero if we want to check the return value of new and avoid calling
405 constructors if it is a null pointer. */
409 /* Nonzero if we want the new ISO rules for pushing a new scope for `for'
410 initialization variables.
411 0: Old rules, set by -fno-for-scope.
412 2: New ISO rules, set by -ffor-scope.
413 1: Try to implement new ISO rules, but with backup compatibility
414 (and warnings). This is the default, for now. */
416 int flag_new_for_scope = 1;
418 /* Nonzero if we want to emit defined symbols with common-like linkage as
419 weak symbols where possible, in order to conform to C++ semantics.
420 Otherwise, emit them as local symbols. */
424 /* 0 means we want the preprocessor to not emit line directives for
425 the current working directory. 1 means we want it to do it. -1
426 means we should decide depending on whether debugging information
427 is being emitted or not. */
429 int flag_working_directory = -1;
431 /* Nonzero to use __cxa_atexit, rather than atexit, to register
432 destructors for local statics and global objects. */
434 int flag_use_cxa_atexit = DEFAULT_USE_CXA_ATEXIT;
436 /* Nonzero means make the default pedwarns warnings instead of errors.
437 The value of this flag is ignored if -pedantic is specified. */
441 /* Nonzero means to implement standard semantics for exception
442 specifications, calling unexpected if an exception is thrown that
443 doesn't match the specification. Zero means to treat them as
444 assertions and optimize accordingly, but not check them. */
446 int flag_enforce_eh_specs = 1;
448 /* Nonzero means to generate thread-safe code for initializing local
451 int flag_threadsafe_statics = 1;
453 /* Nonzero means warn about implicit declarations. */
455 int warn_implicit = 1;
457 /* Maximum template instantiation depth. This limit is rather
458 arbitrary, but it exists to limit the time it takes to notice
459 infinite template instantiations. */
461 int max_tinst_depth = 500;
465 /* The elements of `ridpointers' are identifier nodes for the reserved
466 type names and storage classes. It is indexed by a RID_... value. */
469 tree (*make_fname_decl) (tree, int);
471 /* Nonzero means the expression being parsed will never be evaluated.
472 This is a count, since unevaluated expressions can nest. */
475 /* Information about how a function name is generated. */
478 tree *const decl; /* pointer to the VAR_DECL. */
479 const unsigned rid; /* RID number for the identifier. */
480 const int pretty; /* How pretty is it? */
483 /* The three ways of getting then name of the current function. */
485 const struct fname_var_t fname_vars[] =
487 /* C99 compliant __func__, must be first. */
488 {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
489 /* GCC __FUNCTION__ compliant. */
490 {&function_name_decl_node, RID_FUNCTION_NAME, 0},
491 /* GCC __PRETTY_FUNCTION__ compliant. */
492 {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
496 static int constant_fits_type_p (tree, tree);
497 static tree check_case_value (tree);
498 static bool check_case_bounds (tree, tree, tree *, tree *);
500 static tree handle_packed_attribute (tree *, tree, tree, int, bool *);
501 static tree handle_nocommon_attribute (tree *, tree, tree, int, bool *);
502 static tree handle_common_attribute (tree *, tree, tree, int, bool *);
503 static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
504 static tree handle_noinline_attribute (tree *, tree, tree, int, bool *);
505 static tree handle_always_inline_attribute (tree *, tree, tree, int,
507 static tree handle_flatten_attribute (tree *, tree, tree, int, bool *);
508 static tree handle_used_attribute (tree *, tree, tree, int, bool *);
509 static tree handle_unused_attribute (tree *, tree, tree, int, bool *);
510 static tree handle_externally_visible_attribute (tree *, tree, tree, int,
512 static tree handle_const_attribute (tree *, tree, tree, int, bool *);
513 static tree handle_transparent_union_attribute (tree *, tree, tree,
515 static tree handle_constructor_attribute (tree *, tree, tree, int, bool *);
516 static tree handle_destructor_attribute (tree *, tree, tree, int, bool *);
517 static tree handle_mode_attribute (tree *, tree, tree, int, bool *);
518 static tree handle_section_attribute (tree *, tree, tree, int, bool *);
519 static tree handle_aligned_attribute (tree *, tree, tree, int, bool *);
520 static tree handle_weak_attribute (tree *, tree, tree, int, bool *) ;
521 static tree handle_alias_attribute (tree *, tree, tree, int, bool *);
522 static tree handle_weakref_attribute (tree *, tree, tree, int, bool *) ;
523 static tree handle_visibility_attribute (tree *, tree, tree, int,
525 static tree handle_tls_model_attribute (tree *, tree, tree, int,
527 static tree handle_no_instrument_function_attribute (tree *, tree,
529 static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);
530 static tree handle_returns_twice_attribute (tree *, tree, tree, int, bool *);
531 static tree handle_no_limit_stack_attribute (tree *, tree, tree, int,
533 static tree handle_pure_attribute (tree *, tree, tree, int, bool *);
534 static tree handle_novops_attribute (tree *, tree, tree, int, bool *);
535 static tree handle_deprecated_attribute (tree *, tree, tree, int,
537 static tree handle_vector_size_attribute (tree *, tree, tree, int,
539 static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
540 static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
541 static tree handle_cleanup_attribute (tree *, tree, tree, int, bool *);
542 static tree handle_warn_unused_result_attribute (tree *, tree, tree, int,
544 static tree handle_sentinel_attribute (tree *, tree, tree, int, bool *);
546 static void check_function_nonnull (tree, tree);
547 static void check_nonnull_arg (void *, tree, unsigned HOST_WIDE_INT);
548 static bool nonnull_check_p (tree, unsigned HOST_WIDE_INT);
549 static bool get_nonnull_operand (tree, unsigned HOST_WIDE_INT *);
550 static int resort_field_decl_cmp (const void *, const void *);
552 /* Table of machine-independent attributes common to all C-like languages. */
553 const struct attribute_spec c_common_attribute_table[] =
555 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
556 { "packed", 0, 0, false, false, false,
557 handle_packed_attribute },
558 { "nocommon", 0, 0, true, false, false,
559 handle_nocommon_attribute },
560 { "common", 0, 0, true, false, false,
561 handle_common_attribute },
562 /* FIXME: logically, noreturn attributes should be listed as
563 "false, true, true" and apply to function types. But implementing this
564 would require all the places in the compiler that use TREE_THIS_VOLATILE
565 on a decl to identify non-returning functions to be located and fixed
566 to check the function type instead. */
567 { "noreturn", 0, 0, true, false, false,
568 handle_noreturn_attribute },
569 { "volatile", 0, 0, true, false, false,
570 handle_noreturn_attribute },
571 { "noinline", 0, 0, true, false, false,
572 handle_noinline_attribute },
573 { "always_inline", 0, 0, true, false, false,
574 handle_always_inline_attribute },
575 { "flatten", 0, 0, true, false, false,
576 handle_flatten_attribute },
577 { "used", 0, 0, true, false, false,
578 handle_used_attribute },
579 { "unused", 0, 0, false, false, false,
580 handle_unused_attribute },
581 { "externally_visible", 0, 0, true, false, false,
582 handle_externally_visible_attribute },
583 /* The same comments as for noreturn attributes apply to const ones. */
584 { "const", 0, 0, true, false, false,
585 handle_const_attribute },
586 { "transparent_union", 0, 0, false, false, false,
587 handle_transparent_union_attribute },
588 { "constructor", 0, 0, true, false, false,
589 handle_constructor_attribute },
590 { "destructor", 0, 0, true, false, false,
591 handle_destructor_attribute },
592 { "mode", 1, 1, false, true, false,
593 handle_mode_attribute },
594 { "section", 1, 1, true, false, false,
595 handle_section_attribute },
596 { "aligned", 0, 1, false, false, false,
597 handle_aligned_attribute },
598 { "weak", 0, 0, true, false, false,
599 handle_weak_attribute },
600 { "alias", 1, 1, true, false, false,
601 handle_alias_attribute },
602 { "weakref", 0, 1, true, false, false,
603 handle_weakref_attribute },
604 { "no_instrument_function", 0, 0, true, false, false,
605 handle_no_instrument_function_attribute },
606 { "malloc", 0, 0, true, false, false,
607 handle_malloc_attribute },
608 { "returns_twice", 0, 0, true, false, false,
609 handle_returns_twice_attribute },
610 { "no_stack_limit", 0, 0, true, false, false,
611 handle_no_limit_stack_attribute },
612 { "pure", 0, 0, true, false, false,
613 handle_pure_attribute },
614 /* For internal use (marking of builtins) only. The name contains space
615 to prevent its usage in source code. */
616 { "no vops", 0, 0, true, false, false,
617 handle_novops_attribute },
618 { "deprecated", 0, 0, false, false, false,
619 handle_deprecated_attribute },
620 { "vector_size", 1, 1, false, true, false,
621 handle_vector_size_attribute },
622 { "visibility", 1, 1, false, false, false,
623 handle_visibility_attribute },
624 { "tls_model", 1, 1, true, false, false,
625 handle_tls_model_attribute },
626 { "nonnull", 0, -1, false, true, true,
627 handle_nonnull_attribute },
628 { "nothrow", 0, 0, true, false, false,
629 handle_nothrow_attribute },
630 { "may_alias", 0, 0, false, true, false, NULL },
631 { "cleanup", 1, 1, true, false, false,
632 handle_cleanup_attribute },
633 { "warn_unused_result", 0, 0, false, true, true,
634 handle_warn_unused_result_attribute },
635 { "sentinel", 0, 1, false, true, true,
636 handle_sentinel_attribute },
637 { NULL, 0, 0, false, false, false, NULL }
640 /* Give the specifications for the format attributes, used by C and all
643 const struct attribute_spec c_common_format_attribute_table[] =
645 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
646 { "format", 3, 3, false, true, true,
647 handle_format_attribute },
648 { "format_arg", 1, 1, false, true, true,
649 handle_format_arg_attribute },
650 { NULL, 0, 0, false, false, false, NULL }
653 /* Push current bindings for the function name VAR_DECLS. */
656 start_fname_decls (void)
659 tree saved = NULL_TREE;
661 for (ix = 0; fname_vars[ix].decl; ix++)
663 tree decl = *fname_vars[ix].decl;
667 saved = tree_cons (decl, build_int_cst (NULL_TREE, ix), saved);
668 *fname_vars[ix].decl = NULL_TREE;
671 if (saved || saved_function_name_decls)
672 /* Normally they'll have been NULL, so only push if we've got a
673 stack, or they are non-NULL. */
674 saved_function_name_decls = tree_cons (saved, NULL_TREE,
675 saved_function_name_decls);
678 /* Finish up the current bindings, adding them into the current function's
679 statement tree. This must be done _before_ finish_stmt_tree is called.
680 If there is no current function, we must be at file scope and no statements
681 are involved. Pop the previous bindings. */
684 finish_fname_decls (void)
687 tree stmts = NULL_TREE;
688 tree stack = saved_function_name_decls;
690 for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
691 append_to_statement_list (TREE_VALUE (stack), &stmts);
695 tree *bodyp = &DECL_SAVED_TREE (current_function_decl);
697 if (TREE_CODE (*bodyp) == BIND_EXPR)
698 bodyp = &BIND_EXPR_BODY (*bodyp);
700 append_to_statement_list_force (*bodyp, &stmts);
704 for (ix = 0; fname_vars[ix].decl; ix++)
705 *fname_vars[ix].decl = NULL_TREE;
709 /* We had saved values, restore them. */
712 for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
714 tree decl = TREE_PURPOSE (saved);
715 unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
717 *fname_vars[ix].decl = decl;
719 stack = TREE_CHAIN (stack);
721 saved_function_name_decls = stack;
724 /* Return the text name of the current function, suitably prettified
725 by PRETTY_P. Return string must be freed by caller. */
728 fname_as_string (int pretty_p)
730 const char *name = "top level";
740 if (current_function_decl)
741 name = lang_hooks.decl_printable_name (current_function_decl, vrb);
743 if (c_lex_string_translate)
745 int len = strlen (name) + 3; /* Two for '"'s. One for NULL. */
746 cpp_string cstr = { 0, 0 }, strname;
748 namep = XNEWVEC (char, len);
749 snprintf (namep, len, "\"%s\"", name);
750 strname.text = (unsigned char *) namep;
751 strname.len = len - 1;
753 if (cpp_interpret_string (parse_in, &strname, 1, &cstr, false))
756 return (char *) cstr.text;
760 namep = xstrdup (name);
765 /* Expand DECL if it declares an entity not handled by the
769 c_expand_decl (tree decl)
771 if (TREE_CODE (decl) == VAR_DECL && !TREE_STATIC (decl))
773 /* Let the back-end know about this variable. */
774 if (!anon_aggr_type_p (TREE_TYPE (decl)))
775 emit_local_var (decl);
777 expand_anon_union_decl (decl, NULL_TREE,
778 DECL_ANON_UNION_ELEMS (decl));
787 /* Return the VAR_DECL for a const char array naming the current
788 function. If the VAR_DECL has not yet been created, create it
789 now. RID indicates how it should be formatted and IDENTIFIER_NODE
790 ID is its name (unfortunately C and C++ hold the RID values of
791 keywords in different places, so we can't derive RID from ID in
792 this language independent code. */
795 fname_decl (unsigned int rid, tree id)
798 tree decl = NULL_TREE;
800 for (ix = 0; fname_vars[ix].decl; ix++)
801 if (fname_vars[ix].rid == rid)
804 decl = *fname_vars[ix].decl;
807 /* If a tree is built here, it would normally have the lineno of
808 the current statement. Later this tree will be moved to the
809 beginning of the function and this line number will be wrong.
810 To avoid this problem set the lineno to 0 here; that prevents
811 it from appearing in the RTL. */
813 location_t saved_location = input_location;
814 #ifdef USE_MAPPED_LOCATION
815 input_location = UNKNOWN_LOCATION;
820 stmts = push_stmt_list ();
821 decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
822 stmts = pop_stmt_list (stmts);
823 if (!IS_EMPTY_STMT (stmts))
824 saved_function_name_decls
825 = tree_cons (decl, stmts, saved_function_name_decls);
826 *fname_vars[ix].decl = decl;
827 input_location = saved_location;
829 if (!ix && !current_function_decl)
830 pedwarn ("%qD is not defined outside of function scope", decl);
835 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
838 fix_string_type (tree value)
840 const int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
841 const int wide_flag = TREE_TYPE (value) == wchar_array_type_node;
842 int length = TREE_STRING_LENGTH (value);
844 tree e_type, i_type, a_type;
846 /* Compute the number of elements, for the array type. */
847 nchars = wide_flag ? length / wchar_bytes : length;
849 /* C89 2.2.4.1, C99 5.2.4.1 (Translation limits). The analogous
850 limit in C++98 Annex B is very large (65536) and is not normative,
851 so we do not diagnose it (warn_overlength_strings is forced off
852 in c_common_post_options). */
853 if (warn_overlength_strings)
855 const int nchars_max = flag_isoc99 ? 4095 : 509;
856 const int relevant_std = flag_isoc99 ? 99 : 90;
857 if (nchars - 1 > nchars_max)
858 /* Translators: The %d after 'ISO C' will be 90 or 99. Do not
859 separate the %d from the 'C'. 'ISO' should not be
860 translated, but it may be moved after 'C%d' in languages
861 where modifiers follow nouns. */
862 pedwarn ("string length %qd is greater than the length %qd "
863 "ISO C%d compilers are required to support",
864 nchars - 1, nchars_max, relevant_std);
867 /* Create the array type for the string constant. The ISO C++
868 standard says that a string literal has type `const char[N]' or
869 `const wchar_t[N]'. We use the same logic when invoked as a C
870 front-end with -Wwrite-strings.
871 ??? We should change the type of an expression depending on the
872 state of a warning flag. We should just be warning -- see how
873 this is handled in the C++ front-end for the deprecated implicit
874 conversion from string literals to `char*' or `wchar_t*'.
876 The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified
877 array type being the unqualified version of that type.
878 Therefore, if we are constructing an array of const char, we must
879 construct the matching unqualified array type first. The C front
880 end does not require this, but it does no harm, so we do it
882 e_type = wide_flag ? wchar_type_node : char_type_node;
883 i_type = build_index_type (build_int_cst (NULL_TREE, nchars - 1));
884 a_type = build_array_type (e_type, i_type);
885 if (c_dialect_cxx() || warn_write_strings)
886 a_type = c_build_qualified_type (a_type, TYPE_QUAL_CONST);
888 TREE_TYPE (value) = a_type;
889 TREE_CONSTANT (value) = 1;
890 TREE_INVARIANT (value) = 1;
891 TREE_READONLY (value) = 1;
892 TREE_STATIC (value) = 1;
896 /* Print a warning if a constant expression had overflow in folding.
897 Invoke this function on every expression that the language
898 requires to be a constant expression.
899 Note the ANSI C standard says it is erroneous for a
900 constant expression to overflow. */
903 constant_expression_warning (tree value)
905 if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
906 || TREE_CODE (value) == VECTOR_CST
907 || TREE_CODE (value) == COMPLEX_CST)
908 && TREE_CONSTANT_OVERFLOW (value) && pedantic)
909 pedwarn ("overflow in constant expression");
912 /* Print a warning if an expression had overflow in folding.
913 Invoke this function on every expression that
914 (1) appears in the source code, and
915 (2) might be a constant expression that overflowed, and
916 (3) is not already checked by convert_and_check;
917 however, do not invoke this function on operands of explicit casts. */
920 overflow_warning (tree value)
922 if ((TREE_CODE (value) == INTEGER_CST
923 || (TREE_CODE (value) == COMPLEX_CST
924 && TREE_CODE (TREE_REALPART (value)) == INTEGER_CST))
925 && TREE_OVERFLOW (value))
927 TREE_OVERFLOW (value) = 0;
928 if (skip_evaluation == 0)
929 warning (0, "integer overflow in expression");
931 else if ((TREE_CODE (value) == REAL_CST
932 || (TREE_CODE (value) == COMPLEX_CST
933 && TREE_CODE (TREE_REALPART (value)) == REAL_CST))
934 && TREE_OVERFLOW (value))
936 TREE_OVERFLOW (value) = 0;
937 if (skip_evaluation == 0)
938 warning (0, "floating point overflow in expression");
940 else if (TREE_CODE (value) == VECTOR_CST && TREE_OVERFLOW (value))
942 TREE_OVERFLOW (value) = 0;
943 if (skip_evaluation == 0)
944 warning (0, "vector overflow in expression");
948 /* Print a warning if a large constant is truncated to unsigned,
949 or if -Wconversion is used and a constant < 0 is converted to unsigned.
950 Invoke this function on every expression that might be implicitly
951 converted to an unsigned type. */
954 unsigned_conversion_warning (tree result, tree operand)
956 tree type = TREE_TYPE (result);
958 if (TREE_CODE (operand) == INTEGER_CST
959 && TREE_CODE (type) == INTEGER_TYPE
960 && TYPE_UNSIGNED (type)
961 && skip_evaluation == 0
962 && !int_fits_type_p (operand, type))
964 if (!int_fits_type_p (operand, c_common_signed_type (type)))
965 /* This detects cases like converting -129 or 256 to unsigned char. */
966 warning (0, "large integer implicitly truncated to unsigned type");
968 warning (OPT_Wconversion,
969 "negative integer implicitly converted to unsigned type");
973 /* Print a warning about casts that might indicate violation
974 of strict aliasing rules if -Wstrict-aliasing is used and
975 strict aliasing mode is in effect. otype is the original
976 TREE_TYPE of expr, and type the type we're casting to. */
979 strict_aliasing_warning(tree otype, tree type, tree expr)
981 if (flag_strict_aliasing && warn_strict_aliasing
982 && POINTER_TYPE_P (type) && POINTER_TYPE_P (otype)
983 && TREE_CODE (expr) == ADDR_EXPR
984 && (DECL_P (TREE_OPERAND (expr, 0))
985 || handled_component_p (TREE_OPERAND (expr, 0)))
986 && !VOID_TYPE_P (TREE_TYPE (type)))
988 /* Casting the address of an object to non void pointer. Warn
989 if the cast breaks type based aliasing. */
990 if (!COMPLETE_TYPE_P (TREE_TYPE (type)))
991 warning (OPT_Wstrict_aliasing, "type-punning to incomplete type "
992 "might break strict-aliasing rules");
995 HOST_WIDE_INT set1 = get_alias_set (TREE_TYPE (TREE_OPERAND (expr, 0)));
996 HOST_WIDE_INT set2 = get_alias_set (TREE_TYPE (type));
998 if (!alias_sets_conflict_p (set1, set2))
999 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1000 "pointer will break strict-aliasing rules");
1001 else if (warn_strict_aliasing > 1
1002 && !alias_sets_might_conflict_p (set1, set2))
1003 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1004 "pointer might break strict-aliasing rules");
1010 /* Print a warning about if (); or if () .. else; constructs
1011 via the special empty statement node that we create. INNER_THEN
1012 and INNER_ELSE are the statement lists of the if and the else
1016 empty_body_warning (tree inner_then, tree inner_else)
1020 if (TREE_CODE (inner_then) == STATEMENT_LIST
1021 && STATEMENT_LIST_TAIL (inner_then))
1022 inner_then = STATEMENT_LIST_TAIL (inner_then)->stmt;
1024 if (inner_else && TREE_CODE (inner_else) == STATEMENT_LIST
1025 && STATEMENT_LIST_TAIL (inner_else))
1026 inner_else = STATEMENT_LIST_TAIL (inner_else)->stmt;
1028 if (IS_EMPTY_STMT (inner_then) && !inner_else)
1029 warning (OPT_Wextra, "%Hempty body in an if-statement",
1030 EXPR_LOCUS (inner_then));
1032 if (inner_else && IS_EMPTY_STMT (inner_else))
1033 warning (OPT_Wextra, "%Hempty body in an else-statement",
1034 EXPR_LOCUS (inner_else));
1039 /* Nonzero if constant C has a value that is permissible
1040 for type TYPE (an INTEGER_TYPE). */
1043 constant_fits_type_p (tree c, tree type)
1045 if (TREE_CODE (c) == INTEGER_CST)
1046 return int_fits_type_p (c, type);
1048 c = convert (type, c);
1049 return !TREE_OVERFLOW (c);
1052 /* Nonzero if vector types T1 and T2 can be converted to each other
1053 without an explicit cast. */
1055 vector_types_convertible_p (tree t1, tree t2)
1057 return targetm.vector_opaque_p (t1)
1058 || targetm.vector_opaque_p (t2)
1059 || (tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2))
1060 && (TREE_CODE (TREE_TYPE (t1)) != REAL_TYPE ||
1061 TYPE_PRECISION (t1) == TYPE_PRECISION (t2))
1062 && INTEGRAL_TYPE_P (TREE_TYPE (t1))
1063 == INTEGRAL_TYPE_P (TREE_TYPE (t2)));
1066 /* Convert EXPR to TYPE, warning about conversion problems with constants.
1067 Invoke this function on every expression that is converted implicitly,
1068 i.e. because of language rules and not because of an explicit cast. */
1071 convert_and_check (tree type, tree expr)
1073 tree t = convert (type, expr);
1074 if (TREE_CODE (t) == INTEGER_CST)
1076 if (TREE_OVERFLOW (t))
1078 TREE_OVERFLOW (t) = 0;
1080 /* Do not diagnose overflow in a constant expression merely
1081 because a conversion overflowed. */
1082 TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (expr);
1084 /* No warning for converting 0x80000000 to int. */
1085 if (!(TYPE_UNSIGNED (type) < TYPE_UNSIGNED (TREE_TYPE (expr))
1086 && TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
1087 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr))))
1088 /* If EXPR fits in the unsigned version of TYPE,
1089 don't warn unless pedantic. */
1091 || TYPE_UNSIGNED (type)
1092 || !constant_fits_type_p (expr,
1093 c_common_unsigned_type (type)))
1094 && skip_evaluation == 0)
1095 warning (0, "overflow in implicit constant conversion");
1098 unsigned_conversion_warning (t, expr);
1103 /* A node in a list that describes references to variables (EXPR), which are
1104 either read accesses if WRITER is zero, or write accesses, in which case
1105 WRITER is the parent of EXPR. */
1112 /* Used to implement a cache the results of a call to verify_tree. We only
1113 use this for SAVE_EXPRs. */
1116 struct tlist_cache *next;
1117 struct tlist *cache_before_sp;
1118 struct tlist *cache_after_sp;
1122 /* Obstack to use when allocating tlist structures, and corresponding
1124 static struct obstack tlist_obstack;
1125 static char *tlist_firstobj = 0;
1127 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
1129 static struct tlist *warned_ids;
1130 /* SAVE_EXPRs need special treatment. We process them only once and then
1131 cache the results. */
1132 static struct tlist_cache *save_expr_cache;
1134 static void add_tlist (struct tlist **, struct tlist *, tree, int);
1135 static void merge_tlist (struct tlist **, struct tlist *, int);
1136 static void verify_tree (tree, struct tlist **, struct tlist **, tree);
1137 static int warning_candidate_p (tree);
1138 static void warn_for_collisions (struct tlist *);
1139 static void warn_for_collisions_1 (tree, tree, struct tlist *, int);
1140 static struct tlist *new_tlist (struct tlist *, tree, tree);
1142 /* Create a new struct tlist and fill in its fields. */
1143 static struct tlist *
1144 new_tlist (struct tlist *next, tree t, tree writer)
1147 l = XOBNEW (&tlist_obstack, struct tlist);
1154 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
1155 is nonnull, we ignore any node we find which has a writer equal to it. */
1158 add_tlist (struct tlist **to, struct tlist *add, tree exclude_writer, int copy)
1162 struct tlist *next = add->next;
1165 if (!exclude_writer || add->writer != exclude_writer)
1166 *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
1171 /* Merge the nodes of ADD into TO. This merging process is done so that for
1172 each variable that already exists in TO, no new node is added; however if
1173 there is a write access recorded in ADD, and an occurrence on TO is only
1174 a read access, then the occurrence in TO will be modified to record the
1178 merge_tlist (struct tlist **to, struct tlist *add, int copy)
1180 struct tlist **end = to;
1183 end = &(*end)->next;
1189 struct tlist *next = add->next;
1191 for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
1192 if (tmp2->expr == add->expr)
1196 tmp2->writer = add->writer;
1200 *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
1201 end = &(*end)->next;
1208 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
1209 references in list LIST conflict with it, excluding reads if ONLY writers
1213 warn_for_collisions_1 (tree written, tree writer, struct tlist *list,
1218 /* Avoid duplicate warnings. */
1219 for (tmp = warned_ids; tmp; tmp = tmp->next)
1220 if (tmp->expr == written)
1225 if (list->expr == written
1226 && list->writer != writer
1227 && (!only_writes || list->writer)
1228 && DECL_NAME (list->expr))
1230 warned_ids = new_tlist (warned_ids, written, NULL_TREE);
1231 warning (0, "operation on %qE may be undefined", list->expr);
1237 /* Given a list LIST of references to variables, find whether any of these
1238 can cause conflicts due to missing sequence points. */
1241 warn_for_collisions (struct tlist *list)
1245 for (tmp = list; tmp; tmp = tmp->next)
1248 warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
1252 /* Return nonzero if X is a tree that can be verified by the sequence point
1255 warning_candidate_p (tree x)
1257 return TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == PARM_DECL;
1260 /* Walk the tree X, and record accesses to variables. If X is written by the
1261 parent tree, WRITER is the parent.
1262 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
1263 expression or its only operand forces a sequence point, then everything up
1264 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
1266 Once we return, we will have emitted warnings if any subexpression before
1267 such a sequence point could be undefined. On a higher level, however, the
1268 sequence point may not be relevant, and we'll merge the two lists.
1270 Example: (b++, a) + b;
1271 The call that processes the COMPOUND_EXPR will store the increment of B
1272 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
1273 processes the PLUS_EXPR will need to merge the two lists so that
1274 eventually, all accesses end up on the same list (and we'll warn about the
1275 unordered subexpressions b++ and b.
1277 A note on merging. If we modify the former example so that our expression
1280 care must be taken not simply to add all three expressions into the final
1281 PNO_SP list. The function merge_tlist takes care of that by merging the
1282 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1283 way, so that no more than one access to B is recorded. */
1286 verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp,
1289 struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
1290 enum tree_code code;
1291 enum tree_code_class cl;
1293 /* X may be NULL if it is the operand of an empty statement expression
1299 code = TREE_CODE (x);
1300 cl = TREE_CODE_CLASS (code);
1302 if (warning_candidate_p (x))
1304 *pno_sp = new_tlist (*pno_sp, x, writer);
1314 case TRUTH_ANDIF_EXPR:
1315 case TRUTH_ORIF_EXPR:
1316 tmp_before = tmp_nosp = tmp_list3 = 0;
1317 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1318 warn_for_collisions (tmp_nosp);
1319 merge_tlist (pbefore_sp, tmp_before, 0);
1320 merge_tlist (pbefore_sp, tmp_nosp, 0);
1321 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
1322 merge_tlist (pbefore_sp, tmp_list3, 0);
1326 tmp_before = tmp_list2 = 0;
1327 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
1328 warn_for_collisions (tmp_list2);
1329 merge_tlist (pbefore_sp, tmp_before, 0);
1330 merge_tlist (pbefore_sp, tmp_list2, 1);
1332 tmp_list3 = tmp_nosp = 0;
1333 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
1334 warn_for_collisions (tmp_nosp);
1335 merge_tlist (pbefore_sp, tmp_list3, 0);
1337 tmp_list3 = tmp_list2 = 0;
1338 verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
1339 warn_for_collisions (tmp_list2);
1340 merge_tlist (pbefore_sp, tmp_list3, 0);
1341 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1342 two first, to avoid warning for (a ? b++ : b++). */
1343 merge_tlist (&tmp_nosp, tmp_list2, 0);
1344 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1347 case PREDECREMENT_EXPR:
1348 case PREINCREMENT_EXPR:
1349 case POSTDECREMENT_EXPR:
1350 case POSTINCREMENT_EXPR:
1351 verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
1355 tmp_before = tmp_nosp = tmp_list3 = 0;
1356 verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
1357 verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
1358 /* Expressions inside the LHS are not ordered wrt. the sequence points
1359 in the RHS. Example:
1361 Despite the fact that the modification of "a" is in the before_sp
1362 list (tmp_before), it conflicts with the use of "a" in the LHS.
1363 We can handle this by adding the contents of tmp_list3
1364 to those of tmp_before, and redoing the collision warnings for that
1366 add_tlist (&tmp_before, tmp_list3, x, 1);
1367 warn_for_collisions (tmp_before);
1368 /* Exclude the LHS itself here; we first have to merge it into the
1369 tmp_nosp list. This is done to avoid warning for "a = a"; if we
1370 didn't exclude the LHS, we'd get it twice, once as a read and once
1372 add_tlist (pno_sp, tmp_list3, x, 0);
1373 warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
1375 merge_tlist (pbefore_sp, tmp_before, 0);
1376 if (warning_candidate_p (TREE_OPERAND (x, 0)))
1377 merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
1378 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
1382 /* We need to warn about conflicts among arguments and conflicts between
1383 args and the function address. Side effects of the function address,
1384 however, are not ordered by the sequence point of the call. */
1385 tmp_before = tmp_nosp = tmp_list2 = tmp_list3 = 0;
1386 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1387 if (TREE_OPERAND (x, 1))
1388 verify_tree (TREE_OPERAND (x, 1), &tmp_list2, &tmp_list3, NULL_TREE);
1389 merge_tlist (&tmp_list3, tmp_list2, 0);
1390 add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
1391 add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
1392 warn_for_collisions (tmp_before);
1393 add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
1397 /* Scan all the list, e.g. indices of multi dimensional array. */
1400 tmp_before = tmp_nosp = 0;
1401 verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
1402 merge_tlist (&tmp_nosp, tmp_before, 0);
1403 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1410 struct tlist_cache *t;
1411 for (t = save_expr_cache; t; t = t->next)
1417 t = XOBNEW (&tlist_obstack, struct tlist_cache);
1418 t->next = save_expr_cache;
1420 save_expr_cache = t;
1422 tmp_before = tmp_nosp = 0;
1423 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1424 warn_for_collisions (tmp_nosp);
1429 struct tlist *t = tmp_nosp;
1431 merge_tlist (&tmp_list3, t, 0);
1433 t->cache_before_sp = tmp_before;
1434 t->cache_after_sp = tmp_list3;
1436 merge_tlist (pbefore_sp, t->cache_before_sp, 1);
1437 add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
1442 /* For other expressions, simply recurse on their operands.
1443 Manual tail recursion for unary expressions.
1444 Other non-expressions need not be processed. */
1445 if (cl == tcc_unary)
1447 x = TREE_OPERAND (x, 0);
1451 else if (IS_EXPR_CODE_CLASS (cl))
1454 int max = TREE_CODE_LENGTH (TREE_CODE (x));
1455 for (lp = 0; lp < max; lp++)
1457 tmp_before = tmp_nosp = 0;
1458 verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, 0);
1459 merge_tlist (&tmp_nosp, tmp_before, 0);
1460 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1467 /* Try to warn for undefined behavior in EXPR due to missing sequence
1471 verify_sequence_points (tree expr)
1473 struct tlist *before_sp = 0, *after_sp = 0;
1476 save_expr_cache = 0;
1477 if (tlist_firstobj == 0)
1479 gcc_obstack_init (&tlist_obstack);
1480 tlist_firstobj = (char *) obstack_alloc (&tlist_obstack, 0);
1483 verify_tree (expr, &before_sp, &after_sp, 0);
1484 warn_for_collisions (after_sp);
1485 obstack_free (&tlist_obstack, tlist_firstobj);
1488 /* Validate the expression after `case' and apply default promotions. */
1491 check_case_value (tree value)
1493 if (value == NULL_TREE)
1496 /* ??? Can we ever get nops here for a valid case value? We
1498 STRIP_TYPE_NOPS (value);
1499 /* In C++, the following is allowed:
1502 switch (...) { case i: ... }
1504 So, we try to reduce the VALUE to a constant that way. */
1505 if (c_dialect_cxx ())
1507 value = decl_constant_value (value);
1508 STRIP_TYPE_NOPS (value);
1509 value = fold (value);
1512 if (TREE_CODE (value) == INTEGER_CST)
1513 /* Promote char or short to int. */
1514 value = perform_integral_promotions (value);
1515 else if (value != error_mark_node)
1517 error ("case label does not reduce to an integer constant");
1518 value = error_mark_node;
1521 constant_expression_warning (value);
1526 /* See if the case values LOW and HIGH are in the range of the original
1527 type (i.e. before the default conversion to int) of the switch testing
1529 TYPE is the promoted type of the testing expression, and ORIG_TYPE is
1530 the type before promoting it. CASE_LOW_P is a pointer to the lower
1531 bound of the case label, and CASE_HIGH_P is the upper bound or NULL
1532 if the case is not a case range.
1533 The caller has to make sure that we are not called with NULL for
1534 CASE_LOW_P (i.e. the default case).
1535 Returns true if the case label is in range of ORIG_TYPE (saturated or
1536 untouched) or false if the label is out of range. */
1539 check_case_bounds (tree type, tree orig_type,
1540 tree *case_low_p, tree *case_high_p)
1542 tree min_value, max_value;
1543 tree case_low = *case_low_p;
1544 tree case_high = case_high_p ? *case_high_p : case_low;
1546 /* If there was a problem with the original type, do nothing. */
1547 if (orig_type == error_mark_node)
1550 min_value = TYPE_MIN_VALUE (orig_type);
1551 max_value = TYPE_MAX_VALUE (orig_type);
1553 /* Case label is less than minimum for type. */
1554 if (tree_int_cst_compare (case_low, min_value) < 0
1555 && tree_int_cst_compare (case_high, min_value) < 0)
1557 warning (0, "case label value is less than minimum value for type");
1561 /* Case value is greater than maximum for type. */
1562 if (tree_int_cst_compare (case_low, max_value) > 0
1563 && tree_int_cst_compare (case_high, max_value) > 0)
1565 warning (0, "case label value exceeds maximum value for type");
1569 /* Saturate lower case label value to minimum. */
1570 if (tree_int_cst_compare (case_high, min_value) >= 0
1571 && tree_int_cst_compare (case_low, min_value) < 0)
1573 warning (0, "lower value in case label range"
1574 " less than minimum value for type");
1575 case_low = min_value;
1578 /* Saturate upper case label value to maximum. */
1579 if (tree_int_cst_compare (case_low, max_value) <= 0
1580 && tree_int_cst_compare (case_high, max_value) > 0)
1582 warning (0, "upper value in case label range"
1583 " exceeds maximum value for type");
1584 case_high = max_value;
1587 if (*case_low_p != case_low)
1588 *case_low_p = convert (type, case_low);
1589 if (case_high_p && *case_high_p != case_high)
1590 *case_high_p = convert (type, case_high);
1595 /* Return an integer type with BITS bits of precision,
1596 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1599 c_common_type_for_size (unsigned int bits, int unsignedp)
1601 if (bits == TYPE_PRECISION (integer_type_node))
1602 return unsignedp ? unsigned_type_node : integer_type_node;
1604 if (bits == TYPE_PRECISION (signed_char_type_node))
1605 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1607 if (bits == TYPE_PRECISION (short_integer_type_node))
1608 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1610 if (bits == TYPE_PRECISION (long_integer_type_node))
1611 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1613 if (bits == TYPE_PRECISION (long_long_integer_type_node))
1614 return (unsignedp ? long_long_unsigned_type_node
1615 : long_long_integer_type_node);
1617 if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
1618 return (unsignedp ? widest_unsigned_literal_type_node
1619 : widest_integer_literal_type_node);
1621 if (bits <= TYPE_PRECISION (intQI_type_node))
1622 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1624 if (bits <= TYPE_PRECISION (intHI_type_node))
1625 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1627 if (bits <= TYPE_PRECISION (intSI_type_node))
1628 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1630 if (bits <= TYPE_PRECISION (intDI_type_node))
1631 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1636 /* Used for communication between c_common_type_for_mode and
1637 c_register_builtin_type. */
1638 static GTY(()) tree registered_builtin_types;
1640 /* Return a data type that has machine mode MODE.
1641 If the mode is an integer,
1642 then UNSIGNEDP selects between signed and unsigned types. */
1645 c_common_type_for_mode (enum machine_mode mode, int unsignedp)
1649 if (mode == TYPE_MODE (integer_type_node))
1650 return unsignedp ? unsigned_type_node : integer_type_node;
1652 if (mode == TYPE_MODE (signed_char_type_node))
1653 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1655 if (mode == TYPE_MODE (short_integer_type_node))
1656 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1658 if (mode == TYPE_MODE (long_integer_type_node))
1659 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1661 if (mode == TYPE_MODE (long_long_integer_type_node))
1662 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
1664 if (mode == TYPE_MODE (widest_integer_literal_type_node))
1665 return unsignedp ? widest_unsigned_literal_type_node
1666 : widest_integer_literal_type_node;
1669 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1672 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1675 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1678 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1680 #if HOST_BITS_PER_WIDE_INT >= 64
1681 if (mode == TYPE_MODE (intTI_type_node))
1682 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1685 if (mode == TYPE_MODE (float_type_node))
1686 return float_type_node;
1688 if (mode == TYPE_MODE (double_type_node))
1689 return double_type_node;
1691 if (mode == TYPE_MODE (long_double_type_node))
1692 return long_double_type_node;
1694 if (mode == TYPE_MODE (void_type_node))
1695 return void_type_node;
1697 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
1699 ? make_unsigned_type (GET_MODE_PRECISION (mode))
1700 : make_signed_type (GET_MODE_PRECISION (mode)));
1702 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
1704 ? make_unsigned_type (GET_MODE_PRECISION (mode))
1705 : make_signed_type (GET_MODE_PRECISION (mode)));
1707 if (COMPLEX_MODE_P (mode))
1709 enum machine_mode inner_mode;
1712 if (mode == TYPE_MODE (complex_float_type_node))
1713 return complex_float_type_node;
1714 if (mode == TYPE_MODE (complex_double_type_node))
1715 return complex_double_type_node;
1716 if (mode == TYPE_MODE (complex_long_double_type_node))
1717 return complex_long_double_type_node;
1719 if (mode == TYPE_MODE (complex_integer_type_node) && !unsignedp)
1720 return complex_integer_type_node;
1722 inner_mode = GET_MODE_INNER (mode);
1723 inner_type = c_common_type_for_mode (inner_mode, unsignedp);
1724 if (inner_type != NULL_TREE)
1725 return build_complex_type (inner_type);
1727 else if (VECTOR_MODE_P (mode))
1729 enum machine_mode inner_mode = GET_MODE_INNER (mode);
1730 tree inner_type = c_common_type_for_mode (inner_mode, unsignedp);
1731 if (inner_type != NULL_TREE)
1732 return build_vector_type_for_mode (inner_type, mode);
1735 if (mode == TYPE_MODE (dfloat32_type_node))
1736 return dfloat32_type_node;
1737 if (mode == TYPE_MODE (dfloat64_type_node))
1738 return dfloat64_type_node;
1739 if (mode == TYPE_MODE (dfloat128_type_node))
1740 return dfloat128_type_node;
1742 for (t = registered_builtin_types; t; t = TREE_CHAIN (t))
1743 if (TYPE_MODE (TREE_VALUE (t)) == mode)
1744 return TREE_VALUE (t);
1749 /* Return an unsigned type the same as TYPE in other respects. */
1751 c_common_unsigned_type (tree type)
1753 tree type1 = TYPE_MAIN_VARIANT (type);
1754 if (type1 == signed_char_type_node || type1 == char_type_node)
1755 return unsigned_char_type_node;
1756 if (type1 == integer_type_node)
1757 return unsigned_type_node;
1758 if (type1 == short_integer_type_node)
1759 return short_unsigned_type_node;
1760 if (type1 == long_integer_type_node)
1761 return long_unsigned_type_node;
1762 if (type1 == long_long_integer_type_node)
1763 return long_long_unsigned_type_node;
1764 if (type1 == widest_integer_literal_type_node)
1765 return widest_unsigned_literal_type_node;
1766 #if HOST_BITS_PER_WIDE_INT >= 64
1767 if (type1 == intTI_type_node)
1768 return unsigned_intTI_type_node;
1770 if (type1 == intDI_type_node)
1771 return unsigned_intDI_type_node;
1772 if (type1 == intSI_type_node)
1773 return unsigned_intSI_type_node;
1774 if (type1 == intHI_type_node)
1775 return unsigned_intHI_type_node;
1776 if (type1 == intQI_type_node)
1777 return unsigned_intQI_type_node;
1779 return c_common_signed_or_unsigned_type (1, type);
1782 /* Return a signed type the same as TYPE in other respects. */
1785 c_common_signed_type (tree type)
1787 tree type1 = TYPE_MAIN_VARIANT (type);
1788 if (type1 == unsigned_char_type_node || type1 == char_type_node)
1789 return signed_char_type_node;
1790 if (type1 == unsigned_type_node)
1791 return integer_type_node;
1792 if (type1 == short_unsigned_type_node)
1793 return short_integer_type_node;
1794 if (type1 == long_unsigned_type_node)
1795 return long_integer_type_node;
1796 if (type1 == long_long_unsigned_type_node)
1797 return long_long_integer_type_node;
1798 if (type1 == widest_unsigned_literal_type_node)
1799 return widest_integer_literal_type_node;
1800 #if HOST_BITS_PER_WIDE_INT >= 64
1801 if (type1 == unsigned_intTI_type_node)
1802 return intTI_type_node;
1804 if (type1 == unsigned_intDI_type_node)
1805 return intDI_type_node;
1806 if (type1 == unsigned_intSI_type_node)
1807 return intSI_type_node;
1808 if (type1 == unsigned_intHI_type_node)
1809 return intHI_type_node;
1810 if (type1 == unsigned_intQI_type_node)
1811 return intQI_type_node;
1813 return c_common_signed_or_unsigned_type (0, type);
1816 /* Return a type the same as TYPE except unsigned or
1817 signed according to UNSIGNEDP. */
1820 c_common_signed_or_unsigned_type (int unsignedp, tree type)
1822 if (!INTEGRAL_TYPE_P (type)
1823 || TYPE_UNSIGNED (type) == unsignedp)
1826 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
1827 the precision; they have precision set to match their range, but
1828 may use a wider mode to match an ABI. If we change modes, we may
1829 wind up with bad conversions. For INTEGER_TYPEs in C, must check
1830 the precision as well, so as to yield correct results for
1831 bit-field types. C++ does not have these separate bit-field
1832 types, and producing a signed or unsigned variant of an
1833 ENUMERAL_TYPE may cause other problems as well. */
1835 #define TYPE_OK(node) \
1836 (TYPE_MODE (type) == TYPE_MODE (node) \
1837 && (c_dialect_cxx () || TYPE_PRECISION (type) == TYPE_PRECISION (node)))
1838 if (TYPE_OK (signed_char_type_node))
1839 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1840 if (TYPE_OK (integer_type_node))
1841 return unsignedp ? unsigned_type_node : integer_type_node;
1842 if (TYPE_OK (short_integer_type_node))
1843 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1844 if (TYPE_OK (long_integer_type_node))
1845 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1846 if (TYPE_OK (long_long_integer_type_node))
1847 return (unsignedp ? long_long_unsigned_type_node
1848 : long_long_integer_type_node);
1849 if (TYPE_OK (widest_integer_literal_type_node))
1850 return (unsignedp ? widest_unsigned_literal_type_node
1851 : widest_integer_literal_type_node);
1853 #if HOST_BITS_PER_WIDE_INT >= 64
1854 if (TYPE_OK (intTI_type_node))
1855 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1857 if (TYPE_OK (intDI_type_node))
1858 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1859 if (TYPE_OK (intSI_type_node))
1860 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1861 if (TYPE_OK (intHI_type_node))
1862 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1863 if (TYPE_OK (intQI_type_node))
1864 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1867 if (c_dialect_cxx ())
1870 return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
1873 /* The C version of the register_builtin_type langhook. */
1876 c_register_builtin_type (tree type, const char* name)
1880 decl = build_decl (TYPE_DECL, get_identifier (name), type);
1881 DECL_ARTIFICIAL (decl) = 1;
1882 if (!TYPE_NAME (type))
1883 TYPE_NAME (type) = decl;
1886 registered_builtin_types = tree_cons (0, type, registered_builtin_types);
1890 /* Return the minimum number of bits needed to represent VALUE in a
1891 signed or unsigned type, UNSIGNEDP says which. */
1894 min_precision (tree value, int unsignedp)
1898 /* If the value is negative, compute its negative minus 1. The latter
1899 adjustment is because the absolute value of the largest negative value
1900 is one larger than the largest positive value. This is equivalent to
1901 a bit-wise negation, so use that operation instead. */
1903 if (tree_int_cst_sgn (value) < 0)
1904 value = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (value), value);
1906 /* Return the number of bits needed, taking into account the fact
1907 that we need one more bit for a signed than unsigned type. */
1909 if (integer_zerop (value))
1912 log = tree_floor_log2 (value);
1914 return log + 1 + !unsignedp;
1917 /* Print an error message for invalid operands to arith operation
1921 binary_op_error (enum tree_code code)
1928 opname = "+"; break;
1930 opname = "-"; break;
1932 opname = "*"; break;
1934 opname = "max"; break;
1936 opname = "min"; break;
1938 opname = "=="; break;
1940 opname = "!="; break;
1942 opname = "<="; break;
1944 opname = ">="; break;
1946 opname = "<"; break;
1948 opname = ">"; break;
1950 opname = "<<"; break;
1952 opname = ">>"; break;
1953 case TRUNC_MOD_EXPR:
1954 case FLOOR_MOD_EXPR:
1955 opname = "%"; break;
1956 case TRUNC_DIV_EXPR:
1957 case FLOOR_DIV_EXPR:
1958 opname = "/"; break;
1960 opname = "&"; break;
1962 opname = "|"; break;
1963 case TRUTH_ANDIF_EXPR:
1964 opname = "&&"; break;
1965 case TRUTH_ORIF_EXPR:
1966 opname = "||"; break;
1968 opname = "^"; break;
1972 error ("invalid operands to binary %s", opname);
1975 /* Subroutine of build_binary_op, used for comparison operations.
1976 See if the operands have both been converted from subword integer types
1977 and, if so, perhaps change them both back to their original type.
1978 This function is also responsible for converting the two operands
1979 to the proper common type for comparison.
1981 The arguments of this function are all pointers to local variables
1982 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
1983 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
1985 If this function returns nonzero, it means that the comparison has
1986 a constant value. What this function returns is an expression for
1990 shorten_compare (tree *op0_ptr, tree *op1_ptr, tree *restype_ptr,
1991 enum tree_code *rescode_ptr)
1994 tree op0 = *op0_ptr;
1995 tree op1 = *op1_ptr;
1996 int unsignedp0, unsignedp1;
1998 tree primop0, primop1;
1999 enum tree_code code = *rescode_ptr;
2001 /* Throw away any conversions to wider types
2002 already present in the operands. */
2004 primop0 = get_narrower (op0, &unsignedp0);
2005 primop1 = get_narrower (op1, &unsignedp1);
2007 /* Handle the case that OP0 does not *contain* a conversion
2008 but it *requires* conversion to FINAL_TYPE. */
2010 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
2011 unsignedp0 = TYPE_UNSIGNED (TREE_TYPE (op0));
2012 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
2013 unsignedp1 = TYPE_UNSIGNED (TREE_TYPE (op1));
2015 /* If one of the operands must be floated, we cannot optimize. */
2016 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
2017 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
2019 /* If first arg is constant, swap the args (changing operation
2020 so value is preserved), for canonicalization. Don't do this if
2021 the second arg is 0. */
2023 if (TREE_CONSTANT (primop0)
2024 && !integer_zerop (primop1) && !real_zerop (primop1))
2027 int temi = unsignedp0;
2035 unsignedp0 = unsignedp1;
2058 *rescode_ptr = code;
2061 /* If comparing an integer against a constant more bits wide,
2062 maybe we can deduce a value of 1 or 0 independent of the data.
2063 Or else truncate the constant now
2064 rather than extend the variable at run time.
2066 This is only interesting if the constant is the wider arg.
2067 Also, it is not safe if the constant is unsigned and the
2068 variable arg is signed, since in this case the variable
2069 would be sign-extended and then regarded as unsigned.
2070 Our technique fails in this case because the lowest/highest
2071 possible unsigned results don't follow naturally from the
2072 lowest/highest possible values of the variable operand.
2073 For just EQ_EXPR and NE_EXPR there is another technique that
2074 could be used: see if the constant can be faithfully represented
2075 in the other operand's type, by truncating it and reextending it
2076 and see if that preserves the constant's value. */
2078 if (!real1 && !real2
2079 && TREE_CODE (primop1) == INTEGER_CST
2080 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
2082 int min_gt, max_gt, min_lt, max_lt;
2083 tree maxval, minval;
2084 /* 1 if comparison is nominally unsigned. */
2085 int unsignedp = TYPE_UNSIGNED (*restype_ptr);
2088 type = c_common_signed_or_unsigned_type (unsignedp0,
2089 TREE_TYPE (primop0));
2091 maxval = TYPE_MAX_VALUE (type);
2092 minval = TYPE_MIN_VALUE (type);
2094 if (unsignedp && !unsignedp0)
2095 *restype_ptr = c_common_signed_type (*restype_ptr);
2097 if (TREE_TYPE (primop1) != *restype_ptr)
2099 /* Convert primop1 to target type, but do not introduce
2100 additional overflow. We know primop1 is an int_cst. */
2101 tree tmp = build_int_cst_wide (*restype_ptr,
2102 TREE_INT_CST_LOW (primop1),
2103 TREE_INT_CST_HIGH (primop1));
2105 primop1 = force_fit_type (tmp, 0, TREE_OVERFLOW (primop1),
2106 TREE_CONSTANT_OVERFLOW (primop1));
2108 if (type != *restype_ptr)
2110 minval = convert (*restype_ptr, minval);
2111 maxval = convert (*restype_ptr, maxval);
2114 if (unsignedp && unsignedp0)
2116 min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
2117 max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
2118 min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
2119 max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
2123 min_gt = INT_CST_LT (primop1, minval);
2124 max_gt = INT_CST_LT (primop1, maxval);
2125 min_lt = INT_CST_LT (minval, primop1);
2126 max_lt = INT_CST_LT (maxval, primop1);
2130 /* This used to be a switch, but Genix compiler can't handle that. */
2131 if (code == NE_EXPR)
2133 if (max_lt || min_gt)
2134 val = truthvalue_true_node;
2136 else if (code == EQ_EXPR)
2138 if (max_lt || min_gt)
2139 val = truthvalue_false_node;
2141 else if (code == LT_EXPR)
2144 val = truthvalue_true_node;
2146 val = truthvalue_false_node;
2148 else if (code == GT_EXPR)
2151 val = truthvalue_true_node;
2153 val = truthvalue_false_node;
2155 else if (code == LE_EXPR)
2158 val = truthvalue_true_node;
2160 val = truthvalue_false_node;
2162 else if (code == GE_EXPR)
2165 val = truthvalue_true_node;
2167 val = truthvalue_false_node;
2170 /* If primop0 was sign-extended and unsigned comparison specd,
2171 we did a signed comparison above using the signed type bounds.
2172 But the comparison we output must be unsigned.
2174 Also, for inequalities, VAL is no good; but if the signed
2175 comparison had *any* fixed result, it follows that the
2176 unsigned comparison just tests the sign in reverse
2177 (positive values are LE, negative ones GE).
2178 So we can generate an unsigned comparison
2179 against an extreme value of the signed type. */
2181 if (unsignedp && !unsignedp0)
2188 primop1 = TYPE_MIN_VALUE (type);
2194 primop1 = TYPE_MAX_VALUE (type);
2201 type = c_common_unsigned_type (type);
2204 if (TREE_CODE (primop0) != INTEGER_CST)
2206 if (val == truthvalue_false_node)
2207 warning (0, "comparison is always false due to limited range of data type");
2208 if (val == truthvalue_true_node)
2209 warning (0, "comparison is always true due to limited range of data type");
2214 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2215 if (TREE_SIDE_EFFECTS (primop0))
2216 return build2 (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
2220 /* Value is not predetermined, but do the comparison
2221 in the type of the operand that is not constant.
2222 TYPE is already properly set. */
2225 /* If either arg is decimal float and the other is float, find the
2226 proper common type to use for comparison. */
2227 else if (real1 && real2
2228 && (DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0)))
2229 || DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1)))))
2230 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2232 else if (real1 && real2
2233 && (TYPE_PRECISION (TREE_TYPE (primop0))
2234 == TYPE_PRECISION (TREE_TYPE (primop1))))
2235 type = TREE_TYPE (primop0);
2237 /* If args' natural types are both narrower than nominal type
2238 and both extend in the same manner, compare them
2239 in the type of the wider arg.
2240 Otherwise must actually extend both to the nominal
2241 common type lest different ways of extending
2243 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
2245 else if (unsignedp0 == unsignedp1 && real1 == real2
2246 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
2247 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
2249 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2250 type = c_common_signed_or_unsigned_type (unsignedp0
2251 || TYPE_UNSIGNED (*restype_ptr),
2253 /* Make sure shorter operand is extended the right way
2254 to match the longer operand. */
2256 = convert (c_common_signed_or_unsigned_type (unsignedp0,
2257 TREE_TYPE (primop0)),
2260 = convert (c_common_signed_or_unsigned_type (unsignedp1,
2261 TREE_TYPE (primop1)),
2266 /* Here we must do the comparison on the nominal type
2267 using the args exactly as we received them. */
2268 type = *restype_ptr;
2272 if (!real1 && !real2 && integer_zerop (primop1)
2273 && TYPE_UNSIGNED (*restype_ptr))
2279 /* All unsigned values are >= 0, so we warn if extra warnings
2280 are requested. However, if OP0 is a constant that is
2281 >= 0, the signedness of the comparison isn't an issue,
2282 so suppress the warning. */
2283 if (extra_warnings && !in_system_header
2284 && !(TREE_CODE (primop0) == INTEGER_CST
2285 && !TREE_OVERFLOW (convert (c_common_signed_type (type),
2287 warning (0, "comparison of unsigned expression >= 0 is always true");
2288 value = truthvalue_true_node;
2292 if (extra_warnings && !in_system_header
2293 && !(TREE_CODE (primop0) == INTEGER_CST
2294 && !TREE_OVERFLOW (convert (c_common_signed_type (type),
2296 warning (0, "comparison of unsigned expression < 0 is always false");
2297 value = truthvalue_false_node;
2306 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2307 if (TREE_SIDE_EFFECTS (primop0))
2308 return build2 (COMPOUND_EXPR, TREE_TYPE (value),
2315 *op0_ptr = convert (type, primop0);
2316 *op1_ptr = convert (type, primop1);
2318 *restype_ptr = truthvalue_type_node;
2323 /* Return a tree for the sum or difference (RESULTCODE says which)
2324 of pointer PTROP and integer INTOP. */
2327 pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
2331 /* The result is a pointer of the same type that is being added. */
2333 tree result_type = TREE_TYPE (ptrop);
2335 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
2337 if (pedantic || warn_pointer_arith)
2338 pedwarn ("pointer of type %<void *%> used in arithmetic");
2339 size_exp = integer_one_node;
2341 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
2343 if (pedantic || warn_pointer_arith)
2344 pedwarn ("pointer to a function used in arithmetic");
2345 size_exp = integer_one_node;
2347 else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
2349 if (pedantic || warn_pointer_arith)
2350 pedwarn ("pointer to member function used in arithmetic");
2351 size_exp = integer_one_node;
2354 size_exp = size_in_bytes (TREE_TYPE (result_type));
2356 /* If what we are about to multiply by the size of the elements
2357 contains a constant term, apply distributive law
2358 and multiply that constant term separately.
2359 This helps produce common subexpressions. */
2361 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
2362 && !TREE_CONSTANT (intop)
2363 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
2364 && TREE_CONSTANT (size_exp)
2365 /* If the constant comes from pointer subtraction,
2366 skip this optimization--it would cause an error. */
2367 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
2368 /* If the constant is unsigned, and smaller than the pointer size,
2369 then we must skip this optimization. This is because it could cause
2370 an overflow error if the constant is negative but INTOP is not. */
2371 && (!TYPE_UNSIGNED (TREE_TYPE (intop))
2372 || (TYPE_PRECISION (TREE_TYPE (intop))
2373 == TYPE_PRECISION (TREE_TYPE (ptrop)))))
2375 enum tree_code subcode = resultcode;
2376 tree int_type = TREE_TYPE (intop);
2377 if (TREE_CODE (intop) == MINUS_EXPR)
2378 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
2379 /* Convert both subexpression types to the type of intop,
2380 because weird cases involving pointer arithmetic
2381 can result in a sum or difference with different type args. */
2382 ptrop = build_binary_op (subcode, ptrop,
2383 convert (int_type, TREE_OPERAND (intop, 1)), 1);
2384 intop = convert (int_type, TREE_OPERAND (intop, 0));
2387 /* Convert the integer argument to a type the same size as sizetype
2388 so the multiply won't overflow spuriously. */
2390 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
2391 || TYPE_UNSIGNED (TREE_TYPE (intop)) != TYPE_UNSIGNED (sizetype))
2392 intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
2393 TYPE_UNSIGNED (sizetype)), intop);
2395 /* Replace the integer argument with a suitable product by the object size.
2396 Do this multiplication as signed, then convert to the appropriate
2397 pointer type (actually unsigned integral). */
2399 intop = convert (result_type,
2400 build_binary_op (MULT_EXPR, intop,
2401 convert (TREE_TYPE (intop), size_exp), 1));
2403 /* Create the sum or difference. */
2404 return fold_build2 (resultcode, result_type, ptrop, intop);
2407 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2408 or for an `if' or `while' statement or ?..: exp. It should already
2409 have been validated to be of suitable type; otherwise, a bad
2410 diagnostic may result.
2412 This preparation consists of taking the ordinary
2413 representation of an expression expr and producing a valid tree
2414 boolean expression describing whether expr is nonzero. We could
2415 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
2416 but we optimize comparisons, &&, ||, and !.
2418 The resulting type should always be `truthvalue_type_node'. */
2421 c_common_truthvalue_conversion (tree expr)
2423 switch (TREE_CODE (expr))
2425 case EQ_EXPR: case NE_EXPR: case UNEQ_EXPR: case LTGT_EXPR:
2426 case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
2427 case UNLE_EXPR: case UNGE_EXPR: case UNLT_EXPR: case UNGT_EXPR:
2428 case ORDERED_EXPR: case UNORDERED_EXPR:
2429 if (TREE_TYPE (expr) == truthvalue_type_node)
2431 return build2 (TREE_CODE (expr), truthvalue_type_node,
2432 TREE_OPERAND (expr, 0), TREE_OPERAND (expr, 1));
2434 case TRUTH_ANDIF_EXPR:
2435 case TRUTH_ORIF_EXPR:
2436 case TRUTH_AND_EXPR:
2438 case TRUTH_XOR_EXPR:
2439 if (TREE_TYPE (expr) == truthvalue_type_node)
2441 return build2 (TREE_CODE (expr), truthvalue_type_node,
2442 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)),
2443 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)));
2445 case TRUTH_NOT_EXPR:
2446 if (TREE_TYPE (expr) == truthvalue_type_node)
2448 return build1 (TREE_CODE (expr), truthvalue_type_node,
2449 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)));
2455 /* Avoid integer_zerop to ignore TREE_CONSTANT_OVERFLOW. */
2456 return (TREE_INT_CST_LOW (expr) != 0 || TREE_INT_CST_HIGH (expr) != 0)
2457 ? truthvalue_true_node
2458 : truthvalue_false_node;
2461 return real_compare (NE_EXPR, &TREE_REAL_CST (expr), &dconst0)
2462 ? truthvalue_true_node
2463 : truthvalue_false_node;
2466 expr = build_unary_op (ADDR_EXPR, expr, 0);
2471 tree inner = TREE_OPERAND (expr, 0);
2473 && (TREE_CODE (inner) == PARM_DECL || !DECL_WEAK (inner)))
2475 /* Common Ada/Pascal programmer's mistake. We always warn
2476 about this since it is so bad. */
2477 warning (OPT_Walways_true, "the address of %qD, will always evaluate as %<true%>",
2479 return truthvalue_true_node;
2482 /* If we are taking the address of an external decl, it might be
2483 zero if it is weak, so we cannot optimize. */
2485 && DECL_EXTERNAL (inner))
2488 if (TREE_SIDE_EFFECTS (inner))
2489 return build2 (COMPOUND_EXPR, truthvalue_type_node,
2490 inner, truthvalue_true_node);
2492 return truthvalue_true_node;
2496 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
2497 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2498 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)),
2499 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2505 /* These don't change whether an object is nonzero or zero. */
2506 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2510 /* These don't change whether an object is zero or nonzero, but
2511 we can't ignore them if their second arg has side-effects. */
2512 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2513 return build2 (COMPOUND_EXPR, truthvalue_type_node,
2514 TREE_OPERAND (expr, 1),
2515 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)));
2517 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2520 /* Distribute the conversion into the arms of a COND_EXPR. */
2521 return fold_build3 (COND_EXPR, truthvalue_type_node,
2522 TREE_OPERAND (expr, 0),
2523 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2524 c_common_truthvalue_conversion (TREE_OPERAND (expr, 2)));
2528 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2529 since that affects how `default_conversion' will behave. */
2530 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
2531 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2533 /* If this is widening the argument, we can ignore it. */
2534 if (TYPE_PRECISION (TREE_TYPE (expr))
2535 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2536 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2540 /* Perhaps reduce (x - y) != 0 to (x != y). The expressions
2541 aren't guaranteed to the be same for modes that can represent
2542 infinity, since if x and y are both +infinity, or both
2543 -infinity, then x - y is not a number.
2545 Note that this transformation is safe when x or y is NaN.
2546 (x - y) is then NaN, and both (x - y) != 0 and x != y will
2548 if (HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr, 0)))))
2550 /* Fall through.... */
2552 /* This and MINUS_EXPR can be changed into a comparison of the
2554 if (TREE_TYPE (TREE_OPERAND (expr, 0))
2555 == TREE_TYPE (TREE_OPERAND (expr, 1)))
2556 return fold_build2 (NE_EXPR, truthvalue_type_node,
2557 TREE_OPERAND (expr, 0), TREE_OPERAND (expr, 1));
2558 return fold_build2 (NE_EXPR, truthvalue_type_node,
2559 TREE_OPERAND (expr, 0),
2560 fold_convert (TREE_TYPE (TREE_OPERAND (expr, 0)),
2561 TREE_OPERAND (expr, 1)));
2564 if (integer_onep (TREE_OPERAND (expr, 1))
2565 && TREE_TYPE (expr) != truthvalue_type_node)
2566 /* Using convert here would cause infinite recursion. */
2567 return build1 (NOP_EXPR, truthvalue_type_node, expr);
2571 if (!TREE_NO_WARNING (expr))
2572 warning (OPT_Wparentheses,
2573 "suggest parentheses around assignment used as truth value");
2580 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
2582 tree t = save_expr (expr);
2583 return (build_binary_op
2584 ((TREE_SIDE_EFFECTS (expr)
2585 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2586 c_common_truthvalue_conversion (build_unary_op (REALPART_EXPR, t, 0)),
2587 c_common_truthvalue_conversion (build_unary_op (IMAGPART_EXPR, t, 0)),
2591 return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
2594 static void def_builtin_1 (enum built_in_function fncode,
2596 enum built_in_class fnclass,
2597 tree fntype, tree libtype,
2598 bool both_p, bool fallback_p, bool nonansi_p,
2599 tree fnattrs, bool implicit_p);
2601 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2602 down to the element type of an array. */
2605 c_build_qualified_type (tree type, int type_quals)
2607 if (type == error_mark_node)
2610 if (TREE_CODE (type) == ARRAY_TYPE)
2613 tree element_type = c_build_qualified_type (TREE_TYPE (type),
2616 /* See if we already have an identically qualified type. */
2617 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
2619 if (TYPE_QUALS (strip_array_types (t)) == type_quals
2620 && TYPE_NAME (t) == TYPE_NAME (type)
2621 && TYPE_CONTEXT (t) == TYPE_CONTEXT (type)
2622 && attribute_list_equal (TYPE_ATTRIBUTES (t),
2623 TYPE_ATTRIBUTES (type)))
2628 t = build_variant_type_copy (type);
2629 TREE_TYPE (t) = element_type;
2634 /* A restrict-qualified pointer type must be a pointer to object or
2635 incomplete type. Note that the use of POINTER_TYPE_P also allows
2636 REFERENCE_TYPEs, which is appropriate for C++. */
2637 if ((type_quals & TYPE_QUAL_RESTRICT)
2638 && (!POINTER_TYPE_P (type)
2639 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
2641 error ("invalid use of %<restrict%>");
2642 type_quals &= ~TYPE_QUAL_RESTRICT;
2645 return build_qualified_type (type, type_quals);
2648 /* Apply the TYPE_QUALS to the new DECL. */
2651 c_apply_type_quals_to_decl (int type_quals, tree decl)
2653 tree type = TREE_TYPE (decl);
2655 if (type == error_mark_node)
2658 if (((type_quals & TYPE_QUAL_CONST)
2659 || (type && TREE_CODE (type) == REFERENCE_TYPE))
2660 /* An object declared 'const' is only readonly after it is
2661 initialized. We don't have any way of expressing this currently,
2662 so we need to be conservative and unset TREE_READONLY for types
2663 with constructors. Otherwise aliasing code will ignore stores in
2664 an inline constructor. */
2665 && !(type && TYPE_NEEDS_CONSTRUCTING (type)))
2666 TREE_READONLY (decl) = 1;
2667 if (type_quals & TYPE_QUAL_VOLATILE)
2669 TREE_SIDE_EFFECTS (decl) = 1;
2670 TREE_THIS_VOLATILE (decl) = 1;
2672 if (type_quals & TYPE_QUAL_RESTRICT)
2674 while (type && TREE_CODE (type) == ARRAY_TYPE)
2675 /* Allow 'restrict' on arrays of pointers.
2676 FIXME currently we just ignore it. */
2677 type = TREE_TYPE (type);
2679 || !POINTER_TYPE_P (type)
2680 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type)))
2681 error ("invalid use of %<restrict%>");
2682 else if (flag_strict_aliasing && type == TREE_TYPE (decl))
2683 /* Indicate we need to make a unique alias set for this pointer.
2684 We can't do it here because it might be pointing to an
2686 DECL_POINTER_ALIAS_SET (decl) = -2;
2690 /* Hash function for the problem of multiple type definitions in
2691 different files. This must hash all types that will compare
2692 equal via comptypes to the same value. In practice it hashes
2693 on some of the simple stuff and leaves the details to comptypes. */
2696 c_type_hash (const void *p)
2702 switch (TREE_CODE (t))
2704 /* For pointers, hash on pointee type plus some swizzling. */
2706 return c_type_hash (TREE_TYPE (t)) ^ 0x3003003;
2707 /* Hash on number of elements and total size. */
2710 t2 = TYPE_VALUES (t);
2714 t2 = TYPE_FIELDS (t);
2716 case QUAL_UNION_TYPE:
2718 t2 = TYPE_FIELDS (t);
2722 t2 = TYPE_FIELDS (t);
2727 for (; t2; t2 = TREE_CHAIN (t2))
2729 size = TREE_INT_CST_LOW (TYPE_SIZE (t));
2730 return ((size << 24) | (i << shift));
2733 static GTY((param_is (union tree_node))) htab_t type_hash_table;
2735 /* Return the typed-based alias set for T, which may be an expression
2736 or a type. Return -1 if we don't do anything special. */
2739 c_common_get_alias_set (tree t)
2744 /* Permit type-punning when accessing a union, provided the access
2745 is directly through the union. For example, this code does not
2746 permit taking the address of a union member and then storing
2747 through it. Even the type-punning allowed here is a GCC
2748 extension, albeit a common and useful one; the C standard says
2749 that such accesses have implementation-defined behavior. */
2751 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
2752 u = TREE_OPERAND (u, 0))
2753 if (TREE_CODE (u) == COMPONENT_REF
2754 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
2757 /* That's all the expressions we handle specially. */
2761 /* The C standard guarantees that any object may be accessed via an
2762 lvalue that has character type. */
2763 if (t == char_type_node
2764 || t == signed_char_type_node
2765 || t == unsigned_char_type_node)
2768 /* If it has the may_alias attribute, it can alias anything. */
2769 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (t)))
2772 /* The C standard specifically allows aliasing between signed and
2773 unsigned variants of the same type. We treat the signed
2774 variant as canonical. */
2775 if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
2777 tree t1 = c_common_signed_type (t);
2779 /* t1 == t can happen for boolean nodes which are always unsigned. */
2781 return get_alias_set (t1);
2783 else if (POINTER_TYPE_P (t))
2787 /* Unfortunately, there is no canonical form of a pointer type.
2788 In particular, if we have `typedef int I', then `int *', and
2789 `I *' are different types. So, we have to pick a canonical
2790 representative. We do this below.
2792 Technically, this approach is actually more conservative that
2793 it needs to be. In particular, `const int *' and `int *'
2794 should be in different alias sets, according to the C and C++
2795 standard, since their types are not the same, and so,
2796 technically, an `int **' and `const int **' cannot point at
2799 But, the standard is wrong. In particular, this code is
2804 const int* const* cipp = ipp;
2806 And, it doesn't make sense for that to be legal unless you
2807 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
2808 the pointed-to types. This issue has been reported to the
2810 t1 = build_type_no_quals (t);
2812 return get_alias_set (t1);
2815 /* Handle the case of multiple type nodes referring to "the same" type,
2816 which occurs with IMA. These share an alias set. FIXME: Currently only
2817 C90 is handled. (In C99 type compatibility is not transitive, which
2818 complicates things mightily. The alias set splay trees can theoretically
2819 represent this, but insertion is tricky when you consider all the
2820 different orders things might arrive in.) */
2822 if (c_language != clk_c || flag_isoc99)
2825 /* Save time if there's only one input file. */
2826 if (num_in_fnames == 1)
2829 /* Pointers need special handling if they point to any type that
2830 needs special handling (below). */
2831 if (TREE_CODE (t) == POINTER_TYPE)
2834 /* Find bottom type under any nested POINTERs. */
2835 for (t2 = TREE_TYPE (t);
2836 TREE_CODE (t2) == POINTER_TYPE;
2837 t2 = TREE_TYPE (t2))
2839 if (TREE_CODE (t2) != RECORD_TYPE
2840 && TREE_CODE (t2) != ENUMERAL_TYPE
2841 && TREE_CODE (t2) != QUAL_UNION_TYPE
2842 && TREE_CODE (t2) != UNION_TYPE)
2844 if (TYPE_SIZE (t2) == 0)
2847 /* These are the only cases that need special handling. */
2848 if (TREE_CODE (t) != RECORD_TYPE
2849 && TREE_CODE (t) != ENUMERAL_TYPE
2850 && TREE_CODE (t) != QUAL_UNION_TYPE
2851 && TREE_CODE (t) != UNION_TYPE
2852 && TREE_CODE (t) != POINTER_TYPE)
2855 if (TYPE_SIZE (t) == 0)
2858 /* Look up t in hash table. Only one of the compatible types within each
2859 alias set is recorded in the table. */
2860 if (!type_hash_table)
2861 type_hash_table = htab_create_ggc (1021, c_type_hash,
2862 (htab_eq) lang_hooks.types_compatible_p,
2864 slot = htab_find_slot (type_hash_table, t, INSERT);
2867 TYPE_ALIAS_SET (t) = TYPE_ALIAS_SET ((tree)*slot);
2868 return TYPE_ALIAS_SET ((tree)*slot);
2871 /* Our caller will assign and record (in t) a new alias set; all we need
2872 to do is remember t in the hash table. */
2878 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
2879 second parameter indicates which OPERATOR is being applied. The COMPLAIN
2880 flag controls whether we should diagnose possibly ill-formed
2881 constructs or not. */
2884 c_sizeof_or_alignof_type (tree type, bool is_sizeof, int complain)
2886 const char *op_name;
2888 enum tree_code type_code = TREE_CODE (type);
2890 op_name = is_sizeof ? "sizeof" : "__alignof__";
2892 if (type_code == FUNCTION_TYPE)
2896 if (complain && (pedantic || warn_pointer_arith))
2897 pedwarn ("invalid application of %<sizeof%> to a function type");
2898 value = size_one_node;
2901 value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
2903 else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
2905 if (type_code == VOID_TYPE
2906 && complain && (pedantic || warn_pointer_arith))
2907 pedwarn ("invalid application of %qs to a void type", op_name);
2908 value = size_one_node;
2910 else if (!COMPLETE_TYPE_P (type))
2913 error ("invalid application of %qs to incomplete type %qT ",
2915 value = size_zero_node;
2920 /* Convert in case a char is more than one unit. */
2921 value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
2922 size_int (TYPE_PRECISION (char_type_node)
2925 value = size_int (TYPE_ALIGN_UNIT (type));
2928 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
2929 TYPE_IS_SIZETYPE means that certain things (like overflow) will
2930 never happen. However, this node should really have type
2931 `size_t', which is just a typedef for an ordinary integer type. */
2932 value = fold_convert (size_type_node, value);
2933 gcc_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)));
2938 /* Implement the __alignof keyword: Return the minimum required
2939 alignment of EXPR, measured in bytes. For VAR_DECL's and
2940 FIELD_DECL's return DECL_ALIGN (which can be set from an
2941 "aligned" __attribute__ specification). */
2944 c_alignof_expr (tree expr)
2948 if (TREE_CODE (expr) == VAR_DECL)
2949 t = size_int (DECL_ALIGN_UNIT (expr));
2951 else if (TREE_CODE (expr) == COMPONENT_REF
2952 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
2954 error ("%<__alignof%> applied to a bit-field");
2957 else if (TREE_CODE (expr) == COMPONENT_REF
2958 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
2959 t = size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr, 1)));
2961 else if (TREE_CODE (expr) == INDIRECT_REF)
2963 tree t = TREE_OPERAND (expr, 0);
2965 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
2967 while ((TREE_CODE (t) == NOP_EXPR || TREE_CODE (t) == CONVERT_EXPR)
2968 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
2972 t = TREE_OPERAND (t, 0);
2973 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
2974 if (thisalign > bestalign)
2975 best = t, bestalign = thisalign;
2977 return c_alignof (TREE_TYPE (TREE_TYPE (best)));
2980 return c_alignof (TREE_TYPE (expr));
2982 return fold_convert (size_type_node, t);
2985 /* Handle C and C++ default attributes. */
2987 enum built_in_attribute
2989 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
2990 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
2991 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
2992 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
2993 #include "builtin-attrs.def"
2994 #undef DEF_ATTR_NULL_TREE
2996 #undef DEF_ATTR_IDENT
2997 #undef DEF_ATTR_TREE_LIST
3001 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
3003 static void c_init_attributes (void);
3007 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
3008 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
3009 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
3010 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
3011 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3012 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3013 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
3014 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME,
3015 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME,
3016 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
3017 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
3018 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
3019 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3020 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3021 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
3023 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
3024 #include "builtin-types.def"
3025 #undef DEF_PRIMITIVE_TYPE
3026 #undef DEF_FUNCTION_TYPE_0
3027 #undef DEF_FUNCTION_TYPE_1
3028 #undef DEF_FUNCTION_TYPE_2
3029 #undef DEF_FUNCTION_TYPE_3
3030 #undef DEF_FUNCTION_TYPE_4
3031 #undef DEF_FUNCTION_TYPE_5
3032 #undef DEF_FUNCTION_TYPE_6
3033 #undef DEF_FUNCTION_TYPE_7
3034 #undef DEF_FUNCTION_TYPE_VAR_0
3035 #undef DEF_FUNCTION_TYPE_VAR_1
3036 #undef DEF_FUNCTION_TYPE_VAR_2
3037 #undef DEF_FUNCTION_TYPE_VAR_3
3038 #undef DEF_FUNCTION_TYPE_VAR_4
3039 #undef DEF_FUNCTION_TYPE_VAR_5
3040 #undef DEF_POINTER_TYPE
3044 typedef enum c_builtin_type builtin_type;
3046 /* A temporary array for c_common_nodes_and_builtins. Used in
3047 communication with def_fn_type. */
3048 static tree builtin_types[(int) BT_LAST + 1];
3050 /* A helper function for c_common_nodes_and_builtins. Build function type
3051 for DEF with return type RET and N arguments. If VAR is true, then the
3052 function should be variadic after those N arguments.
3054 Takes special care not to ICE if any of the types involved are
3055 error_mark_node, which indicates that said type is not in fact available
3056 (see builtin_type_for_size). In which case the function type as a whole
3057 should be error_mark_node. */
3060 def_fn_type (builtin_type def, builtin_type ret, bool var, int n, ...)
3062 tree args = NULL, t;
3067 for (i = 0; i < n; ++i)
3069 builtin_type a = va_arg (list, builtin_type);
3070 t = builtin_types[a];
3071 if (t == error_mark_node)
3073 args = tree_cons (NULL_TREE, t, args);
3077 args = nreverse (args);
3079 args = chainon (args, void_list_node);
3081 t = builtin_types[ret];
3082 if (t == error_mark_node)
3084 t = build_function_type (t, args);
3087 builtin_types[def] = t;
3090 /* Build tree nodes and builtin functions common to both C and C++ language
3094 c_common_nodes_and_builtins (void)
3096 int wchar_type_size;
3097 tree array_domain_type;
3098 tree va_list_ref_type_node;
3099 tree va_list_arg_type_node;
3101 /* Define `int' and `char' first so that dbx will output them first. */
3102 record_builtin_type (RID_INT, NULL, integer_type_node);
3103 record_builtin_type (RID_CHAR, "char", char_type_node);
3105 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
3106 "unsigned long", "long long unsigned" and "unsigned short" were in C++
3107 but not C. Are the conditionals here needed? */
3108 if (c_dialect_cxx ())
3109 record_builtin_type (RID_SIGNED, NULL, integer_type_node);
3110 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
3111 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
3112 record_builtin_type (RID_MAX, "long unsigned int",
3113 long_unsigned_type_node);
3114 if (c_dialect_cxx ())
3115 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
3116 record_builtin_type (RID_MAX, "long long int",
3117 long_long_integer_type_node);
3118 record_builtin_type (RID_MAX, "long long unsigned int",
3119 long_long_unsigned_type_node);
3120 if (c_dialect_cxx ())
3121 record_builtin_type (RID_MAX, "long long unsigned",
3122 long_long_unsigned_type_node);
3123 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
3124 record_builtin_type (RID_MAX, "short unsigned int",
3125 short_unsigned_type_node);
3126 if (c_dialect_cxx ())
3127 record_builtin_type (RID_MAX, "unsigned short",
3128 short_unsigned_type_node);
3130 /* Define both `signed char' and `unsigned char'. */
3131 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
3132 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
3134 /* These are types that c_common_type_for_size and
3135 c_common_type_for_mode use. */
3136 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3138 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3140 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3142 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3144 #if HOST_BITS_PER_WIDE_INT >= 64
3145 if (targetm.scalar_mode_supported_p (TImode))
3146 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3147 get_identifier ("__int128_t"),
3150 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3151 unsigned_intQI_type_node));
3152 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3153 unsigned_intHI_type_node));
3154 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3155 unsigned_intSI_type_node));
3156 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3157 unsigned_intDI_type_node));
3158 #if HOST_BITS_PER_WIDE_INT >= 64
3159 if (targetm.scalar_mode_supported_p (TImode))
3160 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3161 get_identifier ("__uint128_t"),
3162 unsigned_intTI_type_node));
3165 /* Create the widest literal types. */
3166 widest_integer_literal_type_node
3167 = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
3168 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3169 widest_integer_literal_type_node));
3171 widest_unsigned_literal_type_node
3172 = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
3173 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3174 widest_unsigned_literal_type_node));
3176 /* `unsigned long' is the standard type for sizeof.
3177 Note that stddef.h uses `unsigned long',
3178 and this must agree, even if long and int are the same size. */
3180 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
3181 signed_size_type_node = c_common_signed_type (size_type_node);
3182 set_sizetype (size_type_node);
3185 TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE)));
3187 build_common_tree_nodes_2 (flag_short_double);
3189 record_builtin_type (RID_FLOAT, NULL, float_type_node);
3190 record_builtin_type (RID_DOUBLE, NULL, double_type_node);
3191 record_builtin_type (RID_MAX, "long double", long_double_type_node);
3193 /* Only supported decimal floating point extension if the target
3194 actually supports underlying modes. */
3195 if (targetm.scalar_mode_supported_p (SDmode)
3196 && targetm.scalar_mode_supported_p (DDmode)
3197 && targetm.scalar_mode_supported_p (TDmode))
3199 record_builtin_type (RID_DFLOAT32, NULL, dfloat32_type_node);
3200 record_builtin_type (RID_DFLOAT64, NULL, dfloat64_type_node);
3201 record_builtin_type (RID_DFLOAT128, NULL, dfloat128_type_node);
3204 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3205 get_identifier ("complex int"),
3206 complex_integer_type_node));
3207 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3208 get_identifier ("complex float"),
3209 complex_float_type_node));
3210 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3211 get_identifier ("complex double"),
3212 complex_double_type_node));
3213 lang_hooks.decls.pushdecl
3214 (build_decl (TYPE_DECL, get_identifier ("complex long double"),
3215 complex_long_double_type_node));
3217 if (c_dialect_cxx ())
3218 /* For C++, make fileptr_type_node a distinct void * type until
3219 FILE type is defined. */
3220 fileptr_type_node = build_variant_type_copy (ptr_type_node);
3222 record_builtin_type (RID_VOID, NULL, void_type_node);
3224 /* This node must not be shared. */
3225 void_zero_node = make_node (INTEGER_CST);
3226 TREE_TYPE (void_zero_node) = void_type_node;
3228 void_list_node = build_void_list_node ();
3230 /* Make a type to be the domain of a few array types
3231 whose domains don't really matter.
3232 200 is small enough that it always fits in size_t
3233 and large enough that it can hold most function names for the
3234 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
3235 array_domain_type = build_index_type (size_int (200));
3237 /* Make a type for arrays of characters.
3238 With luck nothing will ever really depend on the length of this
3240 char_array_type_node
3241 = build_array_type (char_type_node, array_domain_type);
3243 /* Likewise for arrays of ints. */
3245 = build_array_type (integer_type_node, array_domain_type);
3247 string_type_node = build_pointer_type (char_type_node);
3248 const_string_type_node
3249 = build_pointer_type (build_qualified_type
3250 (char_type_node, TYPE_QUAL_CONST));
3252 /* This is special for C++ so functions can be overloaded. */
3253 wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
3254 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
3255 wchar_type_size = TYPE_PRECISION (wchar_type_node);
3256 if (c_dialect_cxx ())
3258 if (TYPE_UNSIGNED (wchar_type_node))
3259 wchar_type_node = make_unsigned_type (wchar_type_size);
3261 wchar_type_node = make_signed_type (wchar_type_size);
3262 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
3266 signed_wchar_type_node = c_common_signed_type (wchar_type_node);
3267 unsigned_wchar_type_node = c_common_unsigned_type (wchar_type_node);
3270 /* This is for wide string constants. */
3271 wchar_array_type_node
3272 = build_array_type (wchar_type_node, array_domain_type);
3275 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
3278 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
3280 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
3282 default_function_type = build_function_type (integer_type_node, NULL_TREE);
3284 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
3285 unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
3287 lang_hooks.decls.pushdecl
3288 (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
3289 va_list_type_node));
3291 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
3293 va_list_arg_type_node = va_list_ref_type_node =
3294 build_pointer_type (TREE_TYPE (va_list_type_node));
3298 va_list_arg_type_node = va_list_type_node;
3299 va_list_ref_type_node = build_reference_type (va_list_type_node);
3302 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3303 builtin_types[ENUM] = VALUE;
3304 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
3305 def_fn_type (ENUM, RETURN, 0, 0);
3306 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
3307 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
3308 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
3309 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
3310 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3311 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
3312 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3313 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
3314 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
3315 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
3316 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3318 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
3319 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3321 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
3322 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
3323 def_fn_type (ENUM, RETURN, 1, 0);
3324 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
3325 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
3326 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
3327 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
3328 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3329 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
3330 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3331 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
3332 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
3333 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
3334 #define DEF_POINTER_TYPE(ENUM, TYPE) \
3335 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
3337 #include "builtin-types.def"
3339 #undef DEF_PRIMITIVE_TYPE
3340 #undef DEF_FUNCTION_TYPE_1
3341 #undef DEF_FUNCTION_TYPE_2
3342 #undef DEF_FUNCTION_TYPE_3
3343 #undef DEF_FUNCTION_TYPE_4
3344 #undef DEF_FUNCTION_TYPE_5
3345 #undef DEF_FUNCTION_TYPE_6
3346 #undef DEF_FUNCTION_TYPE_VAR_0
3347 #undef DEF_FUNCTION_TYPE_VAR_1
3348 #undef DEF_FUNCTION_TYPE_VAR_2
3349 #undef DEF_FUNCTION_TYPE_VAR_3
3350 #undef DEF_FUNCTION_TYPE_VAR_4
3351 #undef DEF_FUNCTION_TYPE_VAR_5
3352 #undef DEF_POINTER_TYPE
3353 builtin_types[(int) BT_LAST] = NULL_TREE;
3355 c_init_attributes ();
3357 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
3358 NONANSI_P, ATTRS, IMPLICIT, COND) \
3360 def_builtin_1 (ENUM, NAME, CLASS, \
3361 builtin_types[(int) TYPE], \
3362 builtin_types[(int) LIBTYPE], \
3363 BOTH_P, FALLBACK_P, NONANSI_P, \
3364 built_in_attributes[(int) ATTRS], IMPLICIT);
3365 #include "builtins.def"
3368 build_common_builtin_nodes ();
3370 targetm.init_builtins ();
3374 main_identifier_node = get_identifier ("main");
3376 /* Create the built-in __null node. It is important that this is
3378 null_node = make_node (INTEGER_CST);
3379 TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0);
3381 /* Since builtin_types isn't gc'ed, don't export these nodes. */
3382 memset (builtin_types, 0, sizeof (builtin_types));
3385 /* Look up the function in built_in_decls that corresponds to DECL
3386 and set ASMSPEC as its user assembler name. DECL must be a
3387 function decl that declares a builtin. */
3390 set_builtin_user_assembler_name (tree decl, const char *asmspec)
3393 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
3394 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
3397 builtin = built_in_decls [DECL_FUNCTION_CODE (decl)];
3398 set_user_assembler_name (builtin, asmspec);
3399 if (DECL_FUNCTION_CODE (decl) == BUILT_IN_MEMCPY)
3400 init_block_move_fn (asmspec);
3401 else if (DECL_FUNCTION_CODE (decl) == BUILT_IN_MEMSET)
3402 init_block_clear_fn (asmspec);
3405 /* The number of named compound-literals generated thus far. */
3406 static GTY(()) int compound_literal_number;
3408 /* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal. */
3411 set_compound_literal_name (tree decl)
3414 ASM_FORMAT_PRIVATE_NAME (name, "__compound_literal",
3415 compound_literal_number);
3416 compound_literal_number++;
3417 DECL_NAME (decl) = get_identifier (name);
3421 build_va_arg (tree expr, tree type)
3423 return build1 (VA_ARG_EXPR, type, expr);
3427 /* Linked list of disabled built-in functions. */
3429 typedef struct disabled_builtin
3432 struct disabled_builtin *next;
3434 static disabled_builtin *disabled_builtins = NULL;
3436 static bool builtin_function_disabled_p (const char *);
3438 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
3439 begins with "__builtin_", give an error. */
3442 disable_builtin_function (const char *name)
3444 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
3445 error ("cannot disable built-in function %qs", name);
3448 disabled_builtin *new_disabled_builtin = XNEW (disabled_builtin);
3449 new_disabled_builtin->name = name;
3450 new_disabled_builtin->next = disabled_builtins;
3451 disabled_builtins = new_disabled_builtin;
3456 /* Return true if the built-in function NAME has been disabled, false
3460 builtin_function_disabled_p (const char *name)
3462 disabled_builtin *p;
3463 for (p = disabled_builtins; p != NULL; p = p->next)
3465 if (strcmp (name, p->name) == 0)
3472 /* Worker for DEF_BUILTIN.
3473 Possibly define a builtin function with one or two names.
3474 Does not declare a non-__builtin_ function if flag_no_builtin, or if
3475 nonansi_p and flag_no_nonansi_builtin. */
3478 def_builtin_1 (enum built_in_function fncode,
3480 enum built_in_class fnclass,
3481 tree fntype, tree libtype,
3482 bool both_p, bool fallback_p, bool nonansi_p,
3483 tree fnattrs, bool implicit_p)
3486 const char *libname;
3488 if (fntype == error_mark_node)
3491 gcc_assert ((!both_p && !fallback_p)
3492 || !strncmp (name, "__builtin_",
3493 strlen ("__builtin_")));
3495 libname = name + strlen ("__builtin_");
3496 decl = lang_hooks.builtin_function (name, fntype, fncode, fnclass,
3497 (fallback_p ? libname : NULL),
3500 && !flag_no_builtin && !builtin_function_disabled_p (libname)
3501 && !(nonansi_p && flag_no_nonansi_builtin))
3502 lang_hooks.builtin_function (libname, libtype, fncode, fnclass,
3505 built_in_decls[(int) fncode] = decl;
3507 implicit_built_in_decls[(int) fncode] = decl;
3510 /* Nonzero if the type T promotes to int. This is (nearly) the
3511 integral promotions defined in ISO C99 6.3.1.1/2. */
3514 c_promoting_integer_type_p (tree t)
3516 switch (TREE_CODE (t))
3519 return (TYPE_MAIN_VARIANT (t) == char_type_node
3520 || TYPE_MAIN_VARIANT (t) == signed_char_type_node
3521 || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
3522 || TYPE_MAIN_VARIANT (t) == short_integer_type_node
3523 || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
3524 || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
3527 /* ??? Technically all enumerations not larger than an int
3528 promote to an int. But this is used along code paths
3529 that only want to notice a size change. */
3530 return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
3540 /* Return 1 if PARMS specifies a fixed number of parameters
3541 and none of their types is affected by default promotions. */
3544 self_promoting_args_p (tree parms)
3547 for (t = parms; t; t = TREE_CHAIN (t))
3549 tree type = TREE_VALUE (t);
3551 if (TREE_CHAIN (t) == 0 && type != void_type_node)
3557 if (TYPE_MAIN_VARIANT (type) == float_type_node)
3560 if (c_promoting_integer_type_p (type))
3566 /* Recursively examines the array elements of TYPE, until a non-array
3567 element type is found. */
3570 strip_array_types (tree type)
3572 while (TREE_CODE (type) == ARRAY_TYPE)
3573 type = TREE_TYPE (type);
3578 /* Recursively remove any '*' or '&' operator from TYPE. */
3580 strip_pointer_operator (tree t)
3582 while (POINTER_TYPE_P (t))
3587 /* Used to compare case labels. K1 and K2 are actually tree nodes
3588 representing case labels, or NULL_TREE for a `default' label.
3589 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3590 K2, and 0 if K1 and K2 are equal. */
3593 case_compare (splay_tree_key k1, splay_tree_key k2)
3595 /* Consider a NULL key (such as arises with a `default' label) to be
3596 smaller than anything else. */
3602 return tree_int_cst_compare ((tree) k1, (tree) k2);
3605 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
3606 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3607 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
3608 case label was declared using the usual C/C++ syntax, rather than
3609 the GNU case range extension. CASES is a tree containing all the
3610 case ranges processed so far; COND is the condition for the
3611 switch-statement itself. Returns the CASE_LABEL_EXPR created, or
3612 ERROR_MARK_NODE if no CASE_LABEL_EXPR is created. */
3615 c_add_case_label (splay_tree cases, tree cond, tree orig_type,
3616 tree low_value, tree high_value)
3621 splay_tree_node node;
3623 /* Create the LABEL_DECL itself. */
3624 label = create_artificial_label ();
3626 /* If there was an error processing the switch condition, bail now
3627 before we get more confused. */
3628 if (!cond || cond == error_mark_node)
3631 if ((low_value && TREE_TYPE (low_value)
3632 && POINTER_TYPE_P (TREE_TYPE (low_value)))
3633 || (high_value && TREE_TYPE (high_value)
3634 && POINTER_TYPE_P (TREE_TYPE (high_value))))
3636 error ("pointers are not permitted as case values");
3640 /* Case ranges are a GNU extension. */
3641 if (high_value && pedantic)
3642 pedwarn ("range expressions in switch statements are non-standard");
3644 type = TREE_TYPE (cond);
3647 low_value = check_case_value (low_value);
3648 low_value = convert_and_check (type, low_value);
3649 if (low_value == error_mark_node)
3654 high_value = check_case_value (high_value);
3655 high_value = convert_and_check (type, high_value);
3656 if (high_value == error_mark_node)
3660 if (low_value && high_value)
3662 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
3663 really a case range, even though it was written that way.
3664 Remove the HIGH_VALUE to simplify later processing. */
3665 if (tree_int_cst_equal (low_value, high_value))
3666 high_value = NULL_TREE;
3667 else if (!tree_int_cst_lt (low_value, high_value))
3668 warning (0, "empty range specified");
3671 /* See if the case is in range of the type of the original testing
3672 expression. If both low_value and high_value are out of range,
3673 don't insert the case label and return NULL_TREE. */
3675 && !check_case_bounds (type, orig_type,
3676 &low_value, high_value ? &high_value : NULL))
3679 /* Look up the LOW_VALUE in the table of case labels we already
3681 node = splay_tree_lookup (cases, (splay_tree_key) low_value);
3682 /* If there was not an exact match, check for overlapping ranges.
3683 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
3684 that's a `default' label and the only overlap is an exact match. */
3685 if (!node && (low_value || high_value))
3687 splay_tree_node low_bound;
3688 splay_tree_node high_bound;
3690 /* Even though there wasn't an exact match, there might be an
3691 overlap between this case range and another case range.
3692 Since we've (inductively) not allowed any overlapping case
3693 ranges, we simply need to find the greatest low case label
3694 that is smaller that LOW_VALUE, and the smallest low case
3695 label that is greater than LOW_VALUE. If there is an overlap
3696 it will occur in one of these two ranges. */
3697 low_bound = splay_tree_predecessor (cases,
3698 (splay_tree_key) low_value);
3699 high_bound = splay_tree_successor (cases,
3700 (splay_tree_key) low_value);
3702 /* Check to see if the LOW_BOUND overlaps. It is smaller than
3703 the LOW_VALUE, so there is no need to check unless the
3704 LOW_BOUND is in fact itself a case range. */
3706 && CASE_HIGH ((tree) low_bound->value)
3707 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
3710 /* Check to see if the HIGH_BOUND overlaps. The low end of that
3711 range is bigger than the low end of the current range, so we
3712 are only interested if the current range is a real range, and
3713 not an ordinary case label. */
3716 && (tree_int_cst_compare ((tree) high_bound->key,
3721 /* If there was an overlap, issue an error. */
3724 tree duplicate = CASE_LABEL ((tree) node->value);
3728 error ("duplicate (or overlapping) case value");
3729 error ("%Jthis is the first entry overlapping that value", duplicate);
3733 error ("duplicate case value") ;
3734 error ("%Jpreviously used here", duplicate);
3738 error ("multiple default labels in one switch");
3739 error ("%Jthis is the first default label", duplicate);
3744 /* Add a CASE_LABEL to the statement-tree. */
3745 case_label = add_stmt (build_case_label (low_value, high_value, label));
3746 /* Register this case label in the splay tree. */
3747 splay_tree_insert (cases,
3748 (splay_tree_key) low_value,
3749 (splay_tree_value) case_label);
3754 /* Add a label so that the back-end doesn't think that the beginning of
3755 the switch is unreachable. Note that we do not add a case label, as
3756 that just leads to duplicates and thence to failure later on. */
3759 tree t = create_artificial_label ();
3760 add_stmt (build_stmt (LABEL_EXPR, t));
3762 return error_mark_node;
3765 /* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
3766 Used to verify that case values match up with enumerator values. */
3769 match_case_to_enum_1 (tree key, tree type, tree label)
3771 char buf[2 + 2*HOST_BITS_PER_WIDE_INT/4 + 1];
3773 /* ??? Not working too hard to print the double-word value.
3774 Should perhaps be done with %lwd in the diagnostic routines? */
3775 if (TREE_INT_CST_HIGH (key) == 0)
3776 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_UNSIGNED,
3777 TREE_INT_CST_LOW (key));
3778 else if (!TYPE_UNSIGNED (type)
3779 && TREE_INT_CST_HIGH (key) == -1
3780 && TREE_INT_CST_LOW (key) != 0)
3781 snprintf (buf, sizeof (buf), "-" HOST_WIDE_INT_PRINT_UNSIGNED,
3782 -TREE_INT_CST_LOW (key));
3784 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_DOUBLE_HEX,
3785 TREE_INT_CST_HIGH (key), TREE_INT_CST_LOW (key));
3787 if (TYPE_NAME (type) == 0)
3788 warning (0, "%Jcase value %qs not in enumerated type",
3789 CASE_LABEL (label), buf);
3791 warning (0, "%Jcase value %qs not in enumerated type %qT",
3792 CASE_LABEL (label), buf, type);
3796 match_case_to_enum (splay_tree_node node, void *data)
3798 tree label = (tree) node->value;
3799 tree type = (tree) data;
3801 /* Skip default case. */
3802 if (!CASE_LOW (label))
3805 /* If TREE_ADDRESSABLE is not set, that means CASE_LOW did not appear
3806 when we did our enum->case scan. Reset our scratch bit after. */
3807 if (!TREE_ADDRESSABLE (label))
3808 match_case_to_enum_1 (CASE_LOW (label), type, label);
3810 TREE_ADDRESSABLE (label) = 0;
3812 /* If CASE_HIGH is non-null, we have a range. Here we must search.
3813 Note that the old code in stmt.c did not check for the values in
3814 the range either, just the endpoints. */
3815 if (CASE_HIGH (label))
3817 tree chain, key = CASE_HIGH (label);
3819 for (chain = TYPE_VALUES (type);
3820 chain && !tree_int_cst_equal (key, TREE_VALUE (chain));
3821 chain = TREE_CHAIN (chain))
3824 match_case_to_enum_1 (key, type, label);
3830 /* Handle -Wswitch*. Called from the front end after parsing the
3831 switch construct. */
3832 /* ??? Should probably be somewhere generic, since other languages
3833 besides C and C++ would want this. At the moment, however, C/C++
3834 are the only tree-ssa languages that support enumerations at all,
3835 so the point is moot. */
3838 c_do_switch_warnings (splay_tree cases, location_t switch_location,
3839 tree type, tree cond)
3841 splay_tree_node default_node;
3843 if (!warn_switch && !warn_switch_enum && !warn_switch_default)
3846 default_node = splay_tree_lookup (cases, (splay_tree_key) NULL);
3848 warning (OPT_Wswitch_default, "%Hswitch missing default case",
3851 /* If the switch expression was an enumerated type, check that
3852 exactly all enumeration literals are covered by the cases.
3853 The check is made when -Wswitch was specified and there is no
3854 default case, or when -Wswitch-enum was specified. */
3855 if (((warn_switch && !default_node) || warn_switch_enum)
3856 && type && TREE_CODE (type) == ENUMERAL_TYPE
3857 && TREE_CODE (cond) != INTEGER_CST)
3861 /* The time complexity here is O(N*lg(N)) worst case, but for the
3862 common case of monotonically increasing enumerators, it is
3863 O(N), since the nature of the splay tree will keep the next
3864 element adjacent to the root at all times. */
3866 for (chain = TYPE_VALUES (type); chain; chain = TREE_CHAIN (chain))
3868 splay_tree_node node
3869 = splay_tree_lookup (cases, (splay_tree_key) TREE_VALUE (chain));
3872 tree low_value = TREE_VALUE (chain);
3873 splay_tree_node low_bound;
3874 splay_tree_node high_bound;
3875 /* Even though there wasn't an exact match, there might be a
3876 case range which includes the enumator's value. */
3877 low_bound = splay_tree_predecessor (cases,
3878 (splay_tree_key) low_value);
3879 high_bound = splay_tree_successor (cases,
3880 (splay_tree_key) low_value);
3882 /* It is smaller than the LOW_VALUE, so there is no need to check
3883 unless the LOW_BOUND is in fact itself a case range. */
3885 && CASE_HIGH ((tree) low_bound->value)
3886 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
3889 /* The low end of that range is bigger than the current value. */
3891 && (tree_int_cst_compare ((tree) high_bound->key,
3898 /* Mark the CASE_LOW part of the case entry as seen, so
3899 that we save time later. Choose TREE_ADDRESSABLE
3900 randomly as a bit that won't have been set to-date. */
3901 tree label = (tree) node->value;
3902 TREE_ADDRESSABLE (label) = 1;
3906 /* Warn if there are enumerators that don't correspond to
3907 case expressions. */
3908 warning (0, "%Henumeration value %qE not handled in switch",
3909 &switch_location, TREE_PURPOSE (chain));
3913 /* Warn if there are case expressions that don't correspond to
3914 enumerators. This can occur since C and C++ don't enforce
3915 type-checking of assignments to enumeration variables.
3917 The time complexity here is O(N**2) worst case, since we've
3918 not sorted the enumeration values. However, in the absence
3919 of case ranges this is O(N), since all single cases that
3920 corresponded to enumerations have been marked above. */
3922 splay_tree_foreach (cases, match_case_to_enum, type);
3926 /* Finish an expression taking the address of LABEL (an
3927 IDENTIFIER_NODE). Returns an expression for the address. */
3930 finish_label_address_expr (tree label)
3935 pedwarn ("taking the address of a label is non-standard");
3937 if (label == error_mark_node)
3938 return error_mark_node;
3940 label = lookup_label (label);
3941 if (label == NULL_TREE)
3942 result = null_pointer_node;
3945 TREE_USED (label) = 1;
3946 result = build1 (ADDR_EXPR, ptr_type_node, label);
3947 /* The current function in not necessarily uninlinable.
3948 Computed gotos are incompatible with inlining, but the value
3949 here could be used only in a diagnostic, for example. */
3955 /* Hook used by expand_expr to expand language-specific tree codes. */
3956 /* The only things that should go here are bits needed to expand
3957 constant initializers. Everything else should be handled by the
3958 gimplification routines. */
3961 c_expand_expr (tree exp, rtx target, enum machine_mode tmode,
3962 int modifier /* Actually enum_modifier. */,
3965 switch (TREE_CODE (exp))
3967 case COMPOUND_LITERAL_EXPR:
3969 /* Initialize the anonymous variable declared in the compound
3970 literal, then return the variable. */
3971 tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
3972 emit_local_var (decl);
3973 return expand_expr_real (decl, target, tmode, modifier, alt_rtl);
3981 /* Hook used by staticp to handle language-specific tree codes. */
3984 c_staticp (tree exp)
3986 return (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR
3987 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp))
3992 /* Given a boolean expression ARG, return a tree representing an increment
3993 or decrement (as indicated by CODE) of ARG. The front end must check for
3994 invalid cases (e.g., decrement in C++). */
3996 boolean_increment (enum tree_code code, tree arg)
3999 tree true_res = boolean_true_node;
4001 arg = stabilize_reference (arg);
4004 case PREINCREMENT_EXPR:
4005 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4007 case POSTINCREMENT_EXPR:
4008 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4009 arg = save_expr (arg);
4010 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4011 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4013 case PREDECREMENT_EXPR:
4014 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
4015 invert_truthvalue (arg));
4017 case POSTDECREMENT_EXPR:
4018 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
4019 invert_truthvalue (arg));
4020 arg = save_expr (arg);
4021 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4022 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4027 TREE_SIDE_EFFECTS (val) = 1;
4031 /* Built-in macros for stddef.h, that require macros defined in this
4034 c_stddef_cpp_builtins(void)
4036 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
4037 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
4038 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
4039 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
4040 builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE, 0);
4041 builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE, 0);
4045 c_init_attributes (void)
4047 /* Fill in the built_in_attributes array. */
4048 #define DEF_ATTR_NULL_TREE(ENUM) \
4049 built_in_attributes[(int) ENUM] = NULL_TREE;
4050 #define DEF_ATTR_INT(ENUM, VALUE) \
4051 built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
4052 #define DEF_ATTR_IDENT(ENUM, STRING) \
4053 built_in_attributes[(int) ENUM] = get_identifier (STRING);
4054 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
4055 built_in_attributes[(int) ENUM] \
4056 = tree_cons (built_in_attributes[(int) PURPOSE], \
4057 built_in_attributes[(int) VALUE], \
4058 built_in_attributes[(int) CHAIN]);
4059 #include "builtin-attrs.def"
4060 #undef DEF_ATTR_NULL_TREE
4062 #undef DEF_ATTR_IDENT
4063 #undef DEF_ATTR_TREE_LIST
4066 /* Attribute handlers common to C front ends. */
4068 /* Handle a "packed" attribute; arguments as in
4069 struct attribute_spec.handler. */
4072 handle_packed_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4073 int flags, bool *no_add_attrs)
4077 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4078 *node = build_variant_type_copy (*node);
4079 TYPE_PACKED (*node) = 1;
4080 if (TYPE_MAIN_VARIANT (*node) == *node)
4082 /* If it is the main variant, then pack the other variants
4083 too. This happens in,
4086 struct Foo const *ptr; // creates a variant w/o packed flag
4087 } __ attribute__((packed)); // packs it now.
4091 for (probe = *node; probe; probe = TYPE_NEXT_VARIANT (probe))
4092 TYPE_PACKED (probe) = 1;
4095 else if (TREE_CODE (*node) == FIELD_DECL)
4097 if (TYPE_ALIGN (TREE_TYPE (*node)) <= BITS_PER_UNIT)
4098 warning (OPT_Wattributes,
4099 "%qE attribute ignored for field of type %qT",
4100 name, TREE_TYPE (*node));
4102 DECL_PACKED (*node) = 1;
4104 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
4105 used for DECL_REGISTER. It wouldn't mean anything anyway.
4106 We can't set DECL_PACKED on the type of a TYPE_DECL, because
4107 that changes what the typedef is typing. */
4110 warning (OPT_Wattributes, "%qE attribute ignored", name);
4111 *no_add_attrs = true;
4117 /* Handle a "nocommon" attribute; arguments as in
4118 struct attribute_spec.handler. */
4121 handle_nocommon_attribute (tree *node, tree name,
4122 tree ARG_UNUSED (args),
4123 int ARG_UNUSED (flags), bool *no_add_attrs)
4125 if (TREE_CODE (*node) == VAR_DECL)
4126 DECL_COMMON (*node) = 0;
4129 warning (OPT_Wattributes, "%qE attribute ignored", name);
4130 *no_add_attrs = true;
4136 /* Handle a "common" attribute; arguments as in
4137 struct attribute_spec.handler. */
4140 handle_common_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4141 int ARG_UNUSED (flags), bool *no_add_attrs)
4143 if (TREE_CODE (*node) == VAR_DECL)
4144 DECL_COMMON (*node) = 1;
4147 warning (OPT_Wattributes, "%qE attribute ignored", name);
4148 *no_add_attrs = true;
4154 /* Handle a "noreturn" attribute; arguments as in
4155 struct attribute_spec.handler. */
4158 handle_noreturn_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4159 int ARG_UNUSED (flags), bool *no_add_attrs)
4161 tree type = TREE_TYPE (*node);
4163 /* See FIXME comment in c_common_attribute_table. */
4164 if (TREE_CODE (*node) == FUNCTION_DECL)
4165 TREE_THIS_VOLATILE (*node) = 1;
4166 else if (TREE_CODE (type) == POINTER_TYPE
4167 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4169 = build_pointer_type
4170 (build_type_variant (TREE_TYPE (type),
4171 TYPE_READONLY (TREE_TYPE (type)), 1));
4174 warning (OPT_Wattributes, "%qE attribute ignored", name);
4175 *no_add_attrs = true;
4181 /* Handle a "noinline" attribute; arguments as in
4182 struct attribute_spec.handler. */
4185 handle_noinline_attribute (tree *node, tree name,
4186 tree ARG_UNUSED (args),
4187 int ARG_UNUSED (flags), bool *no_add_attrs)
4189 if (TREE_CODE (*node) == FUNCTION_DECL)
4190 DECL_UNINLINABLE (*node) = 1;
4193 warning (OPT_Wattributes, "%qE attribute ignored", name);
4194 *no_add_attrs = true;
4200 /* Handle a "always_inline" attribute; arguments as in
4201 struct attribute_spec.handler. */
4204 handle_always_inline_attribute (tree *node, tree name,
4205 tree ARG_UNUSED (args),
4206 int ARG_UNUSED (flags),
4209 if (TREE_CODE (*node) == FUNCTION_DECL)
4211 /* Do nothing else, just set the attribute. We'll get at
4212 it later with lookup_attribute. */
4216 warning (OPT_Wattributes, "%qE attribute ignored", name);
4217 *no_add_attrs = true;
4223 /* Handle a "flatten" attribute; arguments as in
4224 struct attribute_spec.handler. */
4227 handle_flatten_attribute (tree *node, tree name,
4228 tree args ATTRIBUTE_UNUSED,
4229 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4231 if (TREE_CODE (*node) == FUNCTION_DECL)
4232 /* Do nothing else, just set the attribute. We'll get at
4233 it later with lookup_attribute. */
4237 warning (OPT_Wattributes, "%qE attribute ignored", name);
4238 *no_add_attrs = true;
4245 /* Handle a "used" attribute; arguments as in
4246 struct attribute_spec.handler. */
4249 handle_used_attribute (tree *pnode, tree name, tree ARG_UNUSED (args),
4250 int ARG_UNUSED (flags), bool *no_add_attrs)
4254 if (TREE_CODE (node) == FUNCTION_DECL
4255 || (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node)))
4257 TREE_USED (node) = 1;
4258 DECL_PRESERVE_P (node) = 1;
4262 warning (OPT_Wattributes, "%qE attribute ignored", name);
4263 *no_add_attrs = true;
4269 /* Handle a "unused" attribute; arguments as in
4270 struct attribute_spec.handler. */
4273 handle_unused_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4274 int flags, bool *no_add_attrs)
4280 if (TREE_CODE (decl) == PARM_DECL
4281 || TREE_CODE (decl) == VAR_DECL
4282 || TREE_CODE (decl) == FUNCTION_DECL
4283 || TREE_CODE (decl) == LABEL_DECL
4284 || TREE_CODE (decl) == TYPE_DECL)
4285 TREE_USED (decl) = 1;
4288 warning (OPT_Wattributes, "%qE attribute ignored", name);
4289 *no_add_attrs = true;
4294 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4295 *node = build_variant_type_copy (*node);
4296 TREE_USED (*node) = 1;
4302 /* Handle a "externally_visible" attribute; arguments as in
4303 struct attribute_spec.handler. */
4306 handle_externally_visible_attribute (tree *pnode, tree name,
4307 tree ARG_UNUSED (args),
4308 int ARG_UNUSED (flags),
4313 if ((!TREE_STATIC (node) && TREE_CODE (node) != FUNCTION_DECL)
4314 || !TREE_PUBLIC (node))
4316 warning (OPT_Wattributes,
4317 "%qE attribute have effect only on public objects", name);
4318 *no_add_attrs = true;
4320 else if (TREE_CODE (node) == FUNCTION_DECL)
4322 struct cgraph_node *n = cgraph_node (node);
4323 n->local.externally_visible = true;
4324 if (n->local.finalized)
4325 cgraph_mark_needed_node (n);
4327 else if (TREE_CODE (node) == VAR_DECL)
4329 struct cgraph_varpool_node *n = cgraph_varpool_node (node);
4330 n->externally_visible = true;
4332 cgraph_varpool_mark_needed_node (n);
4336 warning (OPT_Wattributes, "%qE attribute ignored", name);
4337 *no_add_attrs = true;
4343 /* Handle a "const" attribute; arguments as in
4344 struct attribute_spec.handler. */
4347 handle_const_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4348 int ARG_UNUSED (flags), bool *no_add_attrs)
4350 tree type = TREE_TYPE (*node);
4352 /* See FIXME comment on noreturn in c_common_attribute_table. */
4353 if (TREE_CODE (*node) == FUNCTION_DECL)
4354 TREE_READONLY (*node) = 1;
4355 else if (TREE_CODE (type) == POINTER_TYPE
4356 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4358 = build_pointer_type
4359 (build_type_variant (TREE_TYPE (type), 1,
4360 TREE_THIS_VOLATILE (TREE_TYPE (type))));
4363 warning (OPT_Wattributes, "%qE attribute ignored", name);
4364 *no_add_attrs = true;
4370 /* Handle a "transparent_union" attribute; arguments as in
4371 struct attribute_spec.handler. */
4374 handle_transparent_union_attribute (tree *node, tree name,
4375 tree ARG_UNUSED (args), int flags,
4380 *no_add_attrs = true;
4384 if (TREE_CODE (*node) != TYPE_DECL)
4386 node = &TREE_TYPE (*node);
4389 else if (TYPE_P (*node))
4394 if (TREE_CODE (type) == UNION_TYPE)
4396 /* When IN_PLACE is set, leave the check for FIELDS and MODE to
4397 the code in finish_struct. */
4398 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4400 if (TYPE_FIELDS (type) == NULL_TREE
4401 || TYPE_MODE (type) != DECL_MODE (TYPE_FIELDS (type)))
4404 /* A type variant isn't good enough, since we don't a cast
4405 to such a type removed as a no-op. */
4406 *node = type = build_duplicate_type (type);
4409 TYPE_TRANSPARENT_UNION (type) = 1;
4414 warning (OPT_Wattributes, "%qE attribute ignored", name);
4418 /* Handle a "constructor" attribute; arguments as in
4419 struct attribute_spec.handler. */
4422 handle_constructor_attribute (tree *node, tree name,
4423 tree ARG_UNUSED (args),
4424 int ARG_UNUSED (flags),
4428 tree type = TREE_TYPE (decl);
4430 if (TREE_CODE (decl) == FUNCTION_DECL
4431 && TREE_CODE (type) == FUNCTION_TYPE
4432 && decl_function_context (decl) == 0)
4434 DECL_STATIC_CONSTRUCTOR (decl) = 1;
4435 TREE_USED (decl) = 1;
4439 warning (OPT_Wattributes, "%qE attribute ignored", name);
4440 *no_add_attrs = true;
4446 /* Handle a "destructor" attribute; arguments as in
4447 struct attribute_spec.handler. */
4450 handle_destructor_attribute (tree *node, tree name,
4451 tree ARG_UNUSED (args),
4452 int ARG_UNUSED (flags),
4456 tree type = TREE_TYPE (decl);
4458 if (TREE_CODE (decl) == FUNCTION_DECL
4459 && TREE_CODE (type) == FUNCTION_TYPE
4460 && decl_function_context (decl) == 0)
4462 DECL_STATIC_DESTRUCTOR (decl) = 1;
4463 TREE_USED (decl) = 1;
4467 warning (OPT_Wattributes, "%qE attribute ignored", name);
4468 *no_add_attrs = true;
4474 /* Handle a "mode" attribute; arguments as in
4475 struct attribute_spec.handler. */
4478 handle_mode_attribute (tree *node, tree name, tree args,
4479 int ARG_UNUSED (flags), bool *no_add_attrs)
4483 *no_add_attrs = true;
4485 if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
4486 warning (OPT_Wattributes, "%qE attribute ignored", name);
4490 const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
4491 int len = strlen (p);
4492 enum machine_mode mode = VOIDmode;
4496 if (len > 4 && p[0] == '_' && p[1] == '_'
4497 && p[len - 1] == '_' && p[len - 2] == '_')
4499 char *newp = (char *) alloca (len - 1);
4501 strcpy (newp, &p[2]);
4502 newp[len - 4] = '\0';
4506 /* Change this type to have a type with the specified mode.
4507 First check for the special modes. */
4508 if (!strcmp (p, "byte"))
4510 else if (!strcmp (p, "word"))
4512 else if (!strcmp (p, "pointer"))
4515 for (j = 0; j < NUM_MACHINE_MODES; j++)
4516 if (!strcmp (p, GET_MODE_NAME (j)))
4518 mode = (enum machine_mode) j;
4522 if (mode == VOIDmode)
4524 error ("unknown machine mode %qs", p);
4529 switch (GET_MODE_CLASS (mode))
4532 case MODE_PARTIAL_INT:
4534 case MODE_DECIMAL_FLOAT:
4535 valid_mode = targetm.scalar_mode_supported_p (mode);
4538 case MODE_COMPLEX_INT:
4539 case MODE_COMPLEX_FLOAT:
4540 valid_mode = targetm.scalar_mode_supported_p (GET_MODE_INNER (mode));
4543 case MODE_VECTOR_INT:
4544 case MODE_VECTOR_FLOAT:
4545 warning (OPT_Wattributes, "specifying vector types with "
4546 "__attribute__ ((mode)) is deprecated");
4547 warning (OPT_Wattributes,
4548 "use __attribute__ ((vector_size)) instead");
4549 valid_mode = vector_mode_valid_p (mode);
4557 error ("unable to emulate %qs", p);
4561 if (POINTER_TYPE_P (type))
4563 tree (*fn)(tree, enum machine_mode, bool);
4565 if (!targetm.valid_pointer_mode (mode))
4567 error ("invalid pointer mode %qs", p);
4571 if (TREE_CODE (type) == POINTER_TYPE)
4572 fn = build_pointer_type_for_mode;
4574 fn = build_reference_type_for_mode;
4575 typefm = fn (TREE_TYPE (type), mode, false);
4578 typefm = lang_hooks.types.type_for_mode (mode, TYPE_UNSIGNED (type));
4580 if (typefm == NULL_TREE)
4582 error ("no data type for mode %qs", p);
4585 else if (TREE_CODE (type) == ENUMERAL_TYPE)
4587 /* For enumeral types, copy the precision from the integer
4588 type returned above. If not an INTEGER_TYPE, we can't use
4589 this mode for this type. */
4590 if (TREE_CODE (typefm) != INTEGER_TYPE)
4592 error ("cannot use mode %qs for enumeral types", p);
4596 if (flags & ATTR_FLAG_TYPE_IN_PLACE)
4598 TYPE_PRECISION (type) = TYPE_PRECISION (typefm);
4603 /* We cannot build a type variant, as there's code that assumes
4604 that TYPE_MAIN_VARIANT has the same mode. This includes the
4605 debug generators. Instead, create a subrange type. This
4606 results in all of the enumeral values being emitted only once
4607 in the original, and the subtype gets them by reference. */
4608 if (TYPE_UNSIGNED (type))
4609 typefm = make_unsigned_type (TYPE_PRECISION (typefm));
4611 typefm = make_signed_type (TYPE_PRECISION (typefm));
4612 TREE_TYPE (typefm) = type;
4615 else if (VECTOR_MODE_P (mode)
4616 ? TREE_CODE (type) != TREE_CODE (TREE_TYPE (typefm))
4617 : TREE_CODE (type) != TREE_CODE (typefm))
4619 error ("mode %qs applied to inappropriate type", p);
4629 /* Handle a "section" attribute; arguments as in
4630 struct attribute_spec.handler. */
4633 handle_section_attribute (tree *node, tree ARG_UNUSED (name), tree args,
4634 int ARG_UNUSED (flags), bool *no_add_attrs)
4638 if (targetm.have_named_sections)
4640 user_defined_section_attribute = true;
4642 if ((TREE_CODE (decl) == FUNCTION_DECL
4643 || TREE_CODE (decl) == VAR_DECL)
4644 && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
4646 if (TREE_CODE (decl) == VAR_DECL
4647 && current_function_decl != NULL_TREE
4648 && !TREE_STATIC (decl))
4650 error ("%Jsection attribute cannot be specified for "
4651 "local variables", decl);
4652 *no_add_attrs = true;
4655 /* The decl may have already been given a section attribute
4656 from a previous declaration. Ensure they match. */
4657 else if (DECL_SECTION_NAME (decl) != NULL_TREE
4658 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
4659 TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
4661 error ("section of %q+D conflicts with previous declaration",
4663 *no_add_attrs = true;
4666 DECL_SECTION_NAME (decl) = TREE_VALUE (args);
4670 error ("section attribute not allowed for %q+D", *node);
4671 *no_add_attrs = true;
4676 error ("%Jsection attributes are not supported for this target", *node);
4677 *no_add_attrs = true;
4683 /* Handle a "aligned" attribute; arguments as in
4684 struct attribute_spec.handler. */
4687 handle_aligned_attribute (tree *node, tree ARG_UNUSED (name), tree args,
4688 int flags, bool *no_add_attrs)
4690 tree decl = NULL_TREE;
4693 tree align_expr = (args ? TREE_VALUE (args)
4694 : size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
4700 type = &TREE_TYPE (decl);
4701 is_type = TREE_CODE (*node) == TYPE_DECL;
4703 else if (TYPE_P (*node))
4704 type = node, is_type = 1;
4706 if (TREE_CODE (align_expr) != INTEGER_CST)
4708 error ("requested alignment is not a constant");
4709 *no_add_attrs = true;
4711 else if ((i = tree_log2 (align_expr)) == -1)
4713 error ("requested alignment is not a power of 2");
4714 *no_add_attrs = true;
4716 else if (i > HOST_BITS_PER_INT - 2)
4718 error ("requested alignment is too large");
4719 *no_add_attrs = true;
4723 /* If we have a TYPE_DECL, then copy the type, so that we
4724 don't accidentally modify a builtin type. See pushdecl. */
4725 if (decl && TREE_TYPE (decl) != error_mark_node
4726 && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
4728 tree tt = TREE_TYPE (decl);
4729 *type = build_variant_type_copy (*type);
4730 DECL_ORIGINAL_TYPE (decl) = tt;
4731 TYPE_NAME (*type) = decl;
4732 TREE_USED (*type) = TREE_USED (decl);
4733 TREE_TYPE (decl) = *type;
4735 else if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4736 *type = build_variant_type_copy (*type);
4738 TYPE_ALIGN (*type) = (1 << i) * BITS_PER_UNIT;
4739 TYPE_USER_ALIGN (*type) = 1;
4741 else if (TREE_CODE (decl) != VAR_DECL
4742 && TREE_CODE (decl) != FIELD_DECL)
4744 error ("alignment may not be specified for %q+D", decl);
4745 *no_add_attrs = true;
4749 DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
4750 DECL_USER_ALIGN (decl) = 1;
4756 /* Handle a "weak" attribute; arguments as in
4757 struct attribute_spec.handler. */
4760 handle_weak_attribute (tree *node, tree ARG_UNUSED (name),
4761 tree ARG_UNUSED (args),
4762 int ARG_UNUSED (flags),
4763 bool * ARG_UNUSED (no_add_attrs))
4765 declare_weak (*node);
4770 /* Handle an "alias" attribute; arguments as in
4771 struct attribute_spec.handler. */
4774 handle_alias_attribute (tree *node, tree name, tree args,
4775 int ARG_UNUSED (flags), bool *no_add_attrs)
4779 if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
4780 || (TREE_CODE (decl) != FUNCTION_DECL
4781 && TREE_PUBLIC (decl) && !DECL_EXTERNAL (decl))
4782 /* A static variable declaration is always a tentative definition,
4783 but the alias is a non-tentative definition which overrides. */
4784 || (TREE_CODE (decl) != FUNCTION_DECL
4785 && ! TREE_PUBLIC (decl) && DECL_INITIAL (decl)))
4787 error ("%q+D defined both normally and as an alias", decl);
4788 *no_add_attrs = true;
4791 /* Note that the very first time we process a nested declaration,
4792 decl_function_context will not be set. Indeed, *would* never
4793 be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
4794 we do below. After such frobbery, pushdecl would set the context.
4795 In any case, this is never what we want. */
4796 else if (decl_function_context (decl) == 0 && current_function_decl == NULL)
4800 id = TREE_VALUE (args);
4801 if (TREE_CODE (id) != STRING_CST)
4803 error ("alias argument not a string");
4804 *no_add_attrs = true;
4807 id = get_identifier (TREE_STRING_POINTER (id));
4808 /* This counts as a use of the object pointed to. */
4811 if (TREE_CODE (decl) == FUNCTION_DECL)
4812 DECL_INITIAL (decl) = error_mark_node;
4815 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
4816 DECL_EXTERNAL (decl) = 1;
4818 DECL_EXTERNAL (decl) = 0;
4819 TREE_STATIC (decl) = 1;
4824 warning (OPT_Wattributes, "%qE attribute ignored", name);
4825 *no_add_attrs = true;
4831 /* Handle a "weakref" attribute; arguments as in struct
4832 attribute_spec.handler. */
4835 handle_weakref_attribute (tree *node, tree ARG_UNUSED (name), tree args,
4836 int flags, bool *no_add_attrs)
4838 tree attr = NULL_TREE;
4840 /* The idea here is that `weakref("name")' mutates into `weakref,
4841 alias("name")', and weakref without arguments, in turn,
4842 implicitly adds weak. */
4846 attr = tree_cons (get_identifier ("alias"), args, attr);
4847 attr = tree_cons (get_identifier ("weakref"), NULL_TREE, attr);
4849 *no_add_attrs = true;
4851 decl_attributes (node, attr, flags);
4855 if (lookup_attribute ("alias", DECL_ATTRIBUTES (*node)))
4856 error ("%Jweakref attribute must appear before alias attribute",
4859 /* Can't call declare_weak because it wants this to be TREE_PUBLIC,
4860 and that isn't supported; and because it wants to add it to
4861 the list of weak decls, which isn't helpful. */
4862 DECL_WEAK (*node) = 1;
4868 /* Handle an "visibility" attribute; arguments as in
4869 struct attribute_spec.handler. */
4872 handle_visibility_attribute (tree *node, tree name, tree args,
4873 int ARG_UNUSED (flags),
4877 tree id = TREE_VALUE (args);
4879 *no_add_attrs = true;
4883 if (TREE_CODE (*node) != RECORD_TYPE && TREE_CODE (*node) != UNION_TYPE)
4885 warning (OPT_Wattributes, "%qE attribute ignored on non-class types",
4890 else if (decl_function_context (decl) != 0 || !TREE_PUBLIC (decl))
4892 warning (OPT_Wattributes, "%qE attribute ignored", name);
4896 if (TREE_CODE (id) != STRING_CST)
4898 error ("visibility argument not a string");
4902 /* If this is a type, set the visibility on the type decl. */
4905 decl = TYPE_NAME (decl);
4908 if (TREE_CODE (decl) == IDENTIFIER_NODE)
4910 warning (OPT_Wattributes, "%qE attribute ignored on types",
4916 if (strcmp (TREE_STRING_POINTER (id), "default") == 0)
4917 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
4918 else if (strcmp (TREE_STRING_POINTER (id), "internal") == 0)
4919 DECL_VISIBILITY (decl) = VISIBILITY_INTERNAL;
4920 else if (strcmp (TREE_STRING_POINTER (id), "hidden") == 0)
4921 DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
4922 else if (strcmp (TREE_STRING_POINTER (id), "protected") == 0)
4923 DECL_VISIBILITY (decl) = VISIBILITY_PROTECTED;
4925 error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
4926 DECL_VISIBILITY_SPECIFIED (decl) = 1;
4928 /* For decls only, go ahead and attach the attribute to the node as well.
4929 This is needed so we can determine whether we have VISIBILITY_DEFAULT
4930 because the visibility was not specified, or because it was explicitly
4931 overridden from the class visibility. */
4933 *no_add_attrs = false;
4938 /* Determine the ELF symbol visibility for DECL, which is either a
4939 variable or a function. It is an error to use this function if a
4940 definition of DECL is not available in this translation unit.
4941 Returns true if the final visibility has been determined by this
4942 function; false if the caller is free to make additional
4946 c_determine_visibility (tree decl)
4948 gcc_assert (TREE_CODE (decl) == VAR_DECL
4949 || TREE_CODE (decl) == FUNCTION_DECL);
4951 /* If the user explicitly specified the visibility with an
4952 attribute, honor that. DECL_VISIBILITY will have been set during
4953 the processing of the attribute. We check for an explicit
4954 attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
4955 to distinguish the use of an attribute from the use of a "#pragma
4956 GCC visibility push(...)"; in the latter case we still want other
4957 considerations to be able to overrule the #pragma. */
4958 if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl)))
4961 /* Anything that is exported must have default visibility. */
4962 if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
4963 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))
4965 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
4966 DECL_VISIBILITY_SPECIFIED (decl) = 1;
4973 /* Handle an "tls_model" attribute; arguments as in
4974 struct attribute_spec.handler. */
4977 handle_tls_model_attribute (tree *node, tree name, tree args,
4978 int ARG_UNUSED (flags), bool *no_add_attrs)
4982 enum tls_model kind;
4984 *no_add_attrs = true;
4986 if (!DECL_THREAD_LOCAL_P (decl))
4988 warning (OPT_Wattributes, "%qE attribute ignored", name);
4992 kind = DECL_TLS_MODEL (decl);
4993 id = TREE_VALUE (args);
4994 if (TREE_CODE (id) != STRING_CST)
4996 error ("tls_model argument not a string");
5000 if (!strcmp (TREE_STRING_POINTER (id), "local-exec"))
5001 kind = TLS_MODEL_LOCAL_EXEC;
5002 else if (!strcmp (TREE_STRING_POINTER (id), "initial-exec"))
5003 kind = TLS_MODEL_INITIAL_EXEC;
5004 else if (!strcmp (TREE_STRING_POINTER (id), "local-dynamic"))
5005 kind = optimize ? TLS_MODEL_LOCAL_DYNAMIC : TLS_MODEL_GLOBAL_DYNAMIC;
5006 else if (!strcmp (TREE_STRING_POINTER (id), "global-dynamic"))
5007 kind = TLS_MODEL_GLOBAL_DYNAMIC;
5009 error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
5011 DECL_TLS_MODEL (decl) = kind;
5015 /* Handle a "no_instrument_function" attribute; arguments as in
5016 struct attribute_spec.handler. */
5019 handle_no_instrument_function_attribute (tree *node, tree name,
5020 tree ARG_UNUSED (args),
5021 int ARG_UNUSED (flags),
5026 if (TREE_CODE (decl) != FUNCTION_DECL)
5028 error ("%J%qE attribute applies only to functions", decl, name);
5029 *no_add_attrs = true;
5031 else if (DECL_INITIAL (decl))
5033 error ("%Jcan%'t set %qE attribute after definition", decl, name);
5034 *no_add_attrs = true;
5037 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
5042 /* Handle a "malloc" attribute; arguments as in
5043 struct attribute_spec.handler. */
5046 handle_malloc_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5047 int ARG_UNUSED (flags), bool *no_add_attrs)
5049 if (TREE_CODE (*node) == FUNCTION_DECL
5050 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node))))
5051 DECL_IS_MALLOC (*node) = 1;
5054 warning (OPT_Wattributes, "%qE attribute ignored", name);
5055 *no_add_attrs = true;
5061 /* Handle a "returns_twice" attribute; arguments as in
5062 struct attribute_spec.handler. */
5065 handle_returns_twice_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5066 int ARG_UNUSED (flags), bool *no_add_attrs)
5068 if (TREE_CODE (*node) == FUNCTION_DECL)
5069 DECL_IS_RETURNS_TWICE (*node) = 1;
5072 warning (OPT_Wattributes, "%qE attribute ignored", name);
5073 *no_add_attrs = true;
5079 /* Handle a "no_limit_stack" attribute; arguments as in
5080 struct attribute_spec.handler. */
5083 handle_no_limit_stack_attribute (tree *node, tree name,
5084 tree ARG_UNUSED (args),
5085 int ARG_UNUSED (flags),
5090 if (TREE_CODE (decl) != FUNCTION_DECL)
5092 error ("%J%qE attribute applies only to functions", decl, name);
5093 *no_add_attrs = true;
5095 else if (DECL_INITIAL (decl))
5097 error ("%Jcan%'t set %qE attribute after definition", decl, name);
5098 *no_add_attrs = true;
5101 DECL_NO_LIMIT_STACK (decl) = 1;
5106 /* Handle a "pure" attribute; arguments as in
5107 struct attribute_spec.handler. */
5110 handle_pure_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5111 int ARG_UNUSED (flags), bool *no_add_attrs)
5113 if (TREE_CODE (*node) == FUNCTION_DECL)
5114 DECL_IS_PURE (*node) = 1;
5115 /* ??? TODO: Support types. */
5118 warning (OPT_Wattributes, "%qE attribute ignored", name);
5119 *no_add_attrs = true;
5125 /* Handle a "no vops" attribute; arguments as in
5126 struct attribute_spec.handler. */
5129 handle_novops_attribute (tree *node, tree ARG_UNUSED (name),
5130 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
5131 bool *ARG_UNUSED (no_add_attrs))
5133 gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
5134 DECL_IS_NOVOPS (*node) = 1;
5138 /* Handle a "deprecated" attribute; arguments as in
5139 struct attribute_spec.handler. */
5142 handle_deprecated_attribute (tree *node, tree name,
5143 tree ARG_UNUSED (args), int flags,
5146 tree type = NULL_TREE;
5148 tree what = NULL_TREE;
5153 type = TREE_TYPE (decl);
5155 if (TREE_CODE (decl) == TYPE_DECL
5156 || TREE_CODE (decl) == PARM_DECL
5157 || TREE_CODE (decl) == VAR_DECL
5158 || TREE_CODE (decl) == FUNCTION_DECL
5159 || TREE_CODE (decl) == FIELD_DECL)
5160 TREE_DEPRECATED (decl) = 1;
5164 else if (TYPE_P (*node))
5166 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5167 *node = build_variant_type_copy (*node);
5168 TREE_DEPRECATED (*node) = 1;
5176 *no_add_attrs = true;
5177 if (type && TYPE_NAME (type))
5179 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
5180 what = TYPE_NAME (*node);
5181 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
5182 && DECL_NAME (TYPE_NAME (type)))
5183 what = DECL_NAME (TYPE_NAME (type));
5186 warning (OPT_Wattributes, "%qE attribute ignored for %qE", name, what);
5188 warning (OPT_Wattributes, "%qE attribute ignored", name);
5194 /* Handle a "vector_size" attribute; arguments as in
5195 struct attribute_spec.handler. */
5198 handle_vector_size_attribute (tree *node, tree name, tree args,
5199 int ARG_UNUSED (flags),
5202 unsigned HOST_WIDE_INT vecsize, nunits;
5203 enum machine_mode orig_mode;
5204 tree type = *node, new_type, size;
5206 *no_add_attrs = true;
5208 size = TREE_VALUE (args);
5210 if (!host_integerp (size, 1))
5212 warning (OPT_Wattributes, "%qE attribute ignored", name);
5216 /* Get the vector size (in bytes). */
5217 vecsize = tree_low_cst (size, 1);
5219 /* We need to provide for vector pointers, vector arrays, and
5220 functions returning vectors. For example:
5222 __attribute__((vector_size(16))) short *foo;
5224 In this case, the mode is SI, but the type being modified is
5225 HI, so we need to look further. */
5227 while (POINTER_TYPE_P (type)
5228 || TREE_CODE (type) == FUNCTION_TYPE
5229 || TREE_CODE (type) == METHOD_TYPE
5230 || TREE_CODE (type) == ARRAY_TYPE)
5231 type = TREE_TYPE (type);
5233 /* Get the mode of the type being modified. */
5234 orig_mode = TYPE_MODE (type);
5236 if (TREE_CODE (type) == RECORD_TYPE
5237 || (!SCALAR_FLOAT_MODE_P (orig_mode)
5238 && GET_MODE_CLASS (orig_mode) != MODE_INT)
5239 || !host_integerp (TYPE_SIZE_UNIT (type), 1))
5241 error ("invalid vector type for attribute %qE", name);
5245 if (vecsize % tree_low_cst (TYPE_SIZE_UNIT (type), 1))
5247 error ("vector size not an integral multiple of component size");
5253 error ("zero vector size");
5257 /* Calculate how many units fit in the vector. */
5258 nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
5259 if (nunits & (nunits - 1))
5261 error ("number of components of the vector not a power of two");
5265 new_type = build_vector_type (type, nunits);
5267 /* Build back pointers if needed. */
5268 *node = reconstruct_complex_type (*node, new_type);
5273 /* Handle the "nonnull" attribute. */
5275 handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
5276 tree args, int ARG_UNUSED (flags),
5280 unsigned HOST_WIDE_INT attr_arg_num;
5282 /* If no arguments are specified, all pointer arguments should be
5283 non-null. Verify a full prototype is given so that the arguments
5284 will have the correct types when we actually check them later. */
5287 if (!TYPE_ARG_TYPES (type))
5289 error ("nonnull attribute without arguments on a non-prototype");
5290 *no_add_attrs = true;
5295 /* Argument list specified. Verify that each argument number references
5296 a pointer argument. */
5297 for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
5300 unsigned HOST_WIDE_INT arg_num = 0, ck_num;
5302 if (!get_nonnull_operand (TREE_VALUE (args), &arg_num))
5304 error ("nonnull argument has invalid operand number (argument %lu)",
5305 (unsigned long) attr_arg_num);
5306 *no_add_attrs = true;
5310 argument = TYPE_ARG_TYPES (type);
5313 for (ck_num = 1; ; ck_num++)
5315 if (!argument || ck_num == arg_num)
5317 argument = TREE_CHAIN (argument);
5321 || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
5323 error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
5324 (unsigned long) attr_arg_num, (unsigned long) arg_num);
5325 *no_add_attrs = true;
5329 if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
5331 error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
5332 (unsigned long) attr_arg_num, (unsigned long) arg_num);
5333 *no_add_attrs = true;
5342 /* Check the argument list of a function call for null in argument slots
5343 that are marked as requiring a non-null pointer argument. */
5346 check_function_nonnull (tree attrs, tree params)
5348 tree a, args, param;
5351 for (a = attrs; a; a = TREE_CHAIN (a))
5353 if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
5355 args = TREE_VALUE (a);
5357 /* Walk the argument list. If we encounter an argument number we
5358 should check for non-null, do it. If the attribute has no args,
5359 then every pointer argument is checked (in which case the check
5360 for pointer type is done in check_nonnull_arg). */
5361 for (param = params, param_num = 1; ;
5362 param_num++, param = TREE_CHAIN (param))
5366 if (!args || nonnull_check_p (args, param_num))
5367 check_function_arguments_recurse (check_nonnull_arg, NULL,
5375 /* Check that the Nth argument of a function call (counting backwards
5376 from the end) is a (pointer)0. */
5379 check_function_sentinel (tree attrs, tree params, tree typelist)
5381 tree attr = lookup_attribute ("sentinel", attrs);
5385 /* Skip over the named arguments. */
5386 while (typelist && params)
5388 typelist = TREE_CHAIN (typelist);
5389 params = TREE_CHAIN (params);
5392 if (typelist || !params)
5393 warning (OPT_Wformat,
5394 "not enough variable arguments to fit a sentinel");
5400 if (TREE_VALUE (attr))
5402 tree p = TREE_VALUE (TREE_VALUE (attr));
5403 pos = TREE_INT_CST_LOW (p);
5406 sentinel = end = params;
5408 /* Advance `end' ahead of `sentinel' by `pos' positions. */
5409 while (pos > 0 && TREE_CHAIN (end))
5412 end = TREE_CHAIN (end);
5416 warning (OPT_Wformat,
5417 "not enough variable arguments to fit a sentinel");
5421 /* Now advance both until we find the last parameter. */
5422 while (TREE_CHAIN (end))
5424 end = TREE_CHAIN (end);
5425 sentinel = TREE_CHAIN (sentinel);
5428 /* Validate the sentinel. */
5429 if ((!POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (sentinel)))
5430 || !integer_zerop (TREE_VALUE (sentinel)))
5431 /* Although __null (in C++) is only an integer we allow it
5432 nevertheless, as we are guaranteed that it's exactly
5433 as wide as a pointer, and we don't want to force
5434 users to cast the NULL they have written there.
5435 We warn with -Wstrict-null-sentinel, though. */
5436 && (warn_strict_null_sentinel
5437 || null_node != TREE_VALUE (sentinel)))
5438 warning (OPT_Wformat, "missing sentinel in function call");
5443 /* Helper for check_function_nonnull; given a list of operands which
5444 must be non-null in ARGS, determine if operand PARAM_NUM should be
5448 nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num)
5450 unsigned HOST_WIDE_INT arg_num = 0;
5452 for (; args; args = TREE_CHAIN (args))
5454 bool found = get_nonnull_operand (TREE_VALUE (args), &arg_num);
5458 if (arg_num == param_num)
5464 /* Check that the function argument PARAM (which is operand number
5465 PARAM_NUM) is non-null. This is called by check_function_nonnull
5466 via check_function_arguments_recurse. */
5469 check_nonnull_arg (void * ARG_UNUSED (ctx), tree param,
5470 unsigned HOST_WIDE_INT param_num)
5472 /* Just skip checking the argument if it's not a pointer. This can
5473 happen if the "nonnull" attribute was given without an operand
5474 list (which means to check every pointer argument). */
5476 if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
5479 if (integer_zerop (param))
5480 warning (OPT_Wnonnull, "null argument where non-null required "
5481 "(argument %lu)", (unsigned long) param_num);
5484 /* Helper for nonnull attribute handling; fetch the operand number
5485 from the attribute argument list. */
5488 get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
5490 /* Verify the arg number is a constant. */
5491 if (TREE_CODE (arg_num_expr) != INTEGER_CST
5492 || TREE_INT_CST_HIGH (arg_num_expr) != 0)
5495 *valp = TREE_INT_CST_LOW (arg_num_expr);
5499 /* Handle a "nothrow" attribute; arguments as in
5500 struct attribute_spec.handler. */
5503 handle_nothrow_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5504 int ARG_UNUSED (flags), bool *no_add_attrs)
5506 if (TREE_CODE (*node) == FUNCTION_DECL)
5507 TREE_NOTHROW (*node) = 1;
5508 /* ??? TODO: Support types. */
5511 warning (OPT_Wattributes, "%qE attribute ignored", name);
5512 *no_add_attrs = true;
5518 /* Handle a "cleanup" attribute; arguments as in
5519 struct attribute_spec.handler. */
5522 handle_cleanup_attribute (tree *node, tree name, tree args,
5523 int ARG_UNUSED (flags), bool *no_add_attrs)
5526 tree cleanup_id, cleanup_decl;
5528 /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
5529 for global destructors in C++. This requires infrastructure that
5530 we don't have generically at the moment. It's also not a feature
5531 we'd be missing too much, since we do have attribute constructor. */
5532 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
5534 warning (OPT_Wattributes, "%qE attribute ignored", name);
5535 *no_add_attrs = true;
5539 /* Verify that the argument is a function in scope. */
5540 /* ??? We could support pointers to functions here as well, if
5541 that was considered desirable. */
5542 cleanup_id = TREE_VALUE (args);
5543 if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE)
5545 error ("cleanup argument not an identifier");
5546 *no_add_attrs = true;
5549 cleanup_decl = lookup_name (cleanup_id);
5550 if (!cleanup_decl || TREE_CODE (cleanup_decl) != FUNCTION_DECL)
5552 error ("cleanup argument not a function");
5553 *no_add_attrs = true;
5557 /* That the function has proper type is checked with the
5558 eventual call to build_function_call. */
5563 /* Handle a "warn_unused_result" attribute. No special handling. */
5566 handle_warn_unused_result_attribute (tree *node, tree name,
5567 tree ARG_UNUSED (args),
5568 int ARG_UNUSED (flags), bool *no_add_attrs)
5570 /* Ignore the attribute for functions not returning any value. */
5571 if (VOID_TYPE_P (TREE_TYPE (*node)))
5573 warning (OPT_Wattributes, "%qE attribute ignored", name);
5574 *no_add_attrs = true;
5580 /* Handle a "sentinel" attribute. */
5583 handle_sentinel_attribute (tree *node, tree name, tree args,
5584 int ARG_UNUSED (flags), bool *no_add_attrs)
5586 tree params = TYPE_ARG_TYPES (*node);
5590 warning (OPT_Wattributes,
5591 "%qE attribute requires prototypes with named arguments", name);
5592 *no_add_attrs = true;
5596 while (TREE_CHAIN (params))
5597 params = TREE_CHAIN (params);
5599 if (VOID_TYPE_P (TREE_VALUE (params)))
5601 warning (OPT_Wattributes,
5602 "%qE attribute only applies to variadic functions", name);
5603 *no_add_attrs = true;
5609 tree position = TREE_VALUE (args);
5611 if (TREE_CODE (position) != INTEGER_CST)
5613 warning (0, "requested position is not an integer constant");
5614 *no_add_attrs = true;
5618 if (tree_int_cst_lt (position, integer_zero_node))
5620 warning (0, "requested position is less than zero");
5621 *no_add_attrs = true;
5629 /* Check for valid arguments being passed to a function. */
5631 check_function_arguments (tree attrs, tree params, tree typelist)
5633 /* Check for null being passed in a pointer argument that must be
5634 non-null. We also need to do this if format checking is enabled. */
5637 check_function_nonnull (attrs, params);
5639 /* Check for errors in format strings. */
5641 if (warn_format || warn_missing_format_attribute)
5642 check_function_format (attrs, params);
5645 check_function_sentinel (attrs, params, typelist);
5648 /* Generic argument checking recursion routine. PARAM is the argument to
5649 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
5650 once the argument is resolved. CTX is context for the callback. */
5652 check_function_arguments_recurse (void (*callback)
5653 (void *, tree, unsigned HOST_WIDE_INT),
5654 void *ctx, tree param,
5655 unsigned HOST_WIDE_INT param_num)
5657 if ((TREE_CODE (param) == NOP_EXPR || TREE_CODE (param) == CONVERT_EXPR)
5658 && (TYPE_PRECISION (TREE_TYPE (param))
5659 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (param, 0)))))
5661 /* Strip coercion. */
5662 check_function_arguments_recurse (callback, ctx,
5663 TREE_OPERAND (param, 0), param_num);
5667 if (TREE_CODE (param) == CALL_EXPR)
5669 tree type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (param, 0)));
5671 bool found_format_arg = false;
5673 /* See if this is a call to a known internationalization function
5674 that modifies a format arg. Such a function may have multiple
5675 format_arg attributes (for example, ngettext). */
5677 for (attrs = TYPE_ATTRIBUTES (type);
5679 attrs = TREE_CHAIN (attrs))
5680 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
5683 tree format_num_expr;
5687 /* Extract the argument number, which was previously checked
5689 format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
5691 gcc_assert (TREE_CODE (format_num_expr) == INTEGER_CST
5692 && !TREE_INT_CST_HIGH (format_num_expr));
5694 format_num = TREE_INT_CST_LOW (format_num_expr);
5696 for (inner_args = TREE_OPERAND (param, 1), i = 1;
5698 inner_args = TREE_CHAIN (inner_args), i++)
5699 if (i == format_num)
5701 check_function_arguments_recurse (callback, ctx,
5702 TREE_VALUE (inner_args),
5704 found_format_arg = true;
5709 /* If we found a format_arg attribute and did a recursive check,
5710 we are done with checking this argument. Otherwise, we continue
5711 and this will be considered a non-literal. */
5712 if (found_format_arg)
5716 if (TREE_CODE (param) == COND_EXPR)
5718 /* Check both halves of the conditional expression. */
5719 check_function_arguments_recurse (callback, ctx,
5720 TREE_OPERAND (param, 1), param_num);
5721 check_function_arguments_recurse (callback, ctx,
5722 TREE_OPERAND (param, 2), param_num);
5726 (*callback) (ctx, param, param_num);
5729 /* Function to help qsort sort FIELD_DECLs by name order. */
5732 field_decl_cmp (const void *x_p, const void *y_p)
5734 const tree *const x = (const tree *const) x_p;
5735 const tree *const y = (const tree *const) y_p;
5737 if (DECL_NAME (*x) == DECL_NAME (*y))
5738 /* A nontype is "greater" than a type. */
5739 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
5740 if (DECL_NAME (*x) == NULL_TREE)
5742 if (DECL_NAME (*y) == NULL_TREE)
5744 if (DECL_NAME (*x) < DECL_NAME (*y))
5750 gt_pointer_operator new_value;
5754 /* This routine compares two fields like field_decl_cmp but using the
5755 pointer operator in resort_data. */
5758 resort_field_decl_cmp (const void *x_p, const void *y_p)
5760 const tree *const x = (const tree *const) x_p;
5761 const tree *const y = (const tree *const) y_p;
5763 if (DECL_NAME (*x) == DECL_NAME (*y))
5764 /* A nontype is "greater" than a type. */
5765 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
5766 if (DECL_NAME (*x) == NULL_TREE)
5768 if (DECL_NAME (*y) == NULL_TREE)
5771 tree d1 = DECL_NAME (*x);
5772 tree d2 = DECL_NAME (*y);
5773 resort_data.new_value (&d1, resort_data.cookie);
5774 resort_data.new_value (&d2, resort_data.cookie);
5781 /* Resort DECL_SORTED_FIELDS because pointers have been reordered. */
5784 resort_sorted_fields (void *obj,
5785 void * ARG_UNUSED (orig_obj),
5786 gt_pointer_operator new_value,
5789 struct sorted_fields_type *sf = (struct sorted_fields_type *) obj;
5790 resort_data.new_value = new_value;
5791 resort_data.cookie = cookie;
5792 qsort (&sf->elts[0], sf->len, sizeof (tree),
5793 resort_field_decl_cmp);
5796 /* Subroutine of c_parse_error.
5797 Return the result of concatenating LHS and RHS. RHS is really
5798 a string literal, its first character is indicated by RHS_START and
5799 RHS_SIZE is its length (including the terminating NUL character).
5801 The caller is responsible for deleting the returned pointer. */
5804 catenate_strings (const char *lhs, const char *rhs_start, int rhs_size)
5806 const int lhs_size = strlen (lhs);
5807 char *result = XNEWVEC (char, lhs_size + rhs_size);
5808 strncpy (result, lhs, lhs_size);
5809 strncpy (result + lhs_size, rhs_start, rhs_size);
5813 /* Issue the error given by GMSGID, indicating that it occurred before
5814 TOKEN, which had the associated VALUE. */
5817 c_parse_error (const char *gmsgid, enum cpp_ttype token, tree value)
5819 #define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
5821 char *message = NULL;
5823 if (token == CPP_EOF)
5824 message = catenate_messages (gmsgid, " at end of input");
5825 else if (token == CPP_CHAR || token == CPP_WCHAR)
5827 unsigned int val = TREE_INT_CST_LOW (value);
5828 const char *const ell = (token == CPP_CHAR) ? "" : "L";
5829 if (val <= UCHAR_MAX && ISGRAPH (val))
5830 message = catenate_messages (gmsgid, " before %s'%c'");
5832 message = catenate_messages (gmsgid, " before %s'\\x%x'");
5834 error (message, ell, val);
5838 else if (token == CPP_STRING || token == CPP_WSTRING)
5839 message = catenate_messages (gmsgid, " before string constant");
5840 else if (token == CPP_NUMBER)
5841 message = catenate_messages (gmsgid, " before numeric constant");
5842 else if (token == CPP_NAME)
5844 message = catenate_messages (gmsgid, " before %qE");
5845 error (message, value);
5849 else if (token == CPP_PRAGMA)
5850 message = catenate_messages (gmsgid, " before %<#pragma%>");
5851 else if (token == CPP_PRAGMA_EOL)
5852 message = catenate_messages (gmsgid, " before end of line");
5853 else if (token < N_TTYPES)
5855 message = catenate_messages (gmsgid, " before %qs token");
5856 error (message, cpp_type2name (token));
5868 #undef catenate_messages
5871 /* Walk a gimplified function and warn for functions whose return value is
5872 ignored and attribute((warn_unused_result)) is set. This is done before
5873 inlining, so we don't have to worry about that. */
5876 c_warn_unused_result (tree *top_p)
5879 tree_stmt_iterator i;
5882 switch (TREE_CODE (t))
5884 case STATEMENT_LIST:
5885 for (i = tsi_start (*top_p); !tsi_end_p (i); tsi_next (&i))
5886 c_warn_unused_result (tsi_stmt_ptr (i));
5890 c_warn_unused_result (&COND_EXPR_THEN (t));
5891 c_warn_unused_result (&COND_EXPR_ELSE (t));
5894 c_warn_unused_result (&BIND_EXPR_BODY (t));
5896 case TRY_FINALLY_EXPR:
5897 case TRY_CATCH_EXPR:
5898 c_warn_unused_result (&TREE_OPERAND (t, 0));
5899 c_warn_unused_result (&TREE_OPERAND (t, 1));
5902 c_warn_unused_result (&CATCH_BODY (t));
5904 case EH_FILTER_EXPR:
5905 c_warn_unused_result (&EH_FILTER_FAILURE (t));
5912 /* This is a naked call, as opposed to a CALL_EXPR nested inside
5913 a MODIFY_EXPR. All calls whose value is ignored should be
5914 represented like this. Look for the attribute. */
5915 fdecl = get_callee_fndecl (t);
5917 ftype = TREE_TYPE (fdecl);
5920 ftype = TREE_TYPE (TREE_OPERAND (t, 0));
5921 /* Look past pointer-to-function to the function type itself. */
5922 ftype = TREE_TYPE (ftype);
5925 if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype)))
5928 warning (0, "%Hignoring return value of %qD, "
5929 "declared with attribute warn_unused_result",
5930 EXPR_LOCUS (t), fdecl);
5932 warning (0, "%Hignoring return value of function "
5933 "declared with attribute warn_unused_result",
5939 /* Not a container, not a call, or a call whose value is used. */
5944 /* Convert a character from the host to the target execution character
5945 set. cpplib handles this, mostly. */
5948 c_common_to_target_charset (HOST_WIDE_INT c)
5950 /* Character constants in GCC proper are sign-extended under -fsigned-char,
5951 zero-extended under -fno-signed-char. cpplib insists that characters
5952 and character constants are always unsigned. Hence we must convert
5954 cppchar_t uc = ((cppchar_t)c) & ((((cppchar_t)1) << CHAR_BIT)-1);
5956 uc = cpp_host_to_exec_charset (parse_in, uc);
5958 if (flag_signed_char)
5959 return ((HOST_WIDE_INT)uc) << (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE)
5960 >> (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE);
5965 /* Build the result of __builtin_offsetof. EXPR is a nested sequence of
5966 component references, with an INDIRECT_REF at the bottom; much like
5967 the traditional rendering of offsetof as a macro. Returns the folded
5968 and properly cast result. */
5971 fold_offsetof_1 (tree expr)
5973 enum tree_code code = PLUS_EXPR;
5976 switch (TREE_CODE (expr))
5982 return size_zero_node;
5985 base = fold_offsetof_1 (TREE_OPERAND (expr, 0));
5986 if (base == error_mark_node)
5989 t = TREE_OPERAND (expr, 1);
5990 if (DECL_C_BIT_FIELD (t))
5992 error ("attempt to take address of bit-field structure "
5994 return error_mark_node;
5996 off = size_binop (PLUS_EXPR, DECL_FIELD_OFFSET (t),
5997 size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t), 1)
6002 base = fold_offsetof_1 (TREE_OPERAND (expr, 0));
6003 if (base == error_mark_node)
6006 t = TREE_OPERAND (expr, 1);
6007 if (TREE_CODE (t) == INTEGER_CST && tree_int_cst_sgn (t) < 0)
6010 t = fold_build1 (NEGATE_EXPR, TREE_TYPE (t), t);
6012 t = convert (sizetype, t);
6013 off = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (TREE_TYPE (expr)), t);
6020 return size_binop (code, base, off);
6024 fold_offsetof (tree expr)
6026 /* Convert back from the internal sizetype to size_t. */
6027 return convert (size_type_node, fold_offsetof_1 (expr));
6030 /* Print an error message for an invalid lvalue. USE says
6031 how the lvalue is being used and so selects the error message. */
6034 lvalue_error (enum lvalue_use use)
6039 error ("lvalue required as left operand of assignment");
6042 error ("lvalue required as increment operand");
6045 error ("lvalue required as decrement operand");
6048 error ("lvalue required as unary %<&%> operand");
6051 error ("lvalue required in asm statement");
6058 /* *PTYPE is an incomplete array. Complete it with a domain based on
6059 INITIAL_VALUE. If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
6060 is true. Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
6061 2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty. */
6064 complete_array_type (tree *ptype, tree initial_value, bool do_default)
6066 tree maxindex, type, main_type, elt, unqual_elt;
6067 int failure = 0, quals;
6069 maxindex = size_zero_node;
6072 if (TREE_CODE (initial_value) == STRING_CST)
6075 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
6076 maxindex = size_int (TREE_STRING_LENGTH (initial_value)/eltsize - 1);
6078 else if (TREE_CODE (initial_value) == CONSTRUCTOR)
6080 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
6082 if (VEC_empty (constructor_elt, v))
6086 maxindex = integer_minus_one_node;
6091 unsigned HOST_WIDE_INT cnt;
6092 constructor_elt *ce;
6094 if (VEC_index (constructor_elt, v, 0)->index)
6095 maxindex = fold_convert (sizetype,
6096 VEC_index (constructor_elt,
6098 curindex = maxindex;
6101 VEC_iterate (constructor_elt, v, cnt, ce);
6105 curindex = fold_convert (sizetype, ce->index);
6107 curindex = size_binop (PLUS_EXPR, curindex, size_one_node);
6109 if (tree_int_cst_lt (maxindex, curindex))
6110 maxindex = curindex;
6116 /* Make an error message unless that happened already. */
6117 if (initial_value != error_mark_node)
6129 elt = TREE_TYPE (type);
6130 quals = TYPE_QUALS (strip_array_types (elt));
6134 unqual_elt = c_build_qualified_type (elt, TYPE_UNQUALIFIED);
6136 /* Using build_distinct_type_copy and modifying things afterward instead
6137 of using build_array_type to create a new type preserves all of the
6138 TYPE_LANG_FLAG_? bits that the front end may have set. */
6139 main_type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
6140 TREE_TYPE (main_type) = unqual_elt;
6141 TYPE_DOMAIN (main_type) = build_index_type (maxindex);
6142 layout_type (main_type);
6147 type = c_build_qualified_type (main_type, quals);
6154 /* Used to help initialize the builtin-types.def table. When a type of
6155 the correct size doesn't exist, use error_mark_node instead of NULL.
6156 The later results in segfaults even when a decl using the type doesn't
6160 builtin_type_for_size (int size, bool unsignedp)
6162 tree type = lang_hooks.types.type_for_size (size, unsignedp);
6163 return type ? type : error_mark_node;
6166 /* A helper function for resolve_overloaded_builtin in resolving the
6167 overloaded __sync_ builtins. Returns a positive power of 2 if the
6168 first operand of PARAMS is a pointer to a supported data type.
6169 Returns 0 if an error is encountered. */
6172 sync_resolve_size (tree function, tree params)
6179 error ("too few arguments to function %qE", function);
6183 type = TREE_TYPE (TREE_VALUE (params));
6184 if (TREE_CODE (type) != POINTER_TYPE)
6187 type = TREE_TYPE (type);
6188 if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
6191 size = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
6192 if (size == 1 || size == 2 || size == 4 || size == 8 || size == 16)
6196 error ("incompatible type for argument %d of %qE", 1, function);
6200 /* A helper function for resolve_overloaded_builtin. Adds casts to
6201 PARAMS to make arguments match up with those of FUNCTION. Drops
6202 the variadic arguments at the end. Returns false if some error
6203 was encountered; true on success. */
6206 sync_resolve_params (tree orig_function, tree function, tree params)
6208 tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (function));
6212 /* We've declared the implementation functions to use "volatile void *"
6213 as the pointer parameter, so we shouldn't get any complaints from the
6214 call to check_function_arguments what ever type the user used. */
6215 arg_types = TREE_CHAIN (arg_types);
6216 ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params)));
6219 /* For the rest of the values, we need to cast these to FTYPE, so that we
6220 don't get warnings for passing pointer types, etc. */
6221 while (arg_types != void_list_node)
6225 params = TREE_CHAIN (params);
6228 error ("too few arguments to function %qE", orig_function);
6232 /* ??? Ideally for the first conversion we'd use convert_for_assignment
6233 so that we get warnings for anything that doesn't match the pointer
6234 type. This isn't portable across the C and C++ front ends atm. */
6235 val = TREE_VALUE (params);
6236 val = convert (ptype, val);
6237 val = convert (TREE_VALUE (arg_types), val);
6238 TREE_VALUE (params) = val;
6240 arg_types = TREE_CHAIN (arg_types);
6244 /* The definition of these primitives is variadic, with the remaining
6245 being "an optional list of variables protected by the memory barrier".
6246 No clue what that's supposed to mean, precisely, but we consider all
6247 call-clobbered variables to be protected so we're safe. */
6248 TREE_CHAIN (params) = NULL;
6253 /* A helper function for resolve_overloaded_builtin. Adds a cast to
6254 RESULT to make it match the type of the first pointer argument in
6258 sync_resolve_return (tree params, tree result)
6260 tree ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params)));
6261 ptype = TYPE_MAIN_VARIANT (ptype);
6262 return convert (ptype, result);
6265 /* Some builtin functions are placeholders for other expressions. This
6266 function should be called immediately after parsing the call expression
6267 before surrounding code has committed to the type of the expression.
6269 FUNCTION is the DECL that has been invoked; it is known to be a builtin.
6270 PARAMS is the argument list for the call. The return value is non-null
6271 when expansion is complete, and null if normal processing should
6275 resolve_overloaded_builtin (tree function, tree params)
6277 enum built_in_function orig_code = DECL_FUNCTION_CODE (function);
6278 switch (DECL_BUILT_IN_CLASS (function))
6280 case BUILT_IN_NORMAL:
6283 if (targetm.resolve_overloaded_builtin)
6284 return targetm.resolve_overloaded_builtin (function, params);
6291 /* Handle BUILT_IN_NORMAL here. */
6294 case BUILT_IN_FETCH_AND_ADD_N:
6295 case BUILT_IN_FETCH_AND_SUB_N:
6296 case BUILT_IN_FETCH_AND_OR_N:
6297 case BUILT_IN_FETCH_AND_AND_N:
6298 case BUILT_IN_FETCH_AND_XOR_N:
6299 case BUILT_IN_FETCH_AND_NAND_N:
6300 case BUILT_IN_ADD_AND_FETCH_N:
6301 case BUILT_IN_SUB_AND_FETCH_N:
6302 case BUILT_IN_OR_AND_FETCH_N:
6303 case BUILT_IN_AND_AND_FETCH_N:
6304 case BUILT_IN_XOR_AND_FETCH_N:
6305 case BUILT_IN_NAND_AND_FETCH_N:
6306 case BUILT_IN_BOOL_COMPARE_AND_SWAP_N:
6307 case BUILT_IN_VAL_COMPARE_AND_SWAP_N:
6308 case BUILT_IN_LOCK_TEST_AND_SET_N:
6309 case BUILT_IN_LOCK_RELEASE_N:
6311 int n = sync_resolve_size (function, params);
6312 tree new_function, result;
6315 return error_mark_node;
6317 new_function = built_in_decls[orig_code + exact_log2 (n) + 1];
6318 if (!sync_resolve_params (function, new_function, params))
6319 return error_mark_node;
6321 result = build_function_call (new_function, params);
6322 if (orig_code != BUILT_IN_BOOL_COMPARE_AND_SWAP_N
6323 && orig_code != BUILT_IN_LOCK_RELEASE_N)
6324 result = sync_resolve_return (params, result);
6334 /* Ignoring their sign, return true if two scalar types are the same. */
6336 same_scalar_type_ignoring_signedness (tree t1, tree t2)
6338 enum tree_code c1 = TREE_CODE (t1), c2 = TREE_CODE (t2);
6340 gcc_assert ((c1 == INTEGER_TYPE || c1 == REAL_TYPE)
6341 && (c2 == INTEGER_TYPE || c2 == REAL_TYPE));
6343 /* Equality works here because c_common_signed_type uses
6344 TYPE_MAIN_VARIANT. */
6345 return lang_hooks.types.signed_type (t1)
6346 == lang_hooks.types.signed_type (t2);
6349 /* Check for missing format attributes on function pointers. LTYPE is
6350 the new type or left-hand side type. RTYPE is the old type or
6351 right-hand side type. Returns TRUE if LTYPE is missing the desired
6355 check_missing_format_attribute (tree ltype, tree rtype)
6357 tree const ttr = TREE_TYPE (rtype), ttl = TREE_TYPE (ltype);
6360 for (ra = TYPE_ATTRIBUTES (ttr); ra; ra = TREE_CHAIN (ra))
6361 if (is_attribute_p ("format", TREE_PURPOSE (ra)))
6366 for (la = TYPE_ATTRIBUTES (ttl); la; la = TREE_CHAIN (la))
6367 if (is_attribute_p ("format", TREE_PURPOSE (la)))
6375 /* Subscripting with type char is likely to lose on a machine where
6376 chars are signed. So warn on any machine, but optionally. Don't
6377 warn for unsigned char since that type is safe. Don't warn for
6378 signed char because anyone who uses that must have done so
6379 deliberately. Furthermore, we reduce the false positive load by
6380 warning only for non-constant value of type char. */
6383 warn_array_subscript_with_type_char (tree index)
6385 if (TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node
6386 && TREE_CODE (index) != INTEGER_CST)
6387 warning (OPT_Wchar_subscripts, "array subscript has type %<char%>");
6391 #include "gt-c-common.h"