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, 2006, 2007 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 /* Warn about #pragma directives that are not recognized. */
270 int warn_unknown_pragmas
; /* Tri state variable. */
272 /* Warn about format/argument anomalies in calls to formatted I/O functions
273 (*printf, *scanf, strftime, strfmon, etc.). */
277 /* Warn about using __null (as NULL in C++) as sentinel. For code compiled
278 with GCC this doesn't matter as __null is guaranteed to have the right
281 int warn_strict_null_sentinel
;
283 /* Zero means that faster, ...NonNil variants of objc_msgSend...
284 calls will be used in ObjC; passing nil receivers to such calls
285 will most likely result in crashes. */
286 int flag_nil_receivers
= 1;
288 /* Nonzero means that code generation will be altered to support
289 "zero-link" execution. This currently affects ObjC only, but may
290 affect other languages in the future. */
291 int flag_zero_link
= 0;
293 /* Nonzero means emit an '__OBJC, __image_info' for the current translation
294 unit. It will inform the ObjC runtime that class definition(s) herein
295 contained are to replace one(s) previously loaded. */
296 int flag_replace_objc_classes
= 0;
298 /* C/ObjC language option variables. */
301 /* Nonzero means allow type mismatches in conditional expressions;
302 just make their values `void'. */
304 int flag_cond_mismatch
;
306 /* Nonzero means enable C89 Amendment 1 features. */
310 /* Nonzero means use the ISO C99 dialect of C. */
314 /* Nonzero means that we have builtin functions, and main is an int. */
318 /* Warn if main is suspicious. */
323 /* ObjC language option variables. */
326 /* Open and close the file for outputting class declarations, if
329 int flag_gen_declaration
;
331 /* Tells the compiler that this is a special run. Do not perform any
332 compiling, instead we are to test some platform dependent features
333 and output a C header file with appropriate definitions. */
335 int print_struct_values
;
337 /* Tells the compiler what is the constant string class for Objc. */
339 const char *constant_string_class_name
;
342 /* C++ language option variables. */
345 /* Nonzero means don't recognize any extension keywords. */
347 int flag_no_gnu_keywords
;
349 /* Nonzero means do emit exported implementations of functions even if
350 they can be inlined. */
352 int flag_implement_inlines
= 1;
354 /* Nonzero means that implicit instantiations will be emitted if needed. */
356 int flag_implicit_templates
= 1;
358 /* Nonzero means that implicit instantiations of inline templates will be
359 emitted if needed, even if instantiations of non-inline templates
362 int flag_implicit_inline_templates
= 1;
364 /* Nonzero means generate separate instantiation control files and
365 juggle them at link time. */
367 int flag_use_repository
;
369 /* Nonzero if we want to issue diagnostics that the standard says are not
372 int flag_optional_diags
= 1;
374 /* Nonzero means we should attempt to elide constructors when possible. */
376 int flag_elide_constructors
= 1;
378 /* Nonzero means that member functions defined in class scope are
379 inline by default. */
381 int flag_default_inline
= 1;
383 /* Controls whether compiler generates 'type descriptor' that give
384 run-time type information. */
388 /* Nonzero if we want to conserve space in the .o files. We do this
389 by putting uninitialized data and runtime initialized data into
390 .common instead of .data at the expense of not flagging multiple
393 int flag_conserve_space
;
395 /* Nonzero if we want to obey access control semantics. */
397 int flag_access_control
= 1;
399 /* Nonzero if we want to check the return value of new and avoid calling
400 constructors if it is a null pointer. */
404 /* Nonzero if we want to allow the use of experimental features that
405 are likely to become part of C++0x. */
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. '2' means it has been
433 set nonzero as a default, not by a command-line flag. */
435 int flag_use_cxa_atexit
= DEFAULT_USE_CXA_ATEXIT
;
437 /* Nonzero to use __cxa_get_exception_ptr in C++ exception-handling
438 code. '2' means it has not been set explicitly on the command line. */
440 int flag_use_cxa_get_exception_ptr
= 2;
442 /* Nonzero means make the default pedwarns warnings instead of errors.
443 The value of this flag is ignored if -pedantic is specified. */
447 /* Nonzero means to implement standard semantics for exception
448 specifications, calling unexpected if an exception is thrown that
449 doesn't match the specification. Zero means to treat them as
450 assertions and optimize accordingly, but not check them. */
452 int flag_enforce_eh_specs
= 1;
454 /* Nonzero means to generate thread-safe code for initializing local
457 int flag_threadsafe_statics
= 1;
459 /* Nonzero means warn about implicit declarations. */
461 int warn_implicit
= 1;
463 /* Maximum template instantiation depth. This limit is rather
464 arbitrary, but it exists to limit the time it takes to notice
465 infinite template instantiations. */
467 int max_tinst_depth
= 500;
471 /* The elements of `ridpointers' are identifier nodes for the reserved
472 type names and storage classes. It is indexed by a RID_... value. */
475 tree (*make_fname_decl
) (tree
, int);
477 /* Nonzero means the expression being parsed will never be evaluated.
478 This is a count, since unevaluated expressions can nest. */
481 /* Information about how a function name is generated. */
484 tree
*const decl
; /* pointer to the VAR_DECL. */
485 const unsigned rid
; /* RID number for the identifier. */
486 const int pretty
; /* How pretty is it? */
489 /* The three ways of getting then name of the current function. */
491 const struct fname_var_t fname_vars
[] =
493 /* C99 compliant __func__, must be first. */
494 {&c99_function_name_decl_node
, RID_C99_FUNCTION_NAME
, 0},
495 /* GCC __FUNCTION__ compliant. */
496 {&function_name_decl_node
, RID_FUNCTION_NAME
, 0},
497 /* GCC __PRETTY_FUNCTION__ compliant. */
498 {&pretty_function_name_decl_node
, RID_PRETTY_FUNCTION_NAME
, 1},
502 static tree
check_case_value (tree
);
503 static bool check_case_bounds (tree
, tree
, tree
*, tree
*);
505 static tree
handle_packed_attribute (tree
*, tree
, tree
, int, bool *);
506 static tree
handle_nocommon_attribute (tree
*, tree
, tree
, int, bool *);
507 static tree
handle_common_attribute (tree
*, tree
, tree
, int, bool *);
508 static tree
handle_noreturn_attribute (tree
*, tree
, tree
, int, bool *);
509 static tree
handle_noinline_attribute (tree
*, tree
, tree
, int, bool *);
510 static tree
handle_always_inline_attribute (tree
*, tree
, tree
, int,
512 static tree
handle_gnu_inline_attribute (tree
*, tree
, tree
, int,
514 static tree
handle_flatten_attribute (tree
*, tree
, tree
, int, bool *);
515 static tree
handle_used_attribute (tree
*, tree
, tree
, int, bool *);
516 static tree
handle_unused_attribute (tree
*, tree
, tree
, int, bool *);
517 static tree
handle_externally_visible_attribute (tree
*, tree
, tree
, int,
519 static tree
handle_const_attribute (tree
*, tree
, tree
, int, bool *);
520 static tree
handle_transparent_union_attribute (tree
*, tree
, tree
,
522 static tree
handle_constructor_attribute (tree
*, tree
, tree
, int, bool *);
523 static tree
handle_destructor_attribute (tree
*, tree
, tree
, int, bool *);
524 static tree
handle_mode_attribute (tree
*, tree
, tree
, int, bool *);
525 static tree
handle_section_attribute (tree
*, tree
, tree
, int, bool *);
526 static tree
handle_aligned_attribute (tree
*, tree
, tree
, int, bool *);
527 static tree
handle_weak_attribute (tree
*, tree
, tree
, int, bool *) ;
528 static tree
handle_alias_attribute (tree
*, tree
, tree
, int, bool *);
529 static tree
handle_weakref_attribute (tree
*, tree
, tree
, int, bool *) ;
530 static tree
handle_visibility_attribute (tree
*, tree
, tree
, int,
532 static tree
handle_tls_model_attribute (tree
*, tree
, tree
, int,
534 static tree
handle_no_instrument_function_attribute (tree
*, tree
,
536 static tree
handle_malloc_attribute (tree
*, tree
, tree
, int, bool *);
537 static tree
handle_returns_twice_attribute (tree
*, tree
, tree
, int, bool *);
538 static tree
handle_no_limit_stack_attribute (tree
*, tree
, tree
, int,
540 static tree
handle_pure_attribute (tree
*, tree
, tree
, int, bool *);
541 static tree
handle_novops_attribute (tree
*, tree
, tree
, int, bool *);
542 static tree
handle_deprecated_attribute (tree
*, tree
, tree
, int,
544 static tree
handle_vector_size_attribute (tree
*, tree
, tree
, int,
546 static tree
handle_nonnull_attribute (tree
*, tree
, tree
, int, bool *);
547 static tree
handle_nothrow_attribute (tree
*, tree
, tree
, int, bool *);
548 static tree
handle_cleanup_attribute (tree
*, tree
, tree
, int, bool *);
549 static tree
handle_warn_unused_result_attribute (tree
*, tree
, tree
, int,
551 static tree
handle_sentinel_attribute (tree
*, tree
, tree
, int, bool *);
553 static void check_function_nonnull (tree
, tree
);
554 static void check_nonnull_arg (void *, tree
, unsigned HOST_WIDE_INT
);
555 static bool nonnull_check_p (tree
, unsigned HOST_WIDE_INT
);
556 static bool get_nonnull_operand (tree
, unsigned HOST_WIDE_INT
*);
557 static int resort_field_decl_cmp (const void *, const void *);
559 /* Table of machine-independent attributes common to all C-like languages. */
560 const struct attribute_spec c_common_attribute_table
[] =
562 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
563 { "packed", 0, 0, false, false, false,
564 handle_packed_attribute
},
565 { "nocommon", 0, 0, true, false, false,
566 handle_nocommon_attribute
},
567 { "common", 0, 0, true, false, false,
568 handle_common_attribute
},
569 /* FIXME: logically, noreturn attributes should be listed as
570 "false, true, true" and apply to function types. But implementing this
571 would require all the places in the compiler that use TREE_THIS_VOLATILE
572 on a decl to identify non-returning functions to be located and fixed
573 to check the function type instead. */
574 { "noreturn", 0, 0, true, false, false,
575 handle_noreturn_attribute
},
576 { "volatile", 0, 0, true, false, false,
577 handle_noreturn_attribute
},
578 { "noinline", 0, 0, true, false, false,
579 handle_noinline_attribute
},
580 { "always_inline", 0, 0, true, false, false,
581 handle_always_inline_attribute
},
582 { "gnu_inline", 0, 0, true, false, false,
583 handle_gnu_inline_attribute
},
584 { "flatten", 0, 0, true, false, false,
585 handle_flatten_attribute
},
586 { "used", 0, 0, true, false, false,
587 handle_used_attribute
},
588 { "unused", 0, 0, false, false, false,
589 handle_unused_attribute
},
590 { "externally_visible", 0, 0, true, false, false,
591 handle_externally_visible_attribute
},
592 /* The same comments as for noreturn attributes apply to const ones. */
593 { "const", 0, 0, true, false, false,
594 handle_const_attribute
},
595 { "transparent_union", 0, 0, false, false, false,
596 handle_transparent_union_attribute
},
597 { "constructor", 0, 0, true, false, false,
598 handle_constructor_attribute
},
599 { "destructor", 0, 0, true, false, false,
600 handle_destructor_attribute
},
601 { "mode", 1, 1, false, true, false,
602 handle_mode_attribute
},
603 { "section", 1, 1, true, false, false,
604 handle_section_attribute
},
605 { "aligned", 0, 1, false, false, false,
606 handle_aligned_attribute
},
607 { "weak", 0, 0, true, false, false,
608 handle_weak_attribute
},
609 { "alias", 1, 1, true, false, false,
610 handle_alias_attribute
},
611 { "weakref", 0, 1, true, false, false,
612 handle_weakref_attribute
},
613 { "no_instrument_function", 0, 0, true, false, false,
614 handle_no_instrument_function_attribute
},
615 { "malloc", 0, 0, true, false, false,
616 handle_malloc_attribute
},
617 { "returns_twice", 0, 0, true, false, false,
618 handle_returns_twice_attribute
},
619 { "no_stack_limit", 0, 0, true, false, false,
620 handle_no_limit_stack_attribute
},
621 { "pure", 0, 0, true, false, false,
622 handle_pure_attribute
},
623 /* For internal use (marking of builtins) only. The name contains space
624 to prevent its usage in source code. */
625 { "no vops", 0, 0, true, false, false,
626 handle_novops_attribute
},
627 { "deprecated", 0, 0, false, false, false,
628 handle_deprecated_attribute
},
629 { "vector_size", 1, 1, false, true, false,
630 handle_vector_size_attribute
},
631 { "visibility", 1, 1, false, false, false,
632 handle_visibility_attribute
},
633 { "tls_model", 1, 1, true, false, false,
634 handle_tls_model_attribute
},
635 { "nonnull", 0, -1, false, true, true,
636 handle_nonnull_attribute
},
637 { "nothrow", 0, 0, true, false, false,
638 handle_nothrow_attribute
},
639 { "may_alias", 0, 0, false, true, false, NULL
},
640 { "cleanup", 1, 1, true, false, false,
641 handle_cleanup_attribute
},
642 { "warn_unused_result", 0, 0, false, true, true,
643 handle_warn_unused_result_attribute
},
644 { "sentinel", 0, 1, false, true, true,
645 handle_sentinel_attribute
},
646 { NULL
, 0, 0, false, false, false, NULL
}
649 /* Give the specifications for the format attributes, used by C and all
652 const struct attribute_spec c_common_format_attribute_table
[] =
654 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
655 { "format", 3, 3, false, true, true,
656 handle_format_attribute
},
657 { "format_arg", 1, 1, false, true, true,
658 handle_format_arg_attribute
},
659 { NULL
, 0, 0, false, false, false, NULL
}
662 /* Push current bindings for the function name VAR_DECLS. */
665 start_fname_decls (void)
668 tree saved
= NULL_TREE
;
670 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
672 tree decl
= *fname_vars
[ix
].decl
;
676 saved
= tree_cons (decl
, build_int_cst (NULL_TREE
, ix
), saved
);
677 *fname_vars
[ix
].decl
= NULL_TREE
;
680 if (saved
|| saved_function_name_decls
)
681 /* Normally they'll have been NULL, so only push if we've got a
682 stack, or they are non-NULL. */
683 saved_function_name_decls
= tree_cons (saved
, NULL_TREE
,
684 saved_function_name_decls
);
687 /* Finish up the current bindings, adding them into the current function's
688 statement tree. This must be done _before_ finish_stmt_tree is called.
689 If there is no current function, we must be at file scope and no statements
690 are involved. Pop the previous bindings. */
693 finish_fname_decls (void)
696 tree stmts
= NULL_TREE
;
697 tree stack
= saved_function_name_decls
;
699 for (; stack
&& TREE_VALUE (stack
); stack
= TREE_CHAIN (stack
))
700 append_to_statement_list (TREE_VALUE (stack
), &stmts
);
704 tree
*bodyp
= &DECL_SAVED_TREE (current_function_decl
);
706 if (TREE_CODE (*bodyp
) == BIND_EXPR
)
707 bodyp
= &BIND_EXPR_BODY (*bodyp
);
709 append_to_statement_list_force (*bodyp
, &stmts
);
713 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
714 *fname_vars
[ix
].decl
= NULL_TREE
;
718 /* We had saved values, restore them. */
721 for (saved
= TREE_PURPOSE (stack
); saved
; saved
= TREE_CHAIN (saved
))
723 tree decl
= TREE_PURPOSE (saved
);
724 unsigned ix
= TREE_INT_CST_LOW (TREE_VALUE (saved
));
726 *fname_vars
[ix
].decl
= decl
;
728 stack
= TREE_CHAIN (stack
);
730 saved_function_name_decls
= stack
;
733 /* Return the text name of the current function, suitably prettified
734 by PRETTY_P. Return string must be freed by caller. */
737 fname_as_string (int pretty_p
)
739 const char *name
= "top level";
749 if (current_function_decl
)
750 name
= lang_hooks
.decl_printable_name (current_function_decl
, vrb
);
752 if (c_lex_string_translate
)
754 int len
= strlen (name
) + 3; /* Two for '"'s. One for NULL. */
755 cpp_string cstr
= { 0, 0 }, strname
;
757 namep
= XNEWVEC (char, len
);
758 snprintf (namep
, len
, "\"%s\"", name
);
759 strname
.text
= (unsigned char *) namep
;
760 strname
.len
= len
- 1;
762 if (cpp_interpret_string (parse_in
, &strname
, 1, &cstr
, false))
765 return (char *) cstr
.text
;
769 namep
= xstrdup (name
);
774 /* Expand DECL if it declares an entity not handled by the
778 c_expand_decl (tree decl
)
780 if (TREE_CODE (decl
) == VAR_DECL
&& !TREE_STATIC (decl
))
782 /* Let the back-end know about this variable. */
783 if (!anon_aggr_type_p (TREE_TYPE (decl
)))
784 emit_local_var (decl
);
786 expand_anon_union_decl (decl
, NULL_TREE
,
787 DECL_ANON_UNION_ELEMS (decl
));
796 /* Return the VAR_DECL for a const char array naming the current
797 function. If the VAR_DECL has not yet been created, create it
798 now. RID indicates how it should be formatted and IDENTIFIER_NODE
799 ID is its name (unfortunately C and C++ hold the RID values of
800 keywords in different places, so we can't derive RID from ID in
801 this language independent code. */
804 fname_decl (unsigned int rid
, tree id
)
807 tree decl
= NULL_TREE
;
809 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
810 if (fname_vars
[ix
].rid
== rid
)
813 decl
= *fname_vars
[ix
].decl
;
816 /* If a tree is built here, it would normally have the lineno of
817 the current statement. Later this tree will be moved to the
818 beginning of the function and this line number will be wrong.
819 To avoid this problem set the lineno to 0 here; that prevents
820 it from appearing in the RTL. */
822 location_t saved_location
= input_location
;
823 #ifdef USE_MAPPED_LOCATION
824 input_location
= UNKNOWN_LOCATION
;
829 stmts
= push_stmt_list ();
830 decl
= (*make_fname_decl
) (id
, fname_vars
[ix
].pretty
);
831 stmts
= pop_stmt_list (stmts
);
832 if (!IS_EMPTY_STMT (stmts
))
833 saved_function_name_decls
834 = tree_cons (decl
, stmts
, saved_function_name_decls
);
835 *fname_vars
[ix
].decl
= decl
;
836 input_location
= saved_location
;
838 if (!ix
&& !current_function_decl
)
839 pedwarn ("%qD is not defined outside of function scope", decl
);
844 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
847 fix_string_type (tree value
)
849 const int wchar_bytes
= TYPE_PRECISION (wchar_type_node
) / BITS_PER_UNIT
;
850 const int wide_flag
= TREE_TYPE (value
) == wchar_array_type_node
;
851 int length
= TREE_STRING_LENGTH (value
);
853 tree e_type
, i_type
, a_type
;
855 /* Compute the number of elements, for the array type. */
856 nchars
= wide_flag
? length
/ wchar_bytes
: length
;
858 /* C89 2.2.4.1, C99 5.2.4.1 (Translation limits). The analogous
859 limit in C++98 Annex B is very large (65536) and is not normative,
860 so we do not diagnose it (warn_overlength_strings is forced off
861 in c_common_post_options). */
862 if (warn_overlength_strings
)
864 const int nchars_max
= flag_isoc99
? 4095 : 509;
865 const int relevant_std
= flag_isoc99
? 99 : 90;
866 if (nchars
- 1 > nchars_max
)
867 /* Translators: The %d after 'ISO C' will be 90 or 99. Do not
868 separate the %d from the 'C'. 'ISO' should not be
869 translated, but it may be moved after 'C%d' in languages
870 where modifiers follow nouns. */
871 pedwarn ("string length %qd is greater than the length %qd "
872 "ISO C%d compilers are required to support",
873 nchars
- 1, nchars_max
, relevant_std
);
876 /* Create the array type for the string constant. The ISO C++
877 standard says that a string literal has type `const char[N]' or
878 `const wchar_t[N]'. We use the same logic when invoked as a C
879 front-end with -Wwrite-strings.
880 ??? We should change the type of an expression depending on the
881 state of a warning flag. We should just be warning -- see how
882 this is handled in the C++ front-end for the deprecated implicit
883 conversion from string literals to `char*' or `wchar_t*'.
885 The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified
886 array type being the unqualified version of that type.
887 Therefore, if we are constructing an array of const char, we must
888 construct the matching unqualified array type first. The C front
889 end does not require this, but it does no harm, so we do it
891 e_type
= wide_flag
? wchar_type_node
: char_type_node
;
892 i_type
= build_index_type (build_int_cst (NULL_TREE
, nchars
- 1));
893 a_type
= build_array_type (e_type
, i_type
);
894 if (c_dialect_cxx() || warn_write_strings
)
895 a_type
= c_build_qualified_type (a_type
, TYPE_QUAL_CONST
);
897 TREE_TYPE (value
) = a_type
;
898 TREE_CONSTANT (value
) = 1;
899 TREE_INVARIANT (value
) = 1;
900 TREE_READONLY (value
) = 1;
901 TREE_STATIC (value
) = 1;
905 /* Print a warning if a constant expression had overflow in folding.
906 Invoke this function on every expression that the language
907 requires to be a constant expression.
908 Note the ANSI C standard says it is erroneous for a
909 constant expression to overflow. */
912 constant_expression_warning (tree value
)
914 if ((TREE_CODE (value
) == INTEGER_CST
|| TREE_CODE (value
) == REAL_CST
915 || TREE_CODE (value
) == VECTOR_CST
916 || TREE_CODE (value
) == COMPLEX_CST
)
917 && TREE_CONSTANT_OVERFLOW (value
)
920 pedwarn ("overflow in constant expression");
923 /* Print a warning if an expression had overflow in folding and its
926 Invoke this function on every expression that
927 (1) appears in the source code, and
928 (2) is a constant expression that overflowed, and
929 (3) is not already checked by convert_and_check;
930 however, do not invoke this function on operands of explicit casts
931 or when the expression is the result of an operator and any operand
932 already overflowed. */
935 overflow_warning (tree value
)
937 if (skip_evaluation
) return;
939 switch (TREE_CODE (value
))
942 warning (OPT_Woverflow
, "integer overflow in expression");
946 warning (OPT_Woverflow
, "floating point overflow in expression");
950 warning (OPT_Woverflow
, "vector overflow in expression");
954 if (TREE_CODE (TREE_REALPART (value
)) == INTEGER_CST
)
955 warning (OPT_Woverflow
, "complex integer overflow in expression");
956 else if (TREE_CODE (TREE_REALPART (value
)) == REAL_CST
)
957 warning (OPT_Woverflow
, "complex floating point overflow in expression");
965 /* Print a warning about casts that might indicate violation
966 of strict aliasing rules if -Wstrict-aliasing is used and
967 strict aliasing mode is in effect. OTYPE is the original
968 TREE_TYPE of EXPR, and TYPE the type we're casting to. */
971 strict_aliasing_warning (tree otype
, tree type
, tree expr
)
973 if (flag_strict_aliasing
&& warn_strict_aliasing
974 && POINTER_TYPE_P (type
) && POINTER_TYPE_P (otype
)
975 && TREE_CODE (expr
) == ADDR_EXPR
976 && (DECL_P (TREE_OPERAND (expr
, 0))
977 || handled_component_p (TREE_OPERAND (expr
, 0)))
978 && !VOID_TYPE_P (TREE_TYPE (type
)))
980 /* Casting the address of an object to non void pointer. Warn
981 if the cast breaks type based aliasing. */
982 if (!COMPLETE_TYPE_P (TREE_TYPE (type
)))
983 warning (OPT_Wstrict_aliasing
, "type-punning to incomplete type "
984 "might break strict-aliasing rules");
987 HOST_WIDE_INT set1
= get_alias_set (TREE_TYPE (TREE_OPERAND (expr
, 0)));
988 HOST_WIDE_INT set2
= get_alias_set (TREE_TYPE (type
));
990 if (!alias_sets_conflict_p (set1
, set2
))
991 warning (OPT_Wstrict_aliasing
, "dereferencing type-punned "
992 "pointer will break strict-aliasing rules");
993 else if (warn_strict_aliasing
> 1
994 && !alias_sets_might_conflict_p (set1
, set2
))
995 warning (OPT_Wstrict_aliasing
, "dereferencing type-punned "
996 "pointer might break strict-aliasing rules");
1001 /* Print a warning about if (); or if () .. else; constructs
1002 via the special empty statement node that we create. INNER_THEN
1003 and INNER_ELSE are the statement lists of the if and the else
1007 empty_body_warning (tree inner_then
, tree inner_else
)
1009 if (warn_empty_body
)
1011 if (TREE_CODE (inner_then
) == STATEMENT_LIST
1012 && STATEMENT_LIST_TAIL (inner_then
))
1013 inner_then
= STATEMENT_LIST_TAIL (inner_then
)->stmt
;
1015 if (inner_else
&& TREE_CODE (inner_else
) == STATEMENT_LIST
1016 && STATEMENT_LIST_TAIL (inner_else
))
1017 inner_else
= STATEMENT_LIST_TAIL (inner_else
)->stmt
;
1019 if (IS_EMPTY_STMT (inner_then
) && !inner_else
)
1020 warning (OPT_Wempty_body
, "%Hempty body in an if-statement",
1021 EXPR_LOCUS (inner_then
));
1023 if (inner_else
&& IS_EMPTY_STMT (inner_else
))
1024 warning (OPT_Wempty_body
, "%Hempty body in an else-statement",
1025 EXPR_LOCUS (inner_else
));
1029 /* Warn for unlikely, improbable, or stupid DECL declarations
1033 check_main_parameter_types (tree decl
)
1038 for (args
= TYPE_ARG_TYPES (TREE_TYPE (decl
)); args
;
1039 args
= TREE_CHAIN (args
))
1041 tree type
= args
? TREE_VALUE (args
) : 0;
1043 if (type
== void_type_node
|| type
== error_mark_node
)
1050 if (TYPE_MAIN_VARIANT (type
) != integer_type_node
)
1051 pedwarn ("first argument of %q+D should be %<int%>", decl
);
1055 if (TREE_CODE (type
) != POINTER_TYPE
1056 || TREE_CODE (TREE_TYPE (type
)) != POINTER_TYPE
1057 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type
)))
1059 pedwarn ("second argument of %q+D should be %<char **%>",
1064 if (TREE_CODE (type
) != POINTER_TYPE
1065 || TREE_CODE (TREE_TYPE (type
)) != POINTER_TYPE
1066 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type
)))
1068 pedwarn ("third argument of %q+D should probably be "
1069 "%<char **%>", decl
);
1074 /* It is intentional that this message does not mention the third
1075 argument because it's only mentioned in an appendix of the
1077 if (argct
> 0 && (argct
< 2 || argct
> 3))
1078 pedwarn ("%q+D takes only zero or two arguments", decl
);
1082 /* Nonzero if vector types T1 and T2 can be converted to each other
1083 without an explicit cast. */
1085 vector_types_convertible_p (tree t1
, tree t2
)
1087 return targetm
.vector_opaque_p (t1
)
1088 || targetm
.vector_opaque_p (t2
)
1089 || (tree_int_cst_equal (TYPE_SIZE (t1
), TYPE_SIZE (t2
))
1090 && (TREE_CODE (TREE_TYPE (t1
)) != REAL_TYPE
||
1091 TYPE_PRECISION (t1
) == TYPE_PRECISION (t2
))
1092 && INTEGRAL_TYPE_P (TREE_TYPE (t1
))
1093 == INTEGRAL_TYPE_P (TREE_TYPE (t2
)));
1096 /* Warns if the conversion of EXPR to TYPE may alter a value.
1097 This function is called from convert_and_check. */
1100 conversion_warning (tree type
, tree expr
)
1102 bool give_warning
= false;
1104 unsigned int formal_prec
= TYPE_PRECISION (type
);
1106 if (TREE_CODE (expr
) == REAL_CST
|| TREE_CODE (expr
) == INTEGER_CST
)
1108 /* Warn for real constant that is not an exact integer converted
1110 if (TREE_CODE (TREE_TYPE (expr
)) == REAL_TYPE
1111 && TREE_CODE (type
) == INTEGER_TYPE
)
1113 if (!real_isinteger (TREE_REAL_CST_PTR (expr
), TYPE_MODE (TREE_TYPE (expr
))))
1114 give_warning
= true;
1116 /* Warn for an integer constant that does not fit into integer type. */
1117 else if (TREE_CODE (TREE_TYPE (expr
)) == INTEGER_TYPE
1118 && TREE_CODE (type
) == INTEGER_TYPE
1119 && !int_fits_type_p (expr
, type
))
1121 if (TYPE_UNSIGNED (type
) && !TYPE_UNSIGNED (TREE_TYPE (expr
)))
1122 warning (OPT_Wconversion
,
1123 "negative integer implicitly converted to unsigned type");
1125 give_warning
= true;
1127 else if (TREE_CODE (type
) == REAL_TYPE
)
1129 /* Warn for an integer constant that does not fit into real type. */
1130 if (TREE_CODE (TREE_TYPE (expr
)) == INTEGER_TYPE
)
1132 REAL_VALUE_TYPE a
= real_value_from_int_cst (0, expr
);
1133 if (!exact_real_truncate (TYPE_MODE (type
), &a
))
1134 give_warning
= true;
1136 /* Warn for a real constant that does not fit into a smaller
1138 else if (TREE_CODE (TREE_TYPE (expr
)) == REAL_TYPE
1139 && formal_prec
< TYPE_PRECISION (TREE_TYPE (expr
)))
1141 REAL_VALUE_TYPE a
= TREE_REAL_CST (expr
);
1142 if (!exact_real_truncate (TYPE_MODE (type
), &a
))
1143 give_warning
= true;
1148 warning (OPT_Wconversion
,
1149 "conversion to %qT alters %qT constant value",
1150 type
, TREE_TYPE (expr
));
1152 else /* 'expr' is not a constant. */
1154 /* Warn for real types converted to integer types. */
1155 if (TREE_CODE (TREE_TYPE (expr
)) == REAL_TYPE
1156 && TREE_CODE (type
) == INTEGER_TYPE
)
1157 give_warning
= true;
1159 else if (TREE_CODE (TREE_TYPE (expr
)) == INTEGER_TYPE
1160 && TREE_CODE (type
) == INTEGER_TYPE
)
1162 /* Warn for integer types converted to smaller integer types. */
1163 if (formal_prec
< TYPE_PRECISION (TREE_TYPE (expr
))
1164 /* When they are the same width but different signedness,
1165 then the value may change. */
1166 || (formal_prec
== TYPE_PRECISION (TREE_TYPE (expr
))
1167 && TYPE_UNSIGNED (TREE_TYPE (expr
)) != TYPE_UNSIGNED (type
))
1168 /* Even when converted to a bigger type, if the type is
1169 unsigned but expr is signed, then negative values
1171 || (TYPE_UNSIGNED (type
) && !TYPE_UNSIGNED (TREE_TYPE (expr
))))
1172 give_warning
= true;
1175 /* Warn for integer types converted to real types if and only if
1176 all the range of values of the integer type cannot be
1177 represented by the real type. */
1178 else if (TREE_CODE (TREE_TYPE (expr
)) == INTEGER_TYPE
1179 && TREE_CODE (type
) == REAL_TYPE
)
1181 tree type_low_bound
= TYPE_MIN_VALUE (TREE_TYPE (expr
));
1182 tree type_high_bound
= TYPE_MAX_VALUE (TREE_TYPE (expr
));
1183 REAL_VALUE_TYPE real_low_bound
= real_value_from_int_cst (0, type_low_bound
);
1184 REAL_VALUE_TYPE real_high_bound
= real_value_from_int_cst (0, type_high_bound
);
1186 if (!exact_real_truncate (TYPE_MODE (type
), &real_low_bound
)
1187 || !exact_real_truncate (TYPE_MODE (type
), &real_high_bound
))
1188 give_warning
= true;
1191 /* Warn for real types converted to smaller real types. */
1192 else if (TREE_CODE (TREE_TYPE (expr
)) == REAL_TYPE
1193 && TREE_CODE (type
) == REAL_TYPE
1194 && formal_prec
< TYPE_PRECISION (TREE_TYPE (expr
)))
1195 give_warning
= true;
1199 warning (OPT_Wconversion
,
1200 "conversion to %qT from %qT may alter its value",
1201 type
, TREE_TYPE (expr
));
1205 /* Convert EXPR to TYPE, warning about conversion problems with constants.
1206 Invoke this function on every expression that is converted implicitly,
1207 i.e. because of language rules and not because of an explicit cast. */
1210 convert_and_check (tree type
, tree expr
)
1214 if (TREE_TYPE (expr
) == type
)
1217 result
= convert (type
, expr
);
1219 if (skip_evaluation
)
1223 if (TREE_CODE (expr
) == INTEGER_CST
1224 && (TREE_CODE (type
) == INTEGER_TYPE
1225 || TREE_CODE (type
) == ENUMERAL_TYPE
)
1226 && !int_fits_type_p (expr
, type
))
1228 /* Do not diagnose overflow in a constant expression merely
1229 because a conversion overflowed. */
1230 if (TREE_OVERFLOW (result
))
1232 TREE_CONSTANT_OVERFLOW (result
) = TREE_CONSTANT_OVERFLOW (expr
);
1233 TREE_OVERFLOW (result
) = TREE_OVERFLOW (expr
);
1236 if (TYPE_UNSIGNED (type
))
1238 /* This detects cases like converting -129 or 256 to
1240 if (!int_fits_type_p (expr
, c_common_signed_type (type
)))
1241 warning (OPT_Woverflow
,
1242 "large integer implicitly truncated to unsigned type");
1243 else if (warn_conversion
)
1244 conversion_warning (type
, expr
);
1248 if (!int_fits_type_p (expr
, c_common_unsigned_type (type
)))
1249 warning (OPT_Woverflow
,
1250 "overflow in implicit constant conversion");
1251 /* No warning for converting 0x80000000 to int. */
1253 && (TREE_CODE (TREE_TYPE (expr
)) != INTEGER_TYPE
1254 || TYPE_PRECISION (TREE_TYPE (expr
))
1255 != TYPE_PRECISION (type
)))
1256 warning (OPT_Woverflow
,
1257 "overflow in implicit constant conversion");
1258 else if (warn_conversion
)
1259 conversion_warning (type
, expr
);
1262 else if (TREE_CODE (result
) == INTEGER_CST
&& TREE_OVERFLOW (result
))
1263 warning (OPT_Woverflow
,
1264 "overflow in implicit constant conversion");
1265 else if (warn_conversion
)
1266 conversion_warning (type
, expr
);
1271 /* A node in a list that describes references to variables (EXPR), which are
1272 either read accesses if WRITER is zero, or write accesses, in which case
1273 WRITER is the parent of EXPR. */
1280 /* Used to implement a cache the results of a call to verify_tree. We only
1281 use this for SAVE_EXPRs. */
1284 struct tlist_cache
*next
;
1285 struct tlist
*cache_before_sp
;
1286 struct tlist
*cache_after_sp
;
1290 /* Obstack to use when allocating tlist structures, and corresponding
1292 static struct obstack tlist_obstack
;
1293 static char *tlist_firstobj
= 0;
1295 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
1297 static struct tlist
*warned_ids
;
1298 /* SAVE_EXPRs need special treatment. We process them only once and then
1299 cache the results. */
1300 static struct tlist_cache
*save_expr_cache
;
1302 static void add_tlist (struct tlist
**, struct tlist
*, tree
, int);
1303 static void merge_tlist (struct tlist
**, struct tlist
*, int);
1304 static void verify_tree (tree
, struct tlist
**, struct tlist
**, tree
);
1305 static int warning_candidate_p (tree
);
1306 static void warn_for_collisions (struct tlist
*);
1307 static void warn_for_collisions_1 (tree
, tree
, struct tlist
*, int);
1308 static struct tlist
*new_tlist (struct tlist
*, tree
, tree
);
1310 /* Create a new struct tlist and fill in its fields. */
1311 static struct tlist
*
1312 new_tlist (struct tlist
*next
, tree t
, tree writer
)
1315 l
= XOBNEW (&tlist_obstack
, struct tlist
);
1322 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
1323 is nonnull, we ignore any node we find which has a writer equal to it. */
1326 add_tlist (struct tlist
**to
, struct tlist
*add
, tree exclude_writer
, int copy
)
1330 struct tlist
*next
= add
->next
;
1333 if (!exclude_writer
|| add
->writer
!= exclude_writer
)
1334 *to
= copy
? new_tlist (*to
, add
->expr
, add
->writer
) : add
;
1339 /* Merge the nodes of ADD into TO. This merging process is done so that for
1340 each variable that already exists in TO, no new node is added; however if
1341 there is a write access recorded in ADD, and an occurrence on TO is only
1342 a read access, then the occurrence in TO will be modified to record the
1346 merge_tlist (struct tlist
**to
, struct tlist
*add
, int copy
)
1348 struct tlist
**end
= to
;
1351 end
= &(*end
)->next
;
1357 struct tlist
*next
= add
->next
;
1359 for (tmp2
= *to
; tmp2
; tmp2
= tmp2
->next
)
1360 if (tmp2
->expr
== add
->expr
)
1364 tmp2
->writer
= add
->writer
;
1368 *end
= copy
? add
: new_tlist (NULL
, add
->expr
, add
->writer
);
1369 end
= &(*end
)->next
;
1376 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
1377 references in list LIST conflict with it, excluding reads if ONLY writers
1381 warn_for_collisions_1 (tree written
, tree writer
, struct tlist
*list
,
1386 /* Avoid duplicate warnings. */
1387 for (tmp
= warned_ids
; tmp
; tmp
= tmp
->next
)
1388 if (tmp
->expr
== written
)
1393 if (list
->expr
== written
1394 && list
->writer
!= writer
1395 && (!only_writes
|| list
->writer
)
1396 && DECL_NAME (list
->expr
))
1398 warned_ids
= new_tlist (warned_ids
, written
, NULL_TREE
);
1399 warning (0, "operation on %qE may be undefined", list
->expr
);
1405 /* Given a list LIST of references to variables, find whether any of these
1406 can cause conflicts due to missing sequence points. */
1409 warn_for_collisions (struct tlist
*list
)
1413 for (tmp
= list
; tmp
; tmp
= tmp
->next
)
1416 warn_for_collisions_1 (tmp
->expr
, tmp
->writer
, list
, 0);
1420 /* Return nonzero if X is a tree that can be verified by the sequence point
1423 warning_candidate_p (tree x
)
1425 return TREE_CODE (x
) == VAR_DECL
|| TREE_CODE (x
) == PARM_DECL
;
1428 /* Walk the tree X, and record accesses to variables. If X is written by the
1429 parent tree, WRITER is the parent.
1430 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
1431 expression or its only operand forces a sequence point, then everything up
1432 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
1434 Once we return, we will have emitted warnings if any subexpression before
1435 such a sequence point could be undefined. On a higher level, however, the
1436 sequence point may not be relevant, and we'll merge the two lists.
1438 Example: (b++, a) + b;
1439 The call that processes the COMPOUND_EXPR will store the increment of B
1440 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
1441 processes the PLUS_EXPR will need to merge the two lists so that
1442 eventually, all accesses end up on the same list (and we'll warn about the
1443 unordered subexpressions b++ and b.
1445 A note on merging. If we modify the former example so that our expression
1448 care must be taken not simply to add all three expressions into the final
1449 PNO_SP list. The function merge_tlist takes care of that by merging the
1450 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1451 way, so that no more than one access to B is recorded. */
1454 verify_tree (tree x
, struct tlist
**pbefore_sp
, struct tlist
**pno_sp
,
1457 struct tlist
*tmp_before
, *tmp_nosp
, *tmp_list2
, *tmp_list3
;
1458 enum tree_code code
;
1459 enum tree_code_class cl
;
1461 /* X may be NULL if it is the operand of an empty statement expression
1467 code
= TREE_CODE (x
);
1468 cl
= TREE_CODE_CLASS (code
);
1470 if (warning_candidate_p (x
))
1472 *pno_sp
= new_tlist (*pno_sp
, x
, writer
);
1482 case TRUTH_ANDIF_EXPR
:
1483 case TRUTH_ORIF_EXPR
:
1484 tmp_before
= tmp_nosp
= tmp_list3
= 0;
1485 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1486 warn_for_collisions (tmp_nosp
);
1487 merge_tlist (pbefore_sp
, tmp_before
, 0);
1488 merge_tlist (pbefore_sp
, tmp_nosp
, 0);
1489 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, pno_sp
, NULL_TREE
);
1490 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1494 tmp_before
= tmp_list2
= 0;
1495 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_list2
, NULL_TREE
);
1496 warn_for_collisions (tmp_list2
);
1497 merge_tlist (pbefore_sp
, tmp_before
, 0);
1498 merge_tlist (pbefore_sp
, tmp_list2
, 1);
1500 tmp_list3
= tmp_nosp
= 0;
1501 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, &tmp_nosp
, NULL_TREE
);
1502 warn_for_collisions (tmp_nosp
);
1503 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1505 tmp_list3
= tmp_list2
= 0;
1506 verify_tree (TREE_OPERAND (x
, 2), &tmp_list3
, &tmp_list2
, NULL_TREE
);
1507 warn_for_collisions (tmp_list2
);
1508 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1509 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1510 two first, to avoid warning for (a ? b++ : b++). */
1511 merge_tlist (&tmp_nosp
, tmp_list2
, 0);
1512 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1515 case PREDECREMENT_EXPR
:
1516 case PREINCREMENT_EXPR
:
1517 case POSTDECREMENT_EXPR
:
1518 case POSTINCREMENT_EXPR
:
1519 verify_tree (TREE_OPERAND (x
, 0), pno_sp
, pno_sp
, x
);
1523 tmp_before
= tmp_nosp
= tmp_list3
= 0;
1524 verify_tree (TREE_OPERAND (x
, 1), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1525 verify_tree (TREE_OPERAND (x
, 0), &tmp_list3
, &tmp_list3
, x
);
1526 /* Expressions inside the LHS are not ordered wrt. the sequence points
1527 in the RHS. Example:
1529 Despite the fact that the modification of "a" is in the before_sp
1530 list (tmp_before), it conflicts with the use of "a" in the LHS.
1531 We can handle this by adding the contents of tmp_list3
1532 to those of tmp_before, and redoing the collision warnings for that
1534 add_tlist (&tmp_before
, tmp_list3
, x
, 1);
1535 warn_for_collisions (tmp_before
);
1536 /* Exclude the LHS itself here; we first have to merge it into the
1537 tmp_nosp list. This is done to avoid warning for "a = a"; if we
1538 didn't exclude the LHS, we'd get it twice, once as a read and once
1540 add_tlist (pno_sp
, tmp_list3
, x
, 0);
1541 warn_for_collisions_1 (TREE_OPERAND (x
, 0), x
, tmp_nosp
, 1);
1543 merge_tlist (pbefore_sp
, tmp_before
, 0);
1544 if (warning_candidate_p (TREE_OPERAND (x
, 0)))
1545 merge_tlist (&tmp_nosp
, new_tlist (NULL
, TREE_OPERAND (x
, 0), x
), 0);
1546 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 1);
1550 /* We need to warn about conflicts among arguments and conflicts between
1551 args and the function address. Side effects of the function address,
1552 however, are not ordered by the sequence point of the call. */
1553 tmp_before
= tmp_nosp
= tmp_list2
= tmp_list3
= 0;
1554 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1555 if (TREE_OPERAND (x
, 1))
1556 verify_tree (TREE_OPERAND (x
, 1), &tmp_list2
, &tmp_list3
, NULL_TREE
);
1557 merge_tlist (&tmp_list3
, tmp_list2
, 0);
1558 add_tlist (&tmp_before
, tmp_list3
, NULL_TREE
, 0);
1559 add_tlist (&tmp_before
, tmp_nosp
, NULL_TREE
, 0);
1560 warn_for_collisions (tmp_before
);
1561 add_tlist (pbefore_sp
, tmp_before
, NULL_TREE
, 0);
1565 /* Scan all the list, e.g. indices of multi dimensional array. */
1568 tmp_before
= tmp_nosp
= 0;
1569 verify_tree (TREE_VALUE (x
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1570 merge_tlist (&tmp_nosp
, tmp_before
, 0);
1571 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1578 struct tlist_cache
*t
;
1579 for (t
= save_expr_cache
; t
; t
= t
->next
)
1585 t
= XOBNEW (&tlist_obstack
, struct tlist_cache
);
1586 t
->next
= save_expr_cache
;
1588 save_expr_cache
= t
;
1590 tmp_before
= tmp_nosp
= 0;
1591 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1592 warn_for_collisions (tmp_nosp
);
1597 struct tlist
*t
= tmp_nosp
;
1599 merge_tlist (&tmp_list3
, t
, 0);
1601 t
->cache_before_sp
= tmp_before
;
1602 t
->cache_after_sp
= tmp_list3
;
1604 merge_tlist (pbefore_sp
, t
->cache_before_sp
, 1);
1605 add_tlist (pno_sp
, t
->cache_after_sp
, NULL_TREE
, 1);
1610 /* For other expressions, simply recurse on their operands.
1611 Manual tail recursion for unary expressions.
1612 Other non-expressions need not be processed. */
1613 if (cl
== tcc_unary
)
1615 x
= TREE_OPERAND (x
, 0);
1619 else if (IS_EXPR_CODE_CLASS (cl
))
1622 int max
= TREE_CODE_LENGTH (TREE_CODE (x
));
1623 for (lp
= 0; lp
< max
; lp
++)
1625 tmp_before
= tmp_nosp
= 0;
1626 verify_tree (TREE_OPERAND (x
, lp
), &tmp_before
, &tmp_nosp
, 0);
1627 merge_tlist (&tmp_nosp
, tmp_before
, 0);
1628 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1635 /* Try to warn for undefined behavior in EXPR due to missing sequence
1639 verify_sequence_points (tree expr
)
1641 struct tlist
*before_sp
= 0, *after_sp
= 0;
1644 save_expr_cache
= 0;
1645 if (tlist_firstobj
== 0)
1647 gcc_obstack_init (&tlist_obstack
);
1648 tlist_firstobj
= (char *) obstack_alloc (&tlist_obstack
, 0);
1651 verify_tree (expr
, &before_sp
, &after_sp
, 0);
1652 warn_for_collisions (after_sp
);
1653 obstack_free (&tlist_obstack
, tlist_firstobj
);
1656 /* Validate the expression after `case' and apply default promotions. */
1659 check_case_value (tree value
)
1661 if (value
== NULL_TREE
)
1664 /* ??? Can we ever get nops here for a valid case value? We
1666 STRIP_TYPE_NOPS (value
);
1667 /* In C++, the following is allowed:
1670 switch (...) { case i: ... }
1672 So, we try to reduce the VALUE to a constant that way. */
1673 if (c_dialect_cxx ())
1675 value
= decl_constant_value (value
);
1676 STRIP_TYPE_NOPS (value
);
1677 value
= fold (value
);
1680 if (TREE_CODE (value
) == INTEGER_CST
)
1681 /* Promote char or short to int. */
1682 value
= perform_integral_promotions (value
);
1683 else if (value
!= error_mark_node
)
1685 error ("case label does not reduce to an integer constant");
1686 value
= error_mark_node
;
1689 constant_expression_warning (value
);
1694 /* See if the case values LOW and HIGH are in the range of the original
1695 type (i.e. before the default conversion to int) of the switch testing
1697 TYPE is the promoted type of the testing expression, and ORIG_TYPE is
1698 the type before promoting it. CASE_LOW_P is a pointer to the lower
1699 bound of the case label, and CASE_HIGH_P is the upper bound or NULL
1700 if the case is not a case range.
1701 The caller has to make sure that we are not called with NULL for
1702 CASE_LOW_P (i.e. the default case).
1703 Returns true if the case label is in range of ORIG_TYPE (saturated or
1704 untouched) or false if the label is out of range. */
1707 check_case_bounds (tree type
, tree orig_type
,
1708 tree
*case_low_p
, tree
*case_high_p
)
1710 tree min_value
, max_value
;
1711 tree case_low
= *case_low_p
;
1712 tree case_high
= case_high_p
? *case_high_p
: case_low
;
1714 /* If there was a problem with the original type, do nothing. */
1715 if (orig_type
== error_mark_node
)
1718 min_value
= TYPE_MIN_VALUE (orig_type
);
1719 max_value
= TYPE_MAX_VALUE (orig_type
);
1721 /* Case label is less than minimum for type. */
1722 if (tree_int_cst_compare (case_low
, min_value
) < 0
1723 && tree_int_cst_compare (case_high
, min_value
) < 0)
1725 warning (0, "case label value is less than minimum value for type");
1729 /* Case value is greater than maximum for type. */
1730 if (tree_int_cst_compare (case_low
, max_value
) > 0
1731 && tree_int_cst_compare (case_high
, max_value
) > 0)
1733 warning (0, "case label value exceeds maximum value for type");
1737 /* Saturate lower case label value to minimum. */
1738 if (tree_int_cst_compare (case_high
, min_value
) >= 0
1739 && tree_int_cst_compare (case_low
, min_value
) < 0)
1741 warning (0, "lower value in case label range"
1742 " less than minimum value for type");
1743 case_low
= min_value
;
1746 /* Saturate upper case label value to maximum. */
1747 if (tree_int_cst_compare (case_low
, max_value
) <= 0
1748 && tree_int_cst_compare (case_high
, max_value
) > 0)
1750 warning (0, "upper value in case label range"
1751 " exceeds maximum value for type");
1752 case_high
= max_value
;
1755 if (*case_low_p
!= case_low
)
1756 *case_low_p
= convert (type
, case_low
);
1757 if (case_high_p
&& *case_high_p
!= case_high
)
1758 *case_high_p
= convert (type
, case_high
);
1763 /* Return an integer type with BITS bits of precision,
1764 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1767 c_common_type_for_size (unsigned int bits
, int unsignedp
)
1769 if (bits
== TYPE_PRECISION (integer_type_node
))
1770 return unsignedp
? unsigned_type_node
: integer_type_node
;
1772 if (bits
== TYPE_PRECISION (signed_char_type_node
))
1773 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1775 if (bits
== TYPE_PRECISION (short_integer_type_node
))
1776 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1778 if (bits
== TYPE_PRECISION (long_integer_type_node
))
1779 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1781 if (bits
== TYPE_PRECISION (long_long_integer_type_node
))
1782 return (unsignedp
? long_long_unsigned_type_node
1783 : long_long_integer_type_node
);
1785 if (bits
== TYPE_PRECISION (widest_integer_literal_type_node
))
1786 return (unsignedp
? widest_unsigned_literal_type_node
1787 : widest_integer_literal_type_node
);
1789 if (bits
<= TYPE_PRECISION (intQI_type_node
))
1790 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
1792 if (bits
<= TYPE_PRECISION (intHI_type_node
))
1793 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
1795 if (bits
<= TYPE_PRECISION (intSI_type_node
))
1796 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
1798 if (bits
<= TYPE_PRECISION (intDI_type_node
))
1799 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
1804 /* Used for communication between c_common_type_for_mode and
1805 c_register_builtin_type. */
1806 static GTY(()) tree registered_builtin_types
;
1808 /* Return a data type that has machine mode MODE.
1809 If the mode is an integer,
1810 then UNSIGNEDP selects between signed and unsigned types. */
1813 c_common_type_for_mode (enum machine_mode mode
, int unsignedp
)
1817 if (mode
== TYPE_MODE (integer_type_node
))
1818 return unsignedp
? unsigned_type_node
: integer_type_node
;
1820 if (mode
== TYPE_MODE (signed_char_type_node
))
1821 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1823 if (mode
== TYPE_MODE (short_integer_type_node
))
1824 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1826 if (mode
== TYPE_MODE (long_integer_type_node
))
1827 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1829 if (mode
== TYPE_MODE (long_long_integer_type_node
))
1830 return unsignedp
? long_long_unsigned_type_node
: long_long_integer_type_node
;
1832 if (mode
== TYPE_MODE (widest_integer_literal_type_node
))
1833 return unsignedp
? widest_unsigned_literal_type_node
1834 : widest_integer_literal_type_node
;
1837 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
1840 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
1843 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
1846 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
1848 #if HOST_BITS_PER_WIDE_INT >= 64
1849 if (mode
== TYPE_MODE (intTI_type_node
))
1850 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
1853 if (mode
== TYPE_MODE (float_type_node
))
1854 return float_type_node
;
1856 if (mode
== TYPE_MODE (double_type_node
))
1857 return double_type_node
;
1859 if (mode
== TYPE_MODE (long_double_type_node
))
1860 return long_double_type_node
;
1862 if (mode
== TYPE_MODE (void_type_node
))
1863 return void_type_node
;
1865 if (mode
== TYPE_MODE (build_pointer_type (char_type_node
)))
1867 ? make_unsigned_type (GET_MODE_PRECISION (mode
))
1868 : make_signed_type (GET_MODE_PRECISION (mode
)));
1870 if (mode
== TYPE_MODE (build_pointer_type (integer_type_node
)))
1872 ? make_unsigned_type (GET_MODE_PRECISION (mode
))
1873 : make_signed_type (GET_MODE_PRECISION (mode
)));
1875 if (COMPLEX_MODE_P (mode
))
1877 enum machine_mode inner_mode
;
1880 if (mode
== TYPE_MODE (complex_float_type_node
))
1881 return complex_float_type_node
;
1882 if (mode
== TYPE_MODE (complex_double_type_node
))
1883 return complex_double_type_node
;
1884 if (mode
== TYPE_MODE (complex_long_double_type_node
))
1885 return complex_long_double_type_node
;
1887 if (mode
== TYPE_MODE (complex_integer_type_node
) && !unsignedp
)
1888 return complex_integer_type_node
;
1890 inner_mode
= GET_MODE_INNER (mode
);
1891 inner_type
= c_common_type_for_mode (inner_mode
, unsignedp
);
1892 if (inner_type
!= NULL_TREE
)
1893 return build_complex_type (inner_type
);
1895 else if (VECTOR_MODE_P (mode
))
1897 enum machine_mode inner_mode
= GET_MODE_INNER (mode
);
1898 tree inner_type
= c_common_type_for_mode (inner_mode
, unsignedp
);
1899 if (inner_type
!= NULL_TREE
)
1900 return build_vector_type_for_mode (inner_type
, mode
);
1903 if (mode
== TYPE_MODE (dfloat32_type_node
))
1904 return dfloat32_type_node
;
1905 if (mode
== TYPE_MODE (dfloat64_type_node
))
1906 return dfloat64_type_node
;
1907 if (mode
== TYPE_MODE (dfloat128_type_node
))
1908 return dfloat128_type_node
;
1910 for (t
= registered_builtin_types
; t
; t
= TREE_CHAIN (t
))
1911 if (TYPE_MODE (TREE_VALUE (t
)) == mode
)
1912 return TREE_VALUE (t
);
1917 /* Return an unsigned type the same as TYPE in other respects. */
1919 c_common_unsigned_type (tree type
)
1921 tree type1
= TYPE_MAIN_VARIANT (type
);
1922 if (type1
== signed_char_type_node
|| type1
== char_type_node
)
1923 return unsigned_char_type_node
;
1924 if (type1
== integer_type_node
)
1925 return unsigned_type_node
;
1926 if (type1
== short_integer_type_node
)
1927 return short_unsigned_type_node
;
1928 if (type1
== long_integer_type_node
)
1929 return long_unsigned_type_node
;
1930 if (type1
== long_long_integer_type_node
)
1931 return long_long_unsigned_type_node
;
1932 if (type1
== widest_integer_literal_type_node
)
1933 return widest_unsigned_literal_type_node
;
1934 #if HOST_BITS_PER_WIDE_INT >= 64
1935 if (type1
== intTI_type_node
)
1936 return unsigned_intTI_type_node
;
1938 if (type1
== intDI_type_node
)
1939 return unsigned_intDI_type_node
;
1940 if (type1
== intSI_type_node
)
1941 return unsigned_intSI_type_node
;
1942 if (type1
== intHI_type_node
)
1943 return unsigned_intHI_type_node
;
1944 if (type1
== intQI_type_node
)
1945 return unsigned_intQI_type_node
;
1947 return c_common_signed_or_unsigned_type (1, type
);
1950 /* Return a signed type the same as TYPE in other respects. */
1953 c_common_signed_type (tree type
)
1955 tree type1
= TYPE_MAIN_VARIANT (type
);
1956 if (type1
== unsigned_char_type_node
|| type1
== char_type_node
)
1957 return signed_char_type_node
;
1958 if (type1
== unsigned_type_node
)
1959 return integer_type_node
;
1960 if (type1
== short_unsigned_type_node
)
1961 return short_integer_type_node
;
1962 if (type1
== long_unsigned_type_node
)
1963 return long_integer_type_node
;
1964 if (type1
== long_long_unsigned_type_node
)
1965 return long_long_integer_type_node
;
1966 if (type1
== widest_unsigned_literal_type_node
)
1967 return widest_integer_literal_type_node
;
1968 #if HOST_BITS_PER_WIDE_INT >= 64
1969 if (type1
== unsigned_intTI_type_node
)
1970 return intTI_type_node
;
1972 if (type1
== unsigned_intDI_type_node
)
1973 return intDI_type_node
;
1974 if (type1
== unsigned_intSI_type_node
)
1975 return intSI_type_node
;
1976 if (type1
== unsigned_intHI_type_node
)
1977 return intHI_type_node
;
1978 if (type1
== unsigned_intQI_type_node
)
1979 return intQI_type_node
;
1981 return c_common_signed_or_unsigned_type (0, type
);
1984 /* Return a type the same as TYPE except unsigned or
1985 signed according to UNSIGNEDP. */
1988 c_common_signed_or_unsigned_type (int unsignedp
, tree type
)
1990 if (!INTEGRAL_TYPE_P (type
)
1991 || TYPE_UNSIGNED (type
) == unsignedp
)
1994 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
1995 the precision; they have precision set to match their range, but
1996 may use a wider mode to match an ABI. If we change modes, we may
1997 wind up with bad conversions. For INTEGER_TYPEs in C, must check
1998 the precision as well, so as to yield correct results for
1999 bit-field types. C++ does not have these separate bit-field
2000 types, and producing a signed or unsigned variant of an
2001 ENUMERAL_TYPE may cause other problems as well. */
2003 #define TYPE_OK(node) \
2004 (TYPE_MODE (type) == TYPE_MODE (node) \
2005 && (c_dialect_cxx () || TYPE_PRECISION (type) == TYPE_PRECISION (node)))
2006 if (TYPE_OK (signed_char_type_node
))
2007 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2008 if (TYPE_OK (integer_type_node
))
2009 return unsignedp
? unsigned_type_node
: integer_type_node
;
2010 if (TYPE_OK (short_integer_type_node
))
2011 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2012 if (TYPE_OK (long_integer_type_node
))
2013 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2014 if (TYPE_OK (long_long_integer_type_node
))
2015 return (unsignedp
? long_long_unsigned_type_node
2016 : long_long_integer_type_node
);
2017 if (TYPE_OK (widest_integer_literal_type_node
))
2018 return (unsignedp
? widest_unsigned_literal_type_node
2019 : widest_integer_literal_type_node
);
2021 #if HOST_BITS_PER_WIDE_INT >= 64
2022 if (TYPE_OK (intTI_type_node
))
2023 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2025 if (TYPE_OK (intDI_type_node
))
2026 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2027 if (TYPE_OK (intSI_type_node
))
2028 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2029 if (TYPE_OK (intHI_type_node
))
2030 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2031 if (TYPE_OK (intQI_type_node
))
2032 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2035 if (c_dialect_cxx ())
2038 return build_nonstandard_integer_type (TYPE_PRECISION (type
), unsignedp
);
2041 /* Build a bit-field integer type for the given WIDTH and UNSIGNEDP. */
2044 c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width
, int unsignedp
)
2046 /* Extended integer types of the same width as a standard type have
2047 lesser rank, so those of the same width as int promote to int or
2048 unsigned int and are valid for printf formats expecting int or
2049 unsigned int. To avoid such special cases, avoid creating
2050 extended integer types for bit-fields if a standard integer type
2052 if (width
== TYPE_PRECISION (integer_type_node
))
2053 return unsignedp
? unsigned_type_node
: integer_type_node
;
2054 if (width
== TYPE_PRECISION (signed_char_type_node
))
2055 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2056 if (width
== TYPE_PRECISION (short_integer_type_node
))
2057 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2058 if (width
== TYPE_PRECISION (long_integer_type_node
))
2059 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2060 if (width
== TYPE_PRECISION (long_long_integer_type_node
))
2061 return (unsignedp
? long_long_unsigned_type_node
2062 : long_long_integer_type_node
);
2063 return build_nonstandard_integer_type (width
, unsignedp
);
2066 /* The C version of the register_builtin_type langhook. */
2069 c_register_builtin_type (tree type
, const char* name
)
2073 decl
= build_decl (TYPE_DECL
, get_identifier (name
), type
);
2074 DECL_ARTIFICIAL (decl
) = 1;
2075 if (!TYPE_NAME (type
))
2076 TYPE_NAME (type
) = decl
;
2079 registered_builtin_types
= tree_cons (0, type
, registered_builtin_types
);
2083 /* Return the minimum number of bits needed to represent VALUE in a
2084 signed or unsigned type, UNSIGNEDP says which. */
2087 min_precision (tree value
, int unsignedp
)
2091 /* If the value is negative, compute its negative minus 1. The latter
2092 adjustment is because the absolute value of the largest negative value
2093 is one larger than the largest positive value. This is equivalent to
2094 a bit-wise negation, so use that operation instead. */
2096 if (tree_int_cst_sgn (value
) < 0)
2097 value
= fold_build1 (BIT_NOT_EXPR
, TREE_TYPE (value
), value
);
2099 /* Return the number of bits needed, taking into account the fact
2100 that we need one more bit for a signed than unsigned type. */
2102 if (integer_zerop (value
))
2105 log
= tree_floor_log2 (value
);
2107 return log
+ 1 + !unsignedp
;
2110 /* Print an error message for invalid operands to arith operation
2114 binary_op_error (enum tree_code code
)
2121 opname
= "+"; break;
2123 opname
= "-"; break;
2125 opname
= "*"; break;
2127 opname
= "max"; break;
2129 opname
= "min"; break;
2131 opname
= "=="; break;
2133 opname
= "!="; break;
2135 opname
= "<="; break;
2137 opname
= ">="; break;
2139 opname
= "<"; break;
2141 opname
= ">"; break;
2143 opname
= "<<"; break;
2145 opname
= ">>"; break;
2146 case TRUNC_MOD_EXPR
:
2147 case FLOOR_MOD_EXPR
:
2148 opname
= "%"; break;
2149 case TRUNC_DIV_EXPR
:
2150 case FLOOR_DIV_EXPR
:
2151 opname
= "/"; break;
2153 opname
= "&"; break;
2155 opname
= "|"; break;
2156 case TRUTH_ANDIF_EXPR
:
2157 opname
= "&&"; break;
2158 case TRUTH_ORIF_EXPR
:
2159 opname
= "||"; break;
2161 opname
= "^"; break;
2165 error ("invalid operands to binary %s", opname
);
2168 /* Subroutine of build_binary_op, used for comparison operations.
2169 See if the operands have both been converted from subword integer types
2170 and, if so, perhaps change them both back to their original type.
2171 This function is also responsible for converting the two operands
2172 to the proper common type for comparison.
2174 The arguments of this function are all pointers to local variables
2175 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2176 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2178 If this function returns nonzero, it means that the comparison has
2179 a constant value. What this function returns is an expression for
2183 shorten_compare (tree
*op0_ptr
, tree
*op1_ptr
, tree
*restype_ptr
,
2184 enum tree_code
*rescode_ptr
)
2187 tree op0
= *op0_ptr
;
2188 tree op1
= *op1_ptr
;
2189 int unsignedp0
, unsignedp1
;
2191 tree primop0
, primop1
;
2192 enum tree_code code
= *rescode_ptr
;
2194 /* Throw away any conversions to wider types
2195 already present in the operands. */
2197 primop0
= get_narrower (op0
, &unsignedp0
);
2198 primop1
= get_narrower (op1
, &unsignedp1
);
2200 /* Handle the case that OP0 does not *contain* a conversion
2201 but it *requires* conversion to FINAL_TYPE. */
2203 if (op0
== primop0
&& TREE_TYPE (op0
) != *restype_ptr
)
2204 unsignedp0
= TYPE_UNSIGNED (TREE_TYPE (op0
));
2205 if (op1
== primop1
&& TREE_TYPE (op1
) != *restype_ptr
)
2206 unsignedp1
= TYPE_UNSIGNED (TREE_TYPE (op1
));
2208 /* If one of the operands must be floated, we cannot optimize. */
2209 real1
= TREE_CODE (TREE_TYPE (primop0
)) == REAL_TYPE
;
2210 real2
= TREE_CODE (TREE_TYPE (primop1
)) == REAL_TYPE
;
2212 /* If first arg is constant, swap the args (changing operation
2213 so value is preserved), for canonicalization. Don't do this if
2214 the second arg is 0. */
2216 if (TREE_CONSTANT (primop0
)
2217 && !integer_zerop (primop1
) && !real_zerop (primop1
))
2220 int temi
= unsignedp0
;
2228 unsignedp0
= unsignedp1
;
2251 *rescode_ptr
= code
;
2254 /* If comparing an integer against a constant more bits wide,
2255 maybe we can deduce a value of 1 or 0 independent of the data.
2256 Or else truncate the constant now
2257 rather than extend the variable at run time.
2259 This is only interesting if the constant is the wider arg.
2260 Also, it is not safe if the constant is unsigned and the
2261 variable arg is signed, since in this case the variable
2262 would be sign-extended and then regarded as unsigned.
2263 Our technique fails in this case because the lowest/highest
2264 possible unsigned results don't follow naturally from the
2265 lowest/highest possible values of the variable operand.
2266 For just EQ_EXPR and NE_EXPR there is another technique that
2267 could be used: see if the constant can be faithfully represented
2268 in the other operand's type, by truncating it and reextending it
2269 and see if that preserves the constant's value. */
2271 if (!real1
&& !real2
2272 && TREE_CODE (primop1
) == INTEGER_CST
2273 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
))
2275 int min_gt
, max_gt
, min_lt
, max_lt
;
2276 tree maxval
, minval
;
2277 /* 1 if comparison is nominally unsigned. */
2278 int unsignedp
= TYPE_UNSIGNED (*restype_ptr
);
2281 type
= c_common_signed_or_unsigned_type (unsignedp0
,
2282 TREE_TYPE (primop0
));
2284 maxval
= TYPE_MAX_VALUE (type
);
2285 minval
= TYPE_MIN_VALUE (type
);
2287 if (unsignedp
&& !unsignedp0
)
2288 *restype_ptr
= c_common_signed_type (*restype_ptr
);
2290 if (TREE_TYPE (primop1
) != *restype_ptr
)
2292 /* Convert primop1 to target type, but do not introduce
2293 additional overflow. We know primop1 is an int_cst. */
2294 tree tmp
= build_int_cst_wide (*restype_ptr
,
2295 TREE_INT_CST_LOW (primop1
),
2296 TREE_INT_CST_HIGH (primop1
));
2298 primop1
= force_fit_type (tmp
, 0, TREE_OVERFLOW (primop1
),
2299 TREE_CONSTANT_OVERFLOW (primop1
));
2301 if (type
!= *restype_ptr
)
2303 minval
= convert (*restype_ptr
, minval
);
2304 maxval
= convert (*restype_ptr
, maxval
);
2307 if (unsignedp
&& unsignedp0
)
2309 min_gt
= INT_CST_LT_UNSIGNED (primop1
, minval
);
2310 max_gt
= INT_CST_LT_UNSIGNED (primop1
, maxval
);
2311 min_lt
= INT_CST_LT_UNSIGNED (minval
, primop1
);
2312 max_lt
= INT_CST_LT_UNSIGNED (maxval
, primop1
);
2316 min_gt
= INT_CST_LT (primop1
, minval
);
2317 max_gt
= INT_CST_LT (primop1
, maxval
);
2318 min_lt
= INT_CST_LT (minval
, primop1
);
2319 max_lt
= INT_CST_LT (maxval
, primop1
);
2323 /* This used to be a switch, but Genix compiler can't handle that. */
2324 if (code
== NE_EXPR
)
2326 if (max_lt
|| min_gt
)
2327 val
= truthvalue_true_node
;
2329 else if (code
== EQ_EXPR
)
2331 if (max_lt
|| min_gt
)
2332 val
= truthvalue_false_node
;
2334 else if (code
== LT_EXPR
)
2337 val
= truthvalue_true_node
;
2339 val
= truthvalue_false_node
;
2341 else if (code
== GT_EXPR
)
2344 val
= truthvalue_true_node
;
2346 val
= truthvalue_false_node
;
2348 else if (code
== LE_EXPR
)
2351 val
= truthvalue_true_node
;
2353 val
= truthvalue_false_node
;
2355 else if (code
== GE_EXPR
)
2358 val
= truthvalue_true_node
;
2360 val
= truthvalue_false_node
;
2363 /* If primop0 was sign-extended and unsigned comparison specd,
2364 we did a signed comparison above using the signed type bounds.
2365 But the comparison we output must be unsigned.
2367 Also, for inequalities, VAL is no good; but if the signed
2368 comparison had *any* fixed result, it follows that the
2369 unsigned comparison just tests the sign in reverse
2370 (positive values are LE, negative ones GE).
2371 So we can generate an unsigned comparison
2372 against an extreme value of the signed type. */
2374 if (unsignedp
&& !unsignedp0
)
2381 primop1
= TYPE_MIN_VALUE (type
);
2387 primop1
= TYPE_MAX_VALUE (type
);
2394 type
= c_common_unsigned_type (type
);
2397 if (TREE_CODE (primop0
) != INTEGER_CST
)
2399 if (val
== truthvalue_false_node
)
2400 warning (0, "comparison is always false due to limited range of data type");
2401 if (val
== truthvalue_true_node
)
2402 warning (0, "comparison is always true due to limited range of data type");
2407 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2408 if (TREE_SIDE_EFFECTS (primop0
))
2409 return build2 (COMPOUND_EXPR
, TREE_TYPE (val
), primop0
, val
);
2413 /* Value is not predetermined, but do the comparison
2414 in the type of the operand that is not constant.
2415 TYPE is already properly set. */
2418 /* If either arg is decimal float and the other is float, find the
2419 proper common type to use for comparison. */
2420 else if (real1
&& real2
2421 && (DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0
)))
2422 || DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1
)))))
2423 type
= common_type (TREE_TYPE (primop0
), TREE_TYPE (primop1
));
2425 else if (real1
&& real2
2426 && (TYPE_PRECISION (TREE_TYPE (primop0
))
2427 == TYPE_PRECISION (TREE_TYPE (primop1
))))
2428 type
= TREE_TYPE (primop0
);
2430 /* If args' natural types are both narrower than nominal type
2431 and both extend in the same manner, compare them
2432 in the type of the wider arg.
2433 Otherwise must actually extend both to the nominal
2434 common type lest different ways of extending
2436 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
2438 else if (unsignedp0
== unsignedp1
&& real1
== real2
2439 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
)
2440 && TYPE_PRECISION (TREE_TYPE (primop1
)) < TYPE_PRECISION (*restype_ptr
))
2442 type
= common_type (TREE_TYPE (primop0
), TREE_TYPE (primop1
));
2443 type
= c_common_signed_or_unsigned_type (unsignedp0
2444 || TYPE_UNSIGNED (*restype_ptr
),
2446 /* Make sure shorter operand is extended the right way
2447 to match the longer operand. */
2449 = convert (c_common_signed_or_unsigned_type (unsignedp0
,
2450 TREE_TYPE (primop0
)),
2453 = convert (c_common_signed_or_unsigned_type (unsignedp1
,
2454 TREE_TYPE (primop1
)),
2459 /* Here we must do the comparison on the nominal type
2460 using the args exactly as we received them. */
2461 type
= *restype_ptr
;
2465 if (!real1
&& !real2
&& integer_zerop (primop1
)
2466 && TYPE_UNSIGNED (*restype_ptr
))
2472 /* All unsigned values are >= 0, so we warn if extra warnings
2473 are requested. However, if OP0 is a constant that is
2474 >= 0, the signedness of the comparison isn't an issue,
2475 so suppress the warning. */
2476 if (extra_warnings
&& !in_system_header
2477 && !(TREE_CODE (primop0
) == INTEGER_CST
2478 && !TREE_OVERFLOW (convert (c_common_signed_type (type
),
2480 warning (0, "comparison of unsigned expression >= 0 is always true");
2481 value
= truthvalue_true_node
;
2485 if (extra_warnings
&& !in_system_header
2486 && !(TREE_CODE (primop0
) == INTEGER_CST
2487 && !TREE_OVERFLOW (convert (c_common_signed_type (type
),
2489 warning (0, "comparison of unsigned expression < 0 is always false");
2490 value
= truthvalue_false_node
;
2499 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2500 if (TREE_SIDE_EFFECTS (primop0
))
2501 return build2 (COMPOUND_EXPR
, TREE_TYPE (value
),
2508 *op0_ptr
= convert (type
, primop0
);
2509 *op1_ptr
= convert (type
, primop1
);
2511 *restype_ptr
= truthvalue_type_node
;
2516 /* Return a tree for the sum or difference (RESULTCODE says which)
2517 of pointer PTROP and integer INTOP. */
2520 pointer_int_sum (enum tree_code resultcode
, tree ptrop
, tree intop
)
2524 /* The result is a pointer of the same type that is being added. */
2526 tree result_type
= TREE_TYPE (ptrop
);
2528 if (TREE_CODE (TREE_TYPE (result_type
)) == VOID_TYPE
)
2530 if (pedantic
|| warn_pointer_arith
)
2531 pedwarn ("pointer of type %<void *%> used in arithmetic");
2532 size_exp
= integer_one_node
;
2534 else if (TREE_CODE (TREE_TYPE (result_type
)) == FUNCTION_TYPE
)
2536 if (pedantic
|| warn_pointer_arith
)
2537 pedwarn ("pointer to a function used in arithmetic");
2538 size_exp
= integer_one_node
;
2540 else if (TREE_CODE (TREE_TYPE (result_type
)) == METHOD_TYPE
)
2542 if (pedantic
|| warn_pointer_arith
)
2543 pedwarn ("pointer to member function used in arithmetic");
2544 size_exp
= integer_one_node
;
2547 size_exp
= size_in_bytes (TREE_TYPE (result_type
));
2549 /* If what we are about to multiply by the size of the elements
2550 contains a constant term, apply distributive law
2551 and multiply that constant term separately.
2552 This helps produce common subexpressions. */
2554 if ((TREE_CODE (intop
) == PLUS_EXPR
|| TREE_CODE (intop
) == MINUS_EXPR
)
2555 && !TREE_CONSTANT (intop
)
2556 && TREE_CONSTANT (TREE_OPERAND (intop
, 1))
2557 && TREE_CONSTANT (size_exp
)
2558 /* If the constant comes from pointer subtraction,
2559 skip this optimization--it would cause an error. */
2560 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop
, 0))) == INTEGER_TYPE
2561 /* If the constant is unsigned, and smaller than the pointer size,
2562 then we must skip this optimization. This is because it could cause
2563 an overflow error if the constant is negative but INTOP is not. */
2564 && (!TYPE_UNSIGNED (TREE_TYPE (intop
))
2565 || (TYPE_PRECISION (TREE_TYPE (intop
))
2566 == TYPE_PRECISION (TREE_TYPE (ptrop
)))))
2568 enum tree_code subcode
= resultcode
;
2569 tree int_type
= TREE_TYPE (intop
);
2570 if (TREE_CODE (intop
) == MINUS_EXPR
)
2571 subcode
= (subcode
== PLUS_EXPR
? MINUS_EXPR
: PLUS_EXPR
);
2572 /* Convert both subexpression types to the type of intop,
2573 because weird cases involving pointer arithmetic
2574 can result in a sum or difference with different type args. */
2575 ptrop
= build_binary_op (subcode
, ptrop
,
2576 convert (int_type
, TREE_OPERAND (intop
, 1)), 1);
2577 intop
= convert (int_type
, TREE_OPERAND (intop
, 0));
2580 /* Convert the integer argument to a type the same size as sizetype
2581 so the multiply won't overflow spuriously. */
2583 if (TYPE_PRECISION (TREE_TYPE (intop
)) != TYPE_PRECISION (sizetype
)
2584 || TYPE_UNSIGNED (TREE_TYPE (intop
)) != TYPE_UNSIGNED (sizetype
))
2585 intop
= convert (c_common_type_for_size (TYPE_PRECISION (sizetype
),
2586 TYPE_UNSIGNED (sizetype
)), intop
);
2588 /* Replace the integer argument with a suitable product by the object size.
2589 Do this multiplication as signed, then convert to the appropriate
2590 pointer type (actually unsigned integral). */
2592 intop
= convert (result_type
,
2593 build_binary_op (MULT_EXPR
, intop
,
2594 convert (TREE_TYPE (intop
), size_exp
), 1));
2596 /* Create the sum or difference. */
2597 return fold_build2 (resultcode
, result_type
, ptrop
, intop
);
2600 /* Return whether EXPR is a declaration whose address can never be
2604 decl_with_nonnull_addr_p (tree expr
)
2606 return (DECL_P (expr
)
2607 && (TREE_CODE (expr
) == PARM_DECL
2608 || TREE_CODE (expr
) == LABEL_DECL
2609 || !DECL_WEAK (expr
)));
2612 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2613 or for an `if' or `while' statement or ?..: exp. It should already
2614 have been validated to be of suitable type; otherwise, a bad
2615 diagnostic may result.
2617 This preparation consists of taking the ordinary
2618 representation of an expression expr and producing a valid tree
2619 boolean expression describing whether expr is nonzero. We could
2620 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
2621 but we optimize comparisons, &&, ||, and !.
2623 The resulting type should always be `truthvalue_type_node'. */
2626 c_common_truthvalue_conversion (tree expr
)
2628 switch (TREE_CODE (expr
))
2630 case EQ_EXPR
: case NE_EXPR
: case UNEQ_EXPR
: case LTGT_EXPR
:
2631 case LE_EXPR
: case GE_EXPR
: case LT_EXPR
: case GT_EXPR
:
2632 case UNLE_EXPR
: case UNGE_EXPR
: case UNLT_EXPR
: case UNGT_EXPR
:
2633 case ORDERED_EXPR
: case UNORDERED_EXPR
:
2634 if (TREE_TYPE (expr
) == truthvalue_type_node
)
2636 return build2 (TREE_CODE (expr
), truthvalue_type_node
,
2637 TREE_OPERAND (expr
, 0), TREE_OPERAND (expr
, 1));
2639 case TRUTH_ANDIF_EXPR
:
2640 case TRUTH_ORIF_EXPR
:
2641 case TRUTH_AND_EXPR
:
2643 case TRUTH_XOR_EXPR
:
2644 if (TREE_TYPE (expr
) == truthvalue_type_node
)
2646 return build2 (TREE_CODE (expr
), truthvalue_type_node
,
2647 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0)),
2648 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 1)));
2650 case TRUTH_NOT_EXPR
:
2651 if (TREE_TYPE (expr
) == truthvalue_type_node
)
2653 return build1 (TREE_CODE (expr
), truthvalue_type_node
,
2654 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0)));
2660 /* Avoid integer_zerop to ignore TREE_CONSTANT_OVERFLOW. */
2661 return (TREE_INT_CST_LOW (expr
) != 0 || TREE_INT_CST_HIGH (expr
) != 0)
2662 ? truthvalue_true_node
2663 : truthvalue_false_node
;
2666 return real_compare (NE_EXPR
, &TREE_REAL_CST (expr
), &dconst0
)
2667 ? truthvalue_true_node
2668 : truthvalue_false_node
;
2671 expr
= build_unary_op (ADDR_EXPR
, expr
, 0);
2676 tree inner
= TREE_OPERAND (expr
, 0);
2677 if (decl_with_nonnull_addr_p (inner
))
2679 /* Common Ada/Pascal programmer's mistake. */
2680 warning (OPT_Walways_true
,
2681 "the address of %qD will always evaluate as %<true%>",
2683 return truthvalue_true_node
;
2686 /* If we still have a decl, it is possible for its address to
2687 be NULL, so we cannot optimize. */
2690 gcc_assert (DECL_WEAK (inner
));
2694 if (TREE_SIDE_EFFECTS (inner
))
2695 return build2 (COMPOUND_EXPR
, truthvalue_type_node
,
2696 inner
, truthvalue_true_node
);
2698 return truthvalue_true_node
;
2702 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1))
2703 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
2704 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0)),
2705 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 1)),
2711 /* These don't change whether an object is nonzero or zero. */
2712 return c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0));
2716 /* These don't change whether an object is zero or nonzero, but
2717 we can't ignore them if their second arg has side-effects. */
2718 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1)))
2719 return build2 (COMPOUND_EXPR
, truthvalue_type_node
,
2720 TREE_OPERAND (expr
, 1),
2721 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0)));
2723 return c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0));
2726 /* Distribute the conversion into the arms of a COND_EXPR. */
2727 return fold_build3 (COND_EXPR
, truthvalue_type_node
,
2728 TREE_OPERAND (expr
, 0),
2729 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 1)),
2730 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 2)));
2734 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2735 since that affects how `default_conversion' will behave. */
2736 if (TREE_CODE (TREE_TYPE (expr
)) == REFERENCE_TYPE
2737 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == REFERENCE_TYPE
)
2739 /* If this is widening the argument, we can ignore it. */
2740 if (TYPE_PRECISION (TREE_TYPE (expr
))
2741 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr
, 0))))
2742 return c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0));
2746 if (!TREE_NO_WARNING (expr
)
2747 && warn_parentheses
)
2749 warning (OPT_Wparentheses
,
2750 "suggest parentheses around assignment used as truth value");
2751 TREE_NO_WARNING (expr
) = 1;
2759 if (TREE_CODE (TREE_TYPE (expr
)) == COMPLEX_TYPE
)
2761 tree t
= save_expr (expr
);
2762 return (build_binary_op
2763 ((TREE_SIDE_EFFECTS (expr
)
2764 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
2765 c_common_truthvalue_conversion (build_unary_op (REALPART_EXPR
, t
, 0)),
2766 c_common_truthvalue_conversion (build_unary_op (IMAGPART_EXPR
, t
, 0)),
2770 return build_binary_op (NE_EXPR
, expr
, integer_zero_node
, 1);
2773 static void def_builtin_1 (enum built_in_function fncode
,
2775 enum built_in_class fnclass
,
2776 tree fntype
, tree libtype
,
2777 bool both_p
, bool fallback_p
, bool nonansi_p
,
2778 tree fnattrs
, bool implicit_p
);
2780 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2781 down to the element type of an array. */
2784 c_build_qualified_type (tree type
, int type_quals
)
2786 if (type
== error_mark_node
)
2789 if (TREE_CODE (type
) == ARRAY_TYPE
)
2792 tree element_type
= c_build_qualified_type (TREE_TYPE (type
),
2795 /* See if we already have an identically qualified type. */
2796 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
2798 if (TYPE_QUALS (strip_array_types (t
)) == type_quals
2799 && TYPE_NAME (t
) == TYPE_NAME (type
)
2800 && TYPE_CONTEXT (t
) == TYPE_CONTEXT (type
)
2801 && attribute_list_equal (TYPE_ATTRIBUTES (t
),
2802 TYPE_ATTRIBUTES (type
)))
2807 t
= build_variant_type_copy (type
);
2808 TREE_TYPE (t
) = element_type
;
2813 /* A restrict-qualified pointer type must be a pointer to object or
2814 incomplete type. Note that the use of POINTER_TYPE_P also allows
2815 REFERENCE_TYPEs, which is appropriate for C++. */
2816 if ((type_quals
& TYPE_QUAL_RESTRICT
)
2817 && (!POINTER_TYPE_P (type
)
2818 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type
))))
2820 error ("invalid use of %<restrict%>");
2821 type_quals
&= ~TYPE_QUAL_RESTRICT
;
2824 return build_qualified_type (type
, type_quals
);
2827 /* Apply the TYPE_QUALS to the new DECL. */
2830 c_apply_type_quals_to_decl (int type_quals
, tree decl
)
2832 tree type
= TREE_TYPE (decl
);
2834 if (type
== error_mark_node
)
2837 if (((type_quals
& TYPE_QUAL_CONST
)
2838 || (type
&& TREE_CODE (type
) == REFERENCE_TYPE
))
2839 /* An object declared 'const' is only readonly after it is
2840 initialized. We don't have any way of expressing this currently,
2841 so we need to be conservative and unset TREE_READONLY for types
2842 with constructors. Otherwise aliasing code will ignore stores in
2843 an inline constructor. */
2844 && !(type
&& TYPE_NEEDS_CONSTRUCTING (type
)))
2845 TREE_READONLY (decl
) = 1;
2846 if (type_quals
& TYPE_QUAL_VOLATILE
)
2848 TREE_SIDE_EFFECTS (decl
) = 1;
2849 TREE_THIS_VOLATILE (decl
) = 1;
2851 if (type_quals
& TYPE_QUAL_RESTRICT
)
2853 while (type
&& TREE_CODE (type
) == ARRAY_TYPE
)
2854 /* Allow 'restrict' on arrays of pointers.
2855 FIXME currently we just ignore it. */
2856 type
= TREE_TYPE (type
);
2858 || !POINTER_TYPE_P (type
)
2859 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type
)))
2860 error ("invalid use of %<restrict%>");
2861 else if (flag_strict_aliasing
&& type
== TREE_TYPE (decl
))
2862 /* Indicate we need to make a unique alias set for this pointer.
2863 We can't do it here because it might be pointing to an
2865 DECL_POINTER_ALIAS_SET (decl
) = -2;
2869 /* Hash function for the problem of multiple type definitions in
2870 different files. This must hash all types that will compare
2871 equal via comptypes to the same value. In practice it hashes
2872 on some of the simple stuff and leaves the details to comptypes. */
2875 c_type_hash (const void *p
)
2881 switch (TREE_CODE (t
))
2883 /* For pointers, hash on pointee type plus some swizzling. */
2885 return c_type_hash (TREE_TYPE (t
)) ^ 0x3003003;
2886 /* Hash on number of elements and total size. */
2889 t2
= TYPE_VALUES (t
);
2893 t2
= TYPE_FIELDS (t
);
2895 case QUAL_UNION_TYPE
:
2897 t2
= TYPE_FIELDS (t
);
2901 t2
= TYPE_FIELDS (t
);
2906 for (; t2
; t2
= TREE_CHAIN (t2
))
2908 size
= TREE_INT_CST_LOW (TYPE_SIZE (t
));
2909 return ((size
<< 24) | (i
<< shift
));
2912 static GTY((param_is (union tree_node
))) htab_t type_hash_table
;
2914 /* Return the typed-based alias set for T, which may be an expression
2915 or a type. Return -1 if we don't do anything special. */
2918 c_common_get_alias_set (tree t
)
2923 /* Permit type-punning when accessing a union, provided the access
2924 is directly through the union. For example, this code does not
2925 permit taking the address of a union member and then storing
2926 through it. Even the type-punning allowed here is a GCC
2927 extension, albeit a common and useful one; the C standard says
2928 that such accesses have implementation-defined behavior. */
2930 TREE_CODE (u
) == COMPONENT_REF
|| TREE_CODE (u
) == ARRAY_REF
;
2931 u
= TREE_OPERAND (u
, 0))
2932 if (TREE_CODE (u
) == COMPONENT_REF
2933 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u
, 0))) == UNION_TYPE
)
2936 /* That's all the expressions we handle specially. */
2940 /* The C standard guarantees that any object may be accessed via an
2941 lvalue that has character type. */
2942 if (t
== char_type_node
2943 || t
== signed_char_type_node
2944 || t
== unsigned_char_type_node
)
2947 /* If it has the may_alias attribute, it can alias anything. */
2948 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (t
)))
2951 /* The C standard specifically allows aliasing between signed and
2952 unsigned variants of the same type. We treat the signed
2953 variant as canonical. */
2954 if (TREE_CODE (t
) == INTEGER_TYPE
&& TYPE_UNSIGNED (t
))
2956 tree t1
= c_common_signed_type (t
);
2958 /* t1 == t can happen for boolean nodes which are always unsigned. */
2960 return get_alias_set (t1
);
2962 else if (POINTER_TYPE_P (t
))
2966 /* Unfortunately, there is no canonical form of a pointer type.
2967 In particular, if we have `typedef int I', then `int *', and
2968 `I *' are different types. So, we have to pick a canonical
2969 representative. We do this below.
2971 Technically, this approach is actually more conservative that
2972 it needs to be. In particular, `const int *' and `int *'
2973 should be in different alias sets, according to the C and C++
2974 standard, since their types are not the same, and so,
2975 technically, an `int **' and `const int **' cannot point at
2978 But, the standard is wrong. In particular, this code is
2983 const int* const* cipp = ipp;
2985 And, it doesn't make sense for that to be legal unless you
2986 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
2987 the pointed-to types. This issue has been reported to the
2989 t1
= build_type_no_quals (t
);
2991 return get_alias_set (t1
);
2994 /* Handle the case of multiple type nodes referring to "the same" type,
2995 which occurs with IMA. These share an alias set. FIXME: Currently only
2996 C90 is handled. (In C99 type compatibility is not transitive, which
2997 complicates things mightily. The alias set splay trees can theoretically
2998 represent this, but insertion is tricky when you consider all the
2999 different orders things might arrive in.) */
3001 if (c_language
!= clk_c
|| flag_isoc99
)
3004 /* Save time if there's only one input file. */
3005 if (num_in_fnames
== 1)
3008 /* Pointers need special handling if they point to any type that
3009 needs special handling (below). */
3010 if (TREE_CODE (t
) == POINTER_TYPE
)
3013 /* Find bottom type under any nested POINTERs. */
3014 for (t2
= TREE_TYPE (t
);
3015 TREE_CODE (t2
) == POINTER_TYPE
;
3016 t2
= TREE_TYPE (t2
))
3018 if (TREE_CODE (t2
) != RECORD_TYPE
3019 && TREE_CODE (t2
) != ENUMERAL_TYPE
3020 && TREE_CODE (t2
) != QUAL_UNION_TYPE
3021 && TREE_CODE (t2
) != UNION_TYPE
)
3023 if (TYPE_SIZE (t2
) == 0)
3026 /* These are the only cases that need special handling. */
3027 if (TREE_CODE (t
) != RECORD_TYPE
3028 && TREE_CODE (t
) != ENUMERAL_TYPE
3029 && TREE_CODE (t
) != QUAL_UNION_TYPE
3030 && TREE_CODE (t
) != UNION_TYPE
3031 && TREE_CODE (t
) != POINTER_TYPE
)
3034 if (TYPE_SIZE (t
) == 0)
3037 /* Look up t in hash table. Only one of the compatible types within each
3038 alias set is recorded in the table. */
3039 if (!type_hash_table
)
3040 type_hash_table
= htab_create_ggc (1021, c_type_hash
,
3041 (htab_eq
) lang_hooks
.types_compatible_p
,
3043 slot
= htab_find_slot (type_hash_table
, t
, INSERT
);
3046 TYPE_ALIAS_SET (t
) = TYPE_ALIAS_SET ((tree
)*slot
);
3047 return TYPE_ALIAS_SET ((tree
)*slot
);
3050 /* Our caller will assign and record (in t) a new alias set; all we need
3051 to do is remember t in the hash table. */
3057 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
3058 second parameter indicates which OPERATOR is being applied. The COMPLAIN
3059 flag controls whether we should diagnose possibly ill-formed
3060 constructs or not. */
3063 c_sizeof_or_alignof_type (tree type
, bool is_sizeof
, int complain
)
3065 const char *op_name
;
3067 enum tree_code type_code
= TREE_CODE (type
);
3069 op_name
= is_sizeof
? "sizeof" : "__alignof__";
3071 if (type_code
== FUNCTION_TYPE
)
3075 if (complain
&& (pedantic
|| warn_pointer_arith
))
3076 pedwarn ("invalid application of %<sizeof%> to a function type");
3077 value
= size_one_node
;
3080 value
= size_int (FUNCTION_BOUNDARY
/ BITS_PER_UNIT
);
3082 else if (type_code
== VOID_TYPE
|| type_code
== ERROR_MARK
)
3084 if (type_code
== VOID_TYPE
3085 && complain
&& (pedantic
|| warn_pointer_arith
))
3086 pedwarn ("invalid application of %qs to a void type", op_name
);
3087 value
= size_one_node
;
3089 else if (!COMPLETE_TYPE_P (type
))
3092 error ("invalid application of %qs to incomplete type %qT ",
3094 value
= size_zero_node
;
3099 /* Convert in case a char is more than one unit. */
3100 value
= size_binop (CEIL_DIV_EXPR
, TYPE_SIZE_UNIT (type
),
3101 size_int (TYPE_PRECISION (char_type_node
)
3104 value
= size_int (TYPE_ALIGN_UNIT (type
));
3107 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
3108 TYPE_IS_SIZETYPE means that certain things (like overflow) will
3109 never happen. However, this node should really have type
3110 `size_t', which is just a typedef for an ordinary integer type. */
3111 value
= fold_convert (size_type_node
, value
);
3112 gcc_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value
)));
3117 /* Implement the __alignof keyword: Return the minimum required
3118 alignment of EXPR, measured in bytes. For VAR_DECL's and
3119 FIELD_DECL's return DECL_ALIGN (which can be set from an
3120 "aligned" __attribute__ specification). */
3123 c_alignof_expr (tree expr
)
3127 if (TREE_CODE (expr
) == VAR_DECL
)
3128 t
= size_int (DECL_ALIGN_UNIT (expr
));
3130 else if (TREE_CODE (expr
) == COMPONENT_REF
3131 && DECL_C_BIT_FIELD (TREE_OPERAND (expr
, 1)))
3133 error ("%<__alignof%> applied to a bit-field");
3136 else if (TREE_CODE (expr
) == COMPONENT_REF
3137 && TREE_CODE (TREE_OPERAND (expr
, 1)) == FIELD_DECL
)
3138 t
= size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr
, 1)));
3140 else if (TREE_CODE (expr
) == INDIRECT_REF
)
3142 tree t
= TREE_OPERAND (expr
, 0);
3144 int bestalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
3146 while ((TREE_CODE (t
) == NOP_EXPR
|| TREE_CODE (t
) == CONVERT_EXPR
)
3147 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0))) == POINTER_TYPE
)
3151 t
= TREE_OPERAND (t
, 0);
3152 thisalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
3153 if (thisalign
> bestalign
)
3154 best
= t
, bestalign
= thisalign
;
3156 return c_alignof (TREE_TYPE (TREE_TYPE (best
)));
3159 return c_alignof (TREE_TYPE (expr
));
3161 return fold_convert (size_type_node
, t
);
3164 /* Handle C and C++ default attributes. */
3166 enum built_in_attribute
3168 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
3169 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
3170 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
3171 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
3172 #include "builtin-attrs.def"
3173 #undef DEF_ATTR_NULL_TREE
3175 #undef DEF_ATTR_IDENT
3176 #undef DEF_ATTR_TREE_LIST
3180 static GTY(()) tree built_in_attributes
[(int) ATTR_LAST
];
3182 static void c_init_attributes (void);
3186 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
3187 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
3188 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
3189 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
3190 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3191 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3192 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
3193 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME,
3194 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME,
3195 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
3196 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
3197 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
3198 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3199 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3200 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
3202 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
3203 #include "builtin-types.def"
3204 #undef DEF_PRIMITIVE_TYPE
3205 #undef DEF_FUNCTION_TYPE_0
3206 #undef DEF_FUNCTION_TYPE_1
3207 #undef DEF_FUNCTION_TYPE_2
3208 #undef DEF_FUNCTION_TYPE_3
3209 #undef DEF_FUNCTION_TYPE_4
3210 #undef DEF_FUNCTION_TYPE_5
3211 #undef DEF_FUNCTION_TYPE_6
3212 #undef DEF_FUNCTION_TYPE_7
3213 #undef DEF_FUNCTION_TYPE_VAR_0
3214 #undef DEF_FUNCTION_TYPE_VAR_1
3215 #undef DEF_FUNCTION_TYPE_VAR_2
3216 #undef DEF_FUNCTION_TYPE_VAR_3
3217 #undef DEF_FUNCTION_TYPE_VAR_4
3218 #undef DEF_FUNCTION_TYPE_VAR_5
3219 #undef DEF_POINTER_TYPE
3223 typedef enum c_builtin_type builtin_type
;
3225 /* A temporary array for c_common_nodes_and_builtins. Used in
3226 communication with def_fn_type. */
3227 static tree builtin_types
[(int) BT_LAST
+ 1];
3229 /* A helper function for c_common_nodes_and_builtins. Build function type
3230 for DEF with return type RET and N arguments. If VAR is true, then the
3231 function should be variadic after those N arguments.
3233 Takes special care not to ICE if any of the types involved are
3234 error_mark_node, which indicates that said type is not in fact available
3235 (see builtin_type_for_size). In which case the function type as a whole
3236 should be error_mark_node. */
3239 def_fn_type (builtin_type def
, builtin_type ret
, bool var
, int n
, ...)
3241 tree args
= NULL
, t
;
3246 for (i
= 0; i
< n
; ++i
)
3248 builtin_type a
= va_arg (list
, builtin_type
);
3249 t
= builtin_types
[a
];
3250 if (t
== error_mark_node
)
3252 args
= tree_cons (NULL_TREE
, t
, args
);
3256 args
= nreverse (args
);
3258 args
= chainon (args
, void_list_node
);
3260 t
= builtin_types
[ret
];
3261 if (t
== error_mark_node
)
3263 t
= build_function_type (t
, args
);
3266 builtin_types
[def
] = t
;
3269 /* Build builtin functions common to both C and C++ language
3273 c_define_builtins (tree va_list_ref_type_node
, tree va_list_arg_type_node
)
3275 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3276 builtin_types[ENUM] = VALUE;
3277 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
3278 def_fn_type (ENUM, RETURN, 0, 0);
3279 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
3280 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
3281 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
3282 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
3283 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3284 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
3285 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3286 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
3287 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
3288 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
3289 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3291 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
3292 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3294 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
3295 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
3296 def_fn_type (ENUM, RETURN, 1, 0);
3297 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
3298 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
3299 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
3300 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
3301 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3302 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
3303 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3304 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
3305 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
3306 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
3307 #define DEF_POINTER_TYPE(ENUM, TYPE) \
3308 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
3310 #include "builtin-types.def"
3312 #undef DEF_PRIMITIVE_TYPE
3313 #undef DEF_FUNCTION_TYPE_1
3314 #undef DEF_FUNCTION_TYPE_2
3315 #undef DEF_FUNCTION_TYPE_3
3316 #undef DEF_FUNCTION_TYPE_4
3317 #undef DEF_FUNCTION_TYPE_5
3318 #undef DEF_FUNCTION_TYPE_6
3319 #undef DEF_FUNCTION_TYPE_VAR_0
3320 #undef DEF_FUNCTION_TYPE_VAR_1
3321 #undef DEF_FUNCTION_TYPE_VAR_2
3322 #undef DEF_FUNCTION_TYPE_VAR_3
3323 #undef DEF_FUNCTION_TYPE_VAR_4
3324 #undef DEF_FUNCTION_TYPE_VAR_5
3325 #undef DEF_POINTER_TYPE
3326 builtin_types
[(int) BT_LAST
] = NULL_TREE
;
3328 c_init_attributes ();
3330 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
3331 NONANSI_P, ATTRS, IMPLICIT, COND) \
3333 def_builtin_1 (ENUM, NAME, CLASS, \
3334 builtin_types[(int) TYPE], \
3335 builtin_types[(int) LIBTYPE], \
3336 BOTH_P, FALLBACK_P, NONANSI_P, \
3337 built_in_attributes[(int) ATTRS], IMPLICIT);
3338 #include "builtins.def"
3341 build_common_builtin_nodes ();
3343 targetm
.init_builtins ();
3348 /* Build tree nodes and builtin functions common to both C and C++ language
3352 c_common_nodes_and_builtins (void)
3354 int wchar_type_size
;
3355 tree array_domain_type
;
3356 tree va_list_ref_type_node
;
3357 tree va_list_arg_type_node
;
3359 /* Define `int' and `char' first so that dbx will output them first. */
3360 record_builtin_type (RID_INT
, NULL
, integer_type_node
);
3361 record_builtin_type (RID_CHAR
, "char", char_type_node
);
3363 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
3364 "unsigned long", "long long unsigned" and "unsigned short" were in C++
3365 but not C. Are the conditionals here needed? */
3366 if (c_dialect_cxx ())
3367 record_builtin_type (RID_SIGNED
, NULL
, integer_type_node
);
3368 record_builtin_type (RID_LONG
, "long int", long_integer_type_node
);
3369 record_builtin_type (RID_UNSIGNED
, "unsigned int", unsigned_type_node
);
3370 record_builtin_type (RID_MAX
, "long unsigned int",
3371 long_unsigned_type_node
);
3372 if (c_dialect_cxx ())
3373 record_builtin_type (RID_MAX
, "unsigned long", long_unsigned_type_node
);
3374 record_builtin_type (RID_MAX
, "long long int",
3375 long_long_integer_type_node
);
3376 record_builtin_type (RID_MAX
, "long long unsigned int",
3377 long_long_unsigned_type_node
);
3378 if (c_dialect_cxx ())
3379 record_builtin_type (RID_MAX
, "long long unsigned",
3380 long_long_unsigned_type_node
);
3381 record_builtin_type (RID_SHORT
, "short int", short_integer_type_node
);
3382 record_builtin_type (RID_MAX
, "short unsigned int",
3383 short_unsigned_type_node
);
3384 if (c_dialect_cxx ())
3385 record_builtin_type (RID_MAX
, "unsigned short",
3386 short_unsigned_type_node
);
3388 /* Define both `signed char' and `unsigned char'. */
3389 record_builtin_type (RID_MAX
, "signed char", signed_char_type_node
);
3390 record_builtin_type (RID_MAX
, "unsigned char", unsigned_char_type_node
);
3392 /* These are types that c_common_type_for_size and
3393 c_common_type_for_mode use. */
3394 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3396 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3398 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3400 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3402 #if HOST_BITS_PER_WIDE_INT >= 64
3403 if (targetm
.scalar_mode_supported_p (TImode
))
3404 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
3405 get_identifier ("__int128_t"),
3408 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3409 unsigned_intQI_type_node
));
3410 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3411 unsigned_intHI_type_node
));
3412 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3413 unsigned_intSI_type_node
));
3414 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3415 unsigned_intDI_type_node
));
3416 #if HOST_BITS_PER_WIDE_INT >= 64
3417 if (targetm
.scalar_mode_supported_p (TImode
))
3418 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
3419 get_identifier ("__uint128_t"),
3420 unsigned_intTI_type_node
));
3423 /* Create the widest literal types. */
3424 widest_integer_literal_type_node
3425 = make_signed_type (HOST_BITS_PER_WIDE_INT
* 2);
3426 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3427 widest_integer_literal_type_node
));
3429 widest_unsigned_literal_type_node
3430 = make_unsigned_type (HOST_BITS_PER_WIDE_INT
* 2);
3431 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3432 widest_unsigned_literal_type_node
));
3434 /* `unsigned long' is the standard type for sizeof.
3435 Note that stddef.h uses `unsigned long',
3436 and this must agree, even if long and int are the same size. */
3438 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE
)));
3439 signed_size_type_node
= c_common_signed_type (size_type_node
);
3440 set_sizetype (size_type_node
);
3443 TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE
)));
3445 build_common_tree_nodes_2 (flag_short_double
);
3447 record_builtin_type (RID_FLOAT
, NULL
, float_type_node
);
3448 record_builtin_type (RID_DOUBLE
, NULL
, double_type_node
);
3449 record_builtin_type (RID_MAX
, "long double", long_double_type_node
);
3451 /* Only supported decimal floating point extension if the target
3452 actually supports underlying modes. */
3453 if (targetm
.scalar_mode_supported_p (SDmode
)
3454 && targetm
.scalar_mode_supported_p (DDmode
)
3455 && targetm
.scalar_mode_supported_p (TDmode
))
3457 record_builtin_type (RID_DFLOAT32
, NULL
, dfloat32_type_node
);
3458 record_builtin_type (RID_DFLOAT64
, NULL
, dfloat64_type_node
);
3459 record_builtin_type (RID_DFLOAT128
, NULL
, dfloat128_type_node
);
3462 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
3463 get_identifier ("complex int"),
3464 complex_integer_type_node
));
3465 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
3466 get_identifier ("complex float"),
3467 complex_float_type_node
));
3468 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
3469 get_identifier ("complex double"),
3470 complex_double_type_node
));
3471 lang_hooks
.decls
.pushdecl
3472 (build_decl (TYPE_DECL
, get_identifier ("complex long double"),
3473 complex_long_double_type_node
));
3475 if (c_dialect_cxx ())
3476 /* For C++, make fileptr_type_node a distinct void * type until
3477 FILE type is defined. */
3478 fileptr_type_node
= build_variant_type_copy (ptr_type_node
);
3480 record_builtin_type (RID_VOID
, NULL
, void_type_node
);
3482 /* Set the TYPE_NAME for any variants that were built before
3483 record_builtin_type gave names to the built-in types. */
3485 tree void_name
= TYPE_NAME (void_type_node
);
3486 TYPE_NAME (void_type_node
) = NULL_TREE
;
3487 TYPE_NAME (build_qualified_type (void_type_node
, TYPE_QUAL_CONST
))
3489 TYPE_NAME (void_type_node
) = void_name
;
3492 /* This node must not be shared. */
3493 void_zero_node
= make_node (INTEGER_CST
);
3494 TREE_TYPE (void_zero_node
) = void_type_node
;
3496 void_list_node
= build_void_list_node ();
3498 /* Make a type to be the domain of a few array types
3499 whose domains don't really matter.
3500 200 is small enough that it always fits in size_t
3501 and large enough that it can hold most function names for the
3502 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
3503 array_domain_type
= build_index_type (size_int (200));
3505 /* Make a type for arrays of characters.
3506 With luck nothing will ever really depend on the length of this
3508 char_array_type_node
3509 = build_array_type (char_type_node
, array_domain_type
);
3511 /* Likewise for arrays of ints. */
3513 = build_array_type (integer_type_node
, array_domain_type
);
3515 string_type_node
= build_pointer_type (char_type_node
);
3516 const_string_type_node
3517 = build_pointer_type (build_qualified_type
3518 (char_type_node
, TYPE_QUAL_CONST
));
3520 /* This is special for C++ so functions can be overloaded. */
3521 wchar_type_node
= get_identifier (MODIFIED_WCHAR_TYPE
);
3522 wchar_type_node
= TREE_TYPE (identifier_global_value (wchar_type_node
));
3523 wchar_type_size
= TYPE_PRECISION (wchar_type_node
);
3524 if (c_dialect_cxx ())
3526 if (TYPE_UNSIGNED (wchar_type_node
))
3527 wchar_type_node
= make_unsigned_type (wchar_type_size
);
3529 wchar_type_node
= make_signed_type (wchar_type_size
);
3530 record_builtin_type (RID_WCHAR
, "wchar_t", wchar_type_node
);
3534 signed_wchar_type_node
= c_common_signed_type (wchar_type_node
);
3535 unsigned_wchar_type_node
= c_common_unsigned_type (wchar_type_node
);
3538 /* This is for wide string constants. */
3539 wchar_array_type_node
3540 = build_array_type (wchar_type_node
, array_domain_type
);
3543 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE
)));
3546 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE
)));
3548 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE
)));
3550 default_function_type
= build_function_type (integer_type_node
, NULL_TREE
);
3552 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE
)));
3553 unsigned_ptrdiff_type_node
= c_common_unsigned_type (ptrdiff_type_node
);
3555 lang_hooks
.decls
.pushdecl
3556 (build_decl (TYPE_DECL
, get_identifier ("__builtin_va_list"),
3557 va_list_type_node
));
3559 if (TREE_CODE (va_list_type_node
) == ARRAY_TYPE
)
3561 va_list_arg_type_node
= va_list_ref_type_node
=
3562 build_pointer_type (TREE_TYPE (va_list_type_node
));
3566 va_list_arg_type_node
= va_list_type_node
;
3567 va_list_ref_type_node
= build_reference_type (va_list_type_node
);
3570 if (!flag_preprocess_only
)
3571 c_define_builtins (va_list_ref_type_node
, va_list_arg_type_node
);
3573 main_identifier_node
= get_identifier ("main");
3575 /* Create the built-in __null node. It is important that this is
3577 null_node
= make_node (INTEGER_CST
);
3578 TREE_TYPE (null_node
) = c_common_type_for_size (POINTER_SIZE
, 0);
3580 /* Since builtin_types isn't gc'ed, don't export these nodes. */
3581 memset (builtin_types
, 0, sizeof (builtin_types
));
3584 /* Look up the function in built_in_decls that corresponds to DECL
3585 and set ASMSPEC as its user assembler name. DECL must be a
3586 function decl that declares a builtin. */
3589 set_builtin_user_assembler_name (tree decl
, const char *asmspec
)
3592 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
3593 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
3596 builtin
= built_in_decls
[DECL_FUNCTION_CODE (decl
)];
3597 set_user_assembler_name (builtin
, asmspec
);
3598 if (DECL_FUNCTION_CODE (decl
) == BUILT_IN_MEMCPY
)
3599 init_block_move_fn (asmspec
);
3600 else if (DECL_FUNCTION_CODE (decl
) == BUILT_IN_MEMSET
)
3601 init_block_clear_fn (asmspec
);
3604 /* The number of named compound-literals generated thus far. */
3605 static GTY(()) int compound_literal_number
;
3607 /* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal. */
3610 set_compound_literal_name (tree decl
)
3613 ASM_FORMAT_PRIVATE_NAME (name
, "__compound_literal",
3614 compound_literal_number
);
3615 compound_literal_number
++;
3616 DECL_NAME (decl
) = get_identifier (name
);
3620 build_va_arg (tree expr
, tree type
)
3622 return build1 (VA_ARG_EXPR
, type
, expr
);
3626 /* Linked list of disabled built-in functions. */
3628 typedef struct disabled_builtin
3631 struct disabled_builtin
*next
;
3633 static disabled_builtin
*disabled_builtins
= NULL
;
3635 static bool builtin_function_disabled_p (const char *);
3637 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
3638 begins with "__builtin_", give an error. */
3641 disable_builtin_function (const char *name
)
3643 if (strncmp (name
, "__builtin_", strlen ("__builtin_")) == 0)
3644 error ("cannot disable built-in function %qs", name
);
3647 disabled_builtin
*new_disabled_builtin
= XNEW (disabled_builtin
);
3648 new_disabled_builtin
->name
= name
;
3649 new_disabled_builtin
->next
= disabled_builtins
;
3650 disabled_builtins
= new_disabled_builtin
;
3655 /* Return true if the built-in function NAME has been disabled, false
3659 builtin_function_disabled_p (const char *name
)
3661 disabled_builtin
*p
;
3662 for (p
= disabled_builtins
; p
!= NULL
; p
= p
->next
)
3664 if (strcmp (name
, p
->name
) == 0)
3671 /* Worker for DEF_BUILTIN.
3672 Possibly define a builtin function with one or two names.
3673 Does not declare a non-__builtin_ function if flag_no_builtin, or if
3674 nonansi_p and flag_no_nonansi_builtin. */
3677 def_builtin_1 (enum built_in_function fncode
,
3679 enum built_in_class fnclass
,
3680 tree fntype
, tree libtype
,
3681 bool both_p
, bool fallback_p
, bool nonansi_p
,
3682 tree fnattrs
, bool implicit_p
)
3685 const char *libname
;
3687 if (fntype
== error_mark_node
)
3690 gcc_assert ((!both_p
&& !fallback_p
)
3691 || !strncmp (name
, "__builtin_",
3692 strlen ("__builtin_")));
3694 libname
= name
+ strlen ("__builtin_");
3695 decl
= add_builtin_function (name
, fntype
, fncode
, fnclass
,
3696 (fallback_p
? libname
: NULL
),
3699 && !flag_no_builtin
&& !builtin_function_disabled_p (libname
)
3700 && !(nonansi_p
&& flag_no_nonansi_builtin
))
3701 add_builtin_function (libname
, libtype
, fncode
, fnclass
,
3704 built_in_decls
[(int) fncode
] = decl
;
3706 implicit_built_in_decls
[(int) fncode
] = decl
;
3709 /* Nonzero if the type T promotes to int. This is (nearly) the
3710 integral promotions defined in ISO C99 6.3.1.1/2. */
3713 c_promoting_integer_type_p (tree t
)
3715 switch (TREE_CODE (t
))
3718 return (TYPE_MAIN_VARIANT (t
) == char_type_node
3719 || TYPE_MAIN_VARIANT (t
) == signed_char_type_node
3720 || TYPE_MAIN_VARIANT (t
) == unsigned_char_type_node
3721 || TYPE_MAIN_VARIANT (t
) == short_integer_type_node
3722 || TYPE_MAIN_VARIANT (t
) == short_unsigned_type_node
3723 || TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
));
3726 /* ??? Technically all enumerations not larger than an int
3727 promote to an int. But this is used along code paths
3728 that only want to notice a size change. */
3729 return TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
);
3739 /* Return 1 if PARMS specifies a fixed number of parameters
3740 and none of their types is affected by default promotions. */
3743 self_promoting_args_p (tree parms
)
3746 for (t
= parms
; t
; t
= TREE_CHAIN (t
))
3748 tree type
= TREE_VALUE (t
);
3750 if (type
== error_mark_node
)
3753 if (TREE_CHAIN (t
) == 0 && type
!= void_type_node
)
3759 if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
3762 if (c_promoting_integer_type_p (type
))
3768 /* Recursively examines the array elements of TYPE, until a non-array
3769 element type is found. */
3772 strip_array_types (tree type
)
3774 while (TREE_CODE (type
) == ARRAY_TYPE
)
3775 type
= TREE_TYPE (type
);
3780 /* Recursively remove any '*' or '&' operator from TYPE. */
3782 strip_pointer_operator (tree t
)
3784 while (POINTER_TYPE_P (t
))
3789 /* Used to compare case labels. K1 and K2 are actually tree nodes
3790 representing case labels, or NULL_TREE for a `default' label.
3791 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3792 K2, and 0 if K1 and K2 are equal. */
3795 case_compare (splay_tree_key k1
, splay_tree_key k2
)
3797 /* Consider a NULL key (such as arises with a `default' label) to be
3798 smaller than anything else. */
3804 return tree_int_cst_compare ((tree
) k1
, (tree
) k2
);
3807 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
3808 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3809 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
3810 case label was declared using the usual C/C++ syntax, rather than
3811 the GNU case range extension. CASES is a tree containing all the
3812 case ranges processed so far; COND is the condition for the
3813 switch-statement itself. Returns the CASE_LABEL_EXPR created, or
3814 ERROR_MARK_NODE if no CASE_LABEL_EXPR is created. */
3817 c_add_case_label (splay_tree cases
, tree cond
, tree orig_type
,
3818 tree low_value
, tree high_value
)
3823 splay_tree_node node
;
3825 /* Create the LABEL_DECL itself. */
3826 label
= create_artificial_label ();
3828 /* If there was an error processing the switch condition, bail now
3829 before we get more confused. */
3830 if (!cond
|| cond
== error_mark_node
)
3833 if ((low_value
&& TREE_TYPE (low_value
)
3834 && POINTER_TYPE_P (TREE_TYPE (low_value
)))
3835 || (high_value
&& TREE_TYPE (high_value
)
3836 && POINTER_TYPE_P (TREE_TYPE (high_value
))))
3838 error ("pointers are not permitted as case values");
3842 /* Case ranges are a GNU extension. */
3843 if (high_value
&& pedantic
)
3844 pedwarn ("range expressions in switch statements are non-standard");
3846 type
= TREE_TYPE (cond
);
3849 low_value
= check_case_value (low_value
);
3850 low_value
= convert_and_check (type
, low_value
);
3851 if (low_value
== error_mark_node
)
3856 high_value
= check_case_value (high_value
);
3857 high_value
= convert_and_check (type
, high_value
);
3858 if (high_value
== error_mark_node
)
3862 if (low_value
&& high_value
)
3864 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
3865 really a case range, even though it was written that way.
3866 Remove the HIGH_VALUE to simplify later processing. */
3867 if (tree_int_cst_equal (low_value
, high_value
))
3868 high_value
= NULL_TREE
;
3869 else if (!tree_int_cst_lt (low_value
, high_value
))
3870 warning (0, "empty range specified");
3873 /* See if the case is in range of the type of the original testing
3874 expression. If both low_value and high_value are out of range,
3875 don't insert the case label and return NULL_TREE. */
3877 && !check_case_bounds (type
, orig_type
,
3878 &low_value
, high_value
? &high_value
: NULL
))
3881 /* Look up the LOW_VALUE in the table of case labels we already
3883 node
= splay_tree_lookup (cases
, (splay_tree_key
) low_value
);
3884 /* If there was not an exact match, check for overlapping ranges.
3885 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
3886 that's a `default' label and the only overlap is an exact match. */
3887 if (!node
&& (low_value
|| high_value
))
3889 splay_tree_node low_bound
;
3890 splay_tree_node high_bound
;
3892 /* Even though there wasn't an exact match, there might be an
3893 overlap between this case range and another case range.
3894 Since we've (inductively) not allowed any overlapping case
3895 ranges, we simply need to find the greatest low case label
3896 that is smaller that LOW_VALUE, and the smallest low case
3897 label that is greater than LOW_VALUE. If there is an overlap
3898 it will occur in one of these two ranges. */
3899 low_bound
= splay_tree_predecessor (cases
,
3900 (splay_tree_key
) low_value
);
3901 high_bound
= splay_tree_successor (cases
,
3902 (splay_tree_key
) low_value
);
3904 /* Check to see if the LOW_BOUND overlaps. It is smaller than
3905 the LOW_VALUE, so there is no need to check unless the
3906 LOW_BOUND is in fact itself a case range. */
3908 && CASE_HIGH ((tree
) low_bound
->value
)
3909 && tree_int_cst_compare (CASE_HIGH ((tree
) low_bound
->value
),
3912 /* Check to see if the HIGH_BOUND overlaps. The low end of that
3913 range is bigger than the low end of the current range, so we
3914 are only interested if the current range is a real range, and
3915 not an ordinary case label. */
3918 && (tree_int_cst_compare ((tree
) high_bound
->key
,
3923 /* If there was an overlap, issue an error. */
3926 tree duplicate
= CASE_LABEL ((tree
) node
->value
);
3930 error ("duplicate (or overlapping) case value");
3931 error ("%Jthis is the first entry overlapping that value", duplicate
);
3935 error ("duplicate case value") ;
3936 error ("%Jpreviously used here", duplicate
);
3940 error ("multiple default labels in one switch");
3941 error ("%Jthis is the first default label", duplicate
);
3946 /* Add a CASE_LABEL to the statement-tree. */
3947 case_label
= add_stmt (build_case_label (low_value
, high_value
, label
));
3948 /* Register this case label in the splay tree. */
3949 splay_tree_insert (cases
,
3950 (splay_tree_key
) low_value
,
3951 (splay_tree_value
) case_label
);
3956 /* Add a label so that the back-end doesn't think that the beginning of
3957 the switch is unreachable. Note that we do not add a case label, as
3958 that just leads to duplicates and thence to failure later on. */
3961 tree t
= create_artificial_label ();
3962 add_stmt (build_stmt (LABEL_EXPR
, t
));
3964 return error_mark_node
;
3967 /* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
3968 Used to verify that case values match up with enumerator values. */
3971 match_case_to_enum_1 (tree key
, tree type
, tree label
)
3973 char buf
[2 + 2*HOST_BITS_PER_WIDE_INT
/4 + 1];
3975 /* ??? Not working too hard to print the double-word value.
3976 Should perhaps be done with %lwd in the diagnostic routines? */
3977 if (TREE_INT_CST_HIGH (key
) == 0)
3978 snprintf (buf
, sizeof (buf
), HOST_WIDE_INT_PRINT_UNSIGNED
,
3979 TREE_INT_CST_LOW (key
));
3980 else if (!TYPE_UNSIGNED (type
)
3981 && TREE_INT_CST_HIGH (key
) == -1
3982 && TREE_INT_CST_LOW (key
) != 0)
3983 snprintf (buf
, sizeof (buf
), "-" HOST_WIDE_INT_PRINT_UNSIGNED
,
3984 -TREE_INT_CST_LOW (key
));
3986 snprintf (buf
, sizeof (buf
), HOST_WIDE_INT_PRINT_DOUBLE_HEX
,
3987 TREE_INT_CST_HIGH (key
), TREE_INT_CST_LOW (key
));
3989 if (TYPE_NAME (type
) == 0)
3990 warning (0, "%Jcase value %qs not in enumerated type",
3991 CASE_LABEL (label
), buf
);
3993 warning (0, "%Jcase value %qs not in enumerated type %qT",
3994 CASE_LABEL (label
), buf
, type
);
3997 /* Subroutine of c_do_switch_warnings, called via splay_tree_foreach.
3998 Used to verify that case values match up with enumerator values. */
4001 match_case_to_enum (splay_tree_node node
, void *data
)
4003 tree label
= (tree
) node
->value
;
4004 tree type
= (tree
) data
;
4006 /* Skip default case. */
4007 if (!CASE_LOW (label
))
4010 /* If CASE_LOW_SEEN is not set, that means CASE_LOW did not appear
4011 when we did our enum->case scan. Reset our scratch bit after. */
4012 if (!CASE_LOW_SEEN (label
))
4013 match_case_to_enum_1 (CASE_LOW (label
), type
, label
);
4015 CASE_LOW_SEEN (label
) = 0;
4017 /* If CASE_HIGH is non-null, we have a range. If CASE_HIGH_SEEN is
4018 not set, that means that CASE_HIGH did not appear when we did our
4019 enum->case scan. Reset our scratch bit after. */
4020 if (CASE_HIGH (label
))
4022 if (!CASE_HIGH_SEEN (label
))
4023 match_case_to_enum_1 (CASE_HIGH (label
), type
, label
);
4025 CASE_HIGH_SEEN (label
) = 0;
4031 /* Handle -Wswitch*. Called from the front end after parsing the
4032 switch construct. */
4033 /* ??? Should probably be somewhere generic, since other languages
4034 besides C and C++ would want this. At the moment, however, C/C++
4035 are the only tree-ssa languages that support enumerations at all,
4036 so the point is moot. */
4039 c_do_switch_warnings (splay_tree cases
, location_t switch_location
,
4040 tree type
, tree cond
)
4042 splay_tree_node default_node
;
4043 splay_tree_node node
;
4046 if (!warn_switch
&& !warn_switch_enum
&& !warn_switch_default
)
4049 default_node
= splay_tree_lookup (cases
, (splay_tree_key
) NULL
);
4051 warning (OPT_Wswitch_default
, "%Hswitch missing default case",
4054 /* From here on, we only care about about enumerated types. */
4055 if (!type
|| TREE_CODE (type
) != ENUMERAL_TYPE
)
4058 /* If the switch expression was an enumerated type, check that
4059 exactly all enumeration literals are covered by the cases.
4060 The check is made when -Wswitch was specified and there is no
4061 default case, or when -Wswitch-enum was specified. */
4063 if (!warn_switch_enum
4064 && !(warn_switch
&& !default_node
))
4067 /* Clearing COND if it is not an integer constant simplifies
4068 the tests inside the loop below. */
4069 if (TREE_CODE (cond
) != INTEGER_CST
)
4072 /* The time complexity here is O(N*lg(N)) worst case, but for the
4073 common case of monotonically increasing enumerators, it is
4074 O(N), since the nature of the splay tree will keep the next
4075 element adjacent to the root at all times. */
4077 for (chain
= TYPE_VALUES (type
); chain
; chain
= TREE_CHAIN (chain
))
4079 tree value
= TREE_VALUE (chain
);
4080 node
= splay_tree_lookup (cases
, (splay_tree_key
) value
);
4083 /* Mark the CASE_LOW part of the case entry as seen. */
4084 tree label
= (tree
) node
->value
;
4085 CASE_LOW_SEEN (label
) = 1;
4089 /* Even though there wasn't an exact match, there might be a
4090 case range which includes the enumator's value. */
4091 node
= splay_tree_predecessor (cases
, (splay_tree_key
) value
);
4092 if (node
&& CASE_HIGH ((tree
) node
->value
))
4094 tree label
= (tree
) node
->value
;
4095 int cmp
= tree_int_cst_compare (CASE_HIGH (label
), value
);
4098 /* If we match the upper bound exactly, mark the CASE_HIGH
4099 part of the case entry as seen. */
4101 CASE_HIGH_SEEN (label
) = 1;
4106 /* We've now determined that this enumerated literal isn't
4107 handled by the case labels of the switch statement. */
4109 /* If the switch expression is a constant, we only really care
4110 about whether that constant is handled by the switch. */
4111 if (cond
&& tree_int_cst_compare (cond
, value
))
4114 warning (0, "%Henumeration value %qE not handled in switch",
4115 &switch_location
, TREE_PURPOSE (chain
));
4118 /* Warn if there are case expressions that don't correspond to
4119 enumerators. This can occur since C and C++ don't enforce
4120 type-checking of assignments to enumeration variables.
4122 The time complexity here is now always O(N) worst case, since
4123 we should have marked both the lower bound and upper bound of
4124 every disjoint case label, with CASE_LOW_SEEN and CASE_HIGH_SEEN
4125 above. This scan also resets those fields. */
4126 splay_tree_foreach (cases
, match_case_to_enum
, type
);
4129 /* Finish an expression taking the address of LABEL (an
4130 IDENTIFIER_NODE). Returns an expression for the address. */
4133 finish_label_address_expr (tree label
)
4138 pedwarn ("taking the address of a label is non-standard");
4140 if (label
== error_mark_node
)
4141 return error_mark_node
;
4143 label
= lookup_label (label
);
4144 if (label
== NULL_TREE
)
4145 result
= null_pointer_node
;
4148 TREE_USED (label
) = 1;
4149 result
= build1 (ADDR_EXPR
, ptr_type_node
, label
);
4150 /* The current function in not necessarily uninlinable.
4151 Computed gotos are incompatible with inlining, but the value
4152 here could be used only in a diagnostic, for example. */
4158 /* Hook used by expand_expr to expand language-specific tree codes. */
4159 /* The only things that should go here are bits needed to expand
4160 constant initializers. Everything else should be handled by the
4161 gimplification routines. */
4164 c_expand_expr (tree exp
, rtx target
, enum machine_mode tmode
,
4165 int modifier
/* Actually enum_modifier. */,
4168 switch (TREE_CODE (exp
))
4170 case COMPOUND_LITERAL_EXPR
:
4172 /* Initialize the anonymous variable declared in the compound
4173 literal, then return the variable. */
4174 tree decl
= COMPOUND_LITERAL_EXPR_DECL (exp
);
4175 emit_local_var (decl
);
4176 return expand_expr_real (decl
, target
, tmode
, modifier
, alt_rtl
);
4184 /* Hook used by staticp to handle language-specific tree codes. */
4187 c_staticp (tree exp
)
4189 return (TREE_CODE (exp
) == COMPOUND_LITERAL_EXPR
4190 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp
))
4195 /* Given a boolean expression ARG, return a tree representing an increment
4196 or decrement (as indicated by CODE) of ARG. The front end must check for
4197 invalid cases (e.g., decrement in C++). */
4199 boolean_increment (enum tree_code code
, tree arg
)
4202 tree true_res
= boolean_true_node
;
4204 arg
= stabilize_reference (arg
);
4207 case PREINCREMENT_EXPR
:
4208 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
4210 case POSTINCREMENT_EXPR
:
4211 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
4212 arg
= save_expr (arg
);
4213 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
4214 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
4216 case PREDECREMENT_EXPR
:
4217 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
,
4218 invert_truthvalue (arg
));
4220 case POSTDECREMENT_EXPR
:
4221 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
,
4222 invert_truthvalue (arg
));
4223 arg
= save_expr (arg
);
4224 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
4225 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
4230 TREE_SIDE_EFFECTS (val
) = 1;
4234 /* Built-in macros for stddef.h, that require macros defined in this
4237 c_stddef_cpp_builtins(void)
4239 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE
, 0);
4240 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE
, 0);
4241 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE
, 0);
4242 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE
, 0);
4243 builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE
, 0);
4244 builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE
, 0);
4248 c_init_attributes (void)
4250 /* Fill in the built_in_attributes array. */
4251 #define DEF_ATTR_NULL_TREE(ENUM) \
4252 built_in_attributes[(int) ENUM] = NULL_TREE;
4253 #define DEF_ATTR_INT(ENUM, VALUE) \
4254 built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
4255 #define DEF_ATTR_IDENT(ENUM, STRING) \
4256 built_in_attributes[(int) ENUM] = get_identifier (STRING);
4257 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
4258 built_in_attributes[(int) ENUM] \
4259 = tree_cons (built_in_attributes[(int) PURPOSE], \
4260 built_in_attributes[(int) VALUE], \
4261 built_in_attributes[(int) CHAIN]);
4262 #include "builtin-attrs.def"
4263 #undef DEF_ATTR_NULL_TREE
4265 #undef DEF_ATTR_IDENT
4266 #undef DEF_ATTR_TREE_LIST
4269 /* Attribute handlers common to C front ends. */
4271 /* Handle a "packed" attribute; arguments as in
4272 struct attribute_spec.handler. */
4275 handle_packed_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
4276 int flags
, bool *no_add_attrs
)
4280 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
4281 *node
= build_variant_type_copy (*node
);
4282 TYPE_PACKED (*node
) = 1;
4284 else if (TREE_CODE (*node
) == FIELD_DECL
)
4286 if (TYPE_ALIGN (TREE_TYPE (*node
)) <= BITS_PER_UNIT
)
4287 warning (OPT_Wattributes
,
4288 "%qE attribute ignored for field of type %qT",
4289 name
, TREE_TYPE (*node
));
4291 DECL_PACKED (*node
) = 1;
4293 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
4294 used for DECL_REGISTER. It wouldn't mean anything anyway.
4295 We can't set DECL_PACKED on the type of a TYPE_DECL, because
4296 that changes what the typedef is typing. */
4299 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4300 *no_add_attrs
= true;
4306 /* Handle a "nocommon" attribute; arguments as in
4307 struct attribute_spec.handler. */
4310 handle_nocommon_attribute (tree
*node
, tree name
,
4311 tree
ARG_UNUSED (args
),
4312 int ARG_UNUSED (flags
), bool *no_add_attrs
)
4314 if (TREE_CODE (*node
) == VAR_DECL
)
4315 DECL_COMMON (*node
) = 0;
4318 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4319 *no_add_attrs
= true;
4325 /* Handle a "common" attribute; arguments as in
4326 struct attribute_spec.handler. */
4329 handle_common_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
4330 int ARG_UNUSED (flags
), bool *no_add_attrs
)
4332 if (TREE_CODE (*node
) == VAR_DECL
)
4333 DECL_COMMON (*node
) = 1;
4336 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4337 *no_add_attrs
= true;
4343 /* Handle a "noreturn" attribute; arguments as in
4344 struct attribute_spec.handler. */
4347 handle_noreturn_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 in c_common_attribute_table. */
4353 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4354 TREE_THIS_VOLATILE (*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
),
4360 TYPE_READONLY (TREE_TYPE (type
)), 1));
4363 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4364 *no_add_attrs
= true;
4370 /* Handle a "noinline" attribute; arguments as in
4371 struct attribute_spec.handler. */
4374 handle_noinline_attribute (tree
*node
, tree name
,
4375 tree
ARG_UNUSED (args
),
4376 int ARG_UNUSED (flags
), bool *no_add_attrs
)
4378 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4379 DECL_UNINLINABLE (*node
) = 1;
4382 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4383 *no_add_attrs
= true;
4389 /* Handle a "always_inline" attribute; arguments as in
4390 struct attribute_spec.handler. */
4393 handle_always_inline_attribute (tree
*node
, tree name
,
4394 tree
ARG_UNUSED (args
),
4395 int ARG_UNUSED (flags
),
4398 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4400 /* Do nothing else, just set the attribute. We'll get at
4401 it later with lookup_attribute. */
4405 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4406 *no_add_attrs
= true;
4412 /* Handle a "gnu_inline" attribute; arguments as in
4413 struct attribute_spec.handler. */
4416 handle_gnu_inline_attribute (tree
*node
, tree name
,
4417 tree
ARG_UNUSED (args
),
4418 int ARG_UNUSED (flags
),
4421 if (TREE_CODE (*node
) == FUNCTION_DECL
&& DECL_DECLARED_INLINE_P (*node
))
4423 /* Do nothing else, just set the attribute. We'll get at
4424 it later with lookup_attribute. */
4428 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4429 *no_add_attrs
= true;
4435 /* Handle a "flatten" attribute; arguments as in
4436 struct attribute_spec.handler. */
4439 handle_flatten_attribute (tree
*node
, tree name
,
4440 tree args ATTRIBUTE_UNUSED
,
4441 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
4443 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4444 /* Do nothing else, just set the attribute. We'll get at
4445 it later with lookup_attribute. */
4449 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4450 *no_add_attrs
= true;
4457 /* Handle a "used" attribute; arguments as in
4458 struct attribute_spec.handler. */
4461 handle_used_attribute (tree
*pnode
, tree name
, tree
ARG_UNUSED (args
),
4462 int ARG_UNUSED (flags
), bool *no_add_attrs
)
4466 if (TREE_CODE (node
) == FUNCTION_DECL
4467 || (TREE_CODE (node
) == VAR_DECL
&& TREE_STATIC (node
)))
4469 TREE_USED (node
) = 1;
4470 DECL_PRESERVE_P (node
) = 1;
4474 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4475 *no_add_attrs
= true;
4481 /* Handle a "unused" attribute; arguments as in
4482 struct attribute_spec.handler. */
4485 handle_unused_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
4486 int flags
, bool *no_add_attrs
)
4492 if (TREE_CODE (decl
) == PARM_DECL
4493 || TREE_CODE (decl
) == VAR_DECL
4494 || TREE_CODE (decl
) == FUNCTION_DECL
4495 || TREE_CODE (decl
) == LABEL_DECL
4496 || TREE_CODE (decl
) == TYPE_DECL
)
4497 TREE_USED (decl
) = 1;
4500 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4501 *no_add_attrs
= true;
4506 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
4507 *node
= build_variant_type_copy (*node
);
4508 TREE_USED (*node
) = 1;
4514 /* Handle a "externally_visible" attribute; arguments as in
4515 struct attribute_spec.handler. */
4518 handle_externally_visible_attribute (tree
*pnode
, tree name
,
4519 tree
ARG_UNUSED (args
),
4520 int ARG_UNUSED (flags
),
4525 if (TREE_CODE (node
) == FUNCTION_DECL
|| TREE_CODE (node
) == VAR_DECL
)
4527 if ((!TREE_STATIC (node
) && TREE_CODE (node
) != FUNCTION_DECL
4528 && !DECL_EXTERNAL (node
)) || !TREE_PUBLIC (node
))
4530 warning (OPT_Wattributes
,
4531 "%qE attribute have effect only on public objects", name
);
4532 *no_add_attrs
= true;
4537 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4538 *no_add_attrs
= true;
4544 /* Handle a "const" attribute; arguments as in
4545 struct attribute_spec.handler. */
4548 handle_const_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
4549 int ARG_UNUSED (flags
), bool *no_add_attrs
)
4551 tree type
= TREE_TYPE (*node
);
4553 /* See FIXME comment on noreturn in c_common_attribute_table. */
4554 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4555 TREE_READONLY (*node
) = 1;
4556 else if (TREE_CODE (type
) == POINTER_TYPE
4557 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
4559 = build_pointer_type
4560 (build_type_variant (TREE_TYPE (type
), 1,
4561 TREE_THIS_VOLATILE (TREE_TYPE (type
))));
4564 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4565 *no_add_attrs
= true;
4571 /* Handle a "transparent_union" attribute; arguments as in
4572 struct attribute_spec.handler. */
4575 handle_transparent_union_attribute (tree
*node
, tree name
,
4576 tree
ARG_UNUSED (args
), int flags
,
4581 *no_add_attrs
= true;
4585 if (TREE_CODE (*node
) != TYPE_DECL
)
4587 node
= &TREE_TYPE (*node
);
4590 else if (TYPE_P (*node
))
4595 if (TREE_CODE (type
) == UNION_TYPE
)
4597 /* When IN_PLACE is set, leave the check for FIELDS and MODE to
4598 the code in finish_struct. */
4599 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
4601 if (TYPE_FIELDS (type
) == NULL_TREE
4602 || TYPE_MODE (type
) != DECL_MODE (TYPE_FIELDS (type
)))
4605 /* A type variant isn't good enough, since we don't a cast
4606 to such a type removed as a no-op. */
4607 *node
= type
= build_duplicate_type (type
);
4610 TYPE_TRANSPARENT_UNION (type
) = 1;
4615 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4619 /* Handle a "constructor" attribute; arguments as in
4620 struct attribute_spec.handler. */
4623 handle_constructor_attribute (tree
*node
, tree name
,
4624 tree
ARG_UNUSED (args
),
4625 int ARG_UNUSED (flags
),
4629 tree type
= TREE_TYPE (decl
);
4631 if (TREE_CODE (decl
) == FUNCTION_DECL
4632 && TREE_CODE (type
) == FUNCTION_TYPE
4633 && decl_function_context (decl
) == 0)
4635 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
4636 TREE_USED (decl
) = 1;
4640 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4641 *no_add_attrs
= true;
4647 /* Handle a "destructor" attribute; arguments as in
4648 struct attribute_spec.handler. */
4651 handle_destructor_attribute (tree
*node
, tree name
,
4652 tree
ARG_UNUSED (args
),
4653 int ARG_UNUSED (flags
),
4657 tree type
= TREE_TYPE (decl
);
4659 if (TREE_CODE (decl
) == FUNCTION_DECL
4660 && TREE_CODE (type
) == FUNCTION_TYPE
4661 && decl_function_context (decl
) == 0)
4663 DECL_STATIC_DESTRUCTOR (decl
) = 1;
4664 TREE_USED (decl
) = 1;
4668 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4669 *no_add_attrs
= true;
4675 /* Handle a "mode" attribute; arguments as in
4676 struct attribute_spec.handler. */
4679 handle_mode_attribute (tree
*node
, tree name
, tree args
,
4680 int ARG_UNUSED (flags
), bool *no_add_attrs
)
4684 *no_add_attrs
= true;
4686 if (TREE_CODE (TREE_VALUE (args
)) != IDENTIFIER_NODE
)
4687 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4691 const char *p
= IDENTIFIER_POINTER (TREE_VALUE (args
));
4692 int len
= strlen (p
);
4693 enum machine_mode mode
= VOIDmode
;
4697 if (len
> 4 && p
[0] == '_' && p
[1] == '_'
4698 && p
[len
- 1] == '_' && p
[len
- 2] == '_')
4700 char *newp
= (char *) alloca (len
- 1);
4702 strcpy (newp
, &p
[2]);
4703 newp
[len
- 4] = '\0';
4707 /* Change this type to have a type with the specified mode.
4708 First check for the special modes. */
4709 if (!strcmp (p
, "byte"))
4711 else if (!strcmp (p
, "word"))
4713 else if (!strcmp (p
, "pointer"))
4716 for (j
= 0; j
< NUM_MACHINE_MODES
; j
++)
4717 if (!strcmp (p
, GET_MODE_NAME (j
)))
4719 mode
= (enum machine_mode
) j
;
4723 if (mode
== VOIDmode
)
4725 error ("unknown machine mode %qs", p
);
4730 switch (GET_MODE_CLASS (mode
))
4733 case MODE_PARTIAL_INT
:
4735 case MODE_DECIMAL_FLOAT
:
4736 valid_mode
= targetm
.scalar_mode_supported_p (mode
);
4739 case MODE_COMPLEX_INT
:
4740 case MODE_COMPLEX_FLOAT
:
4741 valid_mode
= targetm
.scalar_mode_supported_p (GET_MODE_INNER (mode
));
4744 case MODE_VECTOR_INT
:
4745 case MODE_VECTOR_FLOAT
:
4746 warning (OPT_Wattributes
, "specifying vector types with "
4747 "__attribute__ ((mode)) is deprecated");
4748 warning (OPT_Wattributes
,
4749 "use __attribute__ ((vector_size)) instead");
4750 valid_mode
= vector_mode_valid_p (mode
);
4758 error ("unable to emulate %qs", p
);
4762 if (POINTER_TYPE_P (type
))
4764 tree (*fn
)(tree
, enum machine_mode
, bool);
4766 if (!targetm
.valid_pointer_mode (mode
))
4768 error ("invalid pointer mode %qs", p
);
4772 if (TREE_CODE (type
) == POINTER_TYPE
)
4773 fn
= build_pointer_type_for_mode
;
4775 fn
= build_reference_type_for_mode
;
4776 typefm
= fn (TREE_TYPE (type
), mode
, false);
4779 typefm
= lang_hooks
.types
.type_for_mode (mode
, TYPE_UNSIGNED (type
));
4781 if (typefm
== NULL_TREE
)
4783 error ("no data type for mode %qs", p
);
4786 else if (TREE_CODE (type
) == ENUMERAL_TYPE
)
4788 /* For enumeral types, copy the precision from the integer
4789 type returned above. If not an INTEGER_TYPE, we can't use
4790 this mode for this type. */
4791 if (TREE_CODE (typefm
) != INTEGER_TYPE
)
4793 error ("cannot use mode %qs for enumeral types", p
);
4797 if (flags
& ATTR_FLAG_TYPE_IN_PLACE
)
4799 TYPE_PRECISION (type
) = TYPE_PRECISION (typefm
);
4804 /* We cannot build a type variant, as there's code that assumes
4805 that TYPE_MAIN_VARIANT has the same mode. This includes the
4806 debug generators. Instead, create a subrange type. This
4807 results in all of the enumeral values being emitted only once
4808 in the original, and the subtype gets them by reference. */
4809 if (TYPE_UNSIGNED (type
))
4810 typefm
= make_unsigned_type (TYPE_PRECISION (typefm
));
4812 typefm
= make_signed_type (TYPE_PRECISION (typefm
));
4813 TREE_TYPE (typefm
) = type
;
4816 else if (VECTOR_MODE_P (mode
)
4817 ? TREE_CODE (type
) != TREE_CODE (TREE_TYPE (typefm
))
4818 : TREE_CODE (type
) != TREE_CODE (typefm
))
4820 error ("mode %qs applied to inappropriate type", p
);
4830 /* Handle a "section" attribute; arguments as in
4831 struct attribute_spec.handler. */
4834 handle_section_attribute (tree
*node
, tree
ARG_UNUSED (name
), tree args
,
4835 int ARG_UNUSED (flags
), bool *no_add_attrs
)
4839 if (targetm
.have_named_sections
)
4841 user_defined_section_attribute
= true;
4843 if ((TREE_CODE (decl
) == FUNCTION_DECL
4844 || TREE_CODE (decl
) == VAR_DECL
)
4845 && TREE_CODE (TREE_VALUE (args
)) == STRING_CST
)
4847 if (TREE_CODE (decl
) == VAR_DECL
4848 && current_function_decl
!= NULL_TREE
4849 && !TREE_STATIC (decl
))
4851 error ("%Jsection attribute cannot be specified for "
4852 "local variables", decl
);
4853 *no_add_attrs
= true;
4856 /* The decl may have already been given a section attribute
4857 from a previous declaration. Ensure they match. */
4858 else if (DECL_SECTION_NAME (decl
) != NULL_TREE
4859 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl
)),
4860 TREE_STRING_POINTER (TREE_VALUE (args
))) != 0)
4862 error ("section of %q+D conflicts with previous declaration",
4864 *no_add_attrs
= true;
4867 DECL_SECTION_NAME (decl
) = TREE_VALUE (args
);
4871 error ("section attribute not allowed for %q+D", *node
);
4872 *no_add_attrs
= true;
4877 error ("%Jsection attributes are not supported for this target", *node
);
4878 *no_add_attrs
= true;
4884 /* Handle a "aligned" attribute; arguments as in
4885 struct attribute_spec.handler. */
4888 handle_aligned_attribute (tree
*node
, tree
ARG_UNUSED (name
), tree args
,
4889 int flags
, bool *no_add_attrs
)
4891 tree decl
= NULL_TREE
;
4894 tree align_expr
= (args
? TREE_VALUE (args
)
4895 : size_int (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
));
4901 type
= &TREE_TYPE (decl
);
4902 is_type
= TREE_CODE (*node
) == TYPE_DECL
;
4904 else if (TYPE_P (*node
))
4905 type
= node
, is_type
= 1;
4907 if (TREE_CODE (align_expr
) != INTEGER_CST
)
4909 error ("requested alignment is not a constant");
4910 *no_add_attrs
= true;
4912 else if ((i
= tree_log2 (align_expr
)) == -1)
4914 error ("requested alignment is not a power of 2");
4915 *no_add_attrs
= true;
4917 else if (i
> HOST_BITS_PER_INT
- 2)
4919 error ("requested alignment is too large");
4920 *no_add_attrs
= true;
4924 /* If we have a TYPE_DECL, then copy the type, so that we
4925 don't accidentally modify a builtin type. See pushdecl. */
4926 if (decl
&& TREE_TYPE (decl
) != error_mark_node
4927 && DECL_ORIGINAL_TYPE (decl
) == NULL_TREE
)
4929 tree tt
= TREE_TYPE (decl
);
4930 *type
= build_variant_type_copy (*type
);
4931 DECL_ORIGINAL_TYPE (decl
) = tt
;
4932 TYPE_NAME (*type
) = decl
;
4933 TREE_USED (*type
) = TREE_USED (decl
);
4934 TREE_TYPE (decl
) = *type
;
4936 else if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
4937 *type
= build_variant_type_copy (*type
);
4939 TYPE_ALIGN (*type
) = (1 << i
) * BITS_PER_UNIT
;
4940 TYPE_USER_ALIGN (*type
) = 1;
4942 else if (TREE_CODE (decl
) != VAR_DECL
4943 && TREE_CODE (decl
) != FIELD_DECL
)
4945 error ("alignment may not be specified for %q+D", decl
);
4946 *no_add_attrs
= true;
4950 DECL_ALIGN (decl
) = (1 << i
) * BITS_PER_UNIT
;
4951 DECL_USER_ALIGN (decl
) = 1;
4957 /* Handle a "weak" attribute; arguments as in
4958 struct attribute_spec.handler. */
4961 handle_weak_attribute (tree
*node
, tree name
,
4962 tree
ARG_UNUSED (args
),
4963 int ARG_UNUSED (flags
),
4964 bool * ARG_UNUSED (no_add_attrs
))
4966 if (TREE_CODE (*node
) == FUNCTION_DECL
4967 || TREE_CODE (*node
) == VAR_DECL
)
4968 declare_weak (*node
);
4970 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4976 /* Handle an "alias" attribute; arguments as in
4977 struct attribute_spec.handler. */
4980 handle_alias_attribute (tree
*node
, tree name
, tree args
,
4981 int ARG_UNUSED (flags
), bool *no_add_attrs
)
4985 if ((TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_INITIAL (decl
))
4986 || (TREE_CODE (decl
) != FUNCTION_DECL
4987 && TREE_PUBLIC (decl
) && !DECL_EXTERNAL (decl
))
4988 /* A static variable declaration is always a tentative definition,
4989 but the alias is a non-tentative definition which overrides. */
4990 || (TREE_CODE (decl
) != FUNCTION_DECL
4991 && ! TREE_PUBLIC (decl
) && DECL_INITIAL (decl
)))
4993 error ("%q+D defined both normally and as an alias", decl
);
4994 *no_add_attrs
= true;
4997 /* Note that the very first time we process a nested declaration,
4998 decl_function_context will not be set. Indeed, *would* never
4999 be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
5000 we do below. After such frobbery, pushdecl would set the context.
5001 In any case, this is never what we want. */
5002 else if (decl_function_context (decl
) == 0 && current_function_decl
== NULL
)
5006 id
= TREE_VALUE (args
);
5007 if (TREE_CODE (id
) != STRING_CST
)
5009 error ("alias argument not a string");
5010 *no_add_attrs
= true;
5013 id
= get_identifier (TREE_STRING_POINTER (id
));
5014 /* This counts as a use of the object pointed to. */
5017 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5018 DECL_INITIAL (decl
) = error_mark_node
;
5021 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
)))
5022 DECL_EXTERNAL (decl
) = 1;
5024 DECL_EXTERNAL (decl
) = 0;
5025 TREE_STATIC (decl
) = 1;
5030 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5031 *no_add_attrs
= true;
5037 /* Handle a "weakref" attribute; arguments as in struct
5038 attribute_spec.handler. */
5041 handle_weakref_attribute (tree
*node
, tree
ARG_UNUSED (name
), tree args
,
5042 int flags
, bool *no_add_attrs
)
5044 tree attr
= NULL_TREE
;
5046 /* We must ignore the attribute when it is associated with
5047 local-scoped decls, since attribute alias is ignored and many
5048 such symbols do not even have a DECL_WEAK field. */
5049 if (decl_function_context (*node
) || current_function_decl
)
5051 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5052 *no_add_attrs
= true;
5056 /* The idea here is that `weakref("name")' mutates into `weakref,
5057 alias("name")', and weakref without arguments, in turn,
5058 implicitly adds weak. */
5062 attr
= tree_cons (get_identifier ("alias"), args
, attr
);
5063 attr
= tree_cons (get_identifier ("weakref"), NULL_TREE
, attr
);
5065 *no_add_attrs
= true;
5067 decl_attributes (node
, attr
, flags
);
5071 if (lookup_attribute ("alias", DECL_ATTRIBUTES (*node
)))
5072 error ("%Jweakref attribute must appear before alias attribute",
5075 /* Can't call declare_weak because it wants this to be TREE_PUBLIC,
5076 and that isn't supported; and because it wants to add it to
5077 the list of weak decls, which isn't helpful. */
5078 DECL_WEAK (*node
) = 1;
5084 /* Handle an "visibility" attribute; arguments as in
5085 struct attribute_spec.handler. */
5088 handle_visibility_attribute (tree
*node
, tree name
, tree args
,
5089 int ARG_UNUSED (flags
),
5090 bool *ARG_UNUSED (no_add_attrs
))
5093 tree id
= TREE_VALUE (args
);
5094 enum symbol_visibility vis
;
5098 if (TREE_CODE (*node
) == ENUMERAL_TYPE
)
5100 else if (TREE_CODE (*node
) != RECORD_TYPE
&& TREE_CODE (*node
) != UNION_TYPE
)
5102 warning (OPT_Wattributes
, "%qE attribute ignored on non-class types",
5106 else if (TYPE_FIELDS (*node
))
5108 error ("%qE attribute ignored because %qT is already defined",
5113 else if (decl_function_context (decl
) != 0 || !TREE_PUBLIC (decl
))
5115 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5119 if (TREE_CODE (id
) != STRING_CST
)
5121 error ("visibility argument not a string");
5125 /* If this is a type, set the visibility on the type decl. */
5128 decl
= TYPE_NAME (decl
);
5131 if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
5133 warning (OPT_Wattributes
, "%qE attribute ignored on types",
5139 if (strcmp (TREE_STRING_POINTER (id
), "default") == 0)
5140 vis
= VISIBILITY_DEFAULT
;
5141 else if (strcmp (TREE_STRING_POINTER (id
), "internal") == 0)
5142 vis
= VISIBILITY_INTERNAL
;
5143 else if (strcmp (TREE_STRING_POINTER (id
), "hidden") == 0)
5144 vis
= VISIBILITY_HIDDEN
;
5145 else if (strcmp (TREE_STRING_POINTER (id
), "protected") == 0)
5146 vis
= VISIBILITY_PROTECTED
;
5149 error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
5150 vis
= VISIBILITY_DEFAULT
;
5153 if (DECL_VISIBILITY_SPECIFIED (decl
)
5154 && vis
!= DECL_VISIBILITY (decl
)
5155 && lookup_attribute ("visibility", (TYPE_P (*node
)
5156 ? TYPE_ATTRIBUTES (*node
)
5157 : DECL_ATTRIBUTES (decl
))))
5158 error ("%qD redeclared with different visibility", decl
);
5160 DECL_VISIBILITY (decl
) = vis
;
5161 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
5163 /* Go ahead and attach the attribute to the node as well. This is needed
5164 so we can determine whether we have VISIBILITY_DEFAULT because the
5165 visibility was not specified, or because it was explicitly overridden
5166 from the containing scope. */
5171 /* Determine the ELF symbol visibility for DECL, which is either a
5172 variable or a function. It is an error to use this function if a
5173 definition of DECL is not available in this translation unit.
5174 Returns true if the final visibility has been determined by this
5175 function; false if the caller is free to make additional
5179 c_determine_visibility (tree decl
)
5181 gcc_assert (TREE_CODE (decl
) == VAR_DECL
5182 || TREE_CODE (decl
) == FUNCTION_DECL
);
5184 /* If the user explicitly specified the visibility with an
5185 attribute, honor that. DECL_VISIBILITY will have been set during
5186 the processing of the attribute. We check for an explicit
5187 attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
5188 to distinguish the use of an attribute from the use of a "#pragma
5189 GCC visibility push(...)"; in the latter case we still want other
5190 considerations to be able to overrule the #pragma. */
5191 if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl
)))
5194 /* Anything that is exported must have default visibility. */
5195 if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
5196 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl
)))
5198 DECL_VISIBILITY (decl
) = VISIBILITY_DEFAULT
;
5199 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
5203 /* Set default visibility to whatever the user supplied with
5204 visibility_specified depending on #pragma GCC visibility. */
5205 if (!DECL_VISIBILITY_SPECIFIED (decl
))
5207 DECL_VISIBILITY (decl
) = default_visibility
;
5208 DECL_VISIBILITY_SPECIFIED (decl
) = visibility_options
.inpragma
;
5213 /* Handle an "tls_model" attribute; arguments as in
5214 struct attribute_spec.handler. */
5217 handle_tls_model_attribute (tree
*node
, tree name
, tree args
,
5218 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5222 enum tls_model kind
;
5224 *no_add_attrs
= true;
5226 if (!DECL_THREAD_LOCAL_P (decl
))
5228 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5232 kind
= DECL_TLS_MODEL (decl
);
5233 id
= TREE_VALUE (args
);
5234 if (TREE_CODE (id
) != STRING_CST
)
5236 error ("tls_model argument not a string");
5240 if (!strcmp (TREE_STRING_POINTER (id
), "local-exec"))
5241 kind
= TLS_MODEL_LOCAL_EXEC
;
5242 else if (!strcmp (TREE_STRING_POINTER (id
), "initial-exec"))
5243 kind
= TLS_MODEL_INITIAL_EXEC
;
5244 else if (!strcmp (TREE_STRING_POINTER (id
), "local-dynamic"))
5245 kind
= optimize
? TLS_MODEL_LOCAL_DYNAMIC
: TLS_MODEL_GLOBAL_DYNAMIC
;
5246 else if (!strcmp (TREE_STRING_POINTER (id
), "global-dynamic"))
5247 kind
= TLS_MODEL_GLOBAL_DYNAMIC
;
5249 error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
5251 DECL_TLS_MODEL (decl
) = kind
;
5255 /* Handle a "no_instrument_function" attribute; arguments as in
5256 struct attribute_spec.handler. */
5259 handle_no_instrument_function_attribute (tree
*node
, tree name
,
5260 tree
ARG_UNUSED (args
),
5261 int ARG_UNUSED (flags
),
5266 if (TREE_CODE (decl
) != FUNCTION_DECL
)
5268 error ("%J%qE attribute applies only to functions", decl
, name
);
5269 *no_add_attrs
= true;
5271 else if (DECL_INITIAL (decl
))
5273 error ("%Jcan%'t set %qE attribute after definition", decl
, name
);
5274 *no_add_attrs
= true;
5277 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl
) = 1;
5282 /* Handle a "malloc" attribute; arguments as in
5283 struct attribute_spec.handler. */
5286 handle_malloc_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5287 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5289 if (TREE_CODE (*node
) == FUNCTION_DECL
5290 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node
))))
5291 DECL_IS_MALLOC (*node
) = 1;
5294 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5295 *no_add_attrs
= true;
5301 /* Handle a "returns_twice" attribute; arguments as in
5302 struct attribute_spec.handler. */
5305 handle_returns_twice_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5306 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5308 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5309 DECL_IS_RETURNS_TWICE (*node
) = 1;
5312 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5313 *no_add_attrs
= true;
5319 /* Handle a "no_limit_stack" attribute; arguments as in
5320 struct attribute_spec.handler. */
5323 handle_no_limit_stack_attribute (tree
*node
, tree name
,
5324 tree
ARG_UNUSED (args
),
5325 int ARG_UNUSED (flags
),
5330 if (TREE_CODE (decl
) != FUNCTION_DECL
)
5332 error ("%J%qE attribute applies only to functions", decl
, name
);
5333 *no_add_attrs
= true;
5335 else if (DECL_INITIAL (decl
))
5337 error ("%Jcan%'t set %qE attribute after definition", decl
, name
);
5338 *no_add_attrs
= true;
5341 DECL_NO_LIMIT_STACK (decl
) = 1;
5346 /* Handle a "pure" attribute; arguments as in
5347 struct attribute_spec.handler. */
5350 handle_pure_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5351 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5353 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5354 DECL_IS_PURE (*node
) = 1;
5355 /* ??? TODO: Support types. */
5358 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5359 *no_add_attrs
= true;
5365 /* Handle a "no vops" attribute; arguments as in
5366 struct attribute_spec.handler. */
5369 handle_novops_attribute (tree
*node
, tree
ARG_UNUSED (name
),
5370 tree
ARG_UNUSED (args
), int ARG_UNUSED (flags
),
5371 bool *ARG_UNUSED (no_add_attrs
))
5373 gcc_assert (TREE_CODE (*node
) == FUNCTION_DECL
);
5374 DECL_IS_NOVOPS (*node
) = 1;
5378 /* Handle a "deprecated" attribute; arguments as in
5379 struct attribute_spec.handler. */
5382 handle_deprecated_attribute (tree
*node
, tree name
,
5383 tree
ARG_UNUSED (args
), int flags
,
5386 tree type
= NULL_TREE
;
5388 tree what
= NULL_TREE
;
5393 type
= TREE_TYPE (decl
);
5395 if (TREE_CODE (decl
) == TYPE_DECL
5396 || TREE_CODE (decl
) == PARM_DECL
5397 || TREE_CODE (decl
) == VAR_DECL
5398 || TREE_CODE (decl
) == FUNCTION_DECL
5399 || TREE_CODE (decl
) == FIELD_DECL
)
5400 TREE_DEPRECATED (decl
) = 1;
5404 else if (TYPE_P (*node
))
5406 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
5407 *node
= build_variant_type_copy (*node
);
5408 TREE_DEPRECATED (*node
) = 1;
5416 *no_add_attrs
= true;
5417 if (type
&& TYPE_NAME (type
))
5419 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
5420 what
= TYPE_NAME (*node
);
5421 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
5422 && DECL_NAME (TYPE_NAME (type
)))
5423 what
= DECL_NAME (TYPE_NAME (type
));
5426 warning (OPT_Wattributes
, "%qE attribute ignored for %qE", name
, what
);
5428 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5434 /* Handle a "vector_size" attribute; arguments as in
5435 struct attribute_spec.handler. */
5438 handle_vector_size_attribute (tree
*node
, tree name
, tree args
,
5439 int ARG_UNUSED (flags
),
5442 unsigned HOST_WIDE_INT vecsize
, nunits
;
5443 enum machine_mode orig_mode
;
5444 tree type
= *node
, new_type
, size
;
5446 *no_add_attrs
= true;
5448 size
= TREE_VALUE (args
);
5450 if (!host_integerp (size
, 1))
5452 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5456 /* Get the vector size (in bytes). */
5457 vecsize
= tree_low_cst (size
, 1);
5459 /* We need to provide for vector pointers, vector arrays, and
5460 functions returning vectors. For example:
5462 __attribute__((vector_size(16))) short *foo;
5464 In this case, the mode is SI, but the type being modified is
5465 HI, so we need to look further. */
5467 while (POINTER_TYPE_P (type
)
5468 || TREE_CODE (type
) == FUNCTION_TYPE
5469 || TREE_CODE (type
) == METHOD_TYPE
5470 || TREE_CODE (type
) == ARRAY_TYPE
)
5471 type
= TREE_TYPE (type
);
5473 /* Get the mode of the type being modified. */
5474 orig_mode
= TYPE_MODE (type
);
5476 if (TREE_CODE (type
) == RECORD_TYPE
5477 || TREE_CODE (type
) == UNION_TYPE
5478 || TREE_CODE (type
) == VECTOR_TYPE
5479 || (!SCALAR_FLOAT_MODE_P (orig_mode
)
5480 && GET_MODE_CLASS (orig_mode
) != MODE_INT
)
5481 || !host_integerp (TYPE_SIZE_UNIT (type
), 1))
5483 error ("invalid vector type for attribute %qE", name
);
5487 if (vecsize
% tree_low_cst (TYPE_SIZE_UNIT (type
), 1))
5489 error ("vector size not an integral multiple of component size");
5495 error ("zero vector size");
5499 /* Calculate how many units fit in the vector. */
5500 nunits
= vecsize
/ tree_low_cst (TYPE_SIZE_UNIT (type
), 1);
5501 if (nunits
& (nunits
- 1))
5503 error ("number of components of the vector not a power of two");
5507 new_type
= build_vector_type (type
, nunits
);
5509 /* Build back pointers if needed. */
5510 *node
= reconstruct_complex_type (*node
, new_type
);
5515 /* Handle the "nonnull" attribute. */
5517 handle_nonnull_attribute (tree
*node
, tree
ARG_UNUSED (name
),
5518 tree args
, int ARG_UNUSED (flags
),
5522 unsigned HOST_WIDE_INT attr_arg_num
;
5524 /* If no arguments are specified, all pointer arguments should be
5525 non-null. Verify a full prototype is given so that the arguments
5526 will have the correct types when we actually check them later. */
5529 if (!TYPE_ARG_TYPES (type
))
5531 error ("nonnull attribute without arguments on a non-prototype");
5532 *no_add_attrs
= true;
5537 /* Argument list specified. Verify that each argument number references
5538 a pointer argument. */
5539 for (attr_arg_num
= 1; args
; args
= TREE_CHAIN (args
))
5542 unsigned HOST_WIDE_INT arg_num
= 0, ck_num
;
5544 if (!get_nonnull_operand (TREE_VALUE (args
), &arg_num
))
5546 error ("nonnull argument has invalid operand number (argument %lu)",
5547 (unsigned long) attr_arg_num
);
5548 *no_add_attrs
= true;
5552 argument
= TYPE_ARG_TYPES (type
);
5555 for (ck_num
= 1; ; ck_num
++)
5557 if (!argument
|| ck_num
== arg_num
)
5559 argument
= TREE_CHAIN (argument
);
5563 || TREE_CODE (TREE_VALUE (argument
)) == VOID_TYPE
)
5565 error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
5566 (unsigned long) attr_arg_num
, (unsigned long) arg_num
);
5567 *no_add_attrs
= true;
5571 if (TREE_CODE (TREE_VALUE (argument
)) != POINTER_TYPE
)
5573 error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
5574 (unsigned long) attr_arg_num
, (unsigned long) arg_num
);
5575 *no_add_attrs
= true;
5584 /* Check the argument list of a function call for null in argument slots
5585 that are marked as requiring a non-null pointer argument. */
5588 check_function_nonnull (tree attrs
, tree params
)
5590 tree a
, args
, param
;
5593 for (a
= attrs
; a
; a
= TREE_CHAIN (a
))
5595 if (is_attribute_p ("nonnull", TREE_PURPOSE (a
)))
5597 args
= TREE_VALUE (a
);
5599 /* Walk the argument list. If we encounter an argument number we
5600 should check for non-null, do it. If the attribute has no args,
5601 then every pointer argument is checked (in which case the check
5602 for pointer type is done in check_nonnull_arg). */
5603 for (param
= params
, param_num
= 1; ;
5604 param_num
++, param
= TREE_CHAIN (param
))
5608 if (!args
|| nonnull_check_p (args
, param_num
))
5609 check_function_arguments_recurse (check_nonnull_arg
, NULL
,
5617 /* Check that the Nth argument of a function call (counting backwards
5618 from the end) is a (pointer)0. */
5621 check_function_sentinel (tree attrs
, tree params
, tree typelist
)
5623 tree attr
= lookup_attribute ("sentinel", attrs
);
5627 /* Skip over the named arguments. */
5628 while (typelist
&& params
)
5630 typelist
= TREE_CHAIN (typelist
);
5631 params
= TREE_CHAIN (params
);
5634 if (typelist
|| !params
)
5635 warning (OPT_Wformat
,
5636 "not enough variable arguments to fit a sentinel");
5642 if (TREE_VALUE (attr
))
5644 tree p
= TREE_VALUE (TREE_VALUE (attr
));
5645 pos
= TREE_INT_CST_LOW (p
);
5648 sentinel
= end
= params
;
5650 /* Advance `end' ahead of `sentinel' by `pos' positions. */
5651 while (pos
> 0 && TREE_CHAIN (end
))
5654 end
= TREE_CHAIN (end
);
5658 warning (OPT_Wformat
,
5659 "not enough variable arguments to fit a sentinel");
5663 /* Now advance both until we find the last parameter. */
5664 while (TREE_CHAIN (end
))
5666 end
= TREE_CHAIN (end
);
5667 sentinel
= TREE_CHAIN (sentinel
);
5670 /* Validate the sentinel. */
5671 if ((!POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (sentinel
)))
5672 || !integer_zerop (TREE_VALUE (sentinel
)))
5673 /* Although __null (in C++) is only an integer we allow it
5674 nevertheless, as we are guaranteed that it's exactly
5675 as wide as a pointer, and we don't want to force
5676 users to cast the NULL they have written there.
5677 We warn with -Wstrict-null-sentinel, though. */
5678 && (warn_strict_null_sentinel
5679 || null_node
!= TREE_VALUE (sentinel
)))
5680 warning (OPT_Wformat
, "missing sentinel in function call");
5685 /* Helper for check_function_nonnull; given a list of operands which
5686 must be non-null in ARGS, determine if operand PARAM_NUM should be
5690 nonnull_check_p (tree args
, unsigned HOST_WIDE_INT param_num
)
5692 unsigned HOST_WIDE_INT arg_num
= 0;
5694 for (; args
; args
= TREE_CHAIN (args
))
5696 bool found
= get_nonnull_operand (TREE_VALUE (args
), &arg_num
);
5700 if (arg_num
== param_num
)
5706 /* Check that the function argument PARAM (which is operand number
5707 PARAM_NUM) is non-null. This is called by check_function_nonnull
5708 via check_function_arguments_recurse. */
5711 check_nonnull_arg (void * ARG_UNUSED (ctx
), tree param
,
5712 unsigned HOST_WIDE_INT param_num
)
5714 /* Just skip checking the argument if it's not a pointer. This can
5715 happen if the "nonnull" attribute was given without an operand
5716 list (which means to check every pointer argument). */
5718 if (TREE_CODE (TREE_TYPE (param
)) != POINTER_TYPE
)
5721 if (integer_zerop (param
))
5722 warning (OPT_Wnonnull
, "null argument where non-null required "
5723 "(argument %lu)", (unsigned long) param_num
);
5726 /* Helper for nonnull attribute handling; fetch the operand number
5727 from the attribute argument list. */
5730 get_nonnull_operand (tree arg_num_expr
, unsigned HOST_WIDE_INT
*valp
)
5732 /* Verify the arg number is a constant. */
5733 if (TREE_CODE (arg_num_expr
) != INTEGER_CST
5734 || TREE_INT_CST_HIGH (arg_num_expr
) != 0)
5737 *valp
= TREE_INT_CST_LOW (arg_num_expr
);
5741 /* Handle a "nothrow" attribute; arguments as in
5742 struct attribute_spec.handler. */
5745 handle_nothrow_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5746 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5748 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5749 TREE_NOTHROW (*node
) = 1;
5750 /* ??? TODO: Support types. */
5753 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5754 *no_add_attrs
= true;
5760 /* Handle a "cleanup" attribute; arguments as in
5761 struct attribute_spec.handler. */
5764 handle_cleanup_attribute (tree
*node
, tree name
, tree args
,
5765 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5768 tree cleanup_id
, cleanup_decl
;
5770 /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
5771 for global destructors in C++. This requires infrastructure that
5772 we don't have generically at the moment. It's also not a feature
5773 we'd be missing too much, since we do have attribute constructor. */
5774 if (TREE_CODE (decl
) != VAR_DECL
|| TREE_STATIC (decl
))
5776 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5777 *no_add_attrs
= true;
5781 /* Verify that the argument is a function in scope. */
5782 /* ??? We could support pointers to functions here as well, if
5783 that was considered desirable. */
5784 cleanup_id
= TREE_VALUE (args
);
5785 if (TREE_CODE (cleanup_id
) != IDENTIFIER_NODE
)
5787 error ("cleanup argument not an identifier");
5788 *no_add_attrs
= true;
5791 cleanup_decl
= lookup_name (cleanup_id
);
5792 if (!cleanup_decl
|| TREE_CODE (cleanup_decl
) != FUNCTION_DECL
)
5794 error ("cleanup argument not a function");
5795 *no_add_attrs
= true;
5799 /* That the function has proper type is checked with the
5800 eventual call to build_function_call. */
5805 /* Handle a "warn_unused_result" attribute. No special handling. */
5808 handle_warn_unused_result_attribute (tree
*node
, tree name
,
5809 tree
ARG_UNUSED (args
),
5810 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5812 /* Ignore the attribute for functions not returning any value. */
5813 if (VOID_TYPE_P (TREE_TYPE (*node
)))
5815 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5816 *no_add_attrs
= true;
5822 /* Handle a "sentinel" attribute. */
5825 handle_sentinel_attribute (tree
*node
, tree name
, tree args
,
5826 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5828 tree params
= TYPE_ARG_TYPES (*node
);
5832 warning (OPT_Wattributes
,
5833 "%qE attribute requires prototypes with named arguments", name
);
5834 *no_add_attrs
= true;
5838 while (TREE_CHAIN (params
))
5839 params
= TREE_CHAIN (params
);
5841 if (VOID_TYPE_P (TREE_VALUE (params
)))
5843 warning (OPT_Wattributes
,
5844 "%qE attribute only applies to variadic functions", name
);
5845 *no_add_attrs
= true;
5851 tree position
= TREE_VALUE (args
);
5853 if (TREE_CODE (position
) != INTEGER_CST
)
5855 warning (0, "requested position is not an integer constant");
5856 *no_add_attrs
= true;
5860 if (tree_int_cst_lt (position
, integer_zero_node
))
5862 warning (0, "requested position is less than zero");
5863 *no_add_attrs
= true;
5871 /* Check for valid arguments being passed to a function. */
5873 check_function_arguments (tree attrs
, tree params
, tree typelist
)
5875 /* Check for null being passed in a pointer argument that must be
5876 non-null. We also need to do this if format checking is enabled. */
5879 check_function_nonnull (attrs
, params
);
5881 /* Check for errors in format strings. */
5883 if (warn_format
|| warn_missing_format_attribute
)
5884 check_function_format (attrs
, params
);
5887 check_function_sentinel (attrs
, params
, typelist
);
5890 /* Generic argument checking recursion routine. PARAM is the argument to
5891 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
5892 once the argument is resolved. CTX is context for the callback. */
5894 check_function_arguments_recurse (void (*callback
)
5895 (void *, tree
, unsigned HOST_WIDE_INT
),
5896 void *ctx
, tree param
,
5897 unsigned HOST_WIDE_INT param_num
)
5899 if ((TREE_CODE (param
) == NOP_EXPR
|| TREE_CODE (param
) == CONVERT_EXPR
)
5900 && (TYPE_PRECISION (TREE_TYPE (param
))
5901 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (param
, 0)))))
5903 /* Strip coercion. */
5904 check_function_arguments_recurse (callback
, ctx
,
5905 TREE_OPERAND (param
, 0), param_num
);
5909 if (TREE_CODE (param
) == CALL_EXPR
)
5911 tree type
= TREE_TYPE (TREE_TYPE (TREE_OPERAND (param
, 0)));
5913 bool found_format_arg
= false;
5915 /* See if this is a call to a known internationalization function
5916 that modifies a format arg. Such a function may have multiple
5917 format_arg attributes (for example, ngettext). */
5919 for (attrs
= TYPE_ATTRIBUTES (type
);
5921 attrs
= TREE_CHAIN (attrs
))
5922 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs
)))
5925 tree format_num_expr
;
5929 /* Extract the argument number, which was previously checked
5931 format_num_expr
= TREE_VALUE (TREE_VALUE (attrs
));
5933 gcc_assert (TREE_CODE (format_num_expr
) == INTEGER_CST
5934 && !TREE_INT_CST_HIGH (format_num_expr
));
5936 format_num
= TREE_INT_CST_LOW (format_num_expr
);
5938 for (inner_args
= TREE_OPERAND (param
, 1), i
= 1;
5940 inner_args
= TREE_CHAIN (inner_args
), i
++)
5941 if (i
== format_num
)
5943 check_function_arguments_recurse (callback
, ctx
,
5944 TREE_VALUE (inner_args
),
5946 found_format_arg
= true;
5951 /* If we found a format_arg attribute and did a recursive check,
5952 we are done with checking this argument. Otherwise, we continue
5953 and this will be considered a non-literal. */
5954 if (found_format_arg
)
5958 if (TREE_CODE (param
) == COND_EXPR
)
5960 /* Check both halves of the conditional expression. */
5961 check_function_arguments_recurse (callback
, ctx
,
5962 TREE_OPERAND (param
, 1), param_num
);
5963 check_function_arguments_recurse (callback
, ctx
,
5964 TREE_OPERAND (param
, 2), param_num
);
5968 (*callback
) (ctx
, param
, param_num
);
5971 /* Function to help qsort sort FIELD_DECLs by name order. */
5974 field_decl_cmp (const void *x_p
, const void *y_p
)
5976 const tree
*const x
= (const tree
*const) x_p
;
5977 const tree
*const y
= (const tree
*const) y_p
;
5979 if (DECL_NAME (*x
) == DECL_NAME (*y
))
5980 /* A nontype is "greater" than a type. */
5981 return (TREE_CODE (*y
) == TYPE_DECL
) - (TREE_CODE (*x
) == TYPE_DECL
);
5982 if (DECL_NAME (*x
) == NULL_TREE
)
5984 if (DECL_NAME (*y
) == NULL_TREE
)
5986 if (DECL_NAME (*x
) < DECL_NAME (*y
))
5992 gt_pointer_operator new_value
;
5996 /* This routine compares two fields like field_decl_cmp but using the
5997 pointer operator in resort_data. */
6000 resort_field_decl_cmp (const void *x_p
, const void *y_p
)
6002 const tree
*const x
= (const tree
*const) x_p
;
6003 const tree
*const y
= (const tree
*const) y_p
;
6005 if (DECL_NAME (*x
) == DECL_NAME (*y
))
6006 /* A nontype is "greater" than a type. */
6007 return (TREE_CODE (*y
) == TYPE_DECL
) - (TREE_CODE (*x
) == TYPE_DECL
);
6008 if (DECL_NAME (*x
) == NULL_TREE
)
6010 if (DECL_NAME (*y
) == NULL_TREE
)
6013 tree d1
= DECL_NAME (*x
);
6014 tree d2
= DECL_NAME (*y
);
6015 resort_data
.new_value (&d1
, resort_data
.cookie
);
6016 resort_data
.new_value (&d2
, resort_data
.cookie
);
6023 /* Resort DECL_SORTED_FIELDS because pointers have been reordered. */
6026 resort_sorted_fields (void *obj
,
6027 void * ARG_UNUSED (orig_obj
),
6028 gt_pointer_operator new_value
,
6031 struct sorted_fields_type
*sf
= (struct sorted_fields_type
*) obj
;
6032 resort_data
.new_value
= new_value
;
6033 resort_data
.cookie
= cookie
;
6034 qsort (&sf
->elts
[0], sf
->len
, sizeof (tree
),
6035 resort_field_decl_cmp
);
6038 /* Subroutine of c_parse_error.
6039 Return the result of concatenating LHS and RHS. RHS is really
6040 a string literal, its first character is indicated by RHS_START and
6041 RHS_SIZE is its length (including the terminating NUL character).
6043 The caller is responsible for deleting the returned pointer. */
6046 catenate_strings (const char *lhs
, const char *rhs_start
, int rhs_size
)
6048 const int lhs_size
= strlen (lhs
);
6049 char *result
= XNEWVEC (char, lhs_size
+ rhs_size
);
6050 strncpy (result
, lhs
, lhs_size
);
6051 strncpy (result
+ lhs_size
, rhs_start
, rhs_size
);
6055 /* Issue the error given by GMSGID, indicating that it occurred before
6056 TOKEN, which had the associated VALUE. */
6059 c_parse_error (const char *gmsgid
, enum cpp_ttype token
, tree value
)
6061 #define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
6063 char *message
= NULL
;
6065 if (token
== CPP_EOF
)
6066 message
= catenate_messages (gmsgid
, " at end of input");
6067 else if (token
== CPP_CHAR
|| token
== CPP_WCHAR
)
6069 unsigned int val
= TREE_INT_CST_LOW (value
);
6070 const char *const ell
= (token
== CPP_CHAR
) ? "" : "L";
6071 if (val
<= UCHAR_MAX
&& ISGRAPH (val
))
6072 message
= catenate_messages (gmsgid
, " before %s'%c'");
6074 message
= catenate_messages (gmsgid
, " before %s'\\x%x'");
6076 error (message
, ell
, val
);
6080 else if (token
== CPP_STRING
|| token
== CPP_WSTRING
)
6081 message
= catenate_messages (gmsgid
, " before string constant");
6082 else if (token
== CPP_NUMBER
)
6083 message
= catenate_messages (gmsgid
, " before numeric constant");
6084 else if (token
== CPP_NAME
)
6086 message
= catenate_messages (gmsgid
, " before %qE");
6087 error (message
, value
);
6091 else if (token
== CPP_PRAGMA
)
6092 message
= catenate_messages (gmsgid
, " before %<#pragma%>");
6093 else if (token
== CPP_PRAGMA_EOL
)
6094 message
= catenate_messages (gmsgid
, " before end of line");
6095 else if (token
< N_TTYPES
)
6097 message
= catenate_messages (gmsgid
, " before %qs token");
6098 error (message
, cpp_type2name (token
));
6110 #undef catenate_messages
6113 /* Walk a gimplified function and warn for functions whose return value is
6114 ignored and attribute((warn_unused_result)) is set. This is done before
6115 inlining, so we don't have to worry about that. */
6118 c_warn_unused_result (tree
*top_p
)
6121 tree_stmt_iterator i
;
6124 switch (TREE_CODE (t
))
6126 case STATEMENT_LIST
:
6127 for (i
= tsi_start (*top_p
); !tsi_end_p (i
); tsi_next (&i
))
6128 c_warn_unused_result (tsi_stmt_ptr (i
));
6132 c_warn_unused_result (&COND_EXPR_THEN (t
));
6133 c_warn_unused_result (&COND_EXPR_ELSE (t
));
6136 c_warn_unused_result (&BIND_EXPR_BODY (t
));
6138 case TRY_FINALLY_EXPR
:
6139 case TRY_CATCH_EXPR
:
6140 c_warn_unused_result (&TREE_OPERAND (t
, 0));
6141 c_warn_unused_result (&TREE_OPERAND (t
, 1));
6144 c_warn_unused_result (&CATCH_BODY (t
));
6146 case EH_FILTER_EXPR
:
6147 c_warn_unused_result (&EH_FILTER_FAILURE (t
));
6154 /* This is a naked call, as opposed to a CALL_EXPR nested inside
6155 a MODIFY_EXPR. All calls whose value is ignored should be
6156 represented like this. Look for the attribute. */
6157 fdecl
= get_callee_fndecl (t
);
6159 ftype
= TREE_TYPE (fdecl
);
6162 ftype
= TREE_TYPE (TREE_OPERAND (t
, 0));
6163 /* Look past pointer-to-function to the function type itself. */
6164 ftype
= TREE_TYPE (ftype
);
6167 if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype
)))
6170 warning (0, "%Hignoring return value of %qD, "
6171 "declared with attribute warn_unused_result",
6172 EXPR_LOCUS (t
), fdecl
);
6174 warning (0, "%Hignoring return value of function "
6175 "declared with attribute warn_unused_result",
6181 /* Not a container, not a call, or a call whose value is used. */
6186 /* Convert a character from the host to the target execution character
6187 set. cpplib handles this, mostly. */
6190 c_common_to_target_charset (HOST_WIDE_INT c
)
6192 /* Character constants in GCC proper are sign-extended under -fsigned-char,
6193 zero-extended under -fno-signed-char. cpplib insists that characters
6194 and character constants are always unsigned. Hence we must convert
6196 cppchar_t uc
= ((cppchar_t
)c
) & ((((cppchar_t
)1) << CHAR_BIT
)-1);
6198 uc
= cpp_host_to_exec_charset (parse_in
, uc
);
6200 if (flag_signed_char
)
6201 return ((HOST_WIDE_INT
)uc
) << (HOST_BITS_PER_WIDE_INT
- CHAR_TYPE_SIZE
)
6202 >> (HOST_BITS_PER_WIDE_INT
- CHAR_TYPE_SIZE
);
6207 /* Build the result of __builtin_offsetof. EXPR is a nested sequence of
6208 component references, with STOP_REF, or alternatively an INDIRECT_REF of
6209 NULL, at the bottom; much like the traditional rendering of offsetof as a
6210 macro. Returns the folded and properly cast result. */
6213 fold_offsetof_1 (tree expr
, tree stop_ref
)
6215 enum tree_code code
= PLUS_EXPR
;
6218 if (expr
== stop_ref
&& TREE_CODE (expr
) != ERROR_MARK
)
6219 return size_zero_node
;
6221 switch (TREE_CODE (expr
))
6227 error ("cannot apply %<offsetof%> to static data member %qD", expr
);
6228 return error_mark_node
;
6231 error ("cannot apply %<offsetof%> when %<operator[]%> is overloaded");
6232 return error_mark_node
;
6235 gcc_assert (integer_zerop (expr
));
6236 return size_zero_node
;
6240 base
= fold_offsetof_1 (TREE_OPERAND (expr
, 0), stop_ref
);
6241 gcc_assert (base
== error_mark_node
|| base
== size_zero_node
);
6245 base
= fold_offsetof_1 (TREE_OPERAND (expr
, 0), stop_ref
);
6246 if (base
== error_mark_node
)
6249 t
= TREE_OPERAND (expr
, 1);
6250 if (DECL_C_BIT_FIELD (t
))
6252 error ("attempt to take address of bit-field structure "
6254 return error_mark_node
;
6256 off
= size_binop (PLUS_EXPR
, DECL_FIELD_OFFSET (t
),
6257 size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t
), 1)
6262 base
= fold_offsetof_1 (TREE_OPERAND (expr
, 0), stop_ref
);
6263 if (base
== error_mark_node
)
6266 t
= TREE_OPERAND (expr
, 1);
6267 if (TREE_CODE (t
) == INTEGER_CST
&& tree_int_cst_sgn (t
) < 0)
6270 t
= fold_build1 (NEGATE_EXPR
, TREE_TYPE (t
), t
);
6272 t
= convert (sizetype
, t
);
6273 off
= size_binop (MULT_EXPR
, TYPE_SIZE_UNIT (TREE_TYPE (expr
)), t
);
6280 return size_binop (code
, base
, off
);
6284 fold_offsetof (tree expr
, tree stop_ref
)
6286 /* Convert back from the internal sizetype to size_t. */
6287 return convert (size_type_node
, fold_offsetof_1 (expr
, stop_ref
));
6290 /* Print an error message for an invalid lvalue. USE says
6291 how the lvalue is being used and so selects the error message. */
6294 lvalue_error (enum lvalue_use use
)
6299 error ("lvalue required as left operand of assignment");
6302 error ("lvalue required as increment operand");
6305 error ("lvalue required as decrement operand");
6308 error ("lvalue required as unary %<&%> operand");
6311 error ("lvalue required in asm statement");
6318 /* *PTYPE is an incomplete array. Complete it with a domain based on
6319 INITIAL_VALUE. If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
6320 is true. Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
6321 2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty. */
6324 complete_array_type (tree
*ptype
, tree initial_value
, bool do_default
)
6326 tree maxindex
, type
, main_type
, elt
, unqual_elt
;
6327 int failure
= 0, quals
;
6328 hashval_t hashcode
= 0;
6330 maxindex
= size_zero_node
;
6333 if (TREE_CODE (initial_value
) == STRING_CST
)
6336 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value
)));
6337 maxindex
= size_int (TREE_STRING_LENGTH (initial_value
)/eltsize
- 1);
6339 else if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
6341 VEC(constructor_elt
,gc
) *v
= CONSTRUCTOR_ELTS (initial_value
);
6343 if (VEC_empty (constructor_elt
, v
))
6347 maxindex
= integer_minus_one_node
;
6352 unsigned HOST_WIDE_INT cnt
;
6353 constructor_elt
*ce
;
6355 if (VEC_index (constructor_elt
, v
, 0)->index
)
6356 maxindex
= fold_convert (sizetype
,
6357 VEC_index (constructor_elt
,
6359 curindex
= maxindex
;
6362 VEC_iterate (constructor_elt
, v
, cnt
, ce
);
6366 curindex
= fold_convert (sizetype
, ce
->index
);
6368 curindex
= size_binop (PLUS_EXPR
, curindex
, size_one_node
);
6370 if (tree_int_cst_lt (maxindex
, curindex
))
6371 maxindex
= curindex
;
6377 /* Make an error message unless that happened already. */
6378 if (initial_value
!= error_mark_node
)
6390 elt
= TREE_TYPE (type
);
6391 quals
= TYPE_QUALS (strip_array_types (elt
));
6395 unqual_elt
= c_build_qualified_type (elt
, TYPE_UNQUALIFIED
);
6397 /* Using build_distinct_type_copy and modifying things afterward instead
6398 of using build_array_type to create a new type preserves all of the
6399 TYPE_LANG_FLAG_? bits that the front end may have set. */
6400 main_type
= build_distinct_type_copy (TYPE_MAIN_VARIANT (type
));
6401 TREE_TYPE (main_type
) = unqual_elt
;
6402 TYPE_DOMAIN (main_type
) = build_index_type (maxindex
);
6403 layout_type (main_type
);
6405 /* Make sure we have the canonical MAIN_TYPE. */
6406 hashcode
= iterative_hash_object (TYPE_HASH (unqual_elt
), hashcode
);
6407 hashcode
= iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (main_type
)),
6409 main_type
= type_hash_canon (hashcode
, main_type
);
6414 type
= c_build_qualified_type (main_type
, quals
);
6421 /* Used to help initialize the builtin-types.def table. When a type of
6422 the correct size doesn't exist, use error_mark_node instead of NULL.
6423 The later results in segfaults even when a decl using the type doesn't
6427 builtin_type_for_size (int size
, bool unsignedp
)
6429 tree type
= lang_hooks
.types
.type_for_size (size
, unsignedp
);
6430 return type
? type
: error_mark_node
;
6433 /* A helper function for resolve_overloaded_builtin in resolving the
6434 overloaded __sync_ builtins. Returns a positive power of 2 if the
6435 first operand of PARAMS is a pointer to a supported data type.
6436 Returns 0 if an error is encountered. */
6439 sync_resolve_size (tree function
, tree params
)
6446 error ("too few arguments to function %qE", function
);
6450 type
= TREE_TYPE (TREE_VALUE (params
));
6451 if (TREE_CODE (type
) != POINTER_TYPE
)
6454 type
= TREE_TYPE (type
);
6455 if (!INTEGRAL_TYPE_P (type
) && !POINTER_TYPE_P (type
))
6458 size
= tree_low_cst (TYPE_SIZE_UNIT (type
), 1);
6459 if (size
== 1 || size
== 2 || size
== 4 || size
== 8 || size
== 16)
6463 error ("incompatible type for argument %d of %qE", 1, function
);
6467 /* A helper function for resolve_overloaded_builtin. Adds casts to
6468 PARAMS to make arguments match up with those of FUNCTION. Drops
6469 the variadic arguments at the end. Returns false if some error
6470 was encountered; true on success. */
6473 sync_resolve_params (tree orig_function
, tree function
, tree params
)
6475 tree arg_types
= TYPE_ARG_TYPES (TREE_TYPE (function
));
6479 /* We've declared the implementation functions to use "volatile void *"
6480 as the pointer parameter, so we shouldn't get any complaints from the
6481 call to check_function_arguments what ever type the user used. */
6482 arg_types
= TREE_CHAIN (arg_types
);
6483 ptype
= TREE_TYPE (TREE_TYPE (TREE_VALUE (params
)));
6486 /* For the rest of the values, we need to cast these to FTYPE, so that we
6487 don't get warnings for passing pointer types, etc. */
6488 while (arg_types
!= void_list_node
)
6492 params
= TREE_CHAIN (params
);
6495 error ("too few arguments to function %qE", orig_function
);
6499 /* ??? Ideally for the first conversion we'd use convert_for_assignment
6500 so that we get warnings for anything that doesn't match the pointer
6501 type. This isn't portable across the C and C++ front ends atm. */
6502 val
= TREE_VALUE (params
);
6503 val
= convert (ptype
, val
);
6504 val
= convert (TREE_VALUE (arg_types
), val
);
6505 TREE_VALUE (params
) = val
;
6507 arg_types
= TREE_CHAIN (arg_types
);
6511 /* The definition of these primitives is variadic, with the remaining
6512 being "an optional list of variables protected by the memory barrier".
6513 No clue what that's supposed to mean, precisely, but we consider all
6514 call-clobbered variables to be protected so we're safe. */
6515 TREE_CHAIN (params
) = NULL
;
6520 /* A helper function for resolve_overloaded_builtin. Adds a cast to
6521 RESULT to make it match the type of the first pointer argument in
6525 sync_resolve_return (tree params
, tree result
)
6527 tree ptype
= TREE_TYPE (TREE_TYPE (TREE_VALUE (params
)));
6528 ptype
= TYPE_MAIN_VARIANT (ptype
);
6529 return convert (ptype
, result
);
6532 /* Some builtin functions are placeholders for other expressions. This
6533 function should be called immediately after parsing the call expression
6534 before surrounding code has committed to the type of the expression.
6536 FUNCTION is the DECL that has been invoked; it is known to be a builtin.
6537 PARAMS is the argument list for the call. The return value is non-null
6538 when expansion is complete, and null if normal processing should
6542 resolve_overloaded_builtin (tree function
, tree params
)
6544 enum built_in_function orig_code
= DECL_FUNCTION_CODE (function
);
6545 switch (DECL_BUILT_IN_CLASS (function
))
6547 case BUILT_IN_NORMAL
:
6550 if (targetm
.resolve_overloaded_builtin
)
6551 return targetm
.resolve_overloaded_builtin (function
, params
);
6558 /* Handle BUILT_IN_NORMAL here. */
6561 case BUILT_IN_FETCH_AND_ADD_N
:
6562 case BUILT_IN_FETCH_AND_SUB_N
:
6563 case BUILT_IN_FETCH_AND_OR_N
:
6564 case BUILT_IN_FETCH_AND_AND_N
:
6565 case BUILT_IN_FETCH_AND_XOR_N
:
6566 case BUILT_IN_FETCH_AND_NAND_N
:
6567 case BUILT_IN_ADD_AND_FETCH_N
:
6568 case BUILT_IN_SUB_AND_FETCH_N
:
6569 case BUILT_IN_OR_AND_FETCH_N
:
6570 case BUILT_IN_AND_AND_FETCH_N
:
6571 case BUILT_IN_XOR_AND_FETCH_N
:
6572 case BUILT_IN_NAND_AND_FETCH_N
:
6573 case BUILT_IN_BOOL_COMPARE_AND_SWAP_N
:
6574 case BUILT_IN_VAL_COMPARE_AND_SWAP_N
:
6575 case BUILT_IN_LOCK_TEST_AND_SET_N
:
6576 case BUILT_IN_LOCK_RELEASE_N
:
6578 int n
= sync_resolve_size (function
, params
);
6579 tree new_function
, result
;
6582 return error_mark_node
;
6584 new_function
= built_in_decls
[orig_code
+ exact_log2 (n
) + 1];
6585 if (!sync_resolve_params (function
, new_function
, params
))
6586 return error_mark_node
;
6588 result
= build_function_call (new_function
, params
);
6589 if (orig_code
!= BUILT_IN_BOOL_COMPARE_AND_SWAP_N
6590 && orig_code
!= BUILT_IN_LOCK_RELEASE_N
)
6591 result
= sync_resolve_return (params
, result
);
6601 /* Ignoring their sign, return true if two scalar types are the same. */
6603 same_scalar_type_ignoring_signedness (tree t1
, tree t2
)
6605 enum tree_code c1
= TREE_CODE (t1
), c2
= TREE_CODE (t2
);
6607 gcc_assert ((c1
== INTEGER_TYPE
|| c1
== REAL_TYPE
)
6608 && (c2
== INTEGER_TYPE
|| c2
== REAL_TYPE
));
6610 /* Equality works here because c_common_signed_type uses
6611 TYPE_MAIN_VARIANT. */
6612 return lang_hooks
.types
.signed_type (t1
)
6613 == lang_hooks
.types
.signed_type (t2
);
6616 /* Check for missing format attributes on function pointers. LTYPE is
6617 the new type or left-hand side type. RTYPE is the old type or
6618 right-hand side type. Returns TRUE if LTYPE is missing the desired
6622 check_missing_format_attribute (tree ltype
, tree rtype
)
6624 tree
const ttr
= TREE_TYPE (rtype
), ttl
= TREE_TYPE (ltype
);
6627 for (ra
= TYPE_ATTRIBUTES (ttr
); ra
; ra
= TREE_CHAIN (ra
))
6628 if (is_attribute_p ("format", TREE_PURPOSE (ra
)))
6633 for (la
= TYPE_ATTRIBUTES (ttl
); la
; la
= TREE_CHAIN (la
))
6634 if (is_attribute_p ("format", TREE_PURPOSE (la
)))
6642 /* Subscripting with type char is likely to lose on a machine where
6643 chars are signed. So warn on any machine, but optionally. Don't
6644 warn for unsigned char since that type is safe. Don't warn for
6645 signed char because anyone who uses that must have done so
6646 deliberately. Furthermore, we reduce the false positive load by
6647 warning only for non-constant value of type char. */
6650 warn_array_subscript_with_type_char (tree index
)
6652 if (TYPE_MAIN_VARIANT (TREE_TYPE (index
)) == char_type_node
6653 && TREE_CODE (index
) != INTEGER_CST
)
6654 warning (OPT_Wchar_subscripts
, "array subscript has type %<char%>");
6657 /* Implement -Wparentheses for the unexpected C precedence rules, to
6658 cover cases like x + y << z which readers are likely to
6659 misinterpret. We have seen an expression in which CODE is a binary
6660 operator used to combine expressions headed by CODE_LEFT and
6661 CODE_RIGHT. CODE_LEFT and CODE_RIGHT may be ERROR_MARK, which
6662 means that that side of the expression was not formed using a
6663 binary operator, or it was enclosed in parentheses. */
6666 warn_about_parentheses (enum tree_code code
, enum tree_code code_left
,
6667 enum tree_code code_right
)
6669 if (!warn_parentheses
)
6672 if (code
== LSHIFT_EXPR
|| code
== RSHIFT_EXPR
)
6674 if (code_left
== PLUS_EXPR
|| code_left
== MINUS_EXPR
6675 || code_right
== PLUS_EXPR
|| code_right
== MINUS_EXPR
)
6676 warning (OPT_Wparentheses
,
6677 "suggest parentheses around + or - inside shift");
6680 if (code
== TRUTH_ORIF_EXPR
)
6682 if (code_left
== TRUTH_ANDIF_EXPR
6683 || code_right
== TRUTH_ANDIF_EXPR
)
6684 warning (OPT_Wparentheses
,
6685 "suggest parentheses around && within ||");
6688 if (code
== BIT_IOR_EXPR
)
6690 if (code_left
== BIT_AND_EXPR
|| code_left
== BIT_XOR_EXPR
6691 || code_left
== PLUS_EXPR
|| code_left
== MINUS_EXPR
6692 || code_right
== BIT_AND_EXPR
|| code_right
== BIT_XOR_EXPR
6693 || code_right
== PLUS_EXPR
|| code_right
== MINUS_EXPR
)
6694 warning (OPT_Wparentheses
,
6695 "suggest parentheses around arithmetic in operand of |");
6696 /* Check cases like x|y==z */
6697 if (TREE_CODE_CLASS (code_left
) == tcc_comparison
6698 || TREE_CODE_CLASS (code_right
) == tcc_comparison
)
6699 warning (OPT_Wparentheses
,
6700 "suggest parentheses around comparison in operand of |");
6703 if (code
== BIT_XOR_EXPR
)
6705 if (code_left
== BIT_AND_EXPR
6706 || code_left
== PLUS_EXPR
|| code_left
== MINUS_EXPR
6707 || code_right
== BIT_AND_EXPR
6708 || code_right
== PLUS_EXPR
|| code_right
== MINUS_EXPR
)
6709 warning (OPT_Wparentheses
,
6710 "suggest parentheses around arithmetic in operand of ^");
6711 /* Check cases like x^y==z */
6712 if (TREE_CODE_CLASS (code_left
) == tcc_comparison
6713 || TREE_CODE_CLASS (code_right
) == tcc_comparison
)
6714 warning (OPT_Wparentheses
,
6715 "suggest parentheses around comparison in operand of ^");
6718 if (code
== BIT_AND_EXPR
)
6720 if (code_left
== PLUS_EXPR
|| code_left
== MINUS_EXPR
6721 || code_right
== PLUS_EXPR
|| code_right
== MINUS_EXPR
)
6722 warning (OPT_Wparentheses
,
6723 "suggest parentheses around + or - in operand of &");
6724 /* Check cases like x&y==z */
6725 if (TREE_CODE_CLASS (code_left
) == tcc_comparison
6726 || TREE_CODE_CLASS (code_right
) == tcc_comparison
)
6727 warning (OPT_Wparentheses
,
6728 "suggest parentheses around comparison in operand of &");
6731 /* Similarly, check for cases like 1<=i<=10 that are probably errors. */
6732 if (TREE_CODE_CLASS (code
) == tcc_comparison
6733 && (TREE_CODE_CLASS (code_left
) == tcc_comparison
6734 || TREE_CODE_CLASS (code_right
) == tcc_comparison
))
6735 warning (OPT_Wparentheses
, "comparisons like X<=Y<=Z do not "
6736 "have their mathematical meaning");
6740 #include "gt-c-common.h"