1 /* Subroutines shared by all languages that are variants of C.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
24 #include "coretypes.h"
36 #include "diagnostic.h"
41 #include "langhooks.h"
42 #include "tree-inline.h"
45 #include "tree-iterator.h"
47 #include "tree-mudflap.h"
52 cpp_reader
*parse_in
; /* Declared in c-pragma.h. */
54 /* We let tm.h override the types used here, to handle trivial differences
55 such as the choice of unsigned int or long unsigned int for size_t.
56 When machines start needing nontrivial differences in the size type,
57 it would be best to do something here to figure out automatically
58 from other information what type to use. */
61 #define SIZE_TYPE "long unsigned int"
65 #define PID_TYPE "int"
69 #define WCHAR_TYPE "int"
72 /* WCHAR_TYPE gets overridden by -fshort-wchar. */
73 #define MODIFIED_WCHAR_TYPE \
74 (flag_short_wchar ? "short unsigned int" : WCHAR_TYPE)
77 #define PTRDIFF_TYPE "long int"
81 #define WINT_TYPE "unsigned int"
85 #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
87 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
93 #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
95 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
96 ? "long unsigned int" \
97 : "long long unsigned int"))
100 /* The following symbols are subsumed in the c_global_trees array, and
101 listed here individually for documentation purposes.
103 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
105 tree short_integer_type_node;
106 tree long_integer_type_node;
107 tree long_long_integer_type_node;
109 tree short_unsigned_type_node;
110 tree long_unsigned_type_node;
111 tree long_long_unsigned_type_node;
113 tree truthvalue_type_node;
114 tree truthvalue_false_node;
115 tree truthvalue_true_node;
117 tree ptrdiff_type_node;
119 tree unsigned_char_type_node;
120 tree signed_char_type_node;
121 tree wchar_type_node;
122 tree signed_wchar_type_node;
123 tree unsigned_wchar_type_node;
125 tree float_type_node;
126 tree double_type_node;
127 tree long_double_type_node;
129 tree complex_integer_type_node;
130 tree complex_float_type_node;
131 tree complex_double_type_node;
132 tree complex_long_double_type_node;
134 tree dfloat32_type_node;
135 tree dfloat64_type_node;
136 tree_dfloat128_type_node;
138 tree intQI_type_node;
139 tree intHI_type_node;
140 tree intSI_type_node;
141 tree intDI_type_node;
142 tree intTI_type_node;
144 tree unsigned_intQI_type_node;
145 tree unsigned_intHI_type_node;
146 tree unsigned_intSI_type_node;
147 tree unsigned_intDI_type_node;
148 tree unsigned_intTI_type_node;
150 tree widest_integer_literal_type_node;
151 tree widest_unsigned_literal_type_node;
153 Nodes for types `void *' and `const void *'.
155 tree ptr_type_node, const_ptr_type_node;
157 Nodes for types `char *' and `const char *'.
159 tree string_type_node, const_string_type_node;
161 Type `char[SOMENUMBER]'.
162 Used when an array of char is needed and the size is irrelevant.
164 tree char_array_type_node;
166 Type `int[SOMENUMBER]' or something like it.
167 Used when an array of int needed and the size is irrelevant.
169 tree int_array_type_node;
171 Type `wchar_t[SOMENUMBER]' or something like it.
172 Used when a wide string literal is created.
174 tree wchar_array_type_node;
176 Type `int ()' -- used for implicit declaration of functions.
178 tree default_function_type;
180 A VOID_TYPE node, packaged in a TREE_LIST.
184 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
185 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
186 VAR_DECLS, but C++ does.)
188 tree function_name_decl_node;
189 tree pretty_function_name_decl_node;
190 tree c99_function_name_decl_node;
192 Stack of nested function name VAR_DECLs.
194 tree saved_function_name_decls;
198 tree c_global_trees
[CTI_MAX
];
200 /* Switches common to the C front ends. */
202 /* Nonzero if prepreprocessing only. */
204 int flag_preprocess_only
;
206 /* Nonzero means don't output line number information. */
208 char flag_no_line_commands
;
210 /* Nonzero causes -E output not to be done, but directives such as
211 #define that have side effects are still obeyed. */
215 /* Nonzero means dump macros in some fashion. */
217 char flag_dump_macros
;
219 /* Nonzero means pass #include lines through to the output. */
221 char flag_dump_includes
;
223 /* Nonzero means process PCH files while preprocessing. */
225 bool flag_pch_preprocess
;
227 /* The file name to which we should write a precompiled header, or
228 NULL if no header will be written in this compile. */
230 const char *pch_file
;
232 /* Nonzero if an ISO standard was selected. It rejects macros in the
236 /* Nonzero if -undef was given. It suppresses target built-in macros
240 /* Nonzero means don't recognize the non-ANSI builtin functions. */
244 /* Nonzero means don't recognize the non-ANSI builtin functions.
247 int flag_no_nonansi_builtin
;
249 /* Nonzero means give `double' the same size as `float'. */
251 int flag_short_double
;
253 /* Nonzero means give `wchar_t' the same size as `short'. */
255 int flag_short_wchar
;
257 /* Nonzero means allow Microsoft extensions without warnings or errors. */
258 int flag_ms_extensions
;
260 /* Nonzero means don't recognize the keyword `asm'. */
264 /* Nonzero means to treat bitfields as signed unless they say `unsigned'. */
266 int flag_signed_bitfields
= 1;
268 /* 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 int constant_fits_type_p (tree
, tree
);
503 static tree
check_case_value (tree
);
504 static bool check_case_bounds (tree
, tree
, tree
*, tree
*);
506 static tree
handle_packed_attribute (tree
*, tree
, tree
, int, bool *);
507 static tree
handle_nocommon_attribute (tree
*, tree
, tree
, int, bool *);
508 static tree
handle_common_attribute (tree
*, tree
, tree
, int, bool *);
509 static tree
handle_noreturn_attribute (tree
*, tree
, tree
, int, bool *);
510 static tree
handle_noinline_attribute (tree
*, tree
, tree
, int, bool *);
511 static tree
handle_always_inline_attribute (tree
*, tree
, tree
, int,
513 static tree
handle_flatten_attribute (tree
*, tree
, tree
, int, bool *);
514 static tree
handle_used_attribute (tree
*, tree
, tree
, int, bool *);
515 static tree
handle_unused_attribute (tree
*, tree
, tree
, int, bool *);
516 static tree
handle_externally_visible_attribute (tree
*, tree
, tree
, int,
518 static tree
handle_const_attribute (tree
*, tree
, tree
, int, bool *);
519 static tree
handle_transparent_union_attribute (tree
*, tree
, tree
,
521 static tree
handle_constructor_attribute (tree
*, tree
, tree
, int, bool *);
522 static tree
handle_destructor_attribute (tree
*, tree
, tree
, int, bool *);
523 static tree
handle_mode_attribute (tree
*, tree
, tree
, int, bool *);
524 static tree
handle_section_attribute (tree
*, tree
, tree
, int, bool *);
525 static tree
handle_aligned_attribute (tree
*, tree
, tree
, int, bool *);
526 static tree
handle_weak_attribute (tree
*, tree
, tree
, int, bool *) ;
527 static tree
handle_alias_attribute (tree
*, tree
, tree
, int, bool *);
528 static tree
handle_weakref_attribute (tree
*, tree
, tree
, int, bool *) ;
529 static tree
handle_visibility_attribute (tree
*, tree
, tree
, int,
531 static tree
handle_tls_model_attribute (tree
*, tree
, tree
, int,
533 static tree
handle_no_instrument_function_attribute (tree
*, tree
,
535 static tree
handle_malloc_attribute (tree
*, tree
, tree
, int, bool *);
536 static tree
handle_returns_twice_attribute (tree
*, tree
, tree
, int, bool *);
537 static tree
handle_no_limit_stack_attribute (tree
*, tree
, tree
, int,
539 static tree
handle_pure_attribute (tree
*, tree
, tree
, int, bool *);
540 static tree
handle_novops_attribute (tree
*, tree
, tree
, int, bool *);
541 static tree
handle_deprecated_attribute (tree
*, tree
, tree
, int,
543 static tree
handle_vector_size_attribute (tree
*, tree
, tree
, int,
545 static tree
handle_nonnull_attribute (tree
*, tree
, tree
, int, bool *);
546 static tree
handle_nothrow_attribute (tree
*, tree
, tree
, int, bool *);
547 static tree
handle_cleanup_attribute (tree
*, tree
, tree
, int, bool *);
548 static tree
handle_warn_unused_result_attribute (tree
*, tree
, tree
, int,
550 static tree
handle_sentinel_attribute (tree
*, tree
, tree
, int, bool *);
552 static void check_function_nonnull (tree
, tree
);
553 static void check_nonnull_arg (void *, tree
, unsigned HOST_WIDE_INT
);
554 static bool nonnull_check_p (tree
, unsigned HOST_WIDE_INT
);
555 static bool get_nonnull_operand (tree
, unsigned HOST_WIDE_INT
*);
556 static int resort_field_decl_cmp (const void *, const void *);
558 /* Table of machine-independent attributes common to all C-like languages. */
559 const struct attribute_spec c_common_attribute_table
[] =
561 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
562 { "packed", 0, 0, false, false, false,
563 handle_packed_attribute
},
564 { "nocommon", 0, 0, true, false, false,
565 handle_nocommon_attribute
},
566 { "common", 0, 0, true, false, false,
567 handle_common_attribute
},
568 /* FIXME: logically, noreturn attributes should be listed as
569 "false, true, true" and apply to function types. But implementing this
570 would require all the places in the compiler that use TREE_THIS_VOLATILE
571 on a decl to identify non-returning functions to be located and fixed
572 to check the function type instead. */
573 { "noreturn", 0, 0, true, false, false,
574 handle_noreturn_attribute
},
575 { "volatile", 0, 0, true, false, false,
576 handle_noreturn_attribute
},
577 { "noinline", 0, 0, true, false, false,
578 handle_noinline_attribute
},
579 { "always_inline", 0, 0, true, false, false,
580 handle_always_inline_attribute
},
581 { "flatten", 0, 0, true, false, false,
582 handle_flatten_attribute
},
583 { "used", 0, 0, true, false, false,
584 handle_used_attribute
},
585 { "unused", 0, 0, false, false, false,
586 handle_unused_attribute
},
587 { "externally_visible", 0, 0, true, false, false,
588 handle_externally_visible_attribute
},
589 /* The same comments as for noreturn attributes apply to const ones. */
590 { "const", 0, 0, true, false, false,
591 handle_const_attribute
},
592 { "transparent_union", 0, 0, false, false, false,
593 handle_transparent_union_attribute
},
594 { "constructor", 0, 0, true, false, false,
595 handle_constructor_attribute
},
596 { "destructor", 0, 0, true, false, false,
597 handle_destructor_attribute
},
598 { "mode", 1, 1, false, true, false,
599 handle_mode_attribute
},
600 { "section", 1, 1, true, false, false,
601 handle_section_attribute
},
602 { "aligned", 0, 1, false, false, false,
603 handle_aligned_attribute
},
604 { "weak", 0, 0, true, false, false,
605 handle_weak_attribute
},
606 { "alias", 1, 1, true, false, false,
607 handle_alias_attribute
},
608 { "weakref", 0, 1, true, false, false,
609 handle_weakref_attribute
},
610 { "no_instrument_function", 0, 0, true, false, false,
611 handle_no_instrument_function_attribute
},
612 { "malloc", 0, 0, true, false, false,
613 handle_malloc_attribute
},
614 { "returns_twice", 0, 0, true, false, false,
615 handle_returns_twice_attribute
},
616 { "no_stack_limit", 0, 0, true, false, false,
617 handle_no_limit_stack_attribute
},
618 { "pure", 0, 0, true, false, false,
619 handle_pure_attribute
},
620 /* For internal use (marking of builtins) only. The name contains space
621 to prevent its usage in source code. */
622 { "no vops", 0, 0, true, false, false,
623 handle_novops_attribute
},
624 { "deprecated", 0, 0, false, false, false,
625 handle_deprecated_attribute
},
626 { "vector_size", 1, 1, false, true, false,
627 handle_vector_size_attribute
},
628 { "visibility", 1, 1, false, false, false,
629 handle_visibility_attribute
},
630 { "tls_model", 1, 1, true, false, false,
631 handle_tls_model_attribute
},
632 { "nonnull", 0, -1, false, true, true,
633 handle_nonnull_attribute
},
634 { "nothrow", 0, 0, true, false, false,
635 handle_nothrow_attribute
},
636 { "may_alias", 0, 0, false, true, false, NULL
},
637 { "cleanup", 1, 1, true, false, false,
638 handle_cleanup_attribute
},
639 { "warn_unused_result", 0, 0, false, true, true,
640 handle_warn_unused_result_attribute
},
641 { "sentinel", 0, 1, false, true, true,
642 handle_sentinel_attribute
},
643 { NULL
, 0, 0, false, false, false, NULL
}
646 /* Give the specifications for the format attributes, used by C and all
649 const struct attribute_spec c_common_format_attribute_table
[] =
651 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
652 { "format", 3, 3, false, true, true,
653 handle_format_attribute
},
654 { "format_arg", 1, 1, false, true, true,
655 handle_format_arg_attribute
},
656 { NULL
, 0, 0, false, false, false, NULL
}
659 /* Push current bindings for the function name VAR_DECLS. */
662 start_fname_decls (void)
665 tree saved
= NULL_TREE
;
667 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
669 tree decl
= *fname_vars
[ix
].decl
;
673 saved
= tree_cons (decl
, build_int_cst (NULL_TREE
, ix
), saved
);
674 *fname_vars
[ix
].decl
= NULL_TREE
;
677 if (saved
|| saved_function_name_decls
)
678 /* Normally they'll have been NULL, so only push if we've got a
679 stack, or they are non-NULL. */
680 saved_function_name_decls
= tree_cons (saved
, NULL_TREE
,
681 saved_function_name_decls
);
684 /* Finish up the current bindings, adding them into the current function's
685 statement tree. This must be done _before_ finish_stmt_tree is called.
686 If there is no current function, we must be at file scope and no statements
687 are involved. Pop the previous bindings. */
690 finish_fname_decls (void)
693 tree stmts
= NULL_TREE
;
694 tree stack
= saved_function_name_decls
;
696 for (; stack
&& TREE_VALUE (stack
); stack
= TREE_CHAIN (stack
))
697 append_to_statement_list (TREE_VALUE (stack
), &stmts
);
701 tree
*bodyp
= &DECL_SAVED_TREE (current_function_decl
);
703 if (TREE_CODE (*bodyp
) == BIND_EXPR
)
704 bodyp
= &BIND_EXPR_BODY (*bodyp
);
706 append_to_statement_list_force (*bodyp
, &stmts
);
710 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
711 *fname_vars
[ix
].decl
= NULL_TREE
;
715 /* We had saved values, restore them. */
718 for (saved
= TREE_PURPOSE (stack
); saved
; saved
= TREE_CHAIN (saved
))
720 tree decl
= TREE_PURPOSE (saved
);
721 unsigned ix
= TREE_INT_CST_LOW (TREE_VALUE (saved
));
723 *fname_vars
[ix
].decl
= decl
;
725 stack
= TREE_CHAIN (stack
);
727 saved_function_name_decls
= stack
;
730 /* Return the text name of the current function, suitably prettified
731 by PRETTY_P. Return string must be freed by caller. */
734 fname_as_string (int pretty_p
)
736 const char *name
= "top level";
746 if (current_function_decl
)
747 name
= lang_hooks
.decl_printable_name (current_function_decl
, vrb
);
749 if (c_lex_string_translate
)
751 int len
= strlen (name
) + 3; /* Two for '"'s. One for NULL. */
752 cpp_string cstr
= { 0, 0 }, strname
;
754 namep
= XNEWVEC (char, len
);
755 snprintf (namep
, len
, "\"%s\"", name
);
756 strname
.text
= (unsigned char *) namep
;
757 strname
.len
= len
- 1;
759 if (cpp_interpret_string (parse_in
, &strname
, 1, &cstr
, false))
762 return (char *) cstr
.text
;
766 namep
= xstrdup (name
);
771 /* Expand DECL if it declares an entity not handled by the
775 c_expand_decl (tree decl
)
777 if (TREE_CODE (decl
) == VAR_DECL
&& !TREE_STATIC (decl
))
779 /* Let the back-end know about this variable. */
780 if (!anon_aggr_type_p (TREE_TYPE (decl
)))
781 emit_local_var (decl
);
783 expand_anon_union_decl (decl
, NULL_TREE
,
784 DECL_ANON_UNION_ELEMS (decl
));
793 /* Return the VAR_DECL for a const char array naming the current
794 function. If the VAR_DECL has not yet been created, create it
795 now. RID indicates how it should be formatted and IDENTIFIER_NODE
796 ID is its name (unfortunately C and C++ hold the RID values of
797 keywords in different places, so we can't derive RID from ID in
798 this language independent code. */
801 fname_decl (unsigned int rid
, tree id
)
804 tree decl
= NULL_TREE
;
806 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
807 if (fname_vars
[ix
].rid
== rid
)
810 decl
= *fname_vars
[ix
].decl
;
813 /* If a tree is built here, it would normally have the lineno of
814 the current statement. Later this tree will be moved to the
815 beginning of the function and this line number will be wrong.
816 To avoid this problem set the lineno to 0 here; that prevents
817 it from appearing in the RTL. */
819 location_t saved_location
= input_location
;
820 #ifdef USE_MAPPED_LOCATION
821 input_location
= UNKNOWN_LOCATION
;
826 stmts
= push_stmt_list ();
827 decl
= (*make_fname_decl
) (id
, fname_vars
[ix
].pretty
);
828 stmts
= pop_stmt_list (stmts
);
829 if (!IS_EMPTY_STMT (stmts
))
830 saved_function_name_decls
831 = tree_cons (decl
, stmts
, saved_function_name_decls
);
832 *fname_vars
[ix
].decl
= decl
;
833 input_location
= saved_location
;
835 if (!ix
&& !current_function_decl
)
836 pedwarn ("%qD is not defined outside of function scope", decl
);
841 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
844 fix_string_type (tree value
)
846 const int wchar_bytes
= TYPE_PRECISION (wchar_type_node
) / BITS_PER_UNIT
;
847 const int wide_flag
= TREE_TYPE (value
) == wchar_array_type_node
;
848 int length
= TREE_STRING_LENGTH (value
);
850 tree e_type
, i_type
, a_type
;
852 /* Compute the number of elements, for the array type. */
853 nchars
= wide_flag
? length
/ wchar_bytes
: length
;
855 /* C89 2.2.4.1, C99 5.2.4.1 (Translation limits). The analogous
856 limit in C++98 Annex B is very large (65536) and is not normative,
857 so we do not diagnose it (warn_overlength_strings is forced off
858 in c_common_post_options). */
859 if (warn_overlength_strings
)
861 const int nchars_max
= flag_isoc99
? 4095 : 509;
862 const int relevant_std
= flag_isoc99
? 99 : 90;
863 if (nchars
- 1 > nchars_max
)
864 /* Translators: The %d after 'ISO C' will be 90 or 99. Do not
865 separate the %d from the 'C'. 'ISO' should not be
866 translated, but it may be moved after 'C%d' in languages
867 where modifiers follow nouns. */
868 pedwarn ("string length %qd is greater than the length %qd "
869 "ISO C%d compilers are required to support",
870 nchars
- 1, nchars_max
, relevant_std
);
873 /* Create the array type for the string constant. The ISO C++
874 standard says that a string literal has type `const char[N]' or
875 `const wchar_t[N]'. We use the same logic when invoked as a C
876 front-end with -Wwrite-strings.
877 ??? We should change the type of an expression depending on the
878 state of a warning flag. We should just be warning -- see how
879 this is handled in the C++ front-end for the deprecated implicit
880 conversion from string literals to `char*' or `wchar_t*'.
882 The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified
883 array type being the unqualified version of that type.
884 Therefore, if we are constructing an array of const char, we must
885 construct the matching unqualified array type first. The C front
886 end does not require this, but it does no harm, so we do it
888 e_type
= wide_flag
? wchar_type_node
: char_type_node
;
889 i_type
= build_index_type (build_int_cst (NULL_TREE
, nchars
- 1));
890 a_type
= build_array_type (e_type
, i_type
);
891 if (c_dialect_cxx() || warn_write_strings
)
892 a_type
= c_build_qualified_type (a_type
, TYPE_QUAL_CONST
);
894 TREE_TYPE (value
) = a_type
;
895 TREE_CONSTANT (value
) = 1;
896 TREE_INVARIANT (value
) = 1;
897 TREE_READONLY (value
) = 1;
898 TREE_STATIC (value
) = 1;
902 /* Print a warning if a constant expression had overflow in folding.
903 Invoke this function on every expression that the language
904 requires to be a constant expression.
905 Note the ANSI C standard says it is erroneous for a
906 constant expression to overflow. */
909 constant_expression_warning (tree value
)
911 if ((TREE_CODE (value
) == INTEGER_CST
|| TREE_CODE (value
) == REAL_CST
912 || TREE_CODE (value
) == VECTOR_CST
913 || TREE_CODE (value
) == COMPLEX_CST
)
914 && TREE_CONSTANT_OVERFLOW (value
)
917 pedwarn ("overflow in constant expression");
920 /* Print a warning if an expression had overflow in folding.
921 Invoke this function on every expression that
922 (1) appears in the source code, and
923 (2) might be a constant expression that overflowed, and
924 (3) is not already checked by convert_and_check;
925 however, do not invoke this function on operands of explicit casts. */
928 overflow_warning (tree value
)
930 if ((TREE_CODE (value
) == INTEGER_CST
931 || (TREE_CODE (value
) == COMPLEX_CST
932 && TREE_CODE (TREE_REALPART (value
)) == INTEGER_CST
))
933 && TREE_OVERFLOW (value
))
935 TREE_OVERFLOW (value
) = 0;
936 if (skip_evaluation
== 0)
937 warning (OPT_Woverflow
, "integer overflow in expression");
939 else if ((TREE_CODE (value
) == REAL_CST
940 || (TREE_CODE (value
) == COMPLEX_CST
941 && TREE_CODE (TREE_REALPART (value
)) == REAL_CST
))
942 && TREE_OVERFLOW (value
))
944 TREE_OVERFLOW (value
) = 0;
945 if (skip_evaluation
== 0)
946 warning (OPT_Woverflow
, "floating point overflow in expression");
948 else if (TREE_CODE (value
) == VECTOR_CST
&& TREE_OVERFLOW (value
))
950 TREE_OVERFLOW (value
) = 0;
951 if (skip_evaluation
== 0)
952 warning (OPT_Woverflow
, "vector overflow in expression");
956 /* Print a warning if a large constant is truncated to unsigned,
957 or if -Wconversion is used and a constant < 0 is converted to unsigned.
958 Invoke this function on every expression that might be implicitly
959 converted to an unsigned type. */
962 unsigned_conversion_warning (tree result
, tree operand
)
964 tree type
= TREE_TYPE (result
);
966 if (TREE_CODE (operand
) == INTEGER_CST
967 && TREE_CODE (type
) == INTEGER_TYPE
968 && TYPE_UNSIGNED (type
)
969 && skip_evaluation
== 0
970 && !int_fits_type_p (operand
, type
))
972 if (!int_fits_type_p (operand
, c_common_signed_type (type
)))
973 /* This detects cases like converting -129 or 256 to unsigned char. */
974 warning (OPT_Woverflow
,
975 "large integer implicitly truncated to unsigned type");
977 warning (OPT_Wconversion
,
978 "negative integer implicitly converted to unsigned type");
982 /* Print a warning about casts that might indicate violation
983 of strict aliasing rules if -Wstrict-aliasing is used and
984 strict aliasing mode is in effect. OTYPE is the original
985 TREE_TYPE of EXPR, and TYPE the type we're casting to. */
988 strict_aliasing_warning (tree otype
, tree type
, tree expr
)
990 if (flag_strict_aliasing
&& warn_strict_aliasing
991 && POINTER_TYPE_P (type
) && POINTER_TYPE_P (otype
)
992 && TREE_CODE (expr
) == ADDR_EXPR
993 && (DECL_P (TREE_OPERAND (expr
, 0))
994 || handled_component_p (TREE_OPERAND (expr
, 0)))
995 && !VOID_TYPE_P (TREE_TYPE (type
)))
997 /* Casting the address of an object to non void pointer. Warn
998 if the cast breaks type based aliasing. */
999 if (!COMPLETE_TYPE_P (TREE_TYPE (type
)))
1000 warning (OPT_Wstrict_aliasing
, "type-punning to incomplete type "
1001 "might break strict-aliasing rules");
1004 HOST_WIDE_INT set1
= get_alias_set (TREE_TYPE (TREE_OPERAND (expr
, 0)));
1005 HOST_WIDE_INT set2
= get_alias_set (TREE_TYPE (type
));
1007 if (!alias_sets_conflict_p (set1
, set2
))
1008 warning (OPT_Wstrict_aliasing
, "dereferencing type-punned "
1009 "pointer will break strict-aliasing rules");
1010 else if (warn_strict_aliasing
> 1
1011 && !alias_sets_might_conflict_p (set1
, set2
))
1012 warning (OPT_Wstrict_aliasing
, "dereferencing type-punned "
1013 "pointer might break strict-aliasing rules");
1018 /* Print a warning about if (); or if () .. else; constructs
1019 via the special empty statement node that we create. INNER_THEN
1020 and INNER_ELSE are the statement lists of the if and the else
1024 empty_body_warning (tree inner_then
, tree inner_else
)
1028 if (TREE_CODE (inner_then
) == STATEMENT_LIST
1029 && STATEMENT_LIST_TAIL (inner_then
))
1030 inner_then
= STATEMENT_LIST_TAIL (inner_then
)->stmt
;
1032 if (inner_else
&& TREE_CODE (inner_else
) == STATEMENT_LIST
1033 && STATEMENT_LIST_TAIL (inner_else
))
1034 inner_else
= STATEMENT_LIST_TAIL (inner_else
)->stmt
;
1036 if (IS_EMPTY_STMT (inner_then
) && !inner_else
)
1037 warning (OPT_Wextra
, "%Hempty body in an if-statement",
1038 EXPR_LOCUS (inner_then
));
1040 if (inner_else
&& IS_EMPTY_STMT (inner_else
))
1041 warning (OPT_Wextra
, "%Hempty body in an else-statement",
1042 EXPR_LOCUS (inner_else
));
1046 /* Warn for unlikely, improbable, or stupid DECL declarations
1050 check_main_parameter_types (tree decl
)
1055 for (args
= TYPE_ARG_TYPES (TREE_TYPE (decl
)); args
;
1056 args
= TREE_CHAIN (args
))
1058 tree type
= args
? TREE_VALUE (args
) : 0;
1060 if (type
== void_type_node
)
1067 if (TYPE_MAIN_VARIANT (type
) != integer_type_node
)
1068 pedwarn ("first argument of %q+D should be %<int%>", decl
);
1072 if (TREE_CODE (type
) != POINTER_TYPE
1073 || TREE_CODE (TREE_TYPE (type
)) != POINTER_TYPE
1074 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type
)))
1076 pedwarn ("second argument of %q+D should be %<char **%>",
1081 if (TREE_CODE (type
) != POINTER_TYPE
1082 || TREE_CODE (TREE_TYPE (type
)) != POINTER_TYPE
1083 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type
)))
1085 pedwarn ("third argument of %q+D should probably be "
1086 "%<char **%>", decl
);
1091 /* It is intentional that this message does not mention the third
1092 argument because it's only mentioned in an appendix of the
1094 if (argct
> 0 && (argct
< 2 || argct
> 3))
1095 pedwarn ("%q+D takes only zero or two arguments", decl
);
1099 /* Nonzero if constant C has a value that is permissible
1100 for type TYPE (an INTEGER_TYPE). */
1103 constant_fits_type_p (tree c
, tree type
)
1105 if (TREE_CODE (c
) == INTEGER_CST
)
1106 return int_fits_type_p (c
, type
);
1108 c
= convert (type
, c
);
1109 return !TREE_OVERFLOW (c
);
1112 /* Nonzero if vector types T1 and T2 can be converted to each other
1113 without an explicit cast. */
1115 vector_types_convertible_p (tree t1
, tree t2
)
1117 return targetm
.vector_opaque_p (t1
)
1118 || targetm
.vector_opaque_p (t2
)
1119 || (tree_int_cst_equal (TYPE_SIZE (t1
), TYPE_SIZE (t2
))
1120 && (TREE_CODE (TREE_TYPE (t1
)) != REAL_TYPE
||
1121 TYPE_PRECISION (t1
) == TYPE_PRECISION (t2
))
1122 && INTEGRAL_TYPE_P (TREE_TYPE (t1
))
1123 == INTEGRAL_TYPE_P (TREE_TYPE (t2
)));
1126 /* Convert EXPR to TYPE, warning about conversion problems with constants.
1127 Invoke this function on every expression that is converted implicitly,
1128 i.e. because of language rules and not because of an explicit cast. */
1131 convert_and_check (tree type
, tree expr
)
1133 tree t
= convert (type
, expr
);
1134 if (TREE_CODE (t
) == INTEGER_CST
)
1136 if (TREE_OVERFLOW (t
))
1138 TREE_OVERFLOW (t
) = 0;
1140 /* Do not diagnose overflow in a constant expression merely
1141 because a conversion overflowed. */
1142 TREE_CONSTANT_OVERFLOW (t
) = CONSTANT_CLASS_P (expr
)
1143 && TREE_CONSTANT_OVERFLOW (expr
);
1145 /* No warning for converting 0x80000000 to int. */
1146 if (!(TYPE_UNSIGNED (type
) < TYPE_UNSIGNED (TREE_TYPE (expr
))
1147 && TREE_CODE (TREE_TYPE (expr
)) == INTEGER_TYPE
1148 && TYPE_PRECISION (type
) == TYPE_PRECISION (TREE_TYPE (expr
))))
1149 /* If EXPR fits in the unsigned version of TYPE,
1150 don't warn unless pedantic. */
1152 || TYPE_UNSIGNED (type
)
1153 || !constant_fits_type_p (expr
,
1154 c_common_unsigned_type (type
)))
1155 && skip_evaluation
== 0)
1156 warning (OPT_Woverflow
,
1157 "overflow in implicit constant conversion");
1160 unsigned_conversion_warning (t
, expr
);
1165 /* A node in a list that describes references to variables (EXPR), which are
1166 either read accesses if WRITER is zero, or write accesses, in which case
1167 WRITER is the parent of EXPR. */
1174 /* Used to implement a cache the results of a call to verify_tree. We only
1175 use this for SAVE_EXPRs. */
1178 struct tlist_cache
*next
;
1179 struct tlist
*cache_before_sp
;
1180 struct tlist
*cache_after_sp
;
1184 /* Obstack to use when allocating tlist structures, and corresponding
1186 static struct obstack tlist_obstack
;
1187 static char *tlist_firstobj
= 0;
1189 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
1191 static struct tlist
*warned_ids
;
1192 /* SAVE_EXPRs need special treatment. We process them only once and then
1193 cache the results. */
1194 static struct tlist_cache
*save_expr_cache
;
1196 static void add_tlist (struct tlist
**, struct tlist
*, tree
, int);
1197 static void merge_tlist (struct tlist
**, struct tlist
*, int);
1198 static void verify_tree (tree
, struct tlist
**, struct tlist
**, tree
);
1199 static int warning_candidate_p (tree
);
1200 static void warn_for_collisions (struct tlist
*);
1201 static void warn_for_collisions_1 (tree
, tree
, struct tlist
*, int);
1202 static struct tlist
*new_tlist (struct tlist
*, tree
, tree
);
1204 /* Create a new struct tlist and fill in its fields. */
1205 static struct tlist
*
1206 new_tlist (struct tlist
*next
, tree t
, tree writer
)
1209 l
= XOBNEW (&tlist_obstack
, struct tlist
);
1216 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
1217 is nonnull, we ignore any node we find which has a writer equal to it. */
1220 add_tlist (struct tlist
**to
, struct tlist
*add
, tree exclude_writer
, int copy
)
1224 struct tlist
*next
= add
->next
;
1227 if (!exclude_writer
|| add
->writer
!= exclude_writer
)
1228 *to
= copy
? new_tlist (*to
, add
->expr
, add
->writer
) : add
;
1233 /* Merge the nodes of ADD into TO. This merging process is done so that for
1234 each variable that already exists in TO, no new node is added; however if
1235 there is a write access recorded in ADD, and an occurrence on TO is only
1236 a read access, then the occurrence in TO will be modified to record the
1240 merge_tlist (struct tlist
**to
, struct tlist
*add
, int copy
)
1242 struct tlist
**end
= to
;
1245 end
= &(*end
)->next
;
1251 struct tlist
*next
= add
->next
;
1253 for (tmp2
= *to
; tmp2
; tmp2
= tmp2
->next
)
1254 if (tmp2
->expr
== add
->expr
)
1258 tmp2
->writer
= add
->writer
;
1262 *end
= copy
? add
: new_tlist (NULL
, add
->expr
, add
->writer
);
1263 end
= &(*end
)->next
;
1270 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
1271 references in list LIST conflict with it, excluding reads if ONLY writers
1275 warn_for_collisions_1 (tree written
, tree writer
, struct tlist
*list
,
1280 /* Avoid duplicate warnings. */
1281 for (tmp
= warned_ids
; tmp
; tmp
= tmp
->next
)
1282 if (tmp
->expr
== written
)
1287 if (list
->expr
== written
1288 && list
->writer
!= writer
1289 && (!only_writes
|| list
->writer
)
1290 && DECL_NAME (list
->expr
))
1292 warned_ids
= new_tlist (warned_ids
, written
, NULL_TREE
);
1293 warning (0, "operation on %qE may be undefined", list
->expr
);
1299 /* Given a list LIST of references to variables, find whether any of these
1300 can cause conflicts due to missing sequence points. */
1303 warn_for_collisions (struct tlist
*list
)
1307 for (tmp
= list
; tmp
; tmp
= tmp
->next
)
1310 warn_for_collisions_1 (tmp
->expr
, tmp
->writer
, list
, 0);
1314 /* Return nonzero if X is a tree that can be verified by the sequence point
1317 warning_candidate_p (tree x
)
1319 return TREE_CODE (x
) == VAR_DECL
|| TREE_CODE (x
) == PARM_DECL
;
1322 /* Walk the tree X, and record accesses to variables. If X is written by the
1323 parent tree, WRITER is the parent.
1324 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
1325 expression or its only operand forces a sequence point, then everything up
1326 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
1328 Once we return, we will have emitted warnings if any subexpression before
1329 such a sequence point could be undefined. On a higher level, however, the
1330 sequence point may not be relevant, and we'll merge the two lists.
1332 Example: (b++, a) + b;
1333 The call that processes the COMPOUND_EXPR will store the increment of B
1334 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
1335 processes the PLUS_EXPR will need to merge the two lists so that
1336 eventually, all accesses end up on the same list (and we'll warn about the
1337 unordered subexpressions b++ and b.
1339 A note on merging. If we modify the former example so that our expression
1342 care must be taken not simply to add all three expressions into the final
1343 PNO_SP list. The function merge_tlist takes care of that by merging the
1344 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1345 way, so that no more than one access to B is recorded. */
1348 verify_tree (tree x
, struct tlist
**pbefore_sp
, struct tlist
**pno_sp
,
1351 struct tlist
*tmp_before
, *tmp_nosp
, *tmp_list2
, *tmp_list3
;
1352 enum tree_code code
;
1353 enum tree_code_class cl
;
1355 /* X may be NULL if it is the operand of an empty statement expression
1361 code
= TREE_CODE (x
);
1362 cl
= TREE_CODE_CLASS (code
);
1364 if (warning_candidate_p (x
))
1366 *pno_sp
= new_tlist (*pno_sp
, x
, writer
);
1376 case TRUTH_ANDIF_EXPR
:
1377 case TRUTH_ORIF_EXPR
:
1378 tmp_before
= tmp_nosp
= tmp_list3
= 0;
1379 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1380 warn_for_collisions (tmp_nosp
);
1381 merge_tlist (pbefore_sp
, tmp_before
, 0);
1382 merge_tlist (pbefore_sp
, tmp_nosp
, 0);
1383 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, pno_sp
, NULL_TREE
);
1384 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1388 tmp_before
= tmp_list2
= 0;
1389 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_list2
, NULL_TREE
);
1390 warn_for_collisions (tmp_list2
);
1391 merge_tlist (pbefore_sp
, tmp_before
, 0);
1392 merge_tlist (pbefore_sp
, tmp_list2
, 1);
1394 tmp_list3
= tmp_nosp
= 0;
1395 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, &tmp_nosp
, NULL_TREE
);
1396 warn_for_collisions (tmp_nosp
);
1397 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1399 tmp_list3
= tmp_list2
= 0;
1400 verify_tree (TREE_OPERAND (x
, 2), &tmp_list3
, &tmp_list2
, NULL_TREE
);
1401 warn_for_collisions (tmp_list2
);
1402 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1403 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1404 two first, to avoid warning for (a ? b++ : b++). */
1405 merge_tlist (&tmp_nosp
, tmp_list2
, 0);
1406 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1409 case PREDECREMENT_EXPR
:
1410 case PREINCREMENT_EXPR
:
1411 case POSTDECREMENT_EXPR
:
1412 case POSTINCREMENT_EXPR
:
1413 verify_tree (TREE_OPERAND (x
, 0), pno_sp
, pno_sp
, x
);
1417 tmp_before
= tmp_nosp
= tmp_list3
= 0;
1418 verify_tree (TREE_OPERAND (x
, 1), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1419 verify_tree (TREE_OPERAND (x
, 0), &tmp_list3
, &tmp_list3
, x
);
1420 /* Expressions inside the LHS are not ordered wrt. the sequence points
1421 in the RHS. Example:
1423 Despite the fact that the modification of "a" is in the before_sp
1424 list (tmp_before), it conflicts with the use of "a" in the LHS.
1425 We can handle this by adding the contents of tmp_list3
1426 to those of tmp_before, and redoing the collision warnings for that
1428 add_tlist (&tmp_before
, tmp_list3
, x
, 1);
1429 warn_for_collisions (tmp_before
);
1430 /* Exclude the LHS itself here; we first have to merge it into the
1431 tmp_nosp list. This is done to avoid warning for "a = a"; if we
1432 didn't exclude the LHS, we'd get it twice, once as a read and once
1434 add_tlist (pno_sp
, tmp_list3
, x
, 0);
1435 warn_for_collisions_1 (TREE_OPERAND (x
, 0), x
, tmp_nosp
, 1);
1437 merge_tlist (pbefore_sp
, tmp_before
, 0);
1438 if (warning_candidate_p (TREE_OPERAND (x
, 0)))
1439 merge_tlist (&tmp_nosp
, new_tlist (NULL
, TREE_OPERAND (x
, 0), x
), 0);
1440 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 1);
1444 /* We need to warn about conflicts among arguments and conflicts between
1445 args and the function address. Side effects of the function address,
1446 however, are not ordered by the sequence point of the call. */
1447 tmp_before
= tmp_nosp
= tmp_list2
= tmp_list3
= 0;
1448 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1449 if (TREE_OPERAND (x
, 1))
1450 verify_tree (TREE_OPERAND (x
, 1), &tmp_list2
, &tmp_list3
, NULL_TREE
);
1451 merge_tlist (&tmp_list3
, tmp_list2
, 0);
1452 add_tlist (&tmp_before
, tmp_list3
, NULL_TREE
, 0);
1453 add_tlist (&tmp_before
, tmp_nosp
, NULL_TREE
, 0);
1454 warn_for_collisions (tmp_before
);
1455 add_tlist (pbefore_sp
, tmp_before
, NULL_TREE
, 0);
1459 /* Scan all the list, e.g. indices of multi dimensional array. */
1462 tmp_before
= tmp_nosp
= 0;
1463 verify_tree (TREE_VALUE (x
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1464 merge_tlist (&tmp_nosp
, tmp_before
, 0);
1465 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1472 struct tlist_cache
*t
;
1473 for (t
= save_expr_cache
; t
; t
= t
->next
)
1479 t
= XOBNEW (&tlist_obstack
, struct tlist_cache
);
1480 t
->next
= save_expr_cache
;
1482 save_expr_cache
= t
;
1484 tmp_before
= tmp_nosp
= 0;
1485 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1486 warn_for_collisions (tmp_nosp
);
1491 struct tlist
*t
= tmp_nosp
;
1493 merge_tlist (&tmp_list3
, t
, 0);
1495 t
->cache_before_sp
= tmp_before
;
1496 t
->cache_after_sp
= tmp_list3
;
1498 merge_tlist (pbefore_sp
, t
->cache_before_sp
, 1);
1499 add_tlist (pno_sp
, t
->cache_after_sp
, NULL_TREE
, 1);
1504 /* For other expressions, simply recurse on their operands.
1505 Manual tail recursion for unary expressions.
1506 Other non-expressions need not be processed. */
1507 if (cl
== tcc_unary
)
1509 x
= TREE_OPERAND (x
, 0);
1513 else if (IS_EXPR_CODE_CLASS (cl
))
1516 int max
= TREE_CODE_LENGTH (TREE_CODE (x
));
1517 for (lp
= 0; lp
< max
; lp
++)
1519 tmp_before
= tmp_nosp
= 0;
1520 verify_tree (TREE_OPERAND (x
, lp
), &tmp_before
, &tmp_nosp
, 0);
1521 merge_tlist (&tmp_nosp
, tmp_before
, 0);
1522 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1529 /* Try to warn for undefined behavior in EXPR due to missing sequence
1533 verify_sequence_points (tree expr
)
1535 struct tlist
*before_sp
= 0, *after_sp
= 0;
1538 save_expr_cache
= 0;
1539 if (tlist_firstobj
== 0)
1541 gcc_obstack_init (&tlist_obstack
);
1542 tlist_firstobj
= (char *) obstack_alloc (&tlist_obstack
, 0);
1545 verify_tree (expr
, &before_sp
, &after_sp
, 0);
1546 warn_for_collisions (after_sp
);
1547 obstack_free (&tlist_obstack
, tlist_firstobj
);
1550 /* Validate the expression after `case' and apply default promotions. */
1553 check_case_value (tree value
)
1555 if (value
== NULL_TREE
)
1558 /* ??? Can we ever get nops here for a valid case value? We
1560 STRIP_TYPE_NOPS (value
);
1561 /* In C++, the following is allowed:
1564 switch (...) { case i: ... }
1566 So, we try to reduce the VALUE to a constant that way. */
1567 if (c_dialect_cxx ())
1569 value
= decl_constant_value (value
);
1570 STRIP_TYPE_NOPS (value
);
1571 value
= fold (value
);
1574 if (TREE_CODE (value
) == INTEGER_CST
)
1575 /* Promote char or short to int. */
1576 value
= perform_integral_promotions (value
);
1577 else if (value
!= error_mark_node
)
1579 error ("case label does not reduce to an integer constant");
1580 value
= error_mark_node
;
1583 constant_expression_warning (value
);
1588 /* See if the case values LOW and HIGH are in the range of the original
1589 type (i.e. before the default conversion to int) of the switch testing
1591 TYPE is the promoted type of the testing expression, and ORIG_TYPE is
1592 the type before promoting it. CASE_LOW_P is a pointer to the lower
1593 bound of the case label, and CASE_HIGH_P is the upper bound or NULL
1594 if the case is not a case range.
1595 The caller has to make sure that we are not called with NULL for
1596 CASE_LOW_P (i.e. the default case).
1597 Returns true if the case label is in range of ORIG_TYPE (saturated or
1598 untouched) or false if the label is out of range. */
1601 check_case_bounds (tree type
, tree orig_type
,
1602 tree
*case_low_p
, tree
*case_high_p
)
1604 tree min_value
, max_value
;
1605 tree case_low
= *case_low_p
;
1606 tree case_high
= case_high_p
? *case_high_p
: case_low
;
1608 /* If there was a problem with the original type, do nothing. */
1609 if (orig_type
== error_mark_node
)
1612 min_value
= TYPE_MIN_VALUE (orig_type
);
1613 max_value
= TYPE_MAX_VALUE (orig_type
);
1615 /* Case label is less than minimum for type. */
1616 if (tree_int_cst_compare (case_low
, min_value
) < 0
1617 && tree_int_cst_compare (case_high
, min_value
) < 0)
1619 warning (0, "case label value is less than minimum value for type");
1623 /* Case value is greater than maximum for type. */
1624 if (tree_int_cst_compare (case_low
, max_value
) > 0
1625 && tree_int_cst_compare (case_high
, max_value
) > 0)
1627 warning (0, "case label value exceeds maximum value for type");
1631 /* Saturate lower case label value to minimum. */
1632 if (tree_int_cst_compare (case_high
, min_value
) >= 0
1633 && tree_int_cst_compare (case_low
, min_value
) < 0)
1635 warning (0, "lower value in case label range"
1636 " less than minimum value for type");
1637 case_low
= min_value
;
1640 /* Saturate upper case label value to maximum. */
1641 if (tree_int_cst_compare (case_low
, max_value
) <= 0
1642 && tree_int_cst_compare (case_high
, max_value
) > 0)
1644 warning (0, "upper value in case label range"
1645 " exceeds maximum value for type");
1646 case_high
= max_value
;
1649 if (*case_low_p
!= case_low
)
1650 *case_low_p
= convert (type
, case_low
);
1651 if (case_high_p
&& *case_high_p
!= case_high
)
1652 *case_high_p
= convert (type
, case_high
);
1657 /* Return an integer type with BITS bits of precision,
1658 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1661 c_common_type_for_size (unsigned int bits
, int unsignedp
)
1663 if (bits
== TYPE_PRECISION (integer_type_node
))
1664 return unsignedp
? unsigned_type_node
: integer_type_node
;
1666 if (bits
== TYPE_PRECISION (signed_char_type_node
))
1667 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1669 if (bits
== TYPE_PRECISION (short_integer_type_node
))
1670 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1672 if (bits
== TYPE_PRECISION (long_integer_type_node
))
1673 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1675 if (bits
== TYPE_PRECISION (long_long_integer_type_node
))
1676 return (unsignedp
? long_long_unsigned_type_node
1677 : long_long_integer_type_node
);
1679 if (bits
== TYPE_PRECISION (widest_integer_literal_type_node
))
1680 return (unsignedp
? widest_unsigned_literal_type_node
1681 : widest_integer_literal_type_node
);
1683 if (bits
<= TYPE_PRECISION (intQI_type_node
))
1684 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
1686 if (bits
<= TYPE_PRECISION (intHI_type_node
))
1687 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
1689 if (bits
<= TYPE_PRECISION (intSI_type_node
))
1690 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
1692 if (bits
<= TYPE_PRECISION (intDI_type_node
))
1693 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
1698 /* Used for communication between c_common_type_for_mode and
1699 c_register_builtin_type. */
1700 static GTY(()) tree registered_builtin_types
;
1702 /* Return a data type that has machine mode MODE.
1703 If the mode is an integer,
1704 then UNSIGNEDP selects between signed and unsigned types. */
1707 c_common_type_for_mode (enum machine_mode mode
, int unsignedp
)
1711 if (mode
== TYPE_MODE (integer_type_node
))
1712 return unsignedp
? unsigned_type_node
: integer_type_node
;
1714 if (mode
== TYPE_MODE (signed_char_type_node
))
1715 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1717 if (mode
== TYPE_MODE (short_integer_type_node
))
1718 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1720 if (mode
== TYPE_MODE (long_integer_type_node
))
1721 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1723 if (mode
== TYPE_MODE (long_long_integer_type_node
))
1724 return unsignedp
? long_long_unsigned_type_node
: long_long_integer_type_node
;
1726 if (mode
== TYPE_MODE (widest_integer_literal_type_node
))
1727 return unsignedp
? widest_unsigned_literal_type_node
1728 : widest_integer_literal_type_node
;
1731 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
1734 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
1737 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
1740 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
1742 #if HOST_BITS_PER_WIDE_INT >= 64
1743 if (mode
== TYPE_MODE (intTI_type_node
))
1744 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
1747 if (mode
== TYPE_MODE (float_type_node
))
1748 return float_type_node
;
1750 if (mode
== TYPE_MODE (double_type_node
))
1751 return double_type_node
;
1753 if (mode
== TYPE_MODE (long_double_type_node
))
1754 return long_double_type_node
;
1756 if (mode
== TYPE_MODE (void_type_node
))
1757 return void_type_node
;
1759 if (mode
== TYPE_MODE (build_pointer_type (char_type_node
)))
1761 ? make_unsigned_type (GET_MODE_PRECISION (mode
))
1762 : make_signed_type (GET_MODE_PRECISION (mode
)));
1764 if (mode
== TYPE_MODE (build_pointer_type (integer_type_node
)))
1766 ? make_unsigned_type (GET_MODE_PRECISION (mode
))
1767 : make_signed_type (GET_MODE_PRECISION (mode
)));
1769 if (COMPLEX_MODE_P (mode
))
1771 enum machine_mode inner_mode
;
1774 if (mode
== TYPE_MODE (complex_float_type_node
))
1775 return complex_float_type_node
;
1776 if (mode
== TYPE_MODE (complex_double_type_node
))
1777 return complex_double_type_node
;
1778 if (mode
== TYPE_MODE (complex_long_double_type_node
))
1779 return complex_long_double_type_node
;
1781 if (mode
== TYPE_MODE (complex_integer_type_node
) && !unsignedp
)
1782 return complex_integer_type_node
;
1784 inner_mode
= GET_MODE_INNER (mode
);
1785 inner_type
= c_common_type_for_mode (inner_mode
, unsignedp
);
1786 if (inner_type
!= NULL_TREE
)
1787 return build_complex_type (inner_type
);
1789 else if (VECTOR_MODE_P (mode
))
1791 enum machine_mode inner_mode
= GET_MODE_INNER (mode
);
1792 tree inner_type
= c_common_type_for_mode (inner_mode
, unsignedp
);
1793 if (inner_type
!= NULL_TREE
)
1794 return build_vector_type_for_mode (inner_type
, mode
);
1797 if (mode
== TYPE_MODE (dfloat32_type_node
))
1798 return dfloat32_type_node
;
1799 if (mode
== TYPE_MODE (dfloat64_type_node
))
1800 return dfloat64_type_node
;
1801 if (mode
== TYPE_MODE (dfloat128_type_node
))
1802 return dfloat128_type_node
;
1804 for (t
= registered_builtin_types
; t
; t
= TREE_CHAIN (t
))
1805 if (TYPE_MODE (TREE_VALUE (t
)) == mode
)
1806 return TREE_VALUE (t
);
1811 /* Return an unsigned type the same as TYPE in other respects. */
1813 c_common_unsigned_type (tree type
)
1815 tree type1
= TYPE_MAIN_VARIANT (type
);
1816 if (type1
== signed_char_type_node
|| type1
== char_type_node
)
1817 return unsigned_char_type_node
;
1818 if (type1
== integer_type_node
)
1819 return unsigned_type_node
;
1820 if (type1
== short_integer_type_node
)
1821 return short_unsigned_type_node
;
1822 if (type1
== long_integer_type_node
)
1823 return long_unsigned_type_node
;
1824 if (type1
== long_long_integer_type_node
)
1825 return long_long_unsigned_type_node
;
1826 if (type1
== widest_integer_literal_type_node
)
1827 return widest_unsigned_literal_type_node
;
1828 #if HOST_BITS_PER_WIDE_INT >= 64
1829 if (type1
== intTI_type_node
)
1830 return unsigned_intTI_type_node
;
1832 if (type1
== intDI_type_node
)
1833 return unsigned_intDI_type_node
;
1834 if (type1
== intSI_type_node
)
1835 return unsigned_intSI_type_node
;
1836 if (type1
== intHI_type_node
)
1837 return unsigned_intHI_type_node
;
1838 if (type1
== intQI_type_node
)
1839 return unsigned_intQI_type_node
;
1841 return c_common_signed_or_unsigned_type (1, type
);
1844 /* Return a signed type the same as TYPE in other respects. */
1847 c_common_signed_type (tree type
)
1849 tree type1
= TYPE_MAIN_VARIANT (type
);
1850 if (type1
== unsigned_char_type_node
|| type1
== char_type_node
)
1851 return signed_char_type_node
;
1852 if (type1
== unsigned_type_node
)
1853 return integer_type_node
;
1854 if (type1
== short_unsigned_type_node
)
1855 return short_integer_type_node
;
1856 if (type1
== long_unsigned_type_node
)
1857 return long_integer_type_node
;
1858 if (type1
== long_long_unsigned_type_node
)
1859 return long_long_integer_type_node
;
1860 if (type1
== widest_unsigned_literal_type_node
)
1861 return widest_integer_literal_type_node
;
1862 #if HOST_BITS_PER_WIDE_INT >= 64
1863 if (type1
== unsigned_intTI_type_node
)
1864 return intTI_type_node
;
1866 if (type1
== unsigned_intDI_type_node
)
1867 return intDI_type_node
;
1868 if (type1
== unsigned_intSI_type_node
)
1869 return intSI_type_node
;
1870 if (type1
== unsigned_intHI_type_node
)
1871 return intHI_type_node
;
1872 if (type1
== unsigned_intQI_type_node
)
1873 return intQI_type_node
;
1875 return c_common_signed_or_unsigned_type (0, type
);
1878 /* Return a type the same as TYPE except unsigned or
1879 signed according to UNSIGNEDP. */
1882 c_common_signed_or_unsigned_type (int unsignedp
, tree type
)
1884 if (!INTEGRAL_TYPE_P (type
)
1885 || TYPE_UNSIGNED (type
) == unsignedp
)
1888 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
1889 the precision; they have precision set to match their range, but
1890 may use a wider mode to match an ABI. If we change modes, we may
1891 wind up with bad conversions. For INTEGER_TYPEs in C, must check
1892 the precision as well, so as to yield correct results for
1893 bit-field types. C++ does not have these separate bit-field
1894 types, and producing a signed or unsigned variant of an
1895 ENUMERAL_TYPE may cause other problems as well. */
1897 #define TYPE_OK(node) \
1898 (TYPE_MODE (type) == TYPE_MODE (node) \
1899 && (c_dialect_cxx () || TYPE_PRECISION (type) == TYPE_PRECISION (node)))
1900 if (TYPE_OK (signed_char_type_node
))
1901 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1902 if (TYPE_OK (integer_type_node
))
1903 return unsignedp
? unsigned_type_node
: integer_type_node
;
1904 if (TYPE_OK (short_integer_type_node
))
1905 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1906 if (TYPE_OK (long_integer_type_node
))
1907 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1908 if (TYPE_OK (long_long_integer_type_node
))
1909 return (unsignedp
? long_long_unsigned_type_node
1910 : long_long_integer_type_node
);
1911 if (TYPE_OK (widest_integer_literal_type_node
))
1912 return (unsignedp
? widest_unsigned_literal_type_node
1913 : widest_integer_literal_type_node
);
1915 #if HOST_BITS_PER_WIDE_INT >= 64
1916 if (TYPE_OK (intTI_type_node
))
1917 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
1919 if (TYPE_OK (intDI_type_node
))
1920 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
1921 if (TYPE_OK (intSI_type_node
))
1922 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
1923 if (TYPE_OK (intHI_type_node
))
1924 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
1925 if (TYPE_OK (intQI_type_node
))
1926 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
1929 if (c_dialect_cxx ())
1932 return build_nonstandard_integer_type (TYPE_PRECISION (type
), unsignedp
);
1935 /* Build a bit-field integer type for the given WIDTH and UNSIGNEDP. */
1938 c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width
, int unsignedp
)
1940 /* Extended integer types of the same width as a standard type have
1941 lesser rank, so those of the same width as int promote to int or
1942 unsigned int and are valid for printf formats expecting int or
1943 unsigned int. To avoid such special cases, avoid creating
1944 extended integer types for bit-fields if a standard integer type
1946 if (width
== TYPE_PRECISION (integer_type_node
))
1947 return unsignedp
? unsigned_type_node
: integer_type_node
;
1948 if (width
== TYPE_PRECISION (signed_char_type_node
))
1949 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1950 if (width
== TYPE_PRECISION (short_integer_type_node
))
1951 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1952 if (width
== TYPE_PRECISION (long_integer_type_node
))
1953 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1954 if (width
== TYPE_PRECISION (long_long_integer_type_node
))
1955 return (unsignedp
? long_long_unsigned_type_node
1956 : long_long_integer_type_node
);
1957 return build_nonstandard_integer_type (width
, unsignedp
);
1960 /* The C version of the register_builtin_type langhook. */
1963 c_register_builtin_type (tree type
, const char* name
)
1967 decl
= build_decl (TYPE_DECL
, get_identifier (name
), type
);
1968 DECL_ARTIFICIAL (decl
) = 1;
1969 if (!TYPE_NAME (type
))
1970 TYPE_NAME (type
) = decl
;
1973 registered_builtin_types
= tree_cons (0, type
, registered_builtin_types
);
1977 /* Return the minimum number of bits needed to represent VALUE in a
1978 signed or unsigned type, UNSIGNEDP says which. */
1981 min_precision (tree value
, int unsignedp
)
1985 /* If the value is negative, compute its negative minus 1. The latter
1986 adjustment is because the absolute value of the largest negative value
1987 is one larger than the largest positive value. This is equivalent to
1988 a bit-wise negation, so use that operation instead. */
1990 if (tree_int_cst_sgn (value
) < 0)
1991 value
= fold_build1 (BIT_NOT_EXPR
, TREE_TYPE (value
), value
);
1993 /* Return the number of bits needed, taking into account the fact
1994 that we need one more bit for a signed than unsigned type. */
1996 if (integer_zerop (value
))
1999 log
= tree_floor_log2 (value
);
2001 return log
+ 1 + !unsignedp
;
2004 /* Print an error message for invalid operands to arith operation
2008 binary_op_error (enum tree_code code
)
2015 opname
= "+"; break;
2017 opname
= "-"; break;
2019 opname
= "*"; break;
2021 opname
= "max"; break;
2023 opname
= "min"; break;
2025 opname
= "=="; break;
2027 opname
= "!="; break;
2029 opname
= "<="; break;
2031 opname
= ">="; break;
2033 opname
= "<"; break;
2035 opname
= ">"; break;
2037 opname
= "<<"; break;
2039 opname
= ">>"; break;
2040 case TRUNC_MOD_EXPR
:
2041 case FLOOR_MOD_EXPR
:
2042 opname
= "%"; break;
2043 case TRUNC_DIV_EXPR
:
2044 case FLOOR_DIV_EXPR
:
2045 opname
= "/"; break;
2047 opname
= "&"; break;
2049 opname
= "|"; break;
2050 case TRUTH_ANDIF_EXPR
:
2051 opname
= "&&"; break;
2052 case TRUTH_ORIF_EXPR
:
2053 opname
= "||"; break;
2055 opname
= "^"; break;
2059 error ("invalid operands to binary %s", opname
);
2062 /* Subroutine of build_binary_op, used for comparison operations.
2063 See if the operands have both been converted from subword integer types
2064 and, if so, perhaps change them both back to their original type.
2065 This function is also responsible for converting the two operands
2066 to the proper common type for comparison.
2068 The arguments of this function are all pointers to local variables
2069 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2070 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2072 If this function returns nonzero, it means that the comparison has
2073 a constant value. What this function returns is an expression for
2077 shorten_compare (tree
*op0_ptr
, tree
*op1_ptr
, tree
*restype_ptr
,
2078 enum tree_code
*rescode_ptr
)
2081 tree op0
= *op0_ptr
;
2082 tree op1
= *op1_ptr
;
2083 int unsignedp0
, unsignedp1
;
2085 tree primop0
, primop1
;
2086 enum tree_code code
= *rescode_ptr
;
2088 /* Throw away any conversions to wider types
2089 already present in the operands. */
2091 primop0
= get_narrower (op0
, &unsignedp0
);
2092 primop1
= get_narrower (op1
, &unsignedp1
);
2094 /* Handle the case that OP0 does not *contain* a conversion
2095 but it *requires* conversion to FINAL_TYPE. */
2097 if (op0
== primop0
&& TREE_TYPE (op0
) != *restype_ptr
)
2098 unsignedp0
= TYPE_UNSIGNED (TREE_TYPE (op0
));
2099 if (op1
== primop1
&& TREE_TYPE (op1
) != *restype_ptr
)
2100 unsignedp1
= TYPE_UNSIGNED (TREE_TYPE (op1
));
2102 /* If one of the operands must be floated, we cannot optimize. */
2103 real1
= TREE_CODE (TREE_TYPE (primop0
)) == REAL_TYPE
;
2104 real2
= TREE_CODE (TREE_TYPE (primop1
)) == REAL_TYPE
;
2106 /* If first arg is constant, swap the args (changing operation
2107 so value is preserved), for canonicalization. Don't do this if
2108 the second arg is 0. */
2110 if (TREE_CONSTANT (primop0
)
2111 && !integer_zerop (primop1
) && !real_zerop (primop1
))
2114 int temi
= unsignedp0
;
2122 unsignedp0
= unsignedp1
;
2145 *rescode_ptr
= code
;
2148 /* If comparing an integer against a constant more bits wide,
2149 maybe we can deduce a value of 1 or 0 independent of the data.
2150 Or else truncate the constant now
2151 rather than extend the variable at run time.
2153 This is only interesting if the constant is the wider arg.
2154 Also, it is not safe if the constant is unsigned and the
2155 variable arg is signed, since in this case the variable
2156 would be sign-extended and then regarded as unsigned.
2157 Our technique fails in this case because the lowest/highest
2158 possible unsigned results don't follow naturally from the
2159 lowest/highest possible values of the variable operand.
2160 For just EQ_EXPR and NE_EXPR there is another technique that
2161 could be used: see if the constant can be faithfully represented
2162 in the other operand's type, by truncating it and reextending it
2163 and see if that preserves the constant's value. */
2165 if (!real1
&& !real2
2166 && TREE_CODE (primop1
) == INTEGER_CST
2167 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
))
2169 int min_gt
, max_gt
, min_lt
, max_lt
;
2170 tree maxval
, minval
;
2171 /* 1 if comparison is nominally unsigned. */
2172 int unsignedp
= TYPE_UNSIGNED (*restype_ptr
);
2175 type
= c_common_signed_or_unsigned_type (unsignedp0
,
2176 TREE_TYPE (primop0
));
2178 maxval
= TYPE_MAX_VALUE (type
);
2179 minval
= TYPE_MIN_VALUE (type
);
2181 if (unsignedp
&& !unsignedp0
)
2182 *restype_ptr
= c_common_signed_type (*restype_ptr
);
2184 if (TREE_TYPE (primop1
) != *restype_ptr
)
2186 /* Convert primop1 to target type, but do not introduce
2187 additional overflow. We know primop1 is an int_cst. */
2188 tree tmp
= build_int_cst_wide (*restype_ptr
,
2189 TREE_INT_CST_LOW (primop1
),
2190 TREE_INT_CST_HIGH (primop1
));
2192 primop1
= force_fit_type (tmp
, 0, TREE_OVERFLOW (primop1
),
2193 TREE_CONSTANT_OVERFLOW (primop1
));
2195 if (type
!= *restype_ptr
)
2197 minval
= convert (*restype_ptr
, minval
);
2198 maxval
= convert (*restype_ptr
, maxval
);
2201 if (unsignedp
&& unsignedp0
)
2203 min_gt
= INT_CST_LT_UNSIGNED (primop1
, minval
);
2204 max_gt
= INT_CST_LT_UNSIGNED (primop1
, maxval
);
2205 min_lt
= INT_CST_LT_UNSIGNED (minval
, primop1
);
2206 max_lt
= INT_CST_LT_UNSIGNED (maxval
, primop1
);
2210 min_gt
= INT_CST_LT (primop1
, minval
);
2211 max_gt
= INT_CST_LT (primop1
, maxval
);
2212 min_lt
= INT_CST_LT (minval
, primop1
);
2213 max_lt
= INT_CST_LT (maxval
, primop1
);
2217 /* This used to be a switch, but Genix compiler can't handle that. */
2218 if (code
== NE_EXPR
)
2220 if (max_lt
|| min_gt
)
2221 val
= truthvalue_true_node
;
2223 else if (code
== EQ_EXPR
)
2225 if (max_lt
|| min_gt
)
2226 val
= truthvalue_false_node
;
2228 else if (code
== LT_EXPR
)
2231 val
= truthvalue_true_node
;
2233 val
= truthvalue_false_node
;
2235 else if (code
== GT_EXPR
)
2238 val
= truthvalue_true_node
;
2240 val
= truthvalue_false_node
;
2242 else if (code
== LE_EXPR
)
2245 val
= truthvalue_true_node
;
2247 val
= truthvalue_false_node
;
2249 else if (code
== GE_EXPR
)
2252 val
= truthvalue_true_node
;
2254 val
= truthvalue_false_node
;
2257 /* If primop0 was sign-extended and unsigned comparison specd,
2258 we did a signed comparison above using the signed type bounds.
2259 But the comparison we output must be unsigned.
2261 Also, for inequalities, VAL is no good; but if the signed
2262 comparison had *any* fixed result, it follows that the
2263 unsigned comparison just tests the sign in reverse
2264 (positive values are LE, negative ones GE).
2265 So we can generate an unsigned comparison
2266 against an extreme value of the signed type. */
2268 if (unsignedp
&& !unsignedp0
)
2275 primop1
= TYPE_MIN_VALUE (type
);
2281 primop1
= TYPE_MAX_VALUE (type
);
2288 type
= c_common_unsigned_type (type
);
2291 if (TREE_CODE (primop0
) != INTEGER_CST
)
2293 if (val
== truthvalue_false_node
)
2294 warning (0, "comparison is always false due to limited range of data type");
2295 if (val
== truthvalue_true_node
)
2296 warning (0, "comparison is always true due to limited range of data type");
2301 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2302 if (TREE_SIDE_EFFECTS (primop0
))
2303 return build2 (COMPOUND_EXPR
, TREE_TYPE (val
), primop0
, val
);
2307 /* Value is not predetermined, but do the comparison
2308 in the type of the operand that is not constant.
2309 TYPE is already properly set. */
2312 /* If either arg is decimal float and the other is float, find the
2313 proper common type to use for comparison. */
2314 else if (real1
&& real2
2315 && (DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0
)))
2316 || DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1
)))))
2317 type
= common_type (TREE_TYPE (primop0
), TREE_TYPE (primop1
));
2319 else if (real1
&& real2
2320 && (TYPE_PRECISION (TREE_TYPE (primop0
))
2321 == TYPE_PRECISION (TREE_TYPE (primop1
))))
2322 type
= TREE_TYPE (primop0
);
2324 /* If args' natural types are both narrower than nominal type
2325 and both extend in the same manner, compare them
2326 in the type of the wider arg.
2327 Otherwise must actually extend both to the nominal
2328 common type lest different ways of extending
2330 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
2332 else if (unsignedp0
== unsignedp1
&& real1
== real2
2333 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
)
2334 && TYPE_PRECISION (TREE_TYPE (primop1
)) < TYPE_PRECISION (*restype_ptr
))
2336 type
= common_type (TREE_TYPE (primop0
), TREE_TYPE (primop1
));
2337 type
= c_common_signed_or_unsigned_type (unsignedp0
2338 || TYPE_UNSIGNED (*restype_ptr
),
2340 /* Make sure shorter operand is extended the right way
2341 to match the longer operand. */
2343 = convert (c_common_signed_or_unsigned_type (unsignedp0
,
2344 TREE_TYPE (primop0
)),
2347 = convert (c_common_signed_or_unsigned_type (unsignedp1
,
2348 TREE_TYPE (primop1
)),
2353 /* Here we must do the comparison on the nominal type
2354 using the args exactly as we received them. */
2355 type
= *restype_ptr
;
2359 if (!real1
&& !real2
&& integer_zerop (primop1
)
2360 && TYPE_UNSIGNED (*restype_ptr
))
2366 /* All unsigned values are >= 0, so we warn if extra warnings
2367 are requested. However, if OP0 is a constant that is
2368 >= 0, the signedness of the comparison isn't an issue,
2369 so suppress the warning. */
2370 if (extra_warnings
&& !in_system_header
2371 && !(TREE_CODE (primop0
) == INTEGER_CST
2372 && !TREE_OVERFLOW (convert (c_common_signed_type (type
),
2374 warning (0, "comparison of unsigned expression >= 0 is always true");
2375 value
= truthvalue_true_node
;
2379 if (extra_warnings
&& !in_system_header
2380 && !(TREE_CODE (primop0
) == INTEGER_CST
2381 && !TREE_OVERFLOW (convert (c_common_signed_type (type
),
2383 warning (0, "comparison of unsigned expression < 0 is always false");
2384 value
= truthvalue_false_node
;
2393 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2394 if (TREE_SIDE_EFFECTS (primop0
))
2395 return build2 (COMPOUND_EXPR
, TREE_TYPE (value
),
2402 *op0_ptr
= convert (type
, primop0
);
2403 *op1_ptr
= convert (type
, primop1
);
2405 *restype_ptr
= truthvalue_type_node
;
2410 /* Return a tree for the sum or difference (RESULTCODE says which)
2411 of pointer PTROP and integer INTOP. */
2414 pointer_int_sum (enum tree_code resultcode
, tree ptrop
, tree intop
)
2418 /* The result is a pointer of the same type that is being added. */
2420 tree result_type
= TREE_TYPE (ptrop
);
2422 if (TREE_CODE (TREE_TYPE (result_type
)) == VOID_TYPE
)
2424 if (pedantic
|| warn_pointer_arith
)
2425 pedwarn ("pointer of type %<void *%> used in arithmetic");
2426 size_exp
= integer_one_node
;
2428 else if (TREE_CODE (TREE_TYPE (result_type
)) == FUNCTION_TYPE
)
2430 if (pedantic
|| warn_pointer_arith
)
2431 pedwarn ("pointer to a function used in arithmetic");
2432 size_exp
= integer_one_node
;
2434 else if (TREE_CODE (TREE_TYPE (result_type
)) == METHOD_TYPE
)
2436 if (pedantic
|| warn_pointer_arith
)
2437 pedwarn ("pointer to member function used in arithmetic");
2438 size_exp
= integer_one_node
;
2441 size_exp
= size_in_bytes (TREE_TYPE (result_type
));
2443 /* If what we are about to multiply by the size of the elements
2444 contains a constant term, apply distributive law
2445 and multiply that constant term separately.
2446 This helps produce common subexpressions. */
2448 if ((TREE_CODE (intop
) == PLUS_EXPR
|| TREE_CODE (intop
) == MINUS_EXPR
)
2449 && !TREE_CONSTANT (intop
)
2450 && TREE_CONSTANT (TREE_OPERAND (intop
, 1))
2451 && TREE_CONSTANT (size_exp
)
2452 /* If the constant comes from pointer subtraction,
2453 skip this optimization--it would cause an error. */
2454 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop
, 0))) == INTEGER_TYPE
2455 /* If the constant is unsigned, and smaller than the pointer size,
2456 then we must skip this optimization. This is because it could cause
2457 an overflow error if the constant is negative but INTOP is not. */
2458 && (!TYPE_UNSIGNED (TREE_TYPE (intop
))
2459 || (TYPE_PRECISION (TREE_TYPE (intop
))
2460 == TYPE_PRECISION (TREE_TYPE (ptrop
)))))
2462 enum tree_code subcode
= resultcode
;
2463 tree int_type
= TREE_TYPE (intop
);
2464 if (TREE_CODE (intop
) == MINUS_EXPR
)
2465 subcode
= (subcode
== PLUS_EXPR
? MINUS_EXPR
: PLUS_EXPR
);
2466 /* Convert both subexpression types to the type of intop,
2467 because weird cases involving pointer arithmetic
2468 can result in a sum or difference with different type args. */
2469 ptrop
= build_binary_op (subcode
, ptrop
,
2470 convert (int_type
, TREE_OPERAND (intop
, 1)), 1);
2471 intop
= convert (int_type
, TREE_OPERAND (intop
, 0));
2474 /* Convert the integer argument to a type the same size as sizetype
2475 so the multiply won't overflow spuriously. */
2477 if (TYPE_PRECISION (TREE_TYPE (intop
)) != TYPE_PRECISION (sizetype
)
2478 || TYPE_UNSIGNED (TREE_TYPE (intop
)) != TYPE_UNSIGNED (sizetype
))
2479 intop
= convert (c_common_type_for_size (TYPE_PRECISION (sizetype
),
2480 TYPE_UNSIGNED (sizetype
)), intop
);
2482 /* Replace the integer argument with a suitable product by the object size.
2483 Do this multiplication as signed, then convert to the appropriate
2484 pointer type (actually unsigned integral). */
2486 intop
= convert (result_type
,
2487 build_binary_op (MULT_EXPR
, intop
,
2488 convert (TREE_TYPE (intop
), size_exp
), 1));
2490 /* Create the sum or difference. */
2491 return fold_build2 (resultcode
, result_type
, ptrop
, intop
);
2494 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2495 or for an `if' or `while' statement or ?..: exp. It should already
2496 have been validated to be of suitable type; otherwise, a bad
2497 diagnostic may result.
2499 This preparation consists of taking the ordinary
2500 representation of an expression expr and producing a valid tree
2501 boolean expression describing whether expr is nonzero. We could
2502 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
2503 but we optimize comparisons, &&, ||, and !.
2505 The resulting type should always be `truthvalue_type_node'. */
2508 c_common_truthvalue_conversion (tree expr
)
2510 switch (TREE_CODE (expr
))
2512 case EQ_EXPR
: case NE_EXPR
: case UNEQ_EXPR
: case LTGT_EXPR
:
2513 case LE_EXPR
: case GE_EXPR
: case LT_EXPR
: case GT_EXPR
:
2514 case UNLE_EXPR
: case UNGE_EXPR
: case UNLT_EXPR
: case UNGT_EXPR
:
2515 case ORDERED_EXPR
: case UNORDERED_EXPR
:
2516 if (TREE_TYPE (expr
) == truthvalue_type_node
)
2518 return build2 (TREE_CODE (expr
), truthvalue_type_node
,
2519 TREE_OPERAND (expr
, 0), TREE_OPERAND (expr
, 1));
2521 case TRUTH_ANDIF_EXPR
:
2522 case TRUTH_ORIF_EXPR
:
2523 case TRUTH_AND_EXPR
:
2525 case TRUTH_XOR_EXPR
:
2526 if (TREE_TYPE (expr
) == truthvalue_type_node
)
2528 return build2 (TREE_CODE (expr
), truthvalue_type_node
,
2529 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0)),
2530 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 1)));
2532 case TRUTH_NOT_EXPR
:
2533 if (TREE_TYPE (expr
) == truthvalue_type_node
)
2535 return build1 (TREE_CODE (expr
), truthvalue_type_node
,
2536 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0)));
2542 /* Avoid integer_zerop to ignore TREE_CONSTANT_OVERFLOW. */
2543 return (TREE_INT_CST_LOW (expr
) != 0 || TREE_INT_CST_HIGH (expr
) != 0)
2544 ? truthvalue_true_node
2545 : truthvalue_false_node
;
2548 return real_compare (NE_EXPR
, &TREE_REAL_CST (expr
), &dconst0
)
2549 ? truthvalue_true_node
2550 : truthvalue_false_node
;
2553 expr
= build_unary_op (ADDR_EXPR
, expr
, 0);
2558 tree inner
= TREE_OPERAND (expr
, 0);
2560 && (TREE_CODE (inner
) == PARM_DECL
2561 || TREE_CODE (inner
) == LABEL_DECL
2562 || !DECL_WEAK (inner
)))
2564 /* Common Ada/Pascal programmer's mistake. We always warn
2565 about this since it is so bad. */
2566 warning (OPT_Walways_true
, "the address of %qD will always evaluate as %<true%>",
2568 return truthvalue_true_node
;
2571 /* If we are taking the address of an external decl, it might be
2572 zero if it is weak, so we cannot optimize. */
2574 && DECL_EXTERNAL (inner
))
2577 if (TREE_SIDE_EFFECTS (inner
))
2578 return build2 (COMPOUND_EXPR
, truthvalue_type_node
,
2579 inner
, truthvalue_true_node
);
2581 return truthvalue_true_node
;
2585 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1))
2586 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
2587 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0)),
2588 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 1)),
2594 /* These don't change whether an object is nonzero or zero. */
2595 return c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0));
2599 /* These don't change whether an object is zero or nonzero, but
2600 we can't ignore them if their second arg has side-effects. */
2601 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1)))
2602 return build2 (COMPOUND_EXPR
, truthvalue_type_node
,
2603 TREE_OPERAND (expr
, 1),
2604 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0)));
2606 return c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0));
2609 /* Distribute the conversion into the arms of a COND_EXPR. */
2610 return fold_build3 (COND_EXPR
, truthvalue_type_node
,
2611 TREE_OPERAND (expr
, 0),
2612 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 1)),
2613 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 2)));
2617 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2618 since that affects how `default_conversion' will behave. */
2619 if (TREE_CODE (TREE_TYPE (expr
)) == REFERENCE_TYPE
2620 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == REFERENCE_TYPE
)
2622 /* If this is widening the argument, we can ignore it. */
2623 if (TYPE_PRECISION (TREE_TYPE (expr
))
2624 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr
, 0))))
2625 return c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0));
2629 if (!TREE_NO_WARNING (expr
))
2630 warning (OPT_Wparentheses
,
2631 "suggest parentheses around assignment used as truth value");
2638 if (TREE_CODE (TREE_TYPE (expr
)) == COMPLEX_TYPE
)
2640 tree t
= save_expr (expr
);
2641 return (build_binary_op
2642 ((TREE_SIDE_EFFECTS (expr
)
2643 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
2644 c_common_truthvalue_conversion (build_unary_op (REALPART_EXPR
, t
, 0)),
2645 c_common_truthvalue_conversion (build_unary_op (IMAGPART_EXPR
, t
, 0)),
2649 return build_binary_op (NE_EXPR
, expr
, integer_zero_node
, 1);
2652 static void def_builtin_1 (enum built_in_function fncode
,
2654 enum built_in_class fnclass
,
2655 tree fntype
, tree libtype
,
2656 bool both_p
, bool fallback_p
, bool nonansi_p
,
2657 tree fnattrs
, bool implicit_p
);
2659 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2660 down to the element type of an array. */
2663 c_build_qualified_type (tree type
, int type_quals
)
2665 if (type
== error_mark_node
)
2668 if (TREE_CODE (type
) == ARRAY_TYPE
)
2671 tree element_type
= c_build_qualified_type (TREE_TYPE (type
),
2674 /* See if we already have an identically qualified type. */
2675 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
2677 if (TYPE_QUALS (strip_array_types (t
)) == type_quals
2678 && TYPE_NAME (t
) == TYPE_NAME (type
)
2679 && TYPE_CONTEXT (t
) == TYPE_CONTEXT (type
)
2680 && attribute_list_equal (TYPE_ATTRIBUTES (t
),
2681 TYPE_ATTRIBUTES (type
)))
2686 t
= build_variant_type_copy (type
);
2687 TREE_TYPE (t
) = element_type
;
2692 /* A restrict-qualified pointer type must be a pointer to object or
2693 incomplete type. Note that the use of POINTER_TYPE_P also allows
2694 REFERENCE_TYPEs, which is appropriate for C++. */
2695 if ((type_quals
& TYPE_QUAL_RESTRICT
)
2696 && (!POINTER_TYPE_P (type
)
2697 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type
))))
2699 error ("invalid use of %<restrict%>");
2700 type_quals
&= ~TYPE_QUAL_RESTRICT
;
2703 return build_qualified_type (type
, type_quals
);
2706 /* Apply the TYPE_QUALS to the new DECL. */
2709 c_apply_type_quals_to_decl (int type_quals
, tree decl
)
2711 tree type
= TREE_TYPE (decl
);
2713 if (type
== error_mark_node
)
2716 if (((type_quals
& TYPE_QUAL_CONST
)
2717 || (type
&& TREE_CODE (type
) == REFERENCE_TYPE
))
2718 /* An object declared 'const' is only readonly after it is
2719 initialized. We don't have any way of expressing this currently,
2720 so we need to be conservative and unset TREE_READONLY for types
2721 with constructors. Otherwise aliasing code will ignore stores in
2722 an inline constructor. */
2723 && !(type
&& TYPE_NEEDS_CONSTRUCTING (type
)))
2724 TREE_READONLY (decl
) = 1;
2725 if (type_quals
& TYPE_QUAL_VOLATILE
)
2727 TREE_SIDE_EFFECTS (decl
) = 1;
2728 TREE_THIS_VOLATILE (decl
) = 1;
2730 if (type_quals
& TYPE_QUAL_RESTRICT
)
2732 while (type
&& TREE_CODE (type
) == ARRAY_TYPE
)
2733 /* Allow 'restrict' on arrays of pointers.
2734 FIXME currently we just ignore it. */
2735 type
= TREE_TYPE (type
);
2737 || !POINTER_TYPE_P (type
)
2738 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type
)))
2739 error ("invalid use of %<restrict%>");
2740 else if (flag_strict_aliasing
&& type
== TREE_TYPE (decl
))
2741 /* Indicate we need to make a unique alias set for this pointer.
2742 We can't do it here because it might be pointing to an
2744 DECL_POINTER_ALIAS_SET (decl
) = -2;
2748 /* Hash function for the problem of multiple type definitions in
2749 different files. This must hash all types that will compare
2750 equal via comptypes to the same value. In practice it hashes
2751 on some of the simple stuff and leaves the details to comptypes. */
2754 c_type_hash (const void *p
)
2760 switch (TREE_CODE (t
))
2762 /* For pointers, hash on pointee type plus some swizzling. */
2764 return c_type_hash (TREE_TYPE (t
)) ^ 0x3003003;
2765 /* Hash on number of elements and total size. */
2768 t2
= TYPE_VALUES (t
);
2772 t2
= TYPE_FIELDS (t
);
2774 case QUAL_UNION_TYPE
:
2776 t2
= TYPE_FIELDS (t
);
2780 t2
= TYPE_FIELDS (t
);
2785 for (; t2
; t2
= TREE_CHAIN (t2
))
2787 size
= TREE_INT_CST_LOW (TYPE_SIZE (t
));
2788 return ((size
<< 24) | (i
<< shift
));
2791 static GTY((param_is (union tree_node
))) htab_t type_hash_table
;
2793 /* Return the typed-based alias set for T, which may be an expression
2794 or a type. Return -1 if we don't do anything special. */
2797 c_common_get_alias_set (tree t
)
2802 /* Permit type-punning when accessing a union, provided the access
2803 is directly through the union. For example, this code does not
2804 permit taking the address of a union member and then storing
2805 through it. Even the type-punning allowed here is a GCC
2806 extension, albeit a common and useful one; the C standard says
2807 that such accesses have implementation-defined behavior. */
2809 TREE_CODE (u
) == COMPONENT_REF
|| TREE_CODE (u
) == ARRAY_REF
;
2810 u
= TREE_OPERAND (u
, 0))
2811 if (TREE_CODE (u
) == COMPONENT_REF
2812 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u
, 0))) == UNION_TYPE
)
2815 /* That's all the expressions we handle specially. */
2819 /* The C standard guarantees that any object may be accessed via an
2820 lvalue that has character type. */
2821 if (t
== char_type_node
2822 || t
== signed_char_type_node
2823 || t
== unsigned_char_type_node
)
2826 /* If it has the may_alias attribute, it can alias anything. */
2827 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (t
)))
2830 /* The C standard specifically allows aliasing between signed and
2831 unsigned variants of the same type. We treat the signed
2832 variant as canonical. */
2833 if (TREE_CODE (t
) == INTEGER_TYPE
&& TYPE_UNSIGNED (t
))
2835 tree t1
= c_common_signed_type (t
);
2837 /* t1 == t can happen for boolean nodes which are always unsigned. */
2839 return get_alias_set (t1
);
2841 else if (POINTER_TYPE_P (t
))
2845 /* Unfortunately, there is no canonical form of a pointer type.
2846 In particular, if we have `typedef int I', then `int *', and
2847 `I *' are different types. So, we have to pick a canonical
2848 representative. We do this below.
2850 Technically, this approach is actually more conservative that
2851 it needs to be. In particular, `const int *' and `int *'
2852 should be in different alias sets, according to the C and C++
2853 standard, since their types are not the same, and so,
2854 technically, an `int **' and `const int **' cannot point at
2857 But, the standard is wrong. In particular, this code is
2862 const int* const* cipp = ipp;
2864 And, it doesn't make sense for that to be legal unless you
2865 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
2866 the pointed-to types. This issue has been reported to the
2868 t1
= build_type_no_quals (t
);
2870 return get_alias_set (t1
);
2873 /* Handle the case of multiple type nodes referring to "the same" type,
2874 which occurs with IMA. These share an alias set. FIXME: Currently only
2875 C90 is handled. (In C99 type compatibility is not transitive, which
2876 complicates things mightily. The alias set splay trees can theoretically
2877 represent this, but insertion is tricky when you consider all the
2878 different orders things might arrive in.) */
2880 if (c_language
!= clk_c
|| flag_isoc99
)
2883 /* Save time if there's only one input file. */
2884 if (num_in_fnames
== 1)
2887 /* Pointers need special handling if they point to any type that
2888 needs special handling (below). */
2889 if (TREE_CODE (t
) == POINTER_TYPE
)
2892 /* Find bottom type under any nested POINTERs. */
2893 for (t2
= TREE_TYPE (t
);
2894 TREE_CODE (t2
) == POINTER_TYPE
;
2895 t2
= TREE_TYPE (t2
))
2897 if (TREE_CODE (t2
) != RECORD_TYPE
2898 && TREE_CODE (t2
) != ENUMERAL_TYPE
2899 && TREE_CODE (t2
) != QUAL_UNION_TYPE
2900 && TREE_CODE (t2
) != UNION_TYPE
)
2902 if (TYPE_SIZE (t2
) == 0)
2905 /* These are the only cases that need special handling. */
2906 if (TREE_CODE (t
) != RECORD_TYPE
2907 && TREE_CODE (t
) != ENUMERAL_TYPE
2908 && TREE_CODE (t
) != QUAL_UNION_TYPE
2909 && TREE_CODE (t
) != UNION_TYPE
2910 && TREE_CODE (t
) != POINTER_TYPE
)
2913 if (TYPE_SIZE (t
) == 0)
2916 /* Look up t in hash table. Only one of the compatible types within each
2917 alias set is recorded in the table. */
2918 if (!type_hash_table
)
2919 type_hash_table
= htab_create_ggc (1021, c_type_hash
,
2920 (htab_eq
) lang_hooks
.types_compatible_p
,
2922 slot
= htab_find_slot (type_hash_table
, t
, INSERT
);
2925 TYPE_ALIAS_SET (t
) = TYPE_ALIAS_SET ((tree
)*slot
);
2926 return TYPE_ALIAS_SET ((tree
)*slot
);
2929 /* Our caller will assign and record (in t) a new alias set; all we need
2930 to do is remember t in the hash table. */
2936 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
2937 second parameter indicates which OPERATOR is being applied. The COMPLAIN
2938 flag controls whether we should diagnose possibly ill-formed
2939 constructs or not. */
2942 c_sizeof_or_alignof_type (tree type
, bool is_sizeof
, int complain
)
2944 const char *op_name
;
2946 enum tree_code type_code
= TREE_CODE (type
);
2948 op_name
= is_sizeof
? "sizeof" : "__alignof__";
2950 if (type_code
== FUNCTION_TYPE
)
2954 if (complain
&& (pedantic
|| warn_pointer_arith
))
2955 pedwarn ("invalid application of %<sizeof%> to a function type");
2956 value
= size_one_node
;
2959 value
= size_int (FUNCTION_BOUNDARY
/ BITS_PER_UNIT
);
2961 else if (type_code
== VOID_TYPE
|| type_code
== ERROR_MARK
)
2963 if (type_code
== VOID_TYPE
2964 && complain
&& (pedantic
|| warn_pointer_arith
))
2965 pedwarn ("invalid application of %qs to a void type", op_name
);
2966 value
= size_one_node
;
2968 else if (!COMPLETE_TYPE_P (type
))
2971 error ("invalid application of %qs to incomplete type %qT ",
2973 value
= size_zero_node
;
2978 /* Convert in case a char is more than one unit. */
2979 value
= size_binop (CEIL_DIV_EXPR
, TYPE_SIZE_UNIT (type
),
2980 size_int (TYPE_PRECISION (char_type_node
)
2983 value
= size_int (TYPE_ALIGN_UNIT (type
));
2986 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
2987 TYPE_IS_SIZETYPE means that certain things (like overflow) will
2988 never happen. However, this node should really have type
2989 `size_t', which is just a typedef for an ordinary integer type. */
2990 value
= fold_convert (size_type_node
, value
);
2991 gcc_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value
)));
2996 /* Implement the __alignof keyword: Return the minimum required
2997 alignment of EXPR, measured in bytes. For VAR_DECL's and
2998 FIELD_DECL's return DECL_ALIGN (which can be set from an
2999 "aligned" __attribute__ specification). */
3002 c_alignof_expr (tree expr
)
3006 if (TREE_CODE (expr
) == VAR_DECL
)
3007 t
= size_int (DECL_ALIGN_UNIT (expr
));
3009 else if (TREE_CODE (expr
) == COMPONENT_REF
3010 && DECL_C_BIT_FIELD (TREE_OPERAND (expr
, 1)))
3012 error ("%<__alignof%> applied to a bit-field");
3015 else if (TREE_CODE (expr
) == COMPONENT_REF
3016 && TREE_CODE (TREE_OPERAND (expr
, 1)) == FIELD_DECL
)
3017 t
= size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr
, 1)));
3019 else if (TREE_CODE (expr
) == INDIRECT_REF
)
3021 tree t
= TREE_OPERAND (expr
, 0);
3023 int bestalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
3025 while ((TREE_CODE (t
) == NOP_EXPR
|| TREE_CODE (t
) == CONVERT_EXPR
)
3026 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0))) == POINTER_TYPE
)
3030 t
= TREE_OPERAND (t
, 0);
3031 thisalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
3032 if (thisalign
> bestalign
)
3033 best
= t
, bestalign
= thisalign
;
3035 return c_alignof (TREE_TYPE (TREE_TYPE (best
)));
3038 return c_alignof (TREE_TYPE (expr
));
3040 return fold_convert (size_type_node
, t
);
3043 /* Handle C and C++ default attributes. */
3045 enum built_in_attribute
3047 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
3048 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
3049 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
3050 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
3051 #include "builtin-attrs.def"
3052 #undef DEF_ATTR_NULL_TREE
3054 #undef DEF_ATTR_IDENT
3055 #undef DEF_ATTR_TREE_LIST
3059 static GTY(()) tree built_in_attributes
[(int) ATTR_LAST
];
3061 static void c_init_attributes (void);
3065 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
3066 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
3067 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
3068 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
3069 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3070 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3071 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
3072 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME,
3073 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME,
3074 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
3075 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
3076 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
3077 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3078 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3079 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
3081 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
3082 #include "builtin-types.def"
3083 #undef DEF_PRIMITIVE_TYPE
3084 #undef DEF_FUNCTION_TYPE_0
3085 #undef DEF_FUNCTION_TYPE_1
3086 #undef DEF_FUNCTION_TYPE_2
3087 #undef DEF_FUNCTION_TYPE_3
3088 #undef DEF_FUNCTION_TYPE_4
3089 #undef DEF_FUNCTION_TYPE_5
3090 #undef DEF_FUNCTION_TYPE_6
3091 #undef DEF_FUNCTION_TYPE_7
3092 #undef DEF_FUNCTION_TYPE_VAR_0
3093 #undef DEF_FUNCTION_TYPE_VAR_1
3094 #undef DEF_FUNCTION_TYPE_VAR_2
3095 #undef DEF_FUNCTION_TYPE_VAR_3
3096 #undef DEF_FUNCTION_TYPE_VAR_4
3097 #undef DEF_FUNCTION_TYPE_VAR_5
3098 #undef DEF_POINTER_TYPE
3102 typedef enum c_builtin_type builtin_type
;
3104 /* A temporary array for c_common_nodes_and_builtins. Used in
3105 communication with def_fn_type. */
3106 static tree builtin_types
[(int) BT_LAST
+ 1];
3108 /* A helper function for c_common_nodes_and_builtins. Build function type
3109 for DEF with return type RET and N arguments. If VAR is true, then the
3110 function should be variadic after those N arguments.
3112 Takes special care not to ICE if any of the types involved are
3113 error_mark_node, which indicates that said type is not in fact available
3114 (see builtin_type_for_size). In which case the function type as a whole
3115 should be error_mark_node. */
3118 def_fn_type (builtin_type def
, builtin_type ret
, bool var
, int n
, ...)
3120 tree args
= NULL
, t
;
3125 for (i
= 0; i
< n
; ++i
)
3127 builtin_type a
= va_arg (list
, builtin_type
);
3128 t
= builtin_types
[a
];
3129 if (t
== error_mark_node
)
3131 args
= tree_cons (NULL_TREE
, t
, args
);
3135 args
= nreverse (args
);
3137 args
= chainon (args
, void_list_node
);
3139 t
= builtin_types
[ret
];
3140 if (t
== error_mark_node
)
3142 t
= build_function_type (t
, args
);
3145 builtin_types
[def
] = t
;
3148 /* Build tree nodes and builtin functions common to both C and C++ language
3152 c_common_nodes_and_builtins (void)
3154 int wchar_type_size
;
3155 tree array_domain_type
;
3156 tree va_list_ref_type_node
;
3157 tree va_list_arg_type_node
;
3159 /* Define `int' and `char' first so that dbx will output them first. */
3160 record_builtin_type (RID_INT
, NULL
, integer_type_node
);
3161 record_builtin_type (RID_CHAR
, "char", char_type_node
);
3163 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
3164 "unsigned long", "long long unsigned" and "unsigned short" were in C++
3165 but not C. Are the conditionals here needed? */
3166 if (c_dialect_cxx ())
3167 record_builtin_type (RID_SIGNED
, NULL
, integer_type_node
);
3168 record_builtin_type (RID_LONG
, "long int", long_integer_type_node
);
3169 record_builtin_type (RID_UNSIGNED
, "unsigned int", unsigned_type_node
);
3170 record_builtin_type (RID_MAX
, "long unsigned int",
3171 long_unsigned_type_node
);
3172 if (c_dialect_cxx ())
3173 record_builtin_type (RID_MAX
, "unsigned long", long_unsigned_type_node
);
3174 record_builtin_type (RID_MAX
, "long long int",
3175 long_long_integer_type_node
);
3176 record_builtin_type (RID_MAX
, "long long unsigned int",
3177 long_long_unsigned_type_node
);
3178 if (c_dialect_cxx ())
3179 record_builtin_type (RID_MAX
, "long long unsigned",
3180 long_long_unsigned_type_node
);
3181 record_builtin_type (RID_SHORT
, "short int", short_integer_type_node
);
3182 record_builtin_type (RID_MAX
, "short unsigned int",
3183 short_unsigned_type_node
);
3184 if (c_dialect_cxx ())
3185 record_builtin_type (RID_MAX
, "unsigned short",
3186 short_unsigned_type_node
);
3188 /* Define both `signed char' and `unsigned char'. */
3189 record_builtin_type (RID_MAX
, "signed char", signed_char_type_node
);
3190 record_builtin_type (RID_MAX
, "unsigned char", unsigned_char_type_node
);
3192 /* These are types that c_common_type_for_size and
3193 c_common_type_for_mode use. */
3194 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3196 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3198 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3200 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3202 #if HOST_BITS_PER_WIDE_INT >= 64
3203 if (targetm
.scalar_mode_supported_p (TImode
))
3204 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
3205 get_identifier ("__int128_t"),
3208 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3209 unsigned_intQI_type_node
));
3210 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3211 unsigned_intHI_type_node
));
3212 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3213 unsigned_intSI_type_node
));
3214 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3215 unsigned_intDI_type_node
));
3216 #if HOST_BITS_PER_WIDE_INT >= 64
3217 if (targetm
.scalar_mode_supported_p (TImode
))
3218 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
3219 get_identifier ("__uint128_t"),
3220 unsigned_intTI_type_node
));
3223 /* Create the widest literal types. */
3224 widest_integer_literal_type_node
3225 = make_signed_type (HOST_BITS_PER_WIDE_INT
* 2);
3226 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3227 widest_integer_literal_type_node
));
3229 widest_unsigned_literal_type_node
3230 = make_unsigned_type (HOST_BITS_PER_WIDE_INT
* 2);
3231 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3232 widest_unsigned_literal_type_node
));
3234 /* `unsigned long' is the standard type for sizeof.
3235 Note that stddef.h uses `unsigned long',
3236 and this must agree, even if long and int are the same size. */
3238 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE
)));
3239 signed_size_type_node
= c_common_signed_type (size_type_node
);
3240 set_sizetype (size_type_node
);
3243 TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE
)));
3245 build_common_tree_nodes_2 (flag_short_double
);
3247 record_builtin_type (RID_FLOAT
, NULL
, float_type_node
);
3248 record_builtin_type (RID_DOUBLE
, NULL
, double_type_node
);
3249 record_builtin_type (RID_MAX
, "long double", long_double_type_node
);
3251 /* Only supported decimal floating point extension if the target
3252 actually supports underlying modes. */
3253 if (targetm
.scalar_mode_supported_p (SDmode
)
3254 && targetm
.scalar_mode_supported_p (DDmode
)
3255 && targetm
.scalar_mode_supported_p (TDmode
))
3257 record_builtin_type (RID_DFLOAT32
, NULL
, dfloat32_type_node
);
3258 record_builtin_type (RID_DFLOAT64
, NULL
, dfloat64_type_node
);
3259 record_builtin_type (RID_DFLOAT128
, NULL
, dfloat128_type_node
);
3262 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
3263 get_identifier ("complex int"),
3264 complex_integer_type_node
));
3265 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
3266 get_identifier ("complex float"),
3267 complex_float_type_node
));
3268 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
3269 get_identifier ("complex double"),
3270 complex_double_type_node
));
3271 lang_hooks
.decls
.pushdecl
3272 (build_decl (TYPE_DECL
, get_identifier ("complex long double"),
3273 complex_long_double_type_node
));
3275 if (c_dialect_cxx ())
3276 /* For C++, make fileptr_type_node a distinct void * type until
3277 FILE type is defined. */
3278 fileptr_type_node
= build_variant_type_copy (ptr_type_node
);
3280 record_builtin_type (RID_VOID
, NULL
, void_type_node
);
3282 /* This node must not be shared. */
3283 void_zero_node
= make_node (INTEGER_CST
);
3284 TREE_TYPE (void_zero_node
) = void_type_node
;
3286 void_list_node
= build_void_list_node ();
3288 /* Make a type to be the domain of a few array types
3289 whose domains don't really matter.
3290 200 is small enough that it always fits in size_t
3291 and large enough that it can hold most function names for the
3292 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
3293 array_domain_type
= build_index_type (size_int (200));
3295 /* Make a type for arrays of characters.
3296 With luck nothing will ever really depend on the length of this
3298 char_array_type_node
3299 = build_array_type (char_type_node
, array_domain_type
);
3301 /* Likewise for arrays of ints. */
3303 = build_array_type (integer_type_node
, array_domain_type
);
3305 string_type_node
= build_pointer_type (char_type_node
);
3306 const_string_type_node
3307 = build_pointer_type (build_qualified_type
3308 (char_type_node
, TYPE_QUAL_CONST
));
3310 /* This is special for C++ so functions can be overloaded. */
3311 wchar_type_node
= get_identifier (MODIFIED_WCHAR_TYPE
);
3312 wchar_type_node
= TREE_TYPE (identifier_global_value (wchar_type_node
));
3313 wchar_type_size
= TYPE_PRECISION (wchar_type_node
);
3314 if (c_dialect_cxx ())
3316 if (TYPE_UNSIGNED (wchar_type_node
))
3317 wchar_type_node
= make_unsigned_type (wchar_type_size
);
3319 wchar_type_node
= make_signed_type (wchar_type_size
);
3320 record_builtin_type (RID_WCHAR
, "wchar_t", wchar_type_node
);
3324 signed_wchar_type_node
= c_common_signed_type (wchar_type_node
);
3325 unsigned_wchar_type_node
= c_common_unsigned_type (wchar_type_node
);
3328 /* This is for wide string constants. */
3329 wchar_array_type_node
3330 = build_array_type (wchar_type_node
, array_domain_type
);
3333 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE
)));
3336 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE
)));
3338 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE
)));
3340 default_function_type
= build_function_type (integer_type_node
, NULL_TREE
);
3342 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE
)));
3343 unsigned_ptrdiff_type_node
= c_common_unsigned_type (ptrdiff_type_node
);
3345 lang_hooks
.decls
.pushdecl
3346 (build_decl (TYPE_DECL
, get_identifier ("__builtin_va_list"),
3347 va_list_type_node
));
3349 if (TREE_CODE (va_list_type_node
) == ARRAY_TYPE
)
3351 va_list_arg_type_node
= va_list_ref_type_node
=
3352 build_pointer_type (TREE_TYPE (va_list_type_node
));
3356 va_list_arg_type_node
= va_list_type_node
;
3357 va_list_ref_type_node
= build_reference_type (va_list_type_node
);
3360 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3361 builtin_types[ENUM] = VALUE;
3362 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
3363 def_fn_type (ENUM, RETURN, 0, 0);
3364 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
3365 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
3366 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
3367 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
3368 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3369 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
3370 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3371 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
3372 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
3373 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
3374 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3376 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
3377 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3379 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
3380 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
3381 def_fn_type (ENUM, RETURN, 1, 0);
3382 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
3383 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
3384 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
3385 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
3386 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3387 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
3388 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3389 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
3390 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
3391 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
3392 #define DEF_POINTER_TYPE(ENUM, TYPE) \
3393 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
3395 #include "builtin-types.def"
3397 #undef DEF_PRIMITIVE_TYPE
3398 #undef DEF_FUNCTION_TYPE_1
3399 #undef DEF_FUNCTION_TYPE_2
3400 #undef DEF_FUNCTION_TYPE_3
3401 #undef DEF_FUNCTION_TYPE_4
3402 #undef DEF_FUNCTION_TYPE_5
3403 #undef DEF_FUNCTION_TYPE_6
3404 #undef DEF_FUNCTION_TYPE_VAR_0
3405 #undef DEF_FUNCTION_TYPE_VAR_1
3406 #undef DEF_FUNCTION_TYPE_VAR_2
3407 #undef DEF_FUNCTION_TYPE_VAR_3
3408 #undef DEF_FUNCTION_TYPE_VAR_4
3409 #undef DEF_FUNCTION_TYPE_VAR_5
3410 #undef DEF_POINTER_TYPE
3411 builtin_types
[(int) BT_LAST
] = NULL_TREE
;
3413 c_init_attributes ();
3415 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
3416 NONANSI_P, ATTRS, IMPLICIT, COND) \
3418 def_builtin_1 (ENUM, NAME, CLASS, \
3419 builtin_types[(int) TYPE], \
3420 builtin_types[(int) LIBTYPE], \
3421 BOTH_P, FALLBACK_P, NONANSI_P, \
3422 built_in_attributes[(int) ATTRS], IMPLICIT);
3423 #include "builtins.def"
3426 build_common_builtin_nodes ();
3428 targetm
.init_builtins ();
3432 main_identifier_node
= get_identifier ("main");
3434 /* Create the built-in __null node. It is important that this is
3436 null_node
= make_node (INTEGER_CST
);
3437 TREE_TYPE (null_node
) = c_common_type_for_size (POINTER_SIZE
, 0);
3439 /* Since builtin_types isn't gc'ed, don't export these nodes. */
3440 memset (builtin_types
, 0, sizeof (builtin_types
));
3443 /* Look up the function in built_in_decls that corresponds to DECL
3444 and set ASMSPEC as its user assembler name. DECL must be a
3445 function decl that declares a builtin. */
3448 set_builtin_user_assembler_name (tree decl
, const char *asmspec
)
3451 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
3452 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
3455 builtin
= built_in_decls
[DECL_FUNCTION_CODE (decl
)];
3456 set_user_assembler_name (builtin
, asmspec
);
3457 if (DECL_FUNCTION_CODE (decl
) == BUILT_IN_MEMCPY
)
3458 init_block_move_fn (asmspec
);
3459 else if (DECL_FUNCTION_CODE (decl
) == BUILT_IN_MEMSET
)
3460 init_block_clear_fn (asmspec
);
3463 /* The number of named compound-literals generated thus far. */
3464 static GTY(()) int compound_literal_number
;
3466 /* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal. */
3469 set_compound_literal_name (tree decl
)
3472 ASM_FORMAT_PRIVATE_NAME (name
, "__compound_literal",
3473 compound_literal_number
);
3474 compound_literal_number
++;
3475 DECL_NAME (decl
) = get_identifier (name
);
3479 build_va_arg (tree expr
, tree type
)
3481 return build1 (VA_ARG_EXPR
, type
, expr
);
3485 /* Linked list of disabled built-in functions. */
3487 typedef struct disabled_builtin
3490 struct disabled_builtin
*next
;
3492 static disabled_builtin
*disabled_builtins
= NULL
;
3494 static bool builtin_function_disabled_p (const char *);
3496 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
3497 begins with "__builtin_", give an error. */
3500 disable_builtin_function (const char *name
)
3502 if (strncmp (name
, "__builtin_", strlen ("__builtin_")) == 0)
3503 error ("cannot disable built-in function %qs", name
);
3506 disabled_builtin
*new_disabled_builtin
= XNEW (disabled_builtin
);
3507 new_disabled_builtin
->name
= name
;
3508 new_disabled_builtin
->next
= disabled_builtins
;
3509 disabled_builtins
= new_disabled_builtin
;
3514 /* Return true if the built-in function NAME has been disabled, false
3518 builtin_function_disabled_p (const char *name
)
3520 disabled_builtin
*p
;
3521 for (p
= disabled_builtins
; p
!= NULL
; p
= p
->next
)
3523 if (strcmp (name
, p
->name
) == 0)
3530 /* Worker for DEF_BUILTIN.
3531 Possibly define a builtin function with one or two names.
3532 Does not declare a non-__builtin_ function if flag_no_builtin, or if
3533 nonansi_p and flag_no_nonansi_builtin. */
3536 def_builtin_1 (enum built_in_function fncode
,
3538 enum built_in_class fnclass
,
3539 tree fntype
, tree libtype
,
3540 bool both_p
, bool fallback_p
, bool nonansi_p
,
3541 tree fnattrs
, bool implicit_p
)
3544 const char *libname
;
3546 if (fntype
== error_mark_node
)
3549 gcc_assert ((!both_p
&& !fallback_p
)
3550 || !strncmp (name
, "__builtin_",
3551 strlen ("__builtin_")));
3553 libname
= name
+ strlen ("__builtin_");
3554 decl
= add_builtin_function (name
, fntype
, fncode
, fnclass
,
3555 (fallback_p
? libname
: NULL
),
3558 && !flag_no_builtin
&& !builtin_function_disabled_p (libname
)
3559 && !(nonansi_p
&& flag_no_nonansi_builtin
))
3560 add_builtin_function (libname
, libtype
, fncode
, fnclass
,
3563 built_in_decls
[(int) fncode
] = decl
;
3565 implicit_built_in_decls
[(int) fncode
] = decl
;
3568 /* Nonzero if the type T promotes to int. This is (nearly) the
3569 integral promotions defined in ISO C99 6.3.1.1/2. */
3572 c_promoting_integer_type_p (tree t
)
3574 switch (TREE_CODE (t
))
3577 return (TYPE_MAIN_VARIANT (t
) == char_type_node
3578 || TYPE_MAIN_VARIANT (t
) == signed_char_type_node
3579 || TYPE_MAIN_VARIANT (t
) == unsigned_char_type_node
3580 || TYPE_MAIN_VARIANT (t
) == short_integer_type_node
3581 || TYPE_MAIN_VARIANT (t
) == short_unsigned_type_node
3582 || TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
));
3585 /* ??? Technically all enumerations not larger than an int
3586 promote to an int. But this is used along code paths
3587 that only want to notice a size change. */
3588 return TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
);
3598 /* Return 1 if PARMS specifies a fixed number of parameters
3599 and none of their types is affected by default promotions. */
3602 self_promoting_args_p (tree parms
)
3605 for (t
= parms
; t
; t
= TREE_CHAIN (t
))
3607 tree type
= TREE_VALUE (t
);
3609 if (type
== error_mark_node
)
3612 if (TREE_CHAIN (t
) == 0 && type
!= void_type_node
)
3618 if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
3621 if (c_promoting_integer_type_p (type
))
3627 /* Recursively examines the array elements of TYPE, until a non-array
3628 element type is found. */
3631 strip_array_types (tree type
)
3633 while (TREE_CODE (type
) == ARRAY_TYPE
)
3634 type
= TREE_TYPE (type
);
3639 /* Recursively remove any '*' or '&' operator from TYPE. */
3641 strip_pointer_operator (tree t
)
3643 while (POINTER_TYPE_P (t
))
3648 /* Used to compare case labels. K1 and K2 are actually tree nodes
3649 representing case labels, or NULL_TREE for a `default' label.
3650 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3651 K2, and 0 if K1 and K2 are equal. */
3654 case_compare (splay_tree_key k1
, splay_tree_key k2
)
3656 /* Consider a NULL key (such as arises with a `default' label) to be
3657 smaller than anything else. */
3663 return tree_int_cst_compare ((tree
) k1
, (tree
) k2
);
3666 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
3667 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3668 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
3669 case label was declared using the usual C/C++ syntax, rather than
3670 the GNU case range extension. CASES is a tree containing all the
3671 case ranges processed so far; COND is the condition for the
3672 switch-statement itself. Returns the CASE_LABEL_EXPR created, or
3673 ERROR_MARK_NODE if no CASE_LABEL_EXPR is created. */
3676 c_add_case_label (splay_tree cases
, tree cond
, tree orig_type
,
3677 tree low_value
, tree high_value
)
3682 splay_tree_node node
;
3684 /* Create the LABEL_DECL itself. */
3685 label
= create_artificial_label ();
3687 /* If there was an error processing the switch condition, bail now
3688 before we get more confused. */
3689 if (!cond
|| cond
== error_mark_node
)
3692 if ((low_value
&& TREE_TYPE (low_value
)
3693 && POINTER_TYPE_P (TREE_TYPE (low_value
)))
3694 || (high_value
&& TREE_TYPE (high_value
)
3695 && POINTER_TYPE_P (TREE_TYPE (high_value
))))
3697 error ("pointers are not permitted as case values");
3701 /* Case ranges are a GNU extension. */
3702 if (high_value
&& pedantic
)
3703 pedwarn ("range expressions in switch statements are non-standard");
3705 type
= TREE_TYPE (cond
);
3708 low_value
= check_case_value (low_value
);
3709 low_value
= convert_and_check (type
, low_value
);
3710 if (low_value
== error_mark_node
)
3715 high_value
= check_case_value (high_value
);
3716 high_value
= convert_and_check (type
, high_value
);
3717 if (high_value
== error_mark_node
)
3721 if (low_value
&& high_value
)
3723 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
3724 really a case range, even though it was written that way.
3725 Remove the HIGH_VALUE to simplify later processing. */
3726 if (tree_int_cst_equal (low_value
, high_value
))
3727 high_value
= NULL_TREE
;
3728 else if (!tree_int_cst_lt (low_value
, high_value
))
3729 warning (0, "empty range specified");
3732 /* See if the case is in range of the type of the original testing
3733 expression. If both low_value and high_value are out of range,
3734 don't insert the case label and return NULL_TREE. */
3736 && !check_case_bounds (type
, orig_type
,
3737 &low_value
, high_value
? &high_value
: NULL
))
3740 /* Look up the LOW_VALUE in the table of case labels we already
3742 node
= splay_tree_lookup (cases
, (splay_tree_key
) low_value
);
3743 /* If there was not an exact match, check for overlapping ranges.
3744 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
3745 that's a `default' label and the only overlap is an exact match. */
3746 if (!node
&& (low_value
|| high_value
))
3748 splay_tree_node low_bound
;
3749 splay_tree_node high_bound
;
3751 /* Even though there wasn't an exact match, there might be an
3752 overlap between this case range and another case range.
3753 Since we've (inductively) not allowed any overlapping case
3754 ranges, we simply need to find the greatest low case label
3755 that is smaller that LOW_VALUE, and the smallest low case
3756 label that is greater than LOW_VALUE. If there is an overlap
3757 it will occur in one of these two ranges. */
3758 low_bound
= splay_tree_predecessor (cases
,
3759 (splay_tree_key
) low_value
);
3760 high_bound
= splay_tree_successor (cases
,
3761 (splay_tree_key
) low_value
);
3763 /* Check to see if the LOW_BOUND overlaps. It is smaller than
3764 the LOW_VALUE, so there is no need to check unless the
3765 LOW_BOUND is in fact itself a case range. */
3767 && CASE_HIGH ((tree
) low_bound
->value
)
3768 && tree_int_cst_compare (CASE_HIGH ((tree
) low_bound
->value
),
3771 /* Check to see if the HIGH_BOUND overlaps. The low end of that
3772 range is bigger than the low end of the current range, so we
3773 are only interested if the current range is a real range, and
3774 not an ordinary case label. */
3777 && (tree_int_cst_compare ((tree
) high_bound
->key
,
3782 /* If there was an overlap, issue an error. */
3785 tree duplicate
= CASE_LABEL ((tree
) node
->value
);
3789 error ("duplicate (or overlapping) case value");
3790 error ("%Jthis is the first entry overlapping that value", duplicate
);
3794 error ("duplicate case value") ;
3795 error ("%Jpreviously used here", duplicate
);
3799 error ("multiple default labels in one switch");
3800 error ("%Jthis is the first default label", duplicate
);
3805 /* Add a CASE_LABEL to the statement-tree. */
3806 case_label
= add_stmt (build_case_label (low_value
, high_value
, label
));
3807 /* Register this case label in the splay tree. */
3808 splay_tree_insert (cases
,
3809 (splay_tree_key
) low_value
,
3810 (splay_tree_value
) case_label
);
3815 /* Add a label so that the back-end doesn't think that the beginning of
3816 the switch is unreachable. Note that we do not add a case label, as
3817 that just leads to duplicates and thence to failure later on. */
3820 tree t
= create_artificial_label ();
3821 add_stmt (build_stmt (LABEL_EXPR
, t
));
3823 return error_mark_node
;
3826 /* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
3827 Used to verify that case values match up with enumerator values. */
3830 match_case_to_enum_1 (tree key
, tree type
, tree label
)
3832 char buf
[2 + 2*HOST_BITS_PER_WIDE_INT
/4 + 1];
3834 /* ??? Not working too hard to print the double-word value.
3835 Should perhaps be done with %lwd in the diagnostic routines? */
3836 if (TREE_INT_CST_HIGH (key
) == 0)
3837 snprintf (buf
, sizeof (buf
), HOST_WIDE_INT_PRINT_UNSIGNED
,
3838 TREE_INT_CST_LOW (key
));
3839 else if (!TYPE_UNSIGNED (type
)
3840 && TREE_INT_CST_HIGH (key
) == -1
3841 && TREE_INT_CST_LOW (key
) != 0)
3842 snprintf (buf
, sizeof (buf
), "-" HOST_WIDE_INT_PRINT_UNSIGNED
,
3843 -TREE_INT_CST_LOW (key
));
3845 snprintf (buf
, sizeof (buf
), HOST_WIDE_INT_PRINT_DOUBLE_HEX
,
3846 TREE_INT_CST_HIGH (key
), TREE_INT_CST_LOW (key
));
3848 if (TYPE_NAME (type
) == 0)
3849 warning (0, "%Jcase value %qs not in enumerated type",
3850 CASE_LABEL (label
), buf
);
3852 warning (0, "%Jcase value %qs not in enumerated type %qT",
3853 CASE_LABEL (label
), buf
, type
);
3856 /* Subroutine of c_do_switch_warnings, called via splay_tree_foreach.
3857 Used to verify that case values match up with enumerator values. */
3860 match_case_to_enum (splay_tree_node node
, void *data
)
3862 tree label
= (tree
) node
->value
;
3863 tree type
= (tree
) data
;
3865 /* Skip default case. */
3866 if (!CASE_LOW (label
))
3869 /* If CASE_LOW_SEEN is not set, that means CASE_LOW did not appear
3870 when we did our enum->case scan. Reset our scratch bit after. */
3871 if (!CASE_LOW_SEEN (label
))
3872 match_case_to_enum_1 (CASE_LOW (label
), type
, label
);
3874 CASE_LOW_SEEN (label
) = 0;
3876 /* If CASE_HIGH is non-null, we have a range. If CASE_HIGH_SEEN is
3877 not set, that means that CASE_HIGH did not appear when we did our
3878 enum->case scan. Reset our scratch bit after. */
3879 if (CASE_HIGH (label
))
3881 if (!CASE_HIGH_SEEN (label
))
3882 match_case_to_enum_1 (CASE_HIGH (label
), type
, label
);
3884 CASE_HIGH_SEEN (label
) = 0;
3890 /* Handle -Wswitch*. Called from the front end after parsing the
3891 switch construct. */
3892 /* ??? Should probably be somewhere generic, since other languages
3893 besides C and C++ would want this. At the moment, however, C/C++
3894 are the only tree-ssa languages that support enumerations at all,
3895 so the point is moot. */
3898 c_do_switch_warnings (splay_tree cases
, location_t switch_location
,
3899 tree type
, tree cond
)
3901 splay_tree_node default_node
;
3902 splay_tree_node node
;
3905 if (!warn_switch
&& !warn_switch_enum
&& !warn_switch_default
)
3908 default_node
= splay_tree_lookup (cases
, (splay_tree_key
) NULL
);
3910 warning (OPT_Wswitch_default
, "%Hswitch missing default case",
3913 /* From here on, we only care about about enumerated types. */
3914 if (!type
|| TREE_CODE (type
) != ENUMERAL_TYPE
)
3917 /* If the switch expression was an enumerated type, check that
3918 exactly all enumeration literals are covered by the cases.
3919 The check is made when -Wswitch was specified and there is no
3920 default case, or when -Wswitch-enum was specified. */
3922 if (!warn_switch_enum
3923 && !(warn_switch
&& !default_node
))
3926 /* Clearing COND if it is not an integer constant simplifies
3927 the tests inside the loop below. */
3928 if (TREE_CODE (cond
) != INTEGER_CST
)
3931 /* The time complexity here is O(N*lg(N)) worst case, but for the
3932 common case of monotonically increasing enumerators, it is
3933 O(N), since the nature of the splay tree will keep the next
3934 element adjacent to the root at all times. */
3936 for (chain
= TYPE_VALUES (type
); chain
; chain
= TREE_CHAIN (chain
))
3938 tree value
= TREE_VALUE (chain
);
3939 node
= splay_tree_lookup (cases
, (splay_tree_key
) value
);
3942 /* Mark the CASE_LOW part of the case entry as seen. */
3943 tree label
= (tree
) node
->value
;
3944 CASE_LOW_SEEN (label
) = 1;
3948 /* Even though there wasn't an exact match, there might be a
3949 case range which includes the enumator's value. */
3950 node
= splay_tree_predecessor (cases
, (splay_tree_key
) value
);
3951 if (node
&& CASE_HIGH ((tree
) node
->value
))
3953 tree label
= (tree
) node
->value
;
3954 int cmp
= tree_int_cst_compare (CASE_HIGH (label
), value
);
3957 /* If we match the upper bound exactly, mark the CASE_HIGH
3958 part of the case entry as seen. */
3960 CASE_HIGH_SEEN (label
) = 1;
3965 /* We've now determined that this enumerated literal isn't
3966 handled by the case labels of the switch statement. */
3968 /* If the switch expression is a constant, we only really care
3969 about whether that constant is handled by the switch. */
3970 if (cond
&& tree_int_cst_compare (cond
, value
))
3973 warning (0, "%Henumeration value %qE not handled in switch",
3974 &switch_location
, TREE_PURPOSE (chain
));
3977 /* Warn if there are case expressions that don't correspond to
3978 enumerators. This can occur since C and C++ don't enforce
3979 type-checking of assignments to enumeration variables.
3981 The time complexity here is now always O(N) worst case, since
3982 we should have marked both the lower bound and upper bound of
3983 every disjoint case label, with CASE_LOW_SEEN and CASE_HIGH_SEEN
3984 above. This scan also resets those fields. */
3985 splay_tree_foreach (cases
, match_case_to_enum
, type
);
3988 /* Finish an expression taking the address of LABEL (an
3989 IDENTIFIER_NODE). Returns an expression for the address. */
3992 finish_label_address_expr (tree label
)
3997 pedwarn ("taking the address of a label is non-standard");
3999 if (label
== error_mark_node
)
4000 return error_mark_node
;
4002 label
= lookup_label (label
);
4003 if (label
== NULL_TREE
)
4004 result
= null_pointer_node
;
4007 TREE_USED (label
) = 1;
4008 result
= build1 (ADDR_EXPR
, ptr_type_node
, label
);
4009 /* The current function in not necessarily uninlinable.
4010 Computed gotos are incompatible with inlining, but the value
4011 here could be used only in a diagnostic, for example. */
4017 /* Hook used by expand_expr to expand language-specific tree codes. */
4018 /* The only things that should go here are bits needed to expand
4019 constant initializers. Everything else should be handled by the
4020 gimplification routines. */
4023 c_expand_expr (tree exp
, rtx target
, enum machine_mode tmode
,
4024 int modifier
/* Actually enum_modifier. */,
4027 switch (TREE_CODE (exp
))
4029 case COMPOUND_LITERAL_EXPR
:
4031 /* Initialize the anonymous variable declared in the compound
4032 literal, then return the variable. */
4033 tree decl
= COMPOUND_LITERAL_EXPR_DECL (exp
);
4034 emit_local_var (decl
);
4035 return expand_expr_real (decl
, target
, tmode
, modifier
, alt_rtl
);
4043 /* Hook used by staticp to handle language-specific tree codes. */
4046 c_staticp (tree exp
)
4048 return (TREE_CODE (exp
) == COMPOUND_LITERAL_EXPR
4049 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp
))
4054 /* Given a boolean expression ARG, return a tree representing an increment
4055 or decrement (as indicated by CODE) of ARG. The front end must check for
4056 invalid cases (e.g., decrement in C++). */
4058 boolean_increment (enum tree_code code
, tree arg
)
4061 tree true_res
= boolean_true_node
;
4063 arg
= stabilize_reference (arg
);
4066 case PREINCREMENT_EXPR
:
4067 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
4069 case POSTINCREMENT_EXPR
:
4070 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
4071 arg
= save_expr (arg
);
4072 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
4073 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
4075 case PREDECREMENT_EXPR
:
4076 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
,
4077 invert_truthvalue (arg
));
4079 case POSTDECREMENT_EXPR
:
4080 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
,
4081 invert_truthvalue (arg
));
4082 arg
= save_expr (arg
);
4083 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
4084 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
4089 TREE_SIDE_EFFECTS (val
) = 1;
4093 /* Built-in macros for stddef.h, that require macros defined in this
4096 c_stddef_cpp_builtins(void)
4098 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE
, 0);
4099 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE
, 0);
4100 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE
, 0);
4101 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE
, 0);
4102 builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE
, 0);
4103 builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE
, 0);
4107 c_init_attributes (void)
4109 /* Fill in the built_in_attributes array. */
4110 #define DEF_ATTR_NULL_TREE(ENUM) \
4111 built_in_attributes[(int) ENUM] = NULL_TREE;
4112 #define DEF_ATTR_INT(ENUM, VALUE) \
4113 built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
4114 #define DEF_ATTR_IDENT(ENUM, STRING) \
4115 built_in_attributes[(int) ENUM] = get_identifier (STRING);
4116 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
4117 built_in_attributes[(int) ENUM] \
4118 = tree_cons (built_in_attributes[(int) PURPOSE], \
4119 built_in_attributes[(int) VALUE], \
4120 built_in_attributes[(int) CHAIN]);
4121 #include "builtin-attrs.def"
4122 #undef DEF_ATTR_NULL_TREE
4124 #undef DEF_ATTR_IDENT
4125 #undef DEF_ATTR_TREE_LIST
4128 /* Attribute handlers common to C front ends. */
4130 /* Handle a "packed" attribute; arguments as in
4131 struct attribute_spec.handler. */
4134 handle_packed_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
4135 int flags
, bool *no_add_attrs
)
4139 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
4140 *node
= build_variant_type_copy (*node
);
4141 TYPE_PACKED (*node
) = 1;
4143 else if (TREE_CODE (*node
) == FIELD_DECL
)
4145 if (TYPE_ALIGN (TREE_TYPE (*node
)) <= BITS_PER_UNIT
)
4146 warning (OPT_Wattributes
,
4147 "%qE attribute ignored for field of type %qT",
4148 name
, TREE_TYPE (*node
));
4150 DECL_PACKED (*node
) = 1;
4152 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
4153 used for DECL_REGISTER. It wouldn't mean anything anyway.
4154 We can't set DECL_PACKED on the type of a TYPE_DECL, because
4155 that changes what the typedef is typing. */
4158 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4159 *no_add_attrs
= true;
4165 /* Handle a "nocommon" attribute; arguments as in
4166 struct attribute_spec.handler. */
4169 handle_nocommon_attribute (tree
*node
, tree name
,
4170 tree
ARG_UNUSED (args
),
4171 int ARG_UNUSED (flags
), bool *no_add_attrs
)
4173 if (TREE_CODE (*node
) == VAR_DECL
)
4174 DECL_COMMON (*node
) = 0;
4177 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4178 *no_add_attrs
= true;
4184 /* Handle a "common" attribute; arguments as in
4185 struct attribute_spec.handler. */
4188 handle_common_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
4189 int ARG_UNUSED (flags
), bool *no_add_attrs
)
4191 if (TREE_CODE (*node
) == VAR_DECL
)
4192 DECL_COMMON (*node
) = 1;
4195 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4196 *no_add_attrs
= true;
4202 /* Handle a "noreturn" attribute; arguments as in
4203 struct attribute_spec.handler. */
4206 handle_noreturn_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
4207 int ARG_UNUSED (flags
), bool *no_add_attrs
)
4209 tree type
= TREE_TYPE (*node
);
4211 /* See FIXME comment in c_common_attribute_table. */
4212 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4213 TREE_THIS_VOLATILE (*node
) = 1;
4214 else if (TREE_CODE (type
) == POINTER_TYPE
4215 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
4217 = build_pointer_type
4218 (build_type_variant (TREE_TYPE (type
),
4219 TYPE_READONLY (TREE_TYPE (type
)), 1));
4222 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4223 *no_add_attrs
= true;
4229 /* Handle a "noinline" attribute; arguments as in
4230 struct attribute_spec.handler. */
4233 handle_noinline_attribute (tree
*node
, tree name
,
4234 tree
ARG_UNUSED (args
),
4235 int ARG_UNUSED (flags
), bool *no_add_attrs
)
4237 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4238 DECL_UNINLINABLE (*node
) = 1;
4241 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4242 *no_add_attrs
= true;
4248 /* Handle a "always_inline" attribute; arguments as in
4249 struct attribute_spec.handler. */
4252 handle_always_inline_attribute (tree
*node
, tree name
,
4253 tree
ARG_UNUSED (args
),
4254 int ARG_UNUSED (flags
),
4257 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4259 /* Do nothing else, just set the attribute. We'll get at
4260 it later with lookup_attribute. */
4264 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4265 *no_add_attrs
= true;
4271 /* Handle a "flatten" attribute; arguments as in
4272 struct attribute_spec.handler. */
4275 handle_flatten_attribute (tree
*node
, tree name
,
4276 tree args ATTRIBUTE_UNUSED
,
4277 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
4279 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4280 /* Do nothing else, just set the attribute. We'll get at
4281 it later with lookup_attribute. */
4285 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4286 *no_add_attrs
= true;
4293 /* Handle a "used" attribute; arguments as in
4294 struct attribute_spec.handler. */
4297 handle_used_attribute (tree
*pnode
, tree name
, tree
ARG_UNUSED (args
),
4298 int ARG_UNUSED (flags
), bool *no_add_attrs
)
4302 if (TREE_CODE (node
) == FUNCTION_DECL
4303 || (TREE_CODE (node
) == VAR_DECL
&& TREE_STATIC (node
)))
4305 TREE_USED (node
) = 1;
4306 DECL_PRESERVE_P (node
) = 1;
4310 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4311 *no_add_attrs
= true;
4317 /* Handle a "unused" attribute; arguments as in
4318 struct attribute_spec.handler. */
4321 handle_unused_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
4322 int flags
, bool *no_add_attrs
)
4328 if (TREE_CODE (decl
) == PARM_DECL
4329 || TREE_CODE (decl
) == VAR_DECL
4330 || TREE_CODE (decl
) == FUNCTION_DECL
4331 || TREE_CODE (decl
) == LABEL_DECL
4332 || TREE_CODE (decl
) == TYPE_DECL
)
4333 TREE_USED (decl
) = 1;
4336 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4337 *no_add_attrs
= true;
4342 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
4343 *node
= build_variant_type_copy (*node
);
4344 TREE_USED (*node
) = 1;
4350 /* Handle a "externally_visible" attribute; arguments as in
4351 struct attribute_spec.handler. */
4354 handle_externally_visible_attribute (tree
*pnode
, tree name
,
4355 tree
ARG_UNUSED (args
),
4356 int ARG_UNUSED (flags
),
4361 if (TREE_CODE (node
) == FUNCTION_DECL
|| TREE_CODE (node
) == VAR_DECL
)
4363 if ((!TREE_STATIC (node
) && TREE_CODE (node
) != FUNCTION_DECL
4364 && !DECL_EXTERNAL (node
)) || !TREE_PUBLIC (node
))
4366 warning (OPT_Wattributes
,
4367 "%qE attribute have effect only on public objects", name
);
4368 *no_add_attrs
= true;
4373 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4374 *no_add_attrs
= true;
4380 /* Handle a "const" attribute; arguments as in
4381 struct attribute_spec.handler. */
4384 handle_const_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
4385 int ARG_UNUSED (flags
), bool *no_add_attrs
)
4387 tree type
= TREE_TYPE (*node
);
4389 /* See FIXME comment on noreturn in c_common_attribute_table. */
4390 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4391 TREE_READONLY (*node
) = 1;
4392 else if (TREE_CODE (type
) == POINTER_TYPE
4393 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
4395 = build_pointer_type
4396 (build_type_variant (TREE_TYPE (type
), 1,
4397 TREE_THIS_VOLATILE (TREE_TYPE (type
))));
4400 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4401 *no_add_attrs
= true;
4407 /* Handle a "transparent_union" attribute; arguments as in
4408 struct attribute_spec.handler. */
4411 handle_transparent_union_attribute (tree
*node
, tree name
,
4412 tree
ARG_UNUSED (args
), int flags
,
4417 *no_add_attrs
= true;
4421 if (TREE_CODE (*node
) != TYPE_DECL
)
4423 node
= &TREE_TYPE (*node
);
4426 else if (TYPE_P (*node
))
4431 if (TREE_CODE (type
) == UNION_TYPE
)
4433 /* When IN_PLACE is set, leave the check for FIELDS and MODE to
4434 the code in finish_struct. */
4435 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
4437 if (TYPE_FIELDS (type
) == NULL_TREE
4438 || TYPE_MODE (type
) != DECL_MODE (TYPE_FIELDS (type
)))
4441 /* A type variant isn't good enough, since we don't a cast
4442 to such a type removed as a no-op. */
4443 *node
= type
= build_duplicate_type (type
);
4446 TYPE_TRANSPARENT_UNION (type
) = 1;
4451 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4455 /* Handle a "constructor" attribute; arguments as in
4456 struct attribute_spec.handler. */
4459 handle_constructor_attribute (tree
*node
, tree name
,
4460 tree
ARG_UNUSED (args
),
4461 int ARG_UNUSED (flags
),
4465 tree type
= TREE_TYPE (decl
);
4467 if (TREE_CODE (decl
) == FUNCTION_DECL
4468 && TREE_CODE (type
) == FUNCTION_TYPE
4469 && decl_function_context (decl
) == 0)
4471 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
4472 TREE_USED (decl
) = 1;
4476 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4477 *no_add_attrs
= true;
4483 /* Handle a "destructor" attribute; arguments as in
4484 struct attribute_spec.handler. */
4487 handle_destructor_attribute (tree
*node
, tree name
,
4488 tree
ARG_UNUSED (args
),
4489 int ARG_UNUSED (flags
),
4493 tree type
= TREE_TYPE (decl
);
4495 if (TREE_CODE (decl
) == FUNCTION_DECL
4496 && TREE_CODE (type
) == FUNCTION_TYPE
4497 && decl_function_context (decl
) == 0)
4499 DECL_STATIC_DESTRUCTOR (decl
) = 1;
4500 TREE_USED (decl
) = 1;
4504 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4505 *no_add_attrs
= true;
4511 /* Handle a "mode" attribute; arguments as in
4512 struct attribute_spec.handler. */
4515 handle_mode_attribute (tree
*node
, tree name
, tree args
,
4516 int ARG_UNUSED (flags
), bool *no_add_attrs
)
4520 *no_add_attrs
= true;
4522 if (TREE_CODE (TREE_VALUE (args
)) != IDENTIFIER_NODE
)
4523 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4527 const char *p
= IDENTIFIER_POINTER (TREE_VALUE (args
));
4528 int len
= strlen (p
);
4529 enum machine_mode mode
= VOIDmode
;
4533 if (len
> 4 && p
[0] == '_' && p
[1] == '_'
4534 && p
[len
- 1] == '_' && p
[len
- 2] == '_')
4536 char *newp
= (char *) alloca (len
- 1);
4538 strcpy (newp
, &p
[2]);
4539 newp
[len
- 4] = '\0';
4543 /* Change this type to have a type with the specified mode.
4544 First check for the special modes. */
4545 if (!strcmp (p
, "byte"))
4547 else if (!strcmp (p
, "word"))
4549 else if (!strcmp (p
, "pointer"))
4552 for (j
= 0; j
< NUM_MACHINE_MODES
; j
++)
4553 if (!strcmp (p
, GET_MODE_NAME (j
)))
4555 mode
= (enum machine_mode
) j
;
4559 if (mode
== VOIDmode
)
4561 error ("unknown machine mode %qs", p
);
4566 switch (GET_MODE_CLASS (mode
))
4569 case MODE_PARTIAL_INT
:
4571 case MODE_DECIMAL_FLOAT
:
4572 valid_mode
= targetm
.scalar_mode_supported_p (mode
);
4575 case MODE_COMPLEX_INT
:
4576 case MODE_COMPLEX_FLOAT
:
4577 valid_mode
= targetm
.scalar_mode_supported_p (GET_MODE_INNER (mode
));
4580 case MODE_VECTOR_INT
:
4581 case MODE_VECTOR_FLOAT
:
4582 warning (OPT_Wattributes
, "specifying vector types with "
4583 "__attribute__ ((mode)) is deprecated");
4584 warning (OPT_Wattributes
,
4585 "use __attribute__ ((vector_size)) instead");
4586 valid_mode
= vector_mode_valid_p (mode
);
4594 error ("unable to emulate %qs", p
);
4598 if (POINTER_TYPE_P (type
))
4600 tree (*fn
)(tree
, enum machine_mode
, bool);
4602 if (!targetm
.valid_pointer_mode (mode
))
4604 error ("invalid pointer mode %qs", p
);
4608 if (TREE_CODE (type
) == POINTER_TYPE
)
4609 fn
= build_pointer_type_for_mode
;
4611 fn
= build_reference_type_for_mode
;
4612 typefm
= fn (TREE_TYPE (type
), mode
, false);
4615 typefm
= lang_hooks
.types
.type_for_mode (mode
, TYPE_UNSIGNED (type
));
4617 if (typefm
== NULL_TREE
)
4619 error ("no data type for mode %qs", p
);
4622 else if (TREE_CODE (type
) == ENUMERAL_TYPE
)
4624 /* For enumeral types, copy the precision from the integer
4625 type returned above. If not an INTEGER_TYPE, we can't use
4626 this mode for this type. */
4627 if (TREE_CODE (typefm
) != INTEGER_TYPE
)
4629 error ("cannot use mode %qs for enumeral types", p
);
4633 if (flags
& ATTR_FLAG_TYPE_IN_PLACE
)
4635 TYPE_PRECISION (type
) = TYPE_PRECISION (typefm
);
4640 /* We cannot build a type variant, as there's code that assumes
4641 that TYPE_MAIN_VARIANT has the same mode. This includes the
4642 debug generators. Instead, create a subrange type. This
4643 results in all of the enumeral values being emitted only once
4644 in the original, and the subtype gets them by reference. */
4645 if (TYPE_UNSIGNED (type
))
4646 typefm
= make_unsigned_type (TYPE_PRECISION (typefm
));
4648 typefm
= make_signed_type (TYPE_PRECISION (typefm
));
4649 TREE_TYPE (typefm
) = type
;
4652 else if (VECTOR_MODE_P (mode
)
4653 ? TREE_CODE (type
) != TREE_CODE (TREE_TYPE (typefm
))
4654 : TREE_CODE (type
) != TREE_CODE (typefm
))
4656 error ("mode %qs applied to inappropriate type", p
);
4666 /* Handle a "section" attribute; arguments as in
4667 struct attribute_spec.handler. */
4670 handle_section_attribute (tree
*node
, tree
ARG_UNUSED (name
), tree args
,
4671 int ARG_UNUSED (flags
), bool *no_add_attrs
)
4675 if (targetm
.have_named_sections
)
4677 user_defined_section_attribute
= true;
4679 if ((TREE_CODE (decl
) == FUNCTION_DECL
4680 || TREE_CODE (decl
) == VAR_DECL
)
4681 && TREE_CODE (TREE_VALUE (args
)) == STRING_CST
)
4683 if (TREE_CODE (decl
) == VAR_DECL
4684 && current_function_decl
!= NULL_TREE
4685 && !TREE_STATIC (decl
))
4687 error ("%Jsection attribute cannot be specified for "
4688 "local variables", decl
);
4689 *no_add_attrs
= true;
4692 /* The decl may have already been given a section attribute
4693 from a previous declaration. Ensure they match. */
4694 else if (DECL_SECTION_NAME (decl
) != NULL_TREE
4695 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl
)),
4696 TREE_STRING_POINTER (TREE_VALUE (args
))) != 0)
4698 error ("section of %q+D conflicts with previous declaration",
4700 *no_add_attrs
= true;
4703 DECL_SECTION_NAME (decl
) = TREE_VALUE (args
);
4707 error ("section attribute not allowed for %q+D", *node
);
4708 *no_add_attrs
= true;
4713 error ("%Jsection attributes are not supported for this target", *node
);
4714 *no_add_attrs
= true;
4720 /* Handle a "aligned" attribute; arguments as in
4721 struct attribute_spec.handler. */
4724 handle_aligned_attribute (tree
*node
, tree
ARG_UNUSED (name
), tree args
,
4725 int flags
, bool *no_add_attrs
)
4727 tree decl
= NULL_TREE
;
4730 tree align_expr
= (args
? TREE_VALUE (args
)
4731 : size_int (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
));
4737 type
= &TREE_TYPE (decl
);
4738 is_type
= TREE_CODE (*node
) == TYPE_DECL
;
4740 else if (TYPE_P (*node
))
4741 type
= node
, is_type
= 1;
4743 if (TREE_CODE (align_expr
) != INTEGER_CST
)
4745 error ("requested alignment is not a constant");
4746 *no_add_attrs
= true;
4748 else if ((i
= tree_log2 (align_expr
)) == -1)
4750 error ("requested alignment is not a power of 2");
4751 *no_add_attrs
= true;
4753 else if (i
> HOST_BITS_PER_INT
- 2)
4755 error ("requested alignment is too large");
4756 *no_add_attrs
= true;
4760 /* If we have a TYPE_DECL, then copy the type, so that we
4761 don't accidentally modify a builtin type. See pushdecl. */
4762 if (decl
&& TREE_TYPE (decl
) != error_mark_node
4763 && DECL_ORIGINAL_TYPE (decl
) == NULL_TREE
)
4765 tree tt
= TREE_TYPE (decl
);
4766 *type
= build_variant_type_copy (*type
);
4767 DECL_ORIGINAL_TYPE (decl
) = tt
;
4768 TYPE_NAME (*type
) = decl
;
4769 TREE_USED (*type
) = TREE_USED (decl
);
4770 TREE_TYPE (decl
) = *type
;
4772 else if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
4773 *type
= build_variant_type_copy (*type
);
4775 TYPE_ALIGN (*type
) = (1 << i
) * BITS_PER_UNIT
;
4776 TYPE_USER_ALIGN (*type
) = 1;
4778 else if (TREE_CODE (decl
) != VAR_DECL
4779 && TREE_CODE (decl
) != FIELD_DECL
)
4781 error ("alignment may not be specified for %q+D", decl
);
4782 *no_add_attrs
= true;
4786 DECL_ALIGN (decl
) = (1 << i
) * BITS_PER_UNIT
;
4787 DECL_USER_ALIGN (decl
) = 1;
4793 /* Handle a "weak" attribute; arguments as in
4794 struct attribute_spec.handler. */
4797 handle_weak_attribute (tree
*node
, tree name
,
4798 tree
ARG_UNUSED (args
),
4799 int ARG_UNUSED (flags
),
4800 bool * ARG_UNUSED (no_add_attrs
))
4802 if (TREE_CODE (*node
) == FUNCTION_DECL
4803 || TREE_CODE (*node
) == VAR_DECL
)
4804 declare_weak (*node
);
4806 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4812 /* Handle an "alias" attribute; arguments as in
4813 struct attribute_spec.handler. */
4816 handle_alias_attribute (tree
*node
, tree name
, tree args
,
4817 int ARG_UNUSED (flags
), bool *no_add_attrs
)
4821 if ((TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_INITIAL (decl
))
4822 || (TREE_CODE (decl
) != FUNCTION_DECL
4823 && TREE_PUBLIC (decl
) && !DECL_EXTERNAL (decl
))
4824 /* A static variable declaration is always a tentative definition,
4825 but the alias is a non-tentative definition which overrides. */
4826 || (TREE_CODE (decl
) != FUNCTION_DECL
4827 && ! TREE_PUBLIC (decl
) && DECL_INITIAL (decl
)))
4829 error ("%q+D defined both normally and as an alias", decl
);
4830 *no_add_attrs
= true;
4833 /* Note that the very first time we process a nested declaration,
4834 decl_function_context will not be set. Indeed, *would* never
4835 be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
4836 we do below. After such frobbery, pushdecl would set the context.
4837 In any case, this is never what we want. */
4838 else if (decl_function_context (decl
) == 0 && current_function_decl
== NULL
)
4842 id
= TREE_VALUE (args
);
4843 if (TREE_CODE (id
) != STRING_CST
)
4845 error ("alias argument not a string");
4846 *no_add_attrs
= true;
4849 id
= get_identifier (TREE_STRING_POINTER (id
));
4850 /* This counts as a use of the object pointed to. */
4853 if (TREE_CODE (decl
) == FUNCTION_DECL
)
4854 DECL_INITIAL (decl
) = error_mark_node
;
4857 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
)))
4858 DECL_EXTERNAL (decl
) = 1;
4860 DECL_EXTERNAL (decl
) = 0;
4861 TREE_STATIC (decl
) = 1;
4866 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4867 *no_add_attrs
= true;
4873 /* Handle a "weakref" attribute; arguments as in struct
4874 attribute_spec.handler. */
4877 handle_weakref_attribute (tree
*node
, tree
ARG_UNUSED (name
), tree args
,
4878 int flags
, bool *no_add_attrs
)
4880 tree attr
= NULL_TREE
;
4882 /* We must ignore the attribute when it is associated with
4883 local-scoped decls, since attribute alias is ignored and many
4884 such symbols do not even have a DECL_WEAK field. */
4885 if (decl_function_context (*node
) || current_function_decl
)
4887 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4888 *no_add_attrs
= true;
4892 /* The idea here is that `weakref("name")' mutates into `weakref,
4893 alias("name")', and weakref without arguments, in turn,
4894 implicitly adds weak. */
4898 attr
= tree_cons (get_identifier ("alias"), args
, attr
);
4899 attr
= tree_cons (get_identifier ("weakref"), NULL_TREE
, attr
);
4901 *no_add_attrs
= true;
4903 decl_attributes (node
, attr
, flags
);
4907 if (lookup_attribute ("alias", DECL_ATTRIBUTES (*node
)))
4908 error ("%Jweakref attribute must appear before alias attribute",
4911 /* Can't call declare_weak because it wants this to be TREE_PUBLIC,
4912 and that isn't supported; and because it wants to add it to
4913 the list of weak decls, which isn't helpful. */
4914 DECL_WEAK (*node
) = 1;
4920 /* Handle an "visibility" attribute; arguments as in
4921 struct attribute_spec.handler. */
4924 handle_visibility_attribute (tree
*node
, tree name
, tree args
,
4925 int ARG_UNUSED (flags
),
4926 bool *ARG_UNUSED (no_add_attrs
))
4929 tree id
= TREE_VALUE (args
);
4930 enum symbol_visibility vis
;
4934 if (TREE_CODE (*node
) == ENUMERAL_TYPE
)
4936 else if (TREE_CODE (*node
) != RECORD_TYPE
&& TREE_CODE (*node
) != UNION_TYPE
)
4938 warning (OPT_Wattributes
, "%qE attribute ignored on non-class types",
4942 else if (TYPE_FIELDS (*node
))
4944 error ("%qE attribute ignored because %qT is already defined",
4949 else if (decl_function_context (decl
) != 0 || !TREE_PUBLIC (decl
))
4951 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
4955 if (TREE_CODE (id
) != STRING_CST
)
4957 error ("visibility argument not a string");
4961 /* If this is a type, set the visibility on the type decl. */
4964 decl
= TYPE_NAME (decl
);
4967 if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
4969 warning (OPT_Wattributes
, "%qE attribute ignored on types",
4975 if (strcmp (TREE_STRING_POINTER (id
), "default") == 0)
4976 vis
= VISIBILITY_DEFAULT
;
4977 else if (strcmp (TREE_STRING_POINTER (id
), "internal") == 0)
4978 vis
= VISIBILITY_INTERNAL
;
4979 else if (strcmp (TREE_STRING_POINTER (id
), "hidden") == 0)
4980 vis
= VISIBILITY_HIDDEN
;
4981 else if (strcmp (TREE_STRING_POINTER (id
), "protected") == 0)
4982 vis
= VISIBILITY_PROTECTED
;
4985 error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
4986 vis
= VISIBILITY_DEFAULT
;
4989 if (DECL_VISIBILITY_SPECIFIED (decl
)
4990 && vis
!= DECL_VISIBILITY (decl
)
4991 && lookup_attribute ("visibility", (TYPE_P (*node
)
4992 ? TYPE_ATTRIBUTES (*node
)
4993 : DECL_ATTRIBUTES (decl
))))
4994 error ("%qD redeclared with different visibility", decl
);
4996 DECL_VISIBILITY (decl
) = vis
;
4997 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
4999 /* Go ahead and attach the attribute to the node as well. This is needed
5000 so we can determine whether we have VISIBILITY_DEFAULT because the
5001 visibility was not specified, or because it was explicitly overridden
5002 from the containing scope. */
5007 /* Determine the ELF symbol visibility for DECL, which is either a
5008 variable or a function. It is an error to use this function if a
5009 definition of DECL is not available in this translation unit.
5010 Returns true if the final visibility has been determined by this
5011 function; false if the caller is free to make additional
5015 c_determine_visibility (tree decl
)
5017 gcc_assert (TREE_CODE (decl
) == VAR_DECL
5018 || TREE_CODE (decl
) == FUNCTION_DECL
);
5020 /* If the user explicitly specified the visibility with an
5021 attribute, honor that. DECL_VISIBILITY will have been set during
5022 the processing of the attribute. We check for an explicit
5023 attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
5024 to distinguish the use of an attribute from the use of a "#pragma
5025 GCC visibility push(...)"; in the latter case we still want other
5026 considerations to be able to overrule the #pragma. */
5027 if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl
)))
5030 /* Anything that is exported must have default visibility. */
5031 if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
5032 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl
)))
5034 DECL_VISIBILITY (decl
) = VISIBILITY_DEFAULT
;
5035 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
5039 /* Set default visibility to whatever the user supplied with
5040 visibility_specified depending on #pragma GCC visibility. */
5041 if (!DECL_VISIBILITY_SPECIFIED (decl
))
5043 DECL_VISIBILITY (decl
) = default_visibility
;
5044 DECL_VISIBILITY_SPECIFIED (decl
) = visibility_options
.inpragma
;
5049 /* Handle an "tls_model" attribute; arguments as in
5050 struct attribute_spec.handler. */
5053 handle_tls_model_attribute (tree
*node
, tree name
, tree args
,
5054 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5058 enum tls_model kind
;
5060 *no_add_attrs
= true;
5062 if (!DECL_THREAD_LOCAL_P (decl
))
5064 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5068 kind
= DECL_TLS_MODEL (decl
);
5069 id
= TREE_VALUE (args
);
5070 if (TREE_CODE (id
) != STRING_CST
)
5072 error ("tls_model argument not a string");
5076 if (!strcmp (TREE_STRING_POINTER (id
), "local-exec"))
5077 kind
= TLS_MODEL_LOCAL_EXEC
;
5078 else if (!strcmp (TREE_STRING_POINTER (id
), "initial-exec"))
5079 kind
= TLS_MODEL_INITIAL_EXEC
;
5080 else if (!strcmp (TREE_STRING_POINTER (id
), "local-dynamic"))
5081 kind
= optimize
? TLS_MODEL_LOCAL_DYNAMIC
: TLS_MODEL_GLOBAL_DYNAMIC
;
5082 else if (!strcmp (TREE_STRING_POINTER (id
), "global-dynamic"))
5083 kind
= TLS_MODEL_GLOBAL_DYNAMIC
;
5085 error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
5087 DECL_TLS_MODEL (decl
) = kind
;
5091 /* Handle a "no_instrument_function" attribute; arguments as in
5092 struct attribute_spec.handler. */
5095 handle_no_instrument_function_attribute (tree
*node
, tree name
,
5096 tree
ARG_UNUSED (args
),
5097 int ARG_UNUSED (flags
),
5102 if (TREE_CODE (decl
) != FUNCTION_DECL
)
5104 error ("%J%qE attribute applies only to functions", decl
, name
);
5105 *no_add_attrs
= true;
5107 else if (DECL_INITIAL (decl
))
5109 error ("%Jcan%'t set %qE attribute after definition", decl
, name
);
5110 *no_add_attrs
= true;
5113 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl
) = 1;
5118 /* Handle a "malloc" attribute; arguments as in
5119 struct attribute_spec.handler. */
5122 handle_malloc_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5123 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5125 if (TREE_CODE (*node
) == FUNCTION_DECL
5126 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node
))))
5127 DECL_IS_MALLOC (*node
) = 1;
5130 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5131 *no_add_attrs
= true;
5137 /* Handle a "returns_twice" attribute; arguments as in
5138 struct attribute_spec.handler. */
5141 handle_returns_twice_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5142 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5144 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5145 DECL_IS_RETURNS_TWICE (*node
) = 1;
5148 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5149 *no_add_attrs
= true;
5155 /* Handle a "no_limit_stack" attribute; arguments as in
5156 struct attribute_spec.handler. */
5159 handle_no_limit_stack_attribute (tree
*node
, tree name
,
5160 tree
ARG_UNUSED (args
),
5161 int ARG_UNUSED (flags
),
5166 if (TREE_CODE (decl
) != FUNCTION_DECL
)
5168 error ("%J%qE attribute applies only to functions", decl
, name
);
5169 *no_add_attrs
= true;
5171 else if (DECL_INITIAL (decl
))
5173 error ("%Jcan%'t set %qE attribute after definition", decl
, name
);
5174 *no_add_attrs
= true;
5177 DECL_NO_LIMIT_STACK (decl
) = 1;
5182 /* Handle a "pure" attribute; arguments as in
5183 struct attribute_spec.handler. */
5186 handle_pure_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5187 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5189 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5190 DECL_IS_PURE (*node
) = 1;
5191 /* ??? TODO: Support types. */
5194 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5195 *no_add_attrs
= true;
5201 /* Handle a "no vops" attribute; arguments as in
5202 struct attribute_spec.handler. */
5205 handle_novops_attribute (tree
*node
, tree
ARG_UNUSED (name
),
5206 tree
ARG_UNUSED (args
), int ARG_UNUSED (flags
),
5207 bool *ARG_UNUSED (no_add_attrs
))
5209 gcc_assert (TREE_CODE (*node
) == FUNCTION_DECL
);
5210 DECL_IS_NOVOPS (*node
) = 1;
5214 /* Handle a "deprecated" attribute; arguments as in
5215 struct attribute_spec.handler. */
5218 handle_deprecated_attribute (tree
*node
, tree name
,
5219 tree
ARG_UNUSED (args
), int flags
,
5222 tree type
= NULL_TREE
;
5224 tree what
= NULL_TREE
;
5229 type
= TREE_TYPE (decl
);
5231 if (TREE_CODE (decl
) == TYPE_DECL
5232 || TREE_CODE (decl
) == PARM_DECL
5233 || TREE_CODE (decl
) == VAR_DECL
5234 || TREE_CODE (decl
) == FUNCTION_DECL
5235 || TREE_CODE (decl
) == FIELD_DECL
)
5236 TREE_DEPRECATED (decl
) = 1;
5240 else if (TYPE_P (*node
))
5242 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
5243 *node
= build_variant_type_copy (*node
);
5244 TREE_DEPRECATED (*node
) = 1;
5252 *no_add_attrs
= true;
5253 if (type
&& TYPE_NAME (type
))
5255 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
5256 what
= TYPE_NAME (*node
);
5257 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
5258 && DECL_NAME (TYPE_NAME (type
)))
5259 what
= DECL_NAME (TYPE_NAME (type
));
5262 warning (OPT_Wattributes
, "%qE attribute ignored for %qE", name
, what
);
5264 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5270 /* Handle a "vector_size" attribute; arguments as in
5271 struct attribute_spec.handler. */
5274 handle_vector_size_attribute (tree
*node
, tree name
, tree args
,
5275 int ARG_UNUSED (flags
),
5278 unsigned HOST_WIDE_INT vecsize
, nunits
;
5279 enum machine_mode orig_mode
;
5280 tree type
= *node
, new_type
, size
;
5282 *no_add_attrs
= true;
5284 size
= TREE_VALUE (args
);
5286 if (!host_integerp (size
, 1))
5288 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5292 /* Get the vector size (in bytes). */
5293 vecsize
= tree_low_cst (size
, 1);
5295 /* We need to provide for vector pointers, vector arrays, and
5296 functions returning vectors. For example:
5298 __attribute__((vector_size(16))) short *foo;
5300 In this case, the mode is SI, but the type being modified is
5301 HI, so we need to look further. */
5303 while (POINTER_TYPE_P (type
)
5304 || TREE_CODE (type
) == FUNCTION_TYPE
5305 || TREE_CODE (type
) == METHOD_TYPE
5306 || TREE_CODE (type
) == ARRAY_TYPE
)
5307 type
= TREE_TYPE (type
);
5309 /* Get the mode of the type being modified. */
5310 orig_mode
= TYPE_MODE (type
);
5312 if (TREE_CODE (type
) == RECORD_TYPE
5313 || (!SCALAR_FLOAT_MODE_P (orig_mode
)
5314 && GET_MODE_CLASS (orig_mode
) != MODE_INT
)
5315 || !host_integerp (TYPE_SIZE_UNIT (type
), 1))
5317 error ("invalid vector type for attribute %qE", name
);
5321 if (vecsize
% tree_low_cst (TYPE_SIZE_UNIT (type
), 1))
5323 error ("vector size not an integral multiple of component size");
5329 error ("zero vector size");
5333 /* Calculate how many units fit in the vector. */
5334 nunits
= vecsize
/ tree_low_cst (TYPE_SIZE_UNIT (type
), 1);
5335 if (nunits
& (nunits
- 1))
5337 error ("number of components of the vector not a power of two");
5341 new_type
= build_vector_type (type
, nunits
);
5343 /* Build back pointers if needed. */
5344 *node
= reconstruct_complex_type (*node
, new_type
);
5349 /* Handle the "nonnull" attribute. */
5351 handle_nonnull_attribute (tree
*node
, tree
ARG_UNUSED (name
),
5352 tree args
, int ARG_UNUSED (flags
),
5356 unsigned HOST_WIDE_INT attr_arg_num
;
5358 /* If no arguments are specified, all pointer arguments should be
5359 non-null. Verify a full prototype is given so that the arguments
5360 will have the correct types when we actually check them later. */
5363 if (!TYPE_ARG_TYPES (type
))
5365 error ("nonnull attribute without arguments on a non-prototype");
5366 *no_add_attrs
= true;
5371 /* Argument list specified. Verify that each argument number references
5372 a pointer argument. */
5373 for (attr_arg_num
= 1; args
; args
= TREE_CHAIN (args
))
5376 unsigned HOST_WIDE_INT arg_num
= 0, ck_num
;
5378 if (!get_nonnull_operand (TREE_VALUE (args
), &arg_num
))
5380 error ("nonnull argument has invalid operand number (argument %lu)",
5381 (unsigned long) attr_arg_num
);
5382 *no_add_attrs
= true;
5386 argument
= TYPE_ARG_TYPES (type
);
5389 for (ck_num
= 1; ; ck_num
++)
5391 if (!argument
|| ck_num
== arg_num
)
5393 argument
= TREE_CHAIN (argument
);
5397 || TREE_CODE (TREE_VALUE (argument
)) == VOID_TYPE
)
5399 error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
5400 (unsigned long) attr_arg_num
, (unsigned long) arg_num
);
5401 *no_add_attrs
= true;
5405 if (TREE_CODE (TREE_VALUE (argument
)) != POINTER_TYPE
)
5407 error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
5408 (unsigned long) attr_arg_num
, (unsigned long) arg_num
);
5409 *no_add_attrs
= true;
5418 /* Check the argument list of a function call for null in argument slots
5419 that are marked as requiring a non-null pointer argument. */
5422 check_function_nonnull (tree attrs
, tree params
)
5424 tree a
, args
, param
;
5427 for (a
= attrs
; a
; a
= TREE_CHAIN (a
))
5429 if (is_attribute_p ("nonnull", TREE_PURPOSE (a
)))
5431 args
= TREE_VALUE (a
);
5433 /* Walk the argument list. If we encounter an argument number we
5434 should check for non-null, do it. If the attribute has no args,
5435 then every pointer argument is checked (in which case the check
5436 for pointer type is done in check_nonnull_arg). */
5437 for (param
= params
, param_num
= 1; ;
5438 param_num
++, param
= TREE_CHAIN (param
))
5442 if (!args
|| nonnull_check_p (args
, param_num
))
5443 check_function_arguments_recurse (check_nonnull_arg
, NULL
,
5451 /* Check that the Nth argument of a function call (counting backwards
5452 from the end) is a (pointer)0. */
5455 check_function_sentinel (tree attrs
, tree params
, tree typelist
)
5457 tree attr
= lookup_attribute ("sentinel", attrs
);
5461 /* Skip over the named arguments. */
5462 while (typelist
&& params
)
5464 typelist
= TREE_CHAIN (typelist
);
5465 params
= TREE_CHAIN (params
);
5468 if (typelist
|| !params
)
5469 warning (OPT_Wformat
,
5470 "not enough variable arguments to fit a sentinel");
5476 if (TREE_VALUE (attr
))
5478 tree p
= TREE_VALUE (TREE_VALUE (attr
));
5479 pos
= TREE_INT_CST_LOW (p
);
5482 sentinel
= end
= params
;
5484 /* Advance `end' ahead of `sentinel' by `pos' positions. */
5485 while (pos
> 0 && TREE_CHAIN (end
))
5488 end
= TREE_CHAIN (end
);
5492 warning (OPT_Wformat
,
5493 "not enough variable arguments to fit a sentinel");
5497 /* Now advance both until we find the last parameter. */
5498 while (TREE_CHAIN (end
))
5500 end
= TREE_CHAIN (end
);
5501 sentinel
= TREE_CHAIN (sentinel
);
5504 /* Validate the sentinel. */
5505 if ((!POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (sentinel
)))
5506 || !integer_zerop (TREE_VALUE (sentinel
)))
5507 /* Although __null (in C++) is only an integer we allow it
5508 nevertheless, as we are guaranteed that it's exactly
5509 as wide as a pointer, and we don't want to force
5510 users to cast the NULL they have written there.
5511 We warn with -Wstrict-null-sentinel, though. */
5512 && (warn_strict_null_sentinel
5513 || null_node
!= TREE_VALUE (sentinel
)))
5514 warning (OPT_Wformat
, "missing sentinel in function call");
5519 /* Helper for check_function_nonnull; given a list of operands which
5520 must be non-null in ARGS, determine if operand PARAM_NUM should be
5524 nonnull_check_p (tree args
, unsigned HOST_WIDE_INT param_num
)
5526 unsigned HOST_WIDE_INT arg_num
= 0;
5528 for (; args
; args
= TREE_CHAIN (args
))
5530 bool found
= get_nonnull_operand (TREE_VALUE (args
), &arg_num
);
5534 if (arg_num
== param_num
)
5540 /* Check that the function argument PARAM (which is operand number
5541 PARAM_NUM) is non-null. This is called by check_function_nonnull
5542 via check_function_arguments_recurse. */
5545 check_nonnull_arg (void * ARG_UNUSED (ctx
), tree param
,
5546 unsigned HOST_WIDE_INT param_num
)
5548 /* Just skip checking the argument if it's not a pointer. This can
5549 happen if the "nonnull" attribute was given without an operand
5550 list (which means to check every pointer argument). */
5552 if (TREE_CODE (TREE_TYPE (param
)) != POINTER_TYPE
)
5555 if (integer_zerop (param
))
5556 warning (OPT_Wnonnull
, "null argument where non-null required "
5557 "(argument %lu)", (unsigned long) param_num
);
5560 /* Helper for nonnull attribute handling; fetch the operand number
5561 from the attribute argument list. */
5564 get_nonnull_operand (tree arg_num_expr
, unsigned HOST_WIDE_INT
*valp
)
5566 /* Verify the arg number is a constant. */
5567 if (TREE_CODE (arg_num_expr
) != INTEGER_CST
5568 || TREE_INT_CST_HIGH (arg_num_expr
) != 0)
5571 *valp
= TREE_INT_CST_LOW (arg_num_expr
);
5575 /* Handle a "nothrow" attribute; arguments as in
5576 struct attribute_spec.handler. */
5579 handle_nothrow_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5580 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5582 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5583 TREE_NOTHROW (*node
) = 1;
5584 /* ??? TODO: Support types. */
5587 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5588 *no_add_attrs
= true;
5594 /* Handle a "cleanup" attribute; arguments as in
5595 struct attribute_spec.handler. */
5598 handle_cleanup_attribute (tree
*node
, tree name
, tree args
,
5599 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5602 tree cleanup_id
, cleanup_decl
;
5604 /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
5605 for global destructors in C++. This requires infrastructure that
5606 we don't have generically at the moment. It's also not a feature
5607 we'd be missing too much, since we do have attribute constructor. */
5608 if (TREE_CODE (decl
) != VAR_DECL
|| TREE_STATIC (decl
))
5610 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5611 *no_add_attrs
= true;
5615 /* Verify that the argument is a function in scope. */
5616 /* ??? We could support pointers to functions here as well, if
5617 that was considered desirable. */
5618 cleanup_id
= TREE_VALUE (args
);
5619 if (TREE_CODE (cleanup_id
) != IDENTIFIER_NODE
)
5621 error ("cleanup argument not an identifier");
5622 *no_add_attrs
= true;
5625 cleanup_decl
= lookup_name (cleanup_id
);
5626 if (!cleanup_decl
|| TREE_CODE (cleanup_decl
) != FUNCTION_DECL
)
5628 error ("cleanup argument not a function");
5629 *no_add_attrs
= true;
5633 /* That the function has proper type is checked with the
5634 eventual call to build_function_call. */
5639 /* Handle a "warn_unused_result" attribute. No special handling. */
5642 handle_warn_unused_result_attribute (tree
*node
, tree name
,
5643 tree
ARG_UNUSED (args
),
5644 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5646 /* Ignore the attribute for functions not returning any value. */
5647 if (VOID_TYPE_P (TREE_TYPE (*node
)))
5649 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5650 *no_add_attrs
= true;
5656 /* Handle a "sentinel" attribute. */
5659 handle_sentinel_attribute (tree
*node
, tree name
, tree args
,
5660 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5662 tree params
= TYPE_ARG_TYPES (*node
);
5666 warning (OPT_Wattributes
,
5667 "%qE attribute requires prototypes with named arguments", name
);
5668 *no_add_attrs
= true;
5672 while (TREE_CHAIN (params
))
5673 params
= TREE_CHAIN (params
);
5675 if (VOID_TYPE_P (TREE_VALUE (params
)))
5677 warning (OPT_Wattributes
,
5678 "%qE attribute only applies to variadic functions", name
);
5679 *no_add_attrs
= true;
5685 tree position
= TREE_VALUE (args
);
5687 if (TREE_CODE (position
) != INTEGER_CST
)
5689 warning (0, "requested position is not an integer constant");
5690 *no_add_attrs
= true;
5694 if (tree_int_cst_lt (position
, integer_zero_node
))
5696 warning (0, "requested position is less than zero");
5697 *no_add_attrs
= true;
5705 /* Check for valid arguments being passed to a function. */
5707 check_function_arguments (tree attrs
, tree params
, tree typelist
)
5709 /* Check for null being passed in a pointer argument that must be
5710 non-null. We also need to do this if format checking is enabled. */
5713 check_function_nonnull (attrs
, params
);
5715 /* Check for errors in format strings. */
5717 if (warn_format
|| warn_missing_format_attribute
)
5718 check_function_format (attrs
, params
);
5721 check_function_sentinel (attrs
, params
, typelist
);
5724 /* Generic argument checking recursion routine. PARAM is the argument to
5725 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
5726 once the argument is resolved. CTX is context for the callback. */
5728 check_function_arguments_recurse (void (*callback
)
5729 (void *, tree
, unsigned HOST_WIDE_INT
),
5730 void *ctx
, tree param
,
5731 unsigned HOST_WIDE_INT param_num
)
5733 if ((TREE_CODE (param
) == NOP_EXPR
|| TREE_CODE (param
) == CONVERT_EXPR
)
5734 && (TYPE_PRECISION (TREE_TYPE (param
))
5735 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (param
, 0)))))
5737 /* Strip coercion. */
5738 check_function_arguments_recurse (callback
, ctx
,
5739 TREE_OPERAND (param
, 0), param_num
);
5743 if (TREE_CODE (param
) == CALL_EXPR
)
5745 tree type
= TREE_TYPE (TREE_TYPE (TREE_OPERAND (param
, 0)));
5747 bool found_format_arg
= false;
5749 /* See if this is a call to a known internationalization function
5750 that modifies a format arg. Such a function may have multiple
5751 format_arg attributes (for example, ngettext). */
5753 for (attrs
= TYPE_ATTRIBUTES (type
);
5755 attrs
= TREE_CHAIN (attrs
))
5756 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs
)))
5759 tree format_num_expr
;
5763 /* Extract the argument number, which was previously checked
5765 format_num_expr
= TREE_VALUE (TREE_VALUE (attrs
));
5767 gcc_assert (TREE_CODE (format_num_expr
) == INTEGER_CST
5768 && !TREE_INT_CST_HIGH (format_num_expr
));
5770 format_num
= TREE_INT_CST_LOW (format_num_expr
);
5772 for (inner_args
= TREE_OPERAND (param
, 1), i
= 1;
5774 inner_args
= TREE_CHAIN (inner_args
), i
++)
5775 if (i
== format_num
)
5777 check_function_arguments_recurse (callback
, ctx
,
5778 TREE_VALUE (inner_args
),
5780 found_format_arg
= true;
5785 /* If we found a format_arg attribute and did a recursive check,
5786 we are done with checking this argument. Otherwise, we continue
5787 and this will be considered a non-literal. */
5788 if (found_format_arg
)
5792 if (TREE_CODE (param
) == COND_EXPR
)
5794 /* Check both halves of the conditional expression. */
5795 check_function_arguments_recurse (callback
, ctx
,
5796 TREE_OPERAND (param
, 1), param_num
);
5797 check_function_arguments_recurse (callback
, ctx
,
5798 TREE_OPERAND (param
, 2), param_num
);
5802 (*callback
) (ctx
, param
, param_num
);
5805 /* Function to help qsort sort FIELD_DECLs by name order. */
5808 field_decl_cmp (const void *x_p
, const void *y_p
)
5810 const tree
*const x
= (const tree
*const) x_p
;
5811 const tree
*const y
= (const tree
*const) y_p
;
5813 if (DECL_NAME (*x
) == DECL_NAME (*y
))
5814 /* A nontype is "greater" than a type. */
5815 return (TREE_CODE (*y
) == TYPE_DECL
) - (TREE_CODE (*x
) == TYPE_DECL
);
5816 if (DECL_NAME (*x
) == NULL_TREE
)
5818 if (DECL_NAME (*y
) == NULL_TREE
)
5820 if (DECL_NAME (*x
) < DECL_NAME (*y
))
5826 gt_pointer_operator new_value
;
5830 /* This routine compares two fields like field_decl_cmp but using the
5831 pointer operator in resort_data. */
5834 resort_field_decl_cmp (const void *x_p
, const void *y_p
)
5836 const tree
*const x
= (const tree
*const) x_p
;
5837 const tree
*const y
= (const tree
*const) y_p
;
5839 if (DECL_NAME (*x
) == DECL_NAME (*y
))
5840 /* A nontype is "greater" than a type. */
5841 return (TREE_CODE (*y
) == TYPE_DECL
) - (TREE_CODE (*x
) == TYPE_DECL
);
5842 if (DECL_NAME (*x
) == NULL_TREE
)
5844 if (DECL_NAME (*y
) == NULL_TREE
)
5847 tree d1
= DECL_NAME (*x
);
5848 tree d2
= DECL_NAME (*y
);
5849 resort_data
.new_value (&d1
, resort_data
.cookie
);
5850 resort_data
.new_value (&d2
, resort_data
.cookie
);
5857 /* Resort DECL_SORTED_FIELDS because pointers have been reordered. */
5860 resort_sorted_fields (void *obj
,
5861 void * ARG_UNUSED (orig_obj
),
5862 gt_pointer_operator new_value
,
5865 struct sorted_fields_type
*sf
= (struct sorted_fields_type
*) obj
;
5866 resort_data
.new_value
= new_value
;
5867 resort_data
.cookie
= cookie
;
5868 qsort (&sf
->elts
[0], sf
->len
, sizeof (tree
),
5869 resort_field_decl_cmp
);
5872 /* Subroutine of c_parse_error.
5873 Return the result of concatenating LHS and RHS. RHS is really
5874 a string literal, its first character is indicated by RHS_START and
5875 RHS_SIZE is its length (including the terminating NUL character).
5877 The caller is responsible for deleting the returned pointer. */
5880 catenate_strings (const char *lhs
, const char *rhs_start
, int rhs_size
)
5882 const int lhs_size
= strlen (lhs
);
5883 char *result
= XNEWVEC (char, lhs_size
+ rhs_size
);
5884 strncpy (result
, lhs
, lhs_size
);
5885 strncpy (result
+ lhs_size
, rhs_start
, rhs_size
);
5889 /* Issue the error given by GMSGID, indicating that it occurred before
5890 TOKEN, which had the associated VALUE. */
5893 c_parse_error (const char *gmsgid
, enum cpp_ttype token
, tree value
)
5895 #define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
5897 char *message
= NULL
;
5899 if (token
== CPP_EOF
)
5900 message
= catenate_messages (gmsgid
, " at end of input");
5901 else if (token
== CPP_CHAR
|| token
== CPP_WCHAR
)
5903 unsigned int val
= TREE_INT_CST_LOW (value
);
5904 const char *const ell
= (token
== CPP_CHAR
) ? "" : "L";
5905 if (val
<= UCHAR_MAX
&& ISGRAPH (val
))
5906 message
= catenate_messages (gmsgid
, " before %s'%c'");
5908 message
= catenate_messages (gmsgid
, " before %s'\\x%x'");
5910 error (message
, ell
, val
);
5914 else if (token
== CPP_STRING
|| token
== CPP_WSTRING
)
5915 message
= catenate_messages (gmsgid
, " before string constant");
5916 else if (token
== CPP_NUMBER
)
5917 message
= catenate_messages (gmsgid
, " before numeric constant");
5918 else if (token
== CPP_NAME
)
5920 message
= catenate_messages (gmsgid
, " before %qE");
5921 error (message
, value
);
5925 else if (token
== CPP_PRAGMA
)
5926 message
= catenate_messages (gmsgid
, " before %<#pragma%>");
5927 else if (token
== CPP_PRAGMA_EOL
)
5928 message
= catenate_messages (gmsgid
, " before end of line");
5929 else if (token
< N_TTYPES
)
5931 message
= catenate_messages (gmsgid
, " before %qs token");
5932 error (message
, cpp_type2name (token
));
5944 #undef catenate_messages
5947 /* Walk a gimplified function and warn for functions whose return value is
5948 ignored and attribute((warn_unused_result)) is set. This is done before
5949 inlining, so we don't have to worry about that. */
5952 c_warn_unused_result (tree
*top_p
)
5955 tree_stmt_iterator i
;
5958 switch (TREE_CODE (t
))
5960 case STATEMENT_LIST
:
5961 for (i
= tsi_start (*top_p
); !tsi_end_p (i
); tsi_next (&i
))
5962 c_warn_unused_result (tsi_stmt_ptr (i
));
5966 c_warn_unused_result (&COND_EXPR_THEN (t
));
5967 c_warn_unused_result (&COND_EXPR_ELSE (t
));
5970 c_warn_unused_result (&BIND_EXPR_BODY (t
));
5972 case TRY_FINALLY_EXPR
:
5973 case TRY_CATCH_EXPR
:
5974 c_warn_unused_result (&TREE_OPERAND (t
, 0));
5975 c_warn_unused_result (&TREE_OPERAND (t
, 1));
5978 c_warn_unused_result (&CATCH_BODY (t
));
5980 case EH_FILTER_EXPR
:
5981 c_warn_unused_result (&EH_FILTER_FAILURE (t
));
5988 /* This is a naked call, as opposed to a CALL_EXPR nested inside
5989 a MODIFY_EXPR. All calls whose value is ignored should be
5990 represented like this. Look for the attribute. */
5991 fdecl
= get_callee_fndecl (t
);
5993 ftype
= TREE_TYPE (fdecl
);
5996 ftype
= TREE_TYPE (TREE_OPERAND (t
, 0));
5997 /* Look past pointer-to-function to the function type itself. */
5998 ftype
= TREE_TYPE (ftype
);
6001 if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype
)))
6004 warning (0, "%Hignoring return value of %qD, "
6005 "declared with attribute warn_unused_result",
6006 EXPR_LOCUS (t
), fdecl
);
6008 warning (0, "%Hignoring return value of function "
6009 "declared with attribute warn_unused_result",
6015 /* Not a container, not a call, or a call whose value is used. */
6020 /* Convert a character from the host to the target execution character
6021 set. cpplib handles this, mostly. */
6024 c_common_to_target_charset (HOST_WIDE_INT c
)
6026 /* Character constants in GCC proper are sign-extended under -fsigned-char,
6027 zero-extended under -fno-signed-char. cpplib insists that characters
6028 and character constants are always unsigned. Hence we must convert
6030 cppchar_t uc
= ((cppchar_t
)c
) & ((((cppchar_t
)1) << CHAR_BIT
)-1);
6032 uc
= cpp_host_to_exec_charset (parse_in
, uc
);
6034 if (flag_signed_char
)
6035 return ((HOST_WIDE_INT
)uc
) << (HOST_BITS_PER_WIDE_INT
- CHAR_TYPE_SIZE
)
6036 >> (HOST_BITS_PER_WIDE_INT
- CHAR_TYPE_SIZE
);
6041 /* Build the result of __builtin_offsetof. EXPR is a nested sequence of
6042 component references, with STOP_REF, or alternatively an INDIRECT_REF of
6043 NULL, at the bottom; much like the traditional rendering of offsetof as a
6044 macro. Returns the folded and properly cast result. */
6047 fold_offsetof_1 (tree expr
, tree stop_ref
)
6049 enum tree_code code
= PLUS_EXPR
;
6052 if (expr
== stop_ref
&& TREE_CODE (expr
) != ERROR_MARK
)
6053 return size_zero_node
;
6055 switch (TREE_CODE (expr
))
6061 error ("cannot apply %<offsetof%> to static data member %qD", expr
);
6062 return error_mark_node
;
6065 error ("cannot apply %<offsetof%> when %<operator[]%> is overloaded");
6066 return error_mark_node
;
6069 gcc_assert (integer_zerop (expr
));
6070 return size_zero_node
;
6074 base
= fold_offsetof_1 (TREE_OPERAND (expr
, 0), stop_ref
);
6075 gcc_assert (base
== error_mark_node
|| base
== size_zero_node
);
6079 base
= fold_offsetof_1 (TREE_OPERAND (expr
, 0), stop_ref
);
6080 if (base
== error_mark_node
)
6083 t
= TREE_OPERAND (expr
, 1);
6084 if (DECL_C_BIT_FIELD (t
))
6086 error ("attempt to take address of bit-field structure "
6088 return error_mark_node
;
6090 off
= size_binop (PLUS_EXPR
, DECL_FIELD_OFFSET (t
),
6091 size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t
), 1)
6096 base
= fold_offsetof_1 (TREE_OPERAND (expr
, 0), stop_ref
);
6097 if (base
== error_mark_node
)
6100 t
= TREE_OPERAND (expr
, 1);
6101 if (TREE_CODE (t
) == INTEGER_CST
&& tree_int_cst_sgn (t
) < 0)
6104 t
= fold_build1 (NEGATE_EXPR
, TREE_TYPE (t
), t
);
6106 t
= convert (sizetype
, t
);
6107 off
= size_binop (MULT_EXPR
, TYPE_SIZE_UNIT (TREE_TYPE (expr
)), t
);
6114 return size_binop (code
, base
, off
);
6118 fold_offsetof (tree expr
, tree stop_ref
)
6120 /* Convert back from the internal sizetype to size_t. */
6121 return convert (size_type_node
, fold_offsetof_1 (expr
, stop_ref
));
6124 /* Print an error message for an invalid lvalue. USE says
6125 how the lvalue is being used and so selects the error message. */
6128 lvalue_error (enum lvalue_use use
)
6133 error ("lvalue required as left operand of assignment");
6136 error ("lvalue required as increment operand");
6139 error ("lvalue required as decrement operand");
6142 error ("lvalue required as unary %<&%> operand");
6145 error ("lvalue required in asm statement");
6152 /* *PTYPE is an incomplete array. Complete it with a domain based on
6153 INITIAL_VALUE. If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
6154 is true. Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
6155 2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty. */
6158 complete_array_type (tree
*ptype
, tree initial_value
, bool do_default
)
6160 tree maxindex
, type
, main_type
, elt
, unqual_elt
;
6161 int failure
= 0, quals
;
6163 maxindex
= size_zero_node
;
6166 if (TREE_CODE (initial_value
) == STRING_CST
)
6169 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value
)));
6170 maxindex
= size_int (TREE_STRING_LENGTH (initial_value
)/eltsize
- 1);
6172 else if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
6174 VEC(constructor_elt
,gc
) *v
= CONSTRUCTOR_ELTS (initial_value
);
6176 if (VEC_empty (constructor_elt
, v
))
6180 maxindex
= integer_minus_one_node
;
6185 unsigned HOST_WIDE_INT cnt
;
6186 constructor_elt
*ce
;
6188 if (VEC_index (constructor_elt
, v
, 0)->index
)
6189 maxindex
= fold_convert (sizetype
,
6190 VEC_index (constructor_elt
,
6192 curindex
= maxindex
;
6195 VEC_iterate (constructor_elt
, v
, cnt
, ce
);
6199 curindex
= fold_convert (sizetype
, ce
->index
);
6201 curindex
= size_binop (PLUS_EXPR
, curindex
, size_one_node
);
6203 if (tree_int_cst_lt (maxindex
, curindex
))
6204 maxindex
= curindex
;
6210 /* Make an error message unless that happened already. */
6211 if (initial_value
!= error_mark_node
)
6223 elt
= TREE_TYPE (type
);
6224 quals
= TYPE_QUALS (strip_array_types (elt
));
6228 unqual_elt
= c_build_qualified_type (elt
, TYPE_UNQUALIFIED
);
6230 /* Using build_distinct_type_copy and modifying things afterward instead
6231 of using build_array_type to create a new type preserves all of the
6232 TYPE_LANG_FLAG_? bits that the front end may have set. */
6233 main_type
= build_distinct_type_copy (TYPE_MAIN_VARIANT (type
));
6234 TREE_TYPE (main_type
) = unqual_elt
;
6235 TYPE_DOMAIN (main_type
) = build_index_type (maxindex
);
6236 layout_type (main_type
);
6241 type
= c_build_qualified_type (main_type
, quals
);
6248 /* Used to help initialize the builtin-types.def table. When a type of
6249 the correct size doesn't exist, use error_mark_node instead of NULL.
6250 The later results in segfaults even when a decl using the type doesn't
6254 builtin_type_for_size (int size
, bool unsignedp
)
6256 tree type
= lang_hooks
.types
.type_for_size (size
, unsignedp
);
6257 return type
? type
: error_mark_node
;
6260 /* A helper function for resolve_overloaded_builtin in resolving the
6261 overloaded __sync_ builtins. Returns a positive power of 2 if the
6262 first operand of PARAMS is a pointer to a supported data type.
6263 Returns 0 if an error is encountered. */
6266 sync_resolve_size (tree function
, tree params
)
6273 error ("too few arguments to function %qE", function
);
6277 type
= TREE_TYPE (TREE_VALUE (params
));
6278 if (TREE_CODE (type
) != POINTER_TYPE
)
6281 type
= TREE_TYPE (type
);
6282 if (!INTEGRAL_TYPE_P (type
) && !POINTER_TYPE_P (type
))
6285 size
= tree_low_cst (TYPE_SIZE_UNIT (type
), 1);
6286 if (size
== 1 || size
== 2 || size
== 4 || size
== 8 || size
== 16)
6290 error ("incompatible type for argument %d of %qE", 1, function
);
6294 /* A helper function for resolve_overloaded_builtin. Adds casts to
6295 PARAMS to make arguments match up with those of FUNCTION. Drops
6296 the variadic arguments at the end. Returns false if some error
6297 was encountered; true on success. */
6300 sync_resolve_params (tree orig_function
, tree function
, tree params
)
6302 tree arg_types
= TYPE_ARG_TYPES (TREE_TYPE (function
));
6306 /* We've declared the implementation functions to use "volatile void *"
6307 as the pointer parameter, so we shouldn't get any complaints from the
6308 call to check_function_arguments what ever type the user used. */
6309 arg_types
= TREE_CHAIN (arg_types
);
6310 ptype
= TREE_TYPE (TREE_TYPE (TREE_VALUE (params
)));
6313 /* For the rest of the values, we need to cast these to FTYPE, so that we
6314 don't get warnings for passing pointer types, etc. */
6315 while (arg_types
!= void_list_node
)
6319 params
= TREE_CHAIN (params
);
6322 error ("too few arguments to function %qE", orig_function
);
6326 /* ??? Ideally for the first conversion we'd use convert_for_assignment
6327 so that we get warnings for anything that doesn't match the pointer
6328 type. This isn't portable across the C and C++ front ends atm. */
6329 val
= TREE_VALUE (params
);
6330 val
= convert (ptype
, val
);
6331 val
= convert (TREE_VALUE (arg_types
), val
);
6332 TREE_VALUE (params
) = val
;
6334 arg_types
= TREE_CHAIN (arg_types
);
6338 /* The definition of these primitives is variadic, with the remaining
6339 being "an optional list of variables protected by the memory barrier".
6340 No clue what that's supposed to mean, precisely, but we consider all
6341 call-clobbered variables to be protected so we're safe. */
6342 TREE_CHAIN (params
) = NULL
;
6347 /* A helper function for resolve_overloaded_builtin. Adds a cast to
6348 RESULT to make it match the type of the first pointer argument in
6352 sync_resolve_return (tree params
, tree result
)
6354 tree ptype
= TREE_TYPE (TREE_TYPE (TREE_VALUE (params
)));
6355 ptype
= TYPE_MAIN_VARIANT (ptype
);
6356 return convert (ptype
, result
);
6359 /* Some builtin functions are placeholders for other expressions. This
6360 function should be called immediately after parsing the call expression
6361 before surrounding code has committed to the type of the expression.
6363 FUNCTION is the DECL that has been invoked; it is known to be a builtin.
6364 PARAMS is the argument list for the call. The return value is non-null
6365 when expansion is complete, and null if normal processing should
6369 resolve_overloaded_builtin (tree function
, tree params
)
6371 enum built_in_function orig_code
= DECL_FUNCTION_CODE (function
);
6372 switch (DECL_BUILT_IN_CLASS (function
))
6374 case BUILT_IN_NORMAL
:
6377 if (targetm
.resolve_overloaded_builtin
)
6378 return targetm
.resolve_overloaded_builtin (function
, params
);
6385 /* Handle BUILT_IN_NORMAL here. */
6388 case BUILT_IN_FETCH_AND_ADD_N
:
6389 case BUILT_IN_FETCH_AND_SUB_N
:
6390 case BUILT_IN_FETCH_AND_OR_N
:
6391 case BUILT_IN_FETCH_AND_AND_N
:
6392 case BUILT_IN_FETCH_AND_XOR_N
:
6393 case BUILT_IN_FETCH_AND_NAND_N
:
6394 case BUILT_IN_ADD_AND_FETCH_N
:
6395 case BUILT_IN_SUB_AND_FETCH_N
:
6396 case BUILT_IN_OR_AND_FETCH_N
:
6397 case BUILT_IN_AND_AND_FETCH_N
:
6398 case BUILT_IN_XOR_AND_FETCH_N
:
6399 case BUILT_IN_NAND_AND_FETCH_N
:
6400 case BUILT_IN_BOOL_COMPARE_AND_SWAP_N
:
6401 case BUILT_IN_VAL_COMPARE_AND_SWAP_N
:
6402 case BUILT_IN_LOCK_TEST_AND_SET_N
:
6403 case BUILT_IN_LOCK_RELEASE_N
:
6405 int n
= sync_resolve_size (function
, params
);
6406 tree new_function
, result
;
6409 return error_mark_node
;
6411 new_function
= built_in_decls
[orig_code
+ exact_log2 (n
) + 1];
6412 if (!sync_resolve_params (function
, new_function
, params
))
6413 return error_mark_node
;
6415 result
= build_function_call (new_function
, params
);
6416 if (orig_code
!= BUILT_IN_BOOL_COMPARE_AND_SWAP_N
6417 && orig_code
!= BUILT_IN_LOCK_RELEASE_N
)
6418 result
= sync_resolve_return (params
, result
);
6428 /* Ignoring their sign, return true if two scalar types are the same. */
6430 same_scalar_type_ignoring_signedness (tree t1
, tree t2
)
6432 enum tree_code c1
= TREE_CODE (t1
), c2
= TREE_CODE (t2
);
6434 gcc_assert ((c1
== INTEGER_TYPE
|| c1
== REAL_TYPE
)
6435 && (c2
== INTEGER_TYPE
|| c2
== REAL_TYPE
));
6437 /* Equality works here because c_common_signed_type uses
6438 TYPE_MAIN_VARIANT. */
6439 return lang_hooks
.types
.signed_type (t1
)
6440 == lang_hooks
.types
.signed_type (t2
);
6443 /* Check for missing format attributes on function pointers. LTYPE is
6444 the new type or left-hand side type. RTYPE is the old type or
6445 right-hand side type. Returns TRUE if LTYPE is missing the desired
6449 check_missing_format_attribute (tree ltype
, tree rtype
)
6451 tree
const ttr
= TREE_TYPE (rtype
), ttl
= TREE_TYPE (ltype
);
6454 for (ra
= TYPE_ATTRIBUTES (ttr
); ra
; ra
= TREE_CHAIN (ra
))
6455 if (is_attribute_p ("format", TREE_PURPOSE (ra
)))
6460 for (la
= TYPE_ATTRIBUTES (ttl
); la
; la
= TREE_CHAIN (la
))
6461 if (is_attribute_p ("format", TREE_PURPOSE (la
)))
6469 /* Subscripting with type char is likely to lose on a machine where
6470 chars are signed. So warn on any machine, but optionally. Don't
6471 warn for unsigned char since that type is safe. Don't warn for
6472 signed char because anyone who uses that must have done so
6473 deliberately. Furthermore, we reduce the false positive load by
6474 warning only for non-constant value of type char. */
6477 warn_array_subscript_with_type_char (tree index
)
6479 if (TYPE_MAIN_VARIANT (TREE_TYPE (index
)) == char_type_node
6480 && TREE_CODE (index
) != INTEGER_CST
)
6481 warning (OPT_Wchar_subscripts
, "array subscript has type %<char%>");
6485 #include "gt-c-common.h"