PR middle-end/23971
[official-gcc.git] / gcc / c-common.c
blobedd744893cbaf0430c028d7e223e5f9404d4bdbd
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
10 version.
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
15 for more details.
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
20 02110-1301, USA. */
22 #include "config.h"
23 #include "system.h"
24 #include "coretypes.h"
25 #include "tm.h"
26 #include "intl.h"
27 #include "tree.h"
28 #include "flags.h"
29 #include "output.h"
30 #include "c-pragma.h"
31 #include "rtl.h"
32 #include "ggc.h"
33 #include "varray.h"
34 #include "expr.h"
35 #include "c-common.h"
36 #include "diagnostic.h"
37 #include "tm_p.h"
38 #include "obstack.h"
39 #include "cpplib.h"
40 #include "target.h"
41 #include "langhooks.h"
42 #include "tree-inline.h"
43 #include "c-tree.h"
44 #include "toplev.h"
45 #include "tree-iterator.h"
46 #include "hashtab.h"
47 #include "tree-mudflap.h"
48 #include "opts.h"
49 #include "real.h"
50 #include "cgraph.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. */
60 #ifndef SIZE_TYPE
61 #define SIZE_TYPE "long unsigned int"
62 #endif
64 #ifndef PID_TYPE
65 #define PID_TYPE "int"
66 #endif
68 #ifndef WCHAR_TYPE
69 #define WCHAR_TYPE "int"
70 #endif
72 /* WCHAR_TYPE gets overridden by -fshort-wchar. */
73 #define MODIFIED_WCHAR_TYPE \
74 (flag_short_wchar ? "short unsigned int" : WCHAR_TYPE)
76 #ifndef PTRDIFF_TYPE
77 #define PTRDIFF_TYPE "long int"
78 #endif
80 #ifndef WINT_TYPE
81 #define WINT_TYPE "unsigned int"
82 #endif
84 #ifndef INTMAX_TYPE
85 #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
86 ? "int" \
87 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
88 ? "long int" \
89 : "long long int"))
90 #endif
92 #ifndef UINTMAX_TYPE
93 #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
94 ? "unsigned int" \
95 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
96 ? "long unsigned int" \
97 : "long long unsigned int"))
98 #endif
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 intQI_type_node;
135 tree intHI_type_node;
136 tree intSI_type_node;
137 tree intDI_type_node;
138 tree intTI_type_node;
140 tree unsigned_intQI_type_node;
141 tree unsigned_intHI_type_node;
142 tree unsigned_intSI_type_node;
143 tree unsigned_intDI_type_node;
144 tree unsigned_intTI_type_node;
146 tree widest_integer_literal_type_node;
147 tree widest_unsigned_literal_type_node;
149 Nodes for types `void *' and `const void *'.
151 tree ptr_type_node, const_ptr_type_node;
153 Nodes for types `char *' and `const char *'.
155 tree string_type_node, const_string_type_node;
157 Type `char[SOMENUMBER]'.
158 Used when an array of char is needed and the size is irrelevant.
160 tree char_array_type_node;
162 Type `int[SOMENUMBER]' or something like it.
163 Used when an array of int needed and the size is irrelevant.
165 tree int_array_type_node;
167 Type `wchar_t[SOMENUMBER]' or something like it.
168 Used when a wide string literal is created.
170 tree wchar_array_type_node;
172 Type `int ()' -- used for implicit declaration of functions.
174 tree default_function_type;
176 A VOID_TYPE node, packaged in a TREE_LIST.
178 tree void_list_node;
180 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
181 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
182 VAR_DECLS, but C++ does.)
184 tree function_name_decl_node;
185 tree pretty_function_name_decl_node;
186 tree c99_function_name_decl_node;
188 Stack of nested function name VAR_DECLs.
190 tree saved_function_name_decls;
194 tree c_global_trees[CTI_MAX];
196 /* Switches common to the C front ends. */
198 /* Nonzero if prepreprocessing only. */
200 int flag_preprocess_only;
202 /* Nonzero means don't output line number information. */
204 char flag_no_line_commands;
206 /* Nonzero causes -E output not to be done, but directives such as
207 #define that have side effects are still obeyed. */
209 char flag_no_output;
211 /* Nonzero means dump macros in some fashion. */
213 char flag_dump_macros;
215 /* Nonzero means pass #include lines through to the output. */
217 char flag_dump_includes;
219 /* Nonzero means process PCH files while preprocessing. */
221 bool flag_pch_preprocess;
223 /* The file name to which we should write a precompiled header, or
224 NULL if no header will be written in this compile. */
226 const char *pch_file;
228 /* Nonzero if an ISO standard was selected. It rejects macros in the
229 user's namespace. */
230 int flag_iso;
232 /* Nonzero if -undef was given. It suppresses target built-in macros
233 and assertions. */
234 int flag_undef;
236 /* Nonzero means don't recognize the non-ANSI builtin functions. */
238 int flag_no_builtin;
240 /* Nonzero means don't recognize the non-ANSI builtin functions.
241 -ansi sets this. */
243 int flag_no_nonansi_builtin;
245 /* Nonzero means give `double' the same size as `float'. */
247 int flag_short_double;
249 /* Nonzero means give `wchar_t' the same size as `short'. */
251 int flag_short_wchar;
253 /* Nonzero means allow Microsoft extensions without warnings or errors. */
254 int flag_ms_extensions;
256 /* Nonzero means don't recognize the keyword `asm'. */
258 int flag_no_asm;
260 /* Nonzero means give string constants the type `const char *', as mandated
261 by the standard. */
263 int flag_const_strings;
265 /* Nonzero means to treat bitfields as signed unless they say `unsigned'. */
267 int flag_signed_bitfields = 1;
269 /* Nonzero means warn about deprecated conversion from string constant to
270 `char *'. */
272 int warn_write_strings;
274 /* Warn about #pragma directives that are not recognized. */
276 int warn_unknown_pragmas; /* Tri state variable. */
278 /* Warn about format/argument anomalies in calls to formatted I/O functions
279 (*printf, *scanf, strftime, strfmon, etc.). */
281 int warn_format;
283 /* Warn about using __null (as NULL in C++) as sentinel. For code compiled
284 with GCC this doesn't matter as __null is guaranteed to have the right
285 size. */
287 int warn_strict_null_sentinel;
289 /* Zero means that faster, ...NonNil variants of objc_msgSend...
290 calls will be used in ObjC; passing nil receivers to such calls
291 will most likely result in crashes. */
292 int flag_nil_receivers = 1;
294 /* Nonzero means that code generation will be altered to support
295 "zero-link" execution. This currently affects ObjC only, but may
296 affect other languages in the future. */
297 int flag_zero_link = 0;
299 /* Nonzero means emit an '__OBJC, __image_info' for the current translation
300 unit. It will inform the ObjC runtime that class definition(s) herein
301 contained are to replace one(s) previously loaded. */
302 int flag_replace_objc_classes = 0;
304 /* C/ObjC language option variables. */
307 /* Nonzero means allow type mismatches in conditional expressions;
308 just make their values `void'. */
310 int flag_cond_mismatch;
312 /* Nonzero means enable C89 Amendment 1 features. */
314 int flag_isoc94;
316 /* Nonzero means use the ISO C99 dialect of C. */
318 int flag_isoc99;
320 /* Nonzero means that we have builtin functions, and main is an int. */
322 int flag_hosted = 1;
324 /* Warn if main is suspicious. */
326 int warn_main;
329 /* ObjC language option variables. */
332 /* Open and close the file for outputting class declarations, if
333 requested (ObjC). */
335 int flag_gen_declaration;
337 /* Tells the compiler that this is a special run. Do not perform any
338 compiling, instead we are to test some platform dependent features
339 and output a C header file with appropriate definitions. */
341 int print_struct_values;
343 /* ???. Undocumented. */
345 const char *constant_string_class_name;
348 /* C++ language option variables. */
351 /* Nonzero means don't recognize any extension keywords. */
353 int flag_no_gnu_keywords;
355 /* Nonzero means do emit exported implementations of functions even if
356 they can be inlined. */
358 int flag_implement_inlines = 1;
360 /* Nonzero means that implicit instantiations will be emitted if needed. */
362 int flag_implicit_templates = 1;
364 /* Nonzero means that implicit instantiations of inline templates will be
365 emitted if needed, even if instantiations of non-inline templates
366 aren't. */
368 int flag_implicit_inline_templates = 1;
370 /* Nonzero means generate separate instantiation control files and
371 juggle them at link time. */
373 int flag_use_repository;
375 /* Nonzero if we want to issue diagnostics that the standard says are not
376 required. */
378 int flag_optional_diags = 1;
380 /* Nonzero means we should attempt to elide constructors when possible. */
382 int flag_elide_constructors = 1;
384 /* Nonzero means that member functions defined in class scope are
385 inline by default. */
387 int flag_default_inline = 1;
389 /* Controls whether compiler generates 'type descriptor' that give
390 run-time type information. */
392 int flag_rtti = 1;
394 /* Nonzero if we want to conserve space in the .o files. We do this
395 by putting uninitialized data and runtime initialized data into
396 .common instead of .data at the expense of not flagging multiple
397 definitions. */
399 int flag_conserve_space;
401 /* Nonzero if we want to obey access control semantics. */
403 int flag_access_control = 1;
405 /* Nonzero if we want to check the return value of new and avoid calling
406 constructors if it is a null pointer. */
408 int flag_check_new;
410 /* Nonzero if we want the new ISO rules for pushing a new scope for `for'
411 initialization variables.
412 0: Old rules, set by -fno-for-scope.
413 2: New ISO rules, set by -ffor-scope.
414 1: Try to implement new ISO rules, but with backup compatibility
415 (and warnings). This is the default, for now. */
417 int flag_new_for_scope = 1;
419 /* Nonzero if we want to emit defined symbols with common-like linkage as
420 weak symbols where possible, in order to conform to C++ semantics.
421 Otherwise, emit them as local symbols. */
423 int flag_weak = 1;
425 /* 0 means we want the preprocessor to not emit line directives for
426 the current working directory. 1 means we want it to do it. -1
427 means we should decide depending on whether debugging information
428 is being emitted or not. */
430 int flag_working_directory = -1;
432 /* Nonzero to use __cxa_atexit, rather than atexit, to register
433 destructors for local statics and global objects. */
435 int flag_use_cxa_atexit = DEFAULT_USE_CXA_ATEXIT;
437 /* Nonzero means make the default pedwarns warnings instead of errors.
438 The value of this flag is ignored if -pedantic is specified. */
440 int flag_permissive;
442 /* Nonzero means to implement standard semantics for exception
443 specifications, calling unexpected if an exception is thrown that
444 doesn't match the specification. Zero means to treat them as
445 assertions and optimize accordingly, but not check them. */
447 int flag_enforce_eh_specs = 1;
449 /* Nonzero means to generate thread-safe code for initializing local
450 statics. */
452 int flag_threadsafe_statics = 1;
454 /* Nonzero means warn about implicit declarations. */
456 int warn_implicit = 1;
458 /* Maximum template instantiation depth. This limit is rather
459 arbitrary, but it exists to limit the time it takes to notice
460 infinite template instantiations. */
462 int max_tinst_depth = 500;
466 /* The elements of `ridpointers' are identifier nodes for the reserved
467 type names and storage classes. It is indexed by a RID_... value. */
468 tree *ridpointers;
470 tree (*make_fname_decl) (tree, int);
472 /* Nonzero means the expression being parsed will never be evaluated.
473 This is a count, since unevaluated expressions can nest. */
474 int skip_evaluation;
476 /* Information about how a function name is generated. */
477 struct fname_var_t
479 tree *const decl; /* pointer to the VAR_DECL. */
480 const unsigned rid; /* RID number for the identifier. */
481 const int pretty; /* How pretty is it? */
484 /* The three ways of getting then name of the current function. */
486 const struct fname_var_t fname_vars[] =
488 /* C99 compliant __func__, must be first. */
489 {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
490 /* GCC __FUNCTION__ compliant. */
491 {&function_name_decl_node, RID_FUNCTION_NAME, 0},
492 /* GCC __PRETTY_FUNCTION__ compliant. */
493 {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
494 {NULL, 0, 0},
497 static int constant_fits_type_p (tree, tree);
498 static tree check_case_value (tree);
499 static bool check_case_bounds (tree, tree, tree *, tree *);
501 static tree handle_packed_attribute (tree *, tree, tree, int, bool *);
502 static tree handle_nocommon_attribute (tree *, tree, tree, int, bool *);
503 static tree handle_common_attribute (tree *, tree, tree, int, bool *);
504 static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
505 static tree handle_noinline_attribute (tree *, tree, tree, int, bool *);
506 static tree handle_always_inline_attribute (tree *, tree, tree, int,
507 bool *);
508 static tree handle_flatten_attribute (tree *, tree, tree, int, bool *);
509 static tree handle_used_attribute (tree *, tree, tree, int, bool *);
510 static tree handle_unused_attribute (tree *, tree, tree, int, bool *);
511 static tree handle_externally_visible_attribute (tree *, tree, tree, int,
512 bool *);
513 static tree handle_const_attribute (tree *, tree, tree, int, bool *);
514 static tree handle_transparent_union_attribute (tree *, tree, tree,
515 int, bool *);
516 static tree handle_constructor_attribute (tree *, tree, tree, int, bool *);
517 static tree handle_destructor_attribute (tree *, tree, tree, int, bool *);
518 static tree handle_mode_attribute (tree *, tree, tree, int, bool *);
519 static tree handle_section_attribute (tree *, tree, tree, int, bool *);
520 static tree handle_aligned_attribute (tree *, tree, tree, int, bool *);
521 static tree handle_weak_attribute (tree *, tree, tree, int, bool *) ;
522 static tree handle_alias_attribute (tree *, tree, tree, int, bool *);
523 static tree handle_visibility_attribute (tree *, tree, tree, int,
524 bool *);
525 static tree handle_tls_model_attribute (tree *, tree, tree, int,
526 bool *);
527 static tree handle_no_instrument_function_attribute (tree *, tree,
528 tree, int, bool *);
529 static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);
530 static tree handle_returns_twice_attribute (tree *, tree, tree, int, bool *);
531 static tree handle_no_limit_stack_attribute (tree *, tree, tree, int,
532 bool *);
533 static tree handle_pure_attribute (tree *, tree, tree, int, bool *);
534 static tree handle_novops_attribute (tree *, tree, tree, int, bool *);
535 static tree handle_deprecated_attribute (tree *, tree, tree, int,
536 bool *);
537 static tree handle_vector_size_attribute (tree *, tree, tree, int,
538 bool *);
539 static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
540 static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
541 static tree handle_cleanup_attribute (tree *, tree, tree, int, bool *);
542 static tree handle_warn_unused_result_attribute (tree *, tree, tree, int,
543 bool *);
544 static tree handle_sentinel_attribute (tree *, tree, tree, int, bool *);
546 static void check_function_nonnull (tree, tree);
547 static void check_nonnull_arg (void *, tree, unsigned HOST_WIDE_INT);
548 static bool nonnull_check_p (tree, unsigned HOST_WIDE_INT);
549 static bool get_nonnull_operand (tree, unsigned HOST_WIDE_INT *);
550 static int resort_field_decl_cmp (const void *, const void *);
552 /* Table of machine-independent attributes common to all C-like languages. */
553 const struct attribute_spec c_common_attribute_table[] =
555 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
556 { "packed", 0, 0, false, false, false,
557 handle_packed_attribute },
558 { "nocommon", 0, 0, true, false, false,
559 handle_nocommon_attribute },
560 { "common", 0, 0, true, false, false,
561 handle_common_attribute },
562 /* FIXME: logically, noreturn attributes should be listed as
563 "false, true, true" and apply to function types. But implementing this
564 would require all the places in the compiler that use TREE_THIS_VOLATILE
565 on a decl to identify non-returning functions to be located and fixed
566 to check the function type instead. */
567 { "noreturn", 0, 0, true, false, false,
568 handle_noreturn_attribute },
569 { "volatile", 0, 0, true, false, false,
570 handle_noreturn_attribute },
571 { "noinline", 0, 0, true, false, false,
572 handle_noinline_attribute },
573 { "always_inline", 0, 0, true, false, false,
574 handle_always_inline_attribute },
575 { "flatten", 0, 0, true, false, false,
576 handle_flatten_attribute },
577 { "used", 0, 0, true, false, false,
578 handle_used_attribute },
579 { "unused", 0, 0, false, false, false,
580 handle_unused_attribute },
581 { "externally_visible", 0, 0, true, false, false,
582 handle_externally_visible_attribute },
583 /* The same comments as for noreturn attributes apply to const ones. */
584 { "const", 0, 0, true, false, false,
585 handle_const_attribute },
586 { "transparent_union", 0, 0, false, false, false,
587 handle_transparent_union_attribute },
588 { "constructor", 0, 0, true, false, false,
589 handle_constructor_attribute },
590 { "destructor", 0, 0, true, false, false,
591 handle_destructor_attribute },
592 { "mode", 1, 1, false, true, false,
593 handle_mode_attribute },
594 { "section", 1, 1, true, false, false,
595 handle_section_attribute },
596 { "aligned", 0, 1, false, false, false,
597 handle_aligned_attribute },
598 { "weak", 0, 0, true, false, false,
599 handle_weak_attribute },
600 { "alias", 1, 1, true, false, false,
601 handle_alias_attribute },
602 { "no_instrument_function", 0, 0, true, false, false,
603 handle_no_instrument_function_attribute },
604 { "malloc", 0, 0, true, false, false,
605 handle_malloc_attribute },
606 { "returns_twice", 0, 0, true, false, false,
607 handle_returns_twice_attribute },
608 { "no_stack_limit", 0, 0, true, false, false,
609 handle_no_limit_stack_attribute },
610 { "pure", 0, 0, true, false, false,
611 handle_pure_attribute },
612 /* For internal use (marking of builtins) only. The name contains space
613 to prevent its usage in source code. */
614 { "no vops", 0, 0, true, false, false,
615 handle_novops_attribute },
616 { "deprecated", 0, 0, false, false, false,
617 handle_deprecated_attribute },
618 { "vector_size", 1, 1, false, true, false,
619 handle_vector_size_attribute },
620 { "visibility", 1, 1, false, false, false,
621 handle_visibility_attribute },
622 { "tls_model", 1, 1, true, false, false,
623 handle_tls_model_attribute },
624 { "nonnull", 0, -1, false, true, true,
625 handle_nonnull_attribute },
626 { "nothrow", 0, 0, true, false, false,
627 handle_nothrow_attribute },
628 { "may_alias", 0, 0, false, true, false, NULL },
629 { "cleanup", 1, 1, true, false, false,
630 handle_cleanup_attribute },
631 { "warn_unused_result", 0, 0, false, true, true,
632 handle_warn_unused_result_attribute },
633 { "sentinel", 0, 1, false, true, true,
634 handle_sentinel_attribute },
635 { NULL, 0, 0, false, false, false, NULL }
638 /* Give the specifications for the format attributes, used by C and all
639 descendants. */
641 const struct attribute_spec c_common_format_attribute_table[] =
643 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
644 { "format", 3, 3, false, true, true,
645 handle_format_attribute },
646 { "format_arg", 1, 1, false, true, true,
647 handle_format_arg_attribute },
648 { NULL, 0, 0, false, false, false, NULL }
651 /* Push current bindings for the function name VAR_DECLS. */
653 void
654 start_fname_decls (void)
656 unsigned ix;
657 tree saved = NULL_TREE;
659 for (ix = 0; fname_vars[ix].decl; ix++)
661 tree decl = *fname_vars[ix].decl;
663 if (decl)
665 saved = tree_cons (decl, build_int_cst (NULL_TREE, ix), saved);
666 *fname_vars[ix].decl = NULL_TREE;
669 if (saved || saved_function_name_decls)
670 /* Normally they'll have been NULL, so only push if we've got a
671 stack, or they are non-NULL. */
672 saved_function_name_decls = tree_cons (saved, NULL_TREE,
673 saved_function_name_decls);
676 /* Finish up the current bindings, adding them into the current function's
677 statement tree. This must be done _before_ finish_stmt_tree is called.
678 If there is no current function, we must be at file scope and no statements
679 are involved. Pop the previous bindings. */
681 void
682 finish_fname_decls (void)
684 unsigned ix;
685 tree stmts = NULL_TREE;
686 tree stack = saved_function_name_decls;
688 for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
689 append_to_statement_list (TREE_VALUE (stack), &stmts);
691 if (stmts)
693 tree *bodyp = &DECL_SAVED_TREE (current_function_decl);
695 if (TREE_CODE (*bodyp) == BIND_EXPR)
696 bodyp = &BIND_EXPR_BODY (*bodyp);
698 append_to_statement_list (*bodyp, &stmts);
699 *bodyp = stmts;
702 for (ix = 0; fname_vars[ix].decl; ix++)
703 *fname_vars[ix].decl = NULL_TREE;
705 if (stack)
707 /* We had saved values, restore them. */
708 tree saved;
710 for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
712 tree decl = TREE_PURPOSE (saved);
713 unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
715 *fname_vars[ix].decl = decl;
717 stack = TREE_CHAIN (stack);
719 saved_function_name_decls = stack;
722 /* Return the text name of the current function, suitably prettified
723 by PRETTY_P. Return string must be freed by caller. */
725 const char *
726 fname_as_string (int pretty_p)
728 const char *name = "top level";
729 char *namep;
730 int vrb = 2;
732 if (!pretty_p)
734 name = "";
735 vrb = 0;
738 if (current_function_decl)
739 name = lang_hooks.decl_printable_name (current_function_decl, vrb);
741 if (c_lex_string_translate)
743 int len = strlen (name) + 3; /* Two for '"'s. One for NULL. */
744 cpp_string cstr = { 0, 0 }, strname;
746 namep = XNEWVEC (char, len);
747 snprintf (namep, len, "\"%s\"", name);
748 strname.text = (unsigned char *) namep;
749 strname.len = len - 1;
751 if (cpp_interpret_string (parse_in, &strname, 1, &cstr, false))
753 XDELETEVEC (namep);
754 return (char *) cstr.text;
757 else
758 namep = xstrdup (name);
760 return namep;
763 /* Expand DECL if it declares an entity not handled by the
764 common code. */
767 c_expand_decl (tree decl)
769 if (TREE_CODE (decl) == VAR_DECL && !TREE_STATIC (decl))
771 /* Let the back-end know about this variable. */
772 if (!anon_aggr_type_p (TREE_TYPE (decl)))
773 emit_local_var (decl);
774 else
775 expand_anon_union_decl (decl, NULL_TREE,
776 DECL_ANON_UNION_ELEMS (decl));
778 else
779 return 0;
781 return 1;
785 /* Return the VAR_DECL for a const char array naming the current
786 function. If the VAR_DECL has not yet been created, create it
787 now. RID indicates how it should be formatted and IDENTIFIER_NODE
788 ID is its name (unfortunately C and C++ hold the RID values of
789 keywords in different places, so we can't derive RID from ID in
790 this language independent code. */
792 tree
793 fname_decl (unsigned int rid, tree id)
795 unsigned ix;
796 tree decl = NULL_TREE;
798 for (ix = 0; fname_vars[ix].decl; ix++)
799 if (fname_vars[ix].rid == rid)
800 break;
802 decl = *fname_vars[ix].decl;
803 if (!decl)
805 /* If a tree is built here, it would normally have the lineno of
806 the current statement. Later this tree will be moved to the
807 beginning of the function and this line number will be wrong.
808 To avoid this problem set the lineno to 0 here; that prevents
809 it from appearing in the RTL. */
810 tree stmts;
811 location_t saved_location = input_location;
812 #ifdef USE_MAPPED_LOCATION
813 input_location = UNKNOWN_LOCATION;
814 #else
815 input_line = 0;
816 #endif
818 stmts = push_stmt_list ();
819 decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
820 stmts = pop_stmt_list (stmts);
821 if (!IS_EMPTY_STMT (stmts))
822 saved_function_name_decls
823 = tree_cons (decl, stmts, saved_function_name_decls);
824 *fname_vars[ix].decl = decl;
825 input_location = saved_location;
827 if (!ix && !current_function_decl)
828 pedwarn ("%qD is not defined outside of function scope", decl);
830 return decl;
833 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
835 tree
836 fix_string_type (tree value)
838 const int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
839 const int wide_flag = TREE_TYPE (value) == wchar_array_type_node;
840 const int nchars_max = flag_isoc99 ? 4095 : 509;
841 int length = TREE_STRING_LENGTH (value);
842 int nchars;
843 tree e_type, i_type, a_type;
845 /* Compute the number of elements, for the array type. */
846 nchars = wide_flag ? length / wchar_bytes : length;
848 if (pedantic && nchars - 1 > nchars_max && !c_dialect_cxx ())
849 pedwarn ("string length %qd is greater than the length %qd ISO C%d compilers are required to support",
850 nchars - 1, nchars_max, flag_isoc99 ? 99 : 89);
852 e_type = wide_flag ? wchar_type_node : char_type_node;
853 /* Create the array type for the string constant. flag_const_strings
854 says make the string constant an array of const char so that
855 copying it to a non-const pointer will get a warning. For C++,
856 this is the standard behavior.
858 The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified
859 array type being the unqualified version of that type.
860 Therefore, if we are constructing an array of const char, we must
861 construct the matching unqualified array type first. The C front
862 end does not require this, but it does no harm, so we do it
863 unconditionally. */
864 i_type = build_index_type (build_int_cst (NULL_TREE, nchars - 1));
865 a_type = build_array_type (e_type, i_type);
866 if (flag_const_strings)
867 a_type = c_build_qualified_type (a_type, TYPE_QUAL_CONST);
869 TREE_TYPE (value) = a_type;
870 TREE_CONSTANT (value) = 1;
871 TREE_INVARIANT (value) = 1;
872 TREE_READONLY (value) = 1;
873 TREE_STATIC (value) = 1;
874 return value;
877 /* Print a warning if a constant expression had overflow in folding.
878 Invoke this function on every expression that the language
879 requires to be a constant expression.
880 Note the ANSI C standard says it is erroneous for a
881 constant expression to overflow. */
883 void
884 constant_expression_warning (tree value)
886 if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
887 || TREE_CODE (value) == VECTOR_CST
888 || TREE_CODE (value) == COMPLEX_CST)
889 && TREE_CONSTANT_OVERFLOW (value) && pedantic)
890 pedwarn ("overflow in constant expression");
893 /* Print a warning if an expression had overflow in folding.
894 Invoke this function on every expression that
895 (1) appears in the source code, and
896 (2) might be a constant expression that overflowed, and
897 (3) is not already checked by convert_and_check;
898 however, do not invoke this function on operands of explicit casts. */
900 void
901 overflow_warning (tree value)
903 if ((TREE_CODE (value) == INTEGER_CST
904 || (TREE_CODE (value) == COMPLEX_CST
905 && TREE_CODE (TREE_REALPART (value)) == INTEGER_CST))
906 && TREE_OVERFLOW (value))
908 TREE_OVERFLOW (value) = 0;
909 if (skip_evaluation == 0)
910 warning (0, "integer overflow in expression");
912 else if ((TREE_CODE (value) == REAL_CST
913 || (TREE_CODE (value) == COMPLEX_CST
914 && TREE_CODE (TREE_REALPART (value)) == REAL_CST))
915 && TREE_OVERFLOW (value))
917 TREE_OVERFLOW (value) = 0;
918 if (skip_evaluation == 0)
919 warning (0, "floating point overflow in expression");
921 else if (TREE_CODE (value) == VECTOR_CST && TREE_OVERFLOW (value))
923 TREE_OVERFLOW (value) = 0;
924 if (skip_evaluation == 0)
925 warning (0, "vector overflow in expression");
929 /* Print a warning if a large constant is truncated to unsigned,
930 or if -Wconversion is used and a constant < 0 is converted to unsigned.
931 Invoke this function on every expression that might be implicitly
932 converted to an unsigned type. */
934 void
935 unsigned_conversion_warning (tree result, tree operand)
937 tree type = TREE_TYPE (result);
939 if (TREE_CODE (operand) == INTEGER_CST
940 && TREE_CODE (type) == INTEGER_TYPE
941 && TYPE_UNSIGNED (type)
942 && skip_evaluation == 0
943 && !int_fits_type_p (operand, type))
945 if (!int_fits_type_p (operand, c_common_signed_type (type)))
946 /* This detects cases like converting -129 or 256 to unsigned char. */
947 warning (0, "large integer implicitly truncated to unsigned type");
948 else
949 warning (OPT_Wconversion,
950 "negative integer implicitly converted to unsigned type");
954 /* Nonzero if constant C has a value that is permissible
955 for type TYPE (an INTEGER_TYPE). */
957 static int
958 constant_fits_type_p (tree c, tree type)
960 if (TREE_CODE (c) == INTEGER_CST)
961 return int_fits_type_p (c, type);
963 c = convert (type, c);
964 return !TREE_OVERFLOW (c);
967 /* Nonzero if vector types T1 and T2 can be converted to each other
968 without an explicit cast. */
970 vector_types_convertible_p (tree t1, tree t2)
972 return targetm.vector_opaque_p (t1)
973 || targetm.vector_opaque_p (t2)
974 || (tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2))
975 && INTEGRAL_TYPE_P (TREE_TYPE (t1))
976 == INTEGRAL_TYPE_P (TREE_TYPE (t2)));
979 /* Convert EXPR to TYPE, warning about conversion problems with constants.
980 Invoke this function on every expression that is converted implicitly,
981 i.e. because of language rules and not because of an explicit cast. */
983 tree
984 convert_and_check (tree type, tree expr)
986 tree t = convert (type, expr);
987 if (TREE_CODE (t) == INTEGER_CST)
989 if (TREE_OVERFLOW (t))
991 TREE_OVERFLOW (t) = 0;
993 /* Do not diagnose overflow in a constant expression merely
994 because a conversion overflowed. */
995 TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (expr);
997 /* No warning for converting 0x80000000 to int. */
998 if (!(TYPE_UNSIGNED (type) < TYPE_UNSIGNED (TREE_TYPE (expr))
999 && TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
1000 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr))))
1001 /* If EXPR fits in the unsigned version of TYPE,
1002 don't warn unless pedantic. */
1003 if ((pedantic
1004 || TYPE_UNSIGNED (type)
1005 || !constant_fits_type_p (expr,
1006 c_common_unsigned_type (type)))
1007 && skip_evaluation == 0)
1008 warning (0, "overflow in implicit constant conversion");
1010 else
1011 unsigned_conversion_warning (t, expr);
1013 return t;
1016 /* A node in a list that describes references to variables (EXPR), which are
1017 either read accesses if WRITER is zero, or write accesses, in which case
1018 WRITER is the parent of EXPR. */
1019 struct tlist
1021 struct tlist *next;
1022 tree expr, writer;
1025 /* Used to implement a cache the results of a call to verify_tree. We only
1026 use this for SAVE_EXPRs. */
1027 struct tlist_cache
1029 struct tlist_cache *next;
1030 struct tlist *cache_before_sp;
1031 struct tlist *cache_after_sp;
1032 tree expr;
1035 /* Obstack to use when allocating tlist structures, and corresponding
1036 firstobj. */
1037 static struct obstack tlist_obstack;
1038 static char *tlist_firstobj = 0;
1040 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
1041 warnings. */
1042 static struct tlist *warned_ids;
1043 /* SAVE_EXPRs need special treatment. We process them only once and then
1044 cache the results. */
1045 static struct tlist_cache *save_expr_cache;
1047 static void add_tlist (struct tlist **, struct tlist *, tree, int);
1048 static void merge_tlist (struct tlist **, struct tlist *, int);
1049 static void verify_tree (tree, struct tlist **, struct tlist **, tree);
1050 static int warning_candidate_p (tree);
1051 static void warn_for_collisions (struct tlist *);
1052 static void warn_for_collisions_1 (tree, tree, struct tlist *, int);
1053 static struct tlist *new_tlist (struct tlist *, tree, tree);
1055 /* Create a new struct tlist and fill in its fields. */
1056 static struct tlist *
1057 new_tlist (struct tlist *next, tree t, tree writer)
1059 struct tlist *l;
1060 l = XOBNEW (&tlist_obstack, struct tlist);
1061 l->next = next;
1062 l->expr = t;
1063 l->writer = writer;
1064 return l;
1067 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
1068 is nonnull, we ignore any node we find which has a writer equal to it. */
1070 static void
1071 add_tlist (struct tlist **to, struct tlist *add, tree exclude_writer, int copy)
1073 while (add)
1075 struct tlist *next = add->next;
1076 if (!copy)
1077 add->next = *to;
1078 if (!exclude_writer || add->writer != exclude_writer)
1079 *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
1080 add = next;
1084 /* Merge the nodes of ADD into TO. This merging process is done so that for
1085 each variable that already exists in TO, no new node is added; however if
1086 there is a write access recorded in ADD, and an occurrence on TO is only
1087 a read access, then the occurrence in TO will be modified to record the
1088 write. */
1090 static void
1091 merge_tlist (struct tlist **to, struct tlist *add, int copy)
1093 struct tlist **end = to;
1095 while (*end)
1096 end = &(*end)->next;
1098 while (add)
1100 int found = 0;
1101 struct tlist *tmp2;
1102 struct tlist *next = add->next;
1104 for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
1105 if (tmp2->expr == add->expr)
1107 found = 1;
1108 if (!tmp2->writer)
1109 tmp2->writer = add->writer;
1111 if (!found)
1113 *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
1114 end = &(*end)->next;
1115 *end = 0;
1117 add = next;
1121 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
1122 references in list LIST conflict with it, excluding reads if ONLY writers
1123 is nonzero. */
1125 static void
1126 warn_for_collisions_1 (tree written, tree writer, struct tlist *list,
1127 int only_writes)
1129 struct tlist *tmp;
1131 /* Avoid duplicate warnings. */
1132 for (tmp = warned_ids; tmp; tmp = tmp->next)
1133 if (tmp->expr == written)
1134 return;
1136 while (list)
1138 if (list->expr == written
1139 && list->writer != writer
1140 && (!only_writes || list->writer)
1141 && DECL_NAME (list->expr))
1143 warned_ids = new_tlist (warned_ids, written, NULL_TREE);
1144 warning (0, "operation on %qE may be undefined", list->expr);
1146 list = list->next;
1150 /* Given a list LIST of references to variables, find whether any of these
1151 can cause conflicts due to missing sequence points. */
1153 static void
1154 warn_for_collisions (struct tlist *list)
1156 struct tlist *tmp;
1158 for (tmp = list; tmp; tmp = tmp->next)
1160 if (tmp->writer)
1161 warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
1165 /* Return nonzero if X is a tree that can be verified by the sequence point
1166 warnings. */
1167 static int
1168 warning_candidate_p (tree x)
1170 return TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == PARM_DECL;
1173 /* Walk the tree X, and record accesses to variables. If X is written by the
1174 parent tree, WRITER is the parent.
1175 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
1176 expression or its only operand forces a sequence point, then everything up
1177 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
1178 in PNO_SP.
1179 Once we return, we will have emitted warnings if any subexpression before
1180 such a sequence point could be undefined. On a higher level, however, the
1181 sequence point may not be relevant, and we'll merge the two lists.
1183 Example: (b++, a) + b;
1184 The call that processes the COMPOUND_EXPR will store the increment of B
1185 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
1186 processes the PLUS_EXPR will need to merge the two lists so that
1187 eventually, all accesses end up on the same list (and we'll warn about the
1188 unordered subexpressions b++ and b.
1190 A note on merging. If we modify the former example so that our expression
1191 becomes
1192 (b++, b) + a
1193 care must be taken not simply to add all three expressions into the final
1194 PNO_SP list. The function merge_tlist takes care of that by merging the
1195 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1196 way, so that no more than one access to B is recorded. */
1198 static void
1199 verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp,
1200 tree writer)
1202 struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
1203 enum tree_code code;
1204 enum tree_code_class cl;
1206 /* X may be NULL if it is the operand of an empty statement expression
1207 ({ }). */
1208 if (x == NULL)
1209 return;
1211 restart:
1212 code = TREE_CODE (x);
1213 cl = TREE_CODE_CLASS (code);
1215 if (warning_candidate_p (x))
1217 *pno_sp = new_tlist (*pno_sp, x, writer);
1218 return;
1221 switch (code)
1223 case CONSTRUCTOR:
1224 return;
1226 case COMPOUND_EXPR:
1227 case TRUTH_ANDIF_EXPR:
1228 case TRUTH_ORIF_EXPR:
1229 tmp_before = tmp_nosp = tmp_list3 = 0;
1230 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1231 warn_for_collisions (tmp_nosp);
1232 merge_tlist (pbefore_sp, tmp_before, 0);
1233 merge_tlist (pbefore_sp, tmp_nosp, 0);
1234 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
1235 merge_tlist (pbefore_sp, tmp_list3, 0);
1236 return;
1238 case COND_EXPR:
1239 tmp_before = tmp_list2 = 0;
1240 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
1241 warn_for_collisions (tmp_list2);
1242 merge_tlist (pbefore_sp, tmp_before, 0);
1243 merge_tlist (pbefore_sp, tmp_list2, 1);
1245 tmp_list3 = tmp_nosp = 0;
1246 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
1247 warn_for_collisions (tmp_nosp);
1248 merge_tlist (pbefore_sp, tmp_list3, 0);
1250 tmp_list3 = tmp_list2 = 0;
1251 verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
1252 warn_for_collisions (tmp_list2);
1253 merge_tlist (pbefore_sp, tmp_list3, 0);
1254 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1255 two first, to avoid warning for (a ? b++ : b++). */
1256 merge_tlist (&tmp_nosp, tmp_list2, 0);
1257 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1258 return;
1260 case PREDECREMENT_EXPR:
1261 case PREINCREMENT_EXPR:
1262 case POSTDECREMENT_EXPR:
1263 case POSTINCREMENT_EXPR:
1264 verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
1265 return;
1267 case MODIFY_EXPR:
1268 tmp_before = tmp_nosp = tmp_list3 = 0;
1269 verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
1270 verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
1271 /* Expressions inside the LHS are not ordered wrt. the sequence points
1272 in the RHS. Example:
1273 *a = (a++, 2)
1274 Despite the fact that the modification of "a" is in the before_sp
1275 list (tmp_before), it conflicts with the use of "a" in the LHS.
1276 We can handle this by adding the contents of tmp_list3
1277 to those of tmp_before, and redoing the collision warnings for that
1278 list. */
1279 add_tlist (&tmp_before, tmp_list3, x, 1);
1280 warn_for_collisions (tmp_before);
1281 /* Exclude the LHS itself here; we first have to merge it into the
1282 tmp_nosp list. This is done to avoid warning for "a = a"; if we
1283 didn't exclude the LHS, we'd get it twice, once as a read and once
1284 as a write. */
1285 add_tlist (pno_sp, tmp_list3, x, 0);
1286 warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
1288 merge_tlist (pbefore_sp, tmp_before, 0);
1289 if (warning_candidate_p (TREE_OPERAND (x, 0)))
1290 merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
1291 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
1292 return;
1294 case CALL_EXPR:
1295 /* We need to warn about conflicts among arguments and conflicts between
1296 args and the function address. Side effects of the function address,
1297 however, are not ordered by the sequence point of the call. */
1298 tmp_before = tmp_nosp = tmp_list2 = tmp_list3 = 0;
1299 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1300 if (TREE_OPERAND (x, 1))
1301 verify_tree (TREE_OPERAND (x, 1), &tmp_list2, &tmp_list3, NULL_TREE);
1302 merge_tlist (&tmp_list3, tmp_list2, 0);
1303 add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
1304 add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
1305 warn_for_collisions (tmp_before);
1306 add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
1307 return;
1309 case TREE_LIST:
1310 /* Scan all the list, e.g. indices of multi dimensional array. */
1311 while (x)
1313 tmp_before = tmp_nosp = 0;
1314 verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
1315 merge_tlist (&tmp_nosp, tmp_before, 0);
1316 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1317 x = TREE_CHAIN (x);
1319 return;
1321 case SAVE_EXPR:
1323 struct tlist_cache *t;
1324 for (t = save_expr_cache; t; t = t->next)
1325 if (t->expr == x)
1326 break;
1328 if (!t)
1330 t = XOBNEW (&tlist_obstack, struct tlist_cache);
1331 t->next = save_expr_cache;
1332 t->expr = x;
1333 save_expr_cache = t;
1335 tmp_before = tmp_nosp = 0;
1336 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1337 warn_for_collisions (tmp_nosp);
1339 tmp_list3 = 0;
1340 while (tmp_nosp)
1342 struct tlist *t = tmp_nosp;
1343 tmp_nosp = t->next;
1344 merge_tlist (&tmp_list3, t, 0);
1346 t->cache_before_sp = tmp_before;
1347 t->cache_after_sp = tmp_list3;
1349 merge_tlist (pbefore_sp, t->cache_before_sp, 1);
1350 add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
1351 return;
1354 default:
1355 /* For other expressions, simply recurse on their operands.
1356 Manual tail recursion for unary expressions.
1357 Other non-expressions need not be processed. */
1358 if (cl == tcc_unary)
1360 x = TREE_OPERAND (x, 0);
1361 writer = 0;
1362 goto restart;
1364 else if (IS_EXPR_CODE_CLASS (cl))
1366 int lp;
1367 int max = TREE_CODE_LENGTH (TREE_CODE (x));
1368 for (lp = 0; lp < max; lp++)
1370 tmp_before = tmp_nosp = 0;
1371 verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, 0);
1372 merge_tlist (&tmp_nosp, tmp_before, 0);
1373 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1376 return;
1380 /* Try to warn for undefined behavior in EXPR due to missing sequence
1381 points. */
1383 void
1384 verify_sequence_points (tree expr)
1386 struct tlist *before_sp = 0, *after_sp = 0;
1388 warned_ids = 0;
1389 save_expr_cache = 0;
1390 if (tlist_firstobj == 0)
1392 gcc_obstack_init (&tlist_obstack);
1393 tlist_firstobj = (char *) obstack_alloc (&tlist_obstack, 0);
1396 verify_tree (expr, &before_sp, &after_sp, 0);
1397 warn_for_collisions (after_sp);
1398 obstack_free (&tlist_obstack, tlist_firstobj);
1401 /* Validate the expression after `case' and apply default promotions. */
1403 static tree
1404 check_case_value (tree value)
1406 if (value == NULL_TREE)
1407 return value;
1409 /* ??? Can we ever get nops here for a valid case value? We
1410 shouldn't for C. */
1411 STRIP_TYPE_NOPS (value);
1412 /* In C++, the following is allowed:
1414 const int i = 3;
1415 switch (...) { case i: ... }
1417 So, we try to reduce the VALUE to a constant that way. */
1418 if (c_dialect_cxx ())
1420 value = decl_constant_value (value);
1421 STRIP_TYPE_NOPS (value);
1422 value = fold (value);
1425 if (TREE_CODE (value) == INTEGER_CST)
1426 /* Promote char or short to int. */
1427 value = perform_integral_promotions (value);
1428 else if (value != error_mark_node)
1430 error ("case label does not reduce to an integer constant");
1431 value = error_mark_node;
1434 constant_expression_warning (value);
1436 return value;
1439 /* See if the case values LOW and HIGH are in the range of the original
1440 type (i.e. before the default conversion to int) of the switch testing
1441 expression.
1442 TYPE is the promoted type of the testing expression, and ORIG_TYPE is
1443 the type before promoting it. CASE_LOW_P is a pointer to the lower
1444 bound of the case label, and CASE_HIGH_P is the upper bound or NULL
1445 if the case is not a case range.
1446 The caller has to make sure that we are not called with NULL for
1447 CASE_LOW_P (i.e. the default case).
1448 Returns true if the case label is in range of ORIG_TYPE (saturated or
1449 untouched) or false if the label is out of range. */
1451 static bool
1452 check_case_bounds (tree type, tree orig_type,
1453 tree *case_low_p, tree *case_high_p)
1455 tree min_value, max_value;
1456 tree case_low = *case_low_p;
1457 tree case_high = case_high_p ? *case_high_p : case_low;
1459 /* If there was a problem with the original type, do nothing. */
1460 if (orig_type == error_mark_node)
1461 return true;
1463 min_value = TYPE_MIN_VALUE (orig_type);
1464 max_value = TYPE_MAX_VALUE (orig_type);
1466 /* Case label is less than minimum for type. */
1467 if (tree_int_cst_compare (case_low, min_value) < 0
1468 && tree_int_cst_compare (case_high, min_value) < 0)
1470 warning (0, "case label value is less than minimum value for type");
1471 return false;
1474 /* Case value is greater than maximum for type. */
1475 if (tree_int_cst_compare (case_low, max_value) > 0
1476 && tree_int_cst_compare (case_high, max_value) > 0)
1478 warning (0, "case label value exceeds maximum value for type");
1479 return false;
1482 /* Saturate lower case label value to minimum. */
1483 if (tree_int_cst_compare (case_high, min_value) >= 0
1484 && tree_int_cst_compare (case_low, min_value) < 0)
1486 warning (0, "lower value in case label range"
1487 " less than minimum value for type");
1488 case_low = min_value;
1491 /* Saturate upper case label value to maximum. */
1492 if (tree_int_cst_compare (case_low, max_value) <= 0
1493 && tree_int_cst_compare (case_high, max_value) > 0)
1495 warning (0, "upper value in case label range"
1496 " exceeds maximum value for type");
1497 case_high = max_value;
1500 if (*case_low_p != case_low)
1501 *case_low_p = convert (type, case_low);
1502 if (case_high_p && *case_high_p != case_high)
1503 *case_high_p = convert (type, case_high);
1505 return true;
1508 /* Return an integer type with BITS bits of precision,
1509 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1511 tree
1512 c_common_type_for_size (unsigned int bits, int unsignedp)
1514 if (bits == TYPE_PRECISION (integer_type_node))
1515 return unsignedp ? unsigned_type_node : integer_type_node;
1517 if (bits == TYPE_PRECISION (signed_char_type_node))
1518 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1520 if (bits == TYPE_PRECISION (short_integer_type_node))
1521 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1523 if (bits == TYPE_PRECISION (long_integer_type_node))
1524 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1526 if (bits == TYPE_PRECISION (long_long_integer_type_node))
1527 return (unsignedp ? long_long_unsigned_type_node
1528 : long_long_integer_type_node);
1530 if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
1531 return (unsignedp ? widest_unsigned_literal_type_node
1532 : widest_integer_literal_type_node);
1534 if (bits <= TYPE_PRECISION (intQI_type_node))
1535 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1537 if (bits <= TYPE_PRECISION (intHI_type_node))
1538 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1540 if (bits <= TYPE_PRECISION (intSI_type_node))
1541 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1543 if (bits <= TYPE_PRECISION (intDI_type_node))
1544 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1546 return 0;
1549 /* Used for communication between c_common_type_for_mode and
1550 c_register_builtin_type. */
1551 static GTY(()) tree registered_builtin_types;
1553 /* Return a data type that has machine mode MODE.
1554 If the mode is an integer,
1555 then UNSIGNEDP selects between signed and unsigned types. */
1557 tree
1558 c_common_type_for_mode (enum machine_mode mode, int unsignedp)
1560 tree t;
1562 if (mode == TYPE_MODE (integer_type_node))
1563 return unsignedp ? unsigned_type_node : integer_type_node;
1565 if (mode == TYPE_MODE (signed_char_type_node))
1566 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1568 if (mode == TYPE_MODE (short_integer_type_node))
1569 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1571 if (mode == TYPE_MODE (long_integer_type_node))
1572 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1574 if (mode == TYPE_MODE (long_long_integer_type_node))
1575 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
1577 if (mode == TYPE_MODE (widest_integer_literal_type_node))
1578 return unsignedp ? widest_unsigned_literal_type_node
1579 : widest_integer_literal_type_node;
1581 if (mode == QImode)
1582 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1584 if (mode == HImode)
1585 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1587 if (mode == SImode)
1588 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1590 if (mode == DImode)
1591 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1593 #if HOST_BITS_PER_WIDE_INT >= 64
1594 if (mode == TYPE_MODE (intTI_type_node))
1595 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1596 #endif
1598 if (mode == TYPE_MODE (float_type_node))
1599 return float_type_node;
1601 if (mode == TYPE_MODE (double_type_node))
1602 return double_type_node;
1604 if (mode == TYPE_MODE (long_double_type_node))
1605 return long_double_type_node;
1607 if (mode == TYPE_MODE (void_type_node))
1608 return void_type_node;
1610 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
1611 return (unsignedp
1612 ? make_unsigned_type (GET_MODE_PRECISION (mode))
1613 : make_signed_type (GET_MODE_PRECISION (mode)));
1615 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
1616 return (unsignedp
1617 ? make_unsigned_type (GET_MODE_PRECISION (mode))
1618 : make_signed_type (GET_MODE_PRECISION (mode)));
1620 if (COMPLEX_MODE_P (mode))
1622 enum machine_mode inner_mode;
1623 tree inner_type;
1625 if (mode == TYPE_MODE (complex_float_type_node))
1626 return complex_float_type_node;
1627 if (mode == TYPE_MODE (complex_double_type_node))
1628 return complex_double_type_node;
1629 if (mode == TYPE_MODE (complex_long_double_type_node))
1630 return complex_long_double_type_node;
1632 if (mode == TYPE_MODE (complex_integer_type_node) && !unsignedp)
1633 return complex_integer_type_node;
1635 inner_mode = GET_MODE_INNER (mode);
1636 inner_type = c_common_type_for_mode (inner_mode, unsignedp);
1637 if (inner_type != NULL_TREE)
1638 return build_complex_type (inner_type);
1640 else if (VECTOR_MODE_P (mode))
1642 enum machine_mode inner_mode = GET_MODE_INNER (mode);
1643 tree inner_type = c_common_type_for_mode (inner_mode, unsignedp);
1644 if (inner_type != NULL_TREE)
1645 return build_vector_type_for_mode (inner_type, mode);
1648 for (t = registered_builtin_types; t; t = TREE_CHAIN (t))
1649 if (TYPE_MODE (TREE_VALUE (t)) == mode)
1650 return TREE_VALUE (t);
1652 return 0;
1655 /* Return an unsigned type the same as TYPE in other respects. */
1656 tree
1657 c_common_unsigned_type (tree type)
1659 tree type1 = TYPE_MAIN_VARIANT (type);
1660 if (type1 == signed_char_type_node || type1 == char_type_node)
1661 return unsigned_char_type_node;
1662 if (type1 == integer_type_node)
1663 return unsigned_type_node;
1664 if (type1 == short_integer_type_node)
1665 return short_unsigned_type_node;
1666 if (type1 == long_integer_type_node)
1667 return long_unsigned_type_node;
1668 if (type1 == long_long_integer_type_node)
1669 return long_long_unsigned_type_node;
1670 if (type1 == widest_integer_literal_type_node)
1671 return widest_unsigned_literal_type_node;
1672 #if HOST_BITS_PER_WIDE_INT >= 64
1673 if (type1 == intTI_type_node)
1674 return unsigned_intTI_type_node;
1675 #endif
1676 if (type1 == intDI_type_node)
1677 return unsigned_intDI_type_node;
1678 if (type1 == intSI_type_node)
1679 return unsigned_intSI_type_node;
1680 if (type1 == intHI_type_node)
1681 return unsigned_intHI_type_node;
1682 if (type1 == intQI_type_node)
1683 return unsigned_intQI_type_node;
1685 return c_common_signed_or_unsigned_type (1, type);
1688 /* Return a signed type the same as TYPE in other respects. */
1690 tree
1691 c_common_signed_type (tree type)
1693 tree type1 = TYPE_MAIN_VARIANT (type);
1694 if (type1 == unsigned_char_type_node || type1 == char_type_node)
1695 return signed_char_type_node;
1696 if (type1 == unsigned_type_node)
1697 return integer_type_node;
1698 if (type1 == short_unsigned_type_node)
1699 return short_integer_type_node;
1700 if (type1 == long_unsigned_type_node)
1701 return long_integer_type_node;
1702 if (type1 == long_long_unsigned_type_node)
1703 return long_long_integer_type_node;
1704 if (type1 == widest_unsigned_literal_type_node)
1705 return widest_integer_literal_type_node;
1706 #if HOST_BITS_PER_WIDE_INT >= 64
1707 if (type1 == unsigned_intTI_type_node)
1708 return intTI_type_node;
1709 #endif
1710 if (type1 == unsigned_intDI_type_node)
1711 return intDI_type_node;
1712 if (type1 == unsigned_intSI_type_node)
1713 return intSI_type_node;
1714 if (type1 == unsigned_intHI_type_node)
1715 return intHI_type_node;
1716 if (type1 == unsigned_intQI_type_node)
1717 return intQI_type_node;
1719 return c_common_signed_or_unsigned_type (0, type);
1722 /* Return a type the same as TYPE except unsigned or
1723 signed according to UNSIGNEDP. */
1725 tree
1726 c_common_signed_or_unsigned_type (int unsignedp, tree type)
1728 if (!INTEGRAL_TYPE_P (type)
1729 || TYPE_UNSIGNED (type) == unsignedp)
1730 return type;
1732 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
1733 the precision; they have precision set to match their range, but
1734 may use a wider mode to match an ABI. If we change modes, we may
1735 wind up with bad conversions. For INTEGER_TYPEs in C, must check
1736 the precision as well, so as to yield correct results for
1737 bit-field types. C++ does not have these separate bit-field
1738 types, and producing a signed or unsigned variant of an
1739 ENUMERAL_TYPE may cause other problems as well. */
1741 #define TYPE_OK(node) \
1742 (TYPE_MODE (type) == TYPE_MODE (node) \
1743 && (c_dialect_cxx () || TYPE_PRECISION (type) == TYPE_PRECISION (node)))
1744 if (TYPE_OK (signed_char_type_node))
1745 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1746 if (TYPE_OK (integer_type_node))
1747 return unsignedp ? unsigned_type_node : integer_type_node;
1748 if (TYPE_OK (short_integer_type_node))
1749 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1750 if (TYPE_OK (long_integer_type_node))
1751 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1752 if (TYPE_OK (long_long_integer_type_node))
1753 return (unsignedp ? long_long_unsigned_type_node
1754 : long_long_integer_type_node);
1755 if (TYPE_OK (widest_integer_literal_type_node))
1756 return (unsignedp ? widest_unsigned_literal_type_node
1757 : widest_integer_literal_type_node);
1759 #if HOST_BITS_PER_WIDE_INT >= 64
1760 if (TYPE_OK (intTI_type_node))
1761 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1762 #endif
1763 if (TYPE_OK (intDI_type_node))
1764 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1765 if (TYPE_OK (intSI_type_node))
1766 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1767 if (TYPE_OK (intHI_type_node))
1768 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1769 if (TYPE_OK (intQI_type_node))
1770 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1771 #undef TYPE_OK
1773 if (c_dialect_cxx ())
1774 return type;
1775 else
1776 return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
1779 /* The C version of the register_builtin_type langhook. */
1781 void
1782 c_register_builtin_type (tree type, const char* name)
1784 tree decl;
1786 decl = build_decl (TYPE_DECL, get_identifier (name), type);
1787 DECL_ARTIFICIAL (decl) = 1;
1788 if (!TYPE_NAME (type))
1789 TYPE_NAME (type) = decl;
1790 pushdecl (decl);
1792 registered_builtin_types = tree_cons (0, type, registered_builtin_types);
1796 /* Return the minimum number of bits needed to represent VALUE in a
1797 signed or unsigned type, UNSIGNEDP says which. */
1799 unsigned int
1800 min_precision (tree value, int unsignedp)
1802 int log;
1804 /* If the value is negative, compute its negative minus 1. The latter
1805 adjustment is because the absolute value of the largest negative value
1806 is one larger than the largest positive value. This is equivalent to
1807 a bit-wise negation, so use that operation instead. */
1809 if (tree_int_cst_sgn (value) < 0)
1810 value = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (value), value);
1812 /* Return the number of bits needed, taking into account the fact
1813 that we need one more bit for a signed than unsigned type. */
1815 if (integer_zerop (value))
1816 log = 0;
1817 else
1818 log = tree_floor_log2 (value);
1820 return log + 1 + !unsignedp;
1823 /* Print an error message for invalid operands to arith operation
1824 CODE. NOP_EXPR is used as a special case (see
1825 c_common_truthvalue_conversion). */
1827 void
1828 binary_op_error (enum tree_code code)
1830 const char *opname;
1832 switch (code)
1834 case NOP_EXPR:
1835 error ("invalid truth-value expression");
1836 return;
1838 case PLUS_EXPR:
1839 opname = "+"; break;
1840 case MINUS_EXPR:
1841 opname = "-"; break;
1842 case MULT_EXPR:
1843 opname = "*"; break;
1844 case MAX_EXPR:
1845 opname = "max"; break;
1846 case MIN_EXPR:
1847 opname = "min"; break;
1848 case EQ_EXPR:
1849 opname = "=="; break;
1850 case NE_EXPR:
1851 opname = "!="; break;
1852 case LE_EXPR:
1853 opname = "<="; break;
1854 case GE_EXPR:
1855 opname = ">="; break;
1856 case LT_EXPR:
1857 opname = "<"; break;
1858 case GT_EXPR:
1859 opname = ">"; break;
1860 case LSHIFT_EXPR:
1861 opname = "<<"; break;
1862 case RSHIFT_EXPR:
1863 opname = ">>"; break;
1864 case TRUNC_MOD_EXPR:
1865 case FLOOR_MOD_EXPR:
1866 opname = "%"; break;
1867 case TRUNC_DIV_EXPR:
1868 case FLOOR_DIV_EXPR:
1869 opname = "/"; break;
1870 case BIT_AND_EXPR:
1871 opname = "&"; break;
1872 case BIT_IOR_EXPR:
1873 opname = "|"; break;
1874 case TRUTH_ANDIF_EXPR:
1875 opname = "&&"; break;
1876 case TRUTH_ORIF_EXPR:
1877 opname = "||"; break;
1878 case BIT_XOR_EXPR:
1879 opname = "^"; break;
1880 default:
1881 gcc_unreachable ();
1883 error ("invalid operands to binary %s", opname);
1886 /* Subroutine of build_binary_op, used for comparison operations.
1887 See if the operands have both been converted from subword integer types
1888 and, if so, perhaps change them both back to their original type.
1889 This function is also responsible for converting the two operands
1890 to the proper common type for comparison.
1892 The arguments of this function are all pointers to local variables
1893 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
1894 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
1896 If this function returns nonzero, it means that the comparison has
1897 a constant value. What this function returns is an expression for
1898 that value. */
1900 tree
1901 shorten_compare (tree *op0_ptr, tree *op1_ptr, tree *restype_ptr,
1902 enum tree_code *rescode_ptr)
1904 tree type;
1905 tree op0 = *op0_ptr;
1906 tree op1 = *op1_ptr;
1907 int unsignedp0, unsignedp1;
1908 int real1, real2;
1909 tree primop0, primop1;
1910 enum tree_code code = *rescode_ptr;
1912 /* Throw away any conversions to wider types
1913 already present in the operands. */
1915 primop0 = get_narrower (op0, &unsignedp0);
1916 primop1 = get_narrower (op1, &unsignedp1);
1918 /* Handle the case that OP0 does not *contain* a conversion
1919 but it *requires* conversion to FINAL_TYPE. */
1921 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
1922 unsignedp0 = TYPE_UNSIGNED (TREE_TYPE (op0));
1923 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
1924 unsignedp1 = TYPE_UNSIGNED (TREE_TYPE (op1));
1926 /* If one of the operands must be floated, we cannot optimize. */
1927 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
1928 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
1930 /* If first arg is constant, swap the args (changing operation
1931 so value is preserved), for canonicalization. Don't do this if
1932 the second arg is 0. */
1934 if (TREE_CONSTANT (primop0)
1935 && !integer_zerop (primop1) && !real_zerop (primop1))
1937 tree tem = primop0;
1938 int temi = unsignedp0;
1939 primop0 = primop1;
1940 primop1 = tem;
1941 tem = op0;
1942 op0 = op1;
1943 op1 = tem;
1944 *op0_ptr = op0;
1945 *op1_ptr = op1;
1946 unsignedp0 = unsignedp1;
1947 unsignedp1 = temi;
1948 temi = real1;
1949 real1 = real2;
1950 real2 = temi;
1952 switch (code)
1954 case LT_EXPR:
1955 code = GT_EXPR;
1956 break;
1957 case GT_EXPR:
1958 code = LT_EXPR;
1959 break;
1960 case LE_EXPR:
1961 code = GE_EXPR;
1962 break;
1963 case GE_EXPR:
1964 code = LE_EXPR;
1965 break;
1966 default:
1967 break;
1969 *rescode_ptr = code;
1972 /* If comparing an integer against a constant more bits wide,
1973 maybe we can deduce a value of 1 or 0 independent of the data.
1974 Or else truncate the constant now
1975 rather than extend the variable at run time.
1977 This is only interesting if the constant is the wider arg.
1978 Also, it is not safe if the constant is unsigned and the
1979 variable arg is signed, since in this case the variable
1980 would be sign-extended and then regarded as unsigned.
1981 Our technique fails in this case because the lowest/highest
1982 possible unsigned results don't follow naturally from the
1983 lowest/highest possible values of the variable operand.
1984 For just EQ_EXPR and NE_EXPR there is another technique that
1985 could be used: see if the constant can be faithfully represented
1986 in the other operand's type, by truncating it and reextending it
1987 and see if that preserves the constant's value. */
1989 if (!real1 && !real2
1990 && TREE_CODE (primop1) == INTEGER_CST
1991 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
1993 int min_gt, max_gt, min_lt, max_lt;
1994 tree maxval, minval;
1995 /* 1 if comparison is nominally unsigned. */
1996 int unsignedp = TYPE_UNSIGNED (*restype_ptr);
1997 tree val;
1999 type = c_common_signed_or_unsigned_type (unsignedp0,
2000 TREE_TYPE (primop0));
2002 maxval = TYPE_MAX_VALUE (type);
2003 minval = TYPE_MIN_VALUE (type);
2005 if (unsignedp && !unsignedp0)
2006 *restype_ptr = c_common_signed_type (*restype_ptr);
2008 if (TREE_TYPE (primop1) != *restype_ptr)
2010 /* Convert primop1 to target type, but do not introduce
2011 additional overflow. We know primop1 is an int_cst. */
2012 tree tmp = build_int_cst_wide (*restype_ptr,
2013 TREE_INT_CST_LOW (primop1),
2014 TREE_INT_CST_HIGH (primop1));
2016 primop1 = force_fit_type (tmp, 0, TREE_OVERFLOW (primop1),
2017 TREE_CONSTANT_OVERFLOW (primop1));
2019 if (type != *restype_ptr)
2021 minval = convert (*restype_ptr, minval);
2022 maxval = convert (*restype_ptr, maxval);
2025 if (unsignedp && unsignedp0)
2027 min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
2028 max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
2029 min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
2030 max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
2032 else
2034 min_gt = INT_CST_LT (primop1, minval);
2035 max_gt = INT_CST_LT (primop1, maxval);
2036 min_lt = INT_CST_LT (minval, primop1);
2037 max_lt = INT_CST_LT (maxval, primop1);
2040 val = 0;
2041 /* This used to be a switch, but Genix compiler can't handle that. */
2042 if (code == NE_EXPR)
2044 if (max_lt || min_gt)
2045 val = truthvalue_true_node;
2047 else if (code == EQ_EXPR)
2049 if (max_lt || min_gt)
2050 val = truthvalue_false_node;
2052 else if (code == LT_EXPR)
2054 if (max_lt)
2055 val = truthvalue_true_node;
2056 if (!min_lt)
2057 val = truthvalue_false_node;
2059 else if (code == GT_EXPR)
2061 if (min_gt)
2062 val = truthvalue_true_node;
2063 if (!max_gt)
2064 val = truthvalue_false_node;
2066 else if (code == LE_EXPR)
2068 if (!max_gt)
2069 val = truthvalue_true_node;
2070 if (min_gt)
2071 val = truthvalue_false_node;
2073 else if (code == GE_EXPR)
2075 if (!min_lt)
2076 val = truthvalue_true_node;
2077 if (max_lt)
2078 val = truthvalue_false_node;
2081 /* If primop0 was sign-extended and unsigned comparison specd,
2082 we did a signed comparison above using the signed type bounds.
2083 But the comparison we output must be unsigned.
2085 Also, for inequalities, VAL is no good; but if the signed
2086 comparison had *any* fixed result, it follows that the
2087 unsigned comparison just tests the sign in reverse
2088 (positive values are LE, negative ones GE).
2089 So we can generate an unsigned comparison
2090 against an extreme value of the signed type. */
2092 if (unsignedp && !unsignedp0)
2094 if (val != 0)
2095 switch (code)
2097 case LT_EXPR:
2098 case GE_EXPR:
2099 primop1 = TYPE_MIN_VALUE (type);
2100 val = 0;
2101 break;
2103 case LE_EXPR:
2104 case GT_EXPR:
2105 primop1 = TYPE_MAX_VALUE (type);
2106 val = 0;
2107 break;
2109 default:
2110 break;
2112 type = c_common_unsigned_type (type);
2115 if (TREE_CODE (primop0) != INTEGER_CST)
2117 if (val == truthvalue_false_node)
2118 warning (0, "comparison is always false due to limited range of data type");
2119 if (val == truthvalue_true_node)
2120 warning (0, "comparison is always true due to limited range of data type");
2123 if (val != 0)
2125 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2126 if (TREE_SIDE_EFFECTS (primop0))
2127 return build2 (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
2128 return val;
2131 /* Value is not predetermined, but do the comparison
2132 in the type of the operand that is not constant.
2133 TYPE is already properly set. */
2135 else if (real1 && real2
2136 && (TYPE_PRECISION (TREE_TYPE (primop0))
2137 == TYPE_PRECISION (TREE_TYPE (primop1))))
2138 type = TREE_TYPE (primop0);
2140 /* If args' natural types are both narrower than nominal type
2141 and both extend in the same manner, compare them
2142 in the type of the wider arg.
2143 Otherwise must actually extend both to the nominal
2144 common type lest different ways of extending
2145 alter the result.
2146 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
2148 else if (unsignedp0 == unsignedp1 && real1 == real2
2149 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
2150 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
2152 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2153 type = c_common_signed_or_unsigned_type (unsignedp0
2154 || TYPE_UNSIGNED (*restype_ptr),
2155 type);
2156 /* Make sure shorter operand is extended the right way
2157 to match the longer operand. */
2158 primop0
2159 = convert (c_common_signed_or_unsigned_type (unsignedp0,
2160 TREE_TYPE (primop0)),
2161 primop0);
2162 primop1
2163 = convert (c_common_signed_or_unsigned_type (unsignedp1,
2164 TREE_TYPE (primop1)),
2165 primop1);
2167 else
2169 /* Here we must do the comparison on the nominal type
2170 using the args exactly as we received them. */
2171 type = *restype_ptr;
2172 primop0 = op0;
2173 primop1 = op1;
2175 if (!real1 && !real2 && integer_zerop (primop1)
2176 && TYPE_UNSIGNED (*restype_ptr))
2178 tree value = 0;
2179 switch (code)
2181 case GE_EXPR:
2182 /* All unsigned values are >= 0, so we warn if extra warnings
2183 are requested. However, if OP0 is a constant that is
2184 >= 0, the signedness of the comparison isn't an issue,
2185 so suppress the warning. */
2186 if (extra_warnings && !in_system_header
2187 && !(TREE_CODE (primop0) == INTEGER_CST
2188 && !TREE_OVERFLOW (convert (c_common_signed_type (type),
2189 primop0))))
2190 warning (0, "comparison of unsigned expression >= 0 is always true");
2191 value = truthvalue_true_node;
2192 break;
2194 case LT_EXPR:
2195 if (extra_warnings && !in_system_header
2196 && !(TREE_CODE (primop0) == INTEGER_CST
2197 && !TREE_OVERFLOW (convert (c_common_signed_type (type),
2198 primop0))))
2199 warning (0, "comparison of unsigned expression < 0 is always false");
2200 value = truthvalue_false_node;
2201 break;
2203 default:
2204 break;
2207 if (value != 0)
2209 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2210 if (TREE_SIDE_EFFECTS (primop0))
2211 return build2 (COMPOUND_EXPR, TREE_TYPE (value),
2212 primop0, value);
2213 return value;
2218 *op0_ptr = convert (type, primop0);
2219 *op1_ptr = convert (type, primop1);
2221 *restype_ptr = truthvalue_type_node;
2223 return 0;
2226 /* Return a tree for the sum or difference (RESULTCODE says which)
2227 of pointer PTROP and integer INTOP. */
2229 tree
2230 pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
2232 tree size_exp;
2234 /* The result is a pointer of the same type that is being added. */
2236 tree result_type = TREE_TYPE (ptrop);
2238 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
2240 if (pedantic || warn_pointer_arith)
2241 pedwarn ("pointer of type %<void *%> used in arithmetic");
2242 size_exp = integer_one_node;
2244 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
2246 if (pedantic || warn_pointer_arith)
2247 pedwarn ("pointer to a function used in arithmetic");
2248 size_exp = integer_one_node;
2250 else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
2252 if (pedantic || warn_pointer_arith)
2253 pedwarn ("pointer to member function used in arithmetic");
2254 size_exp = integer_one_node;
2256 else
2257 size_exp = size_in_bytes (TREE_TYPE (result_type));
2259 /* If what we are about to multiply by the size of the elements
2260 contains a constant term, apply distributive law
2261 and multiply that constant term separately.
2262 This helps produce common subexpressions. */
2264 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
2265 && !TREE_CONSTANT (intop)
2266 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
2267 && TREE_CONSTANT (size_exp)
2268 /* If the constant comes from pointer subtraction,
2269 skip this optimization--it would cause an error. */
2270 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
2271 /* If the constant is unsigned, and smaller than the pointer size,
2272 then we must skip this optimization. This is because it could cause
2273 an overflow error if the constant is negative but INTOP is not. */
2274 && (!TYPE_UNSIGNED (TREE_TYPE (intop))
2275 || (TYPE_PRECISION (TREE_TYPE (intop))
2276 == TYPE_PRECISION (TREE_TYPE (ptrop)))))
2278 enum tree_code subcode = resultcode;
2279 tree int_type = TREE_TYPE (intop);
2280 if (TREE_CODE (intop) == MINUS_EXPR)
2281 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
2282 /* Convert both subexpression types to the type of intop,
2283 because weird cases involving pointer arithmetic
2284 can result in a sum or difference with different type args. */
2285 ptrop = build_binary_op (subcode, ptrop,
2286 convert (int_type, TREE_OPERAND (intop, 1)), 1);
2287 intop = convert (int_type, TREE_OPERAND (intop, 0));
2290 /* Convert the integer argument to a type the same size as sizetype
2291 so the multiply won't overflow spuriously. */
2293 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
2294 || TYPE_UNSIGNED (TREE_TYPE (intop)) != TYPE_UNSIGNED (sizetype))
2295 intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
2296 TYPE_UNSIGNED (sizetype)), intop);
2298 /* Replace the integer argument with a suitable product by the object size.
2299 Do this multiplication as signed, then convert to the appropriate
2300 pointer type (actually unsigned integral). */
2302 intop = convert (result_type,
2303 build_binary_op (MULT_EXPR, intop,
2304 convert (TREE_TYPE (intop), size_exp), 1));
2306 /* Create the sum or difference. */
2307 return fold_build2 (resultcode, result_type, ptrop, intop);
2310 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2311 or for an `if' or `while' statement or ?..: exp. It should already
2312 have been validated to be of suitable type; otherwise, a bad
2313 diagnostic may result.
2315 This preparation consists of taking the ordinary
2316 representation of an expression expr and producing a valid tree
2317 boolean expression describing whether expr is nonzero. We could
2318 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
2319 but we optimize comparisons, &&, ||, and !.
2321 The resulting type should always be `truthvalue_type_node'. */
2323 tree
2324 c_common_truthvalue_conversion (tree expr)
2326 switch (TREE_CODE (expr))
2328 case EQ_EXPR: case NE_EXPR: case UNEQ_EXPR: case LTGT_EXPR:
2329 case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
2330 case UNLE_EXPR: case UNGE_EXPR: case UNLT_EXPR: case UNGT_EXPR:
2331 case ORDERED_EXPR: case UNORDERED_EXPR:
2332 if (TREE_TYPE (expr) == truthvalue_type_node)
2333 return expr;
2334 return build2 (TREE_CODE (expr), truthvalue_type_node,
2335 TREE_OPERAND (expr, 0), TREE_OPERAND (expr, 1));
2337 case TRUTH_ANDIF_EXPR:
2338 case TRUTH_ORIF_EXPR:
2339 case TRUTH_AND_EXPR:
2340 case TRUTH_OR_EXPR:
2341 case TRUTH_XOR_EXPR:
2342 if (TREE_TYPE (expr) == truthvalue_type_node)
2343 return expr;
2344 return build2 (TREE_CODE (expr), truthvalue_type_node,
2345 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)),
2346 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)));
2348 case TRUTH_NOT_EXPR:
2349 if (TREE_TYPE (expr) == truthvalue_type_node)
2350 return expr;
2351 return build1 (TREE_CODE (expr), truthvalue_type_node,
2352 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)));
2354 case ERROR_MARK:
2355 return expr;
2357 case INTEGER_CST:
2358 /* Avoid integer_zerop to ignore TREE_CONSTANT_OVERFLOW. */
2359 return (TREE_INT_CST_LOW (expr) != 0 || TREE_INT_CST_HIGH (expr) != 0)
2360 ? truthvalue_true_node
2361 : truthvalue_false_node;
2363 case REAL_CST:
2364 return real_compare (NE_EXPR, &TREE_REAL_CST (expr), &dconst0)
2365 ? truthvalue_true_node
2366 : truthvalue_false_node;
2368 case FUNCTION_DECL:
2369 expr = build_unary_op (ADDR_EXPR, expr, 0);
2370 /* Fall through. */
2372 case ADDR_EXPR:
2374 if (TREE_CODE (TREE_OPERAND (expr, 0)) == FUNCTION_DECL
2375 && !DECL_WEAK (TREE_OPERAND (expr, 0)))
2377 /* Common Ada/Pascal programmer's mistake. We always warn
2378 about this since it is so bad. */
2379 warning (0, "the address of %qD, will always evaluate as %<true%>",
2380 TREE_OPERAND (expr, 0));
2381 return truthvalue_true_node;
2384 /* If we are taking the address of an external decl, it might be
2385 zero if it is weak, so we cannot optimize. */
2386 if (DECL_P (TREE_OPERAND (expr, 0))
2387 && DECL_EXTERNAL (TREE_OPERAND (expr, 0)))
2388 break;
2390 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 0)))
2391 return build2 (COMPOUND_EXPR, truthvalue_type_node,
2392 TREE_OPERAND (expr, 0), truthvalue_true_node);
2393 else
2394 return truthvalue_true_node;
2397 case COMPLEX_EXPR:
2398 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
2399 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2400 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)),
2401 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2404 case NEGATE_EXPR:
2405 case ABS_EXPR:
2406 case FLOAT_EXPR:
2407 /* These don't change whether an object is nonzero or zero. */
2408 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2410 case LROTATE_EXPR:
2411 case RROTATE_EXPR:
2412 /* These don't change whether an object is zero or nonzero, but
2413 we can't ignore them if their second arg has side-effects. */
2414 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2415 return build2 (COMPOUND_EXPR, truthvalue_type_node,
2416 TREE_OPERAND (expr, 1),
2417 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)));
2418 else
2419 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2421 case COND_EXPR:
2422 /* Distribute the conversion into the arms of a COND_EXPR. */
2423 return fold_build3 (COND_EXPR, truthvalue_type_node,
2424 TREE_OPERAND (expr, 0),
2425 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2426 c_common_truthvalue_conversion (TREE_OPERAND (expr, 2)));
2428 case CONVERT_EXPR:
2429 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2430 since that affects how `default_conversion' will behave. */
2431 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
2432 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2433 break;
2434 /* Fall through.... */
2435 case NOP_EXPR:
2436 /* If this is widening the argument, we can ignore it. */
2437 if (TYPE_PRECISION (TREE_TYPE (expr))
2438 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2439 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2440 break;
2442 case MINUS_EXPR:
2443 /* Perhaps reduce (x - y) != 0 to (x != y). The expressions
2444 aren't guaranteed to the be same for modes that can represent
2445 infinity, since if x and y are both +infinity, or both
2446 -infinity, then x - y is not a number.
2448 Note that this transformation is safe when x or y is NaN.
2449 (x - y) is then NaN, and both (x - y) != 0 and x != y will
2450 be false. */
2451 if (HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr, 0)))))
2452 break;
2453 /* Fall through.... */
2454 case BIT_XOR_EXPR:
2455 /* This and MINUS_EXPR can be changed into a comparison of the
2456 two objects. */
2457 if (TREE_TYPE (TREE_OPERAND (expr, 0))
2458 == TREE_TYPE (TREE_OPERAND (expr, 1)))
2459 return fold_build2 (NE_EXPR, truthvalue_type_node,
2460 TREE_OPERAND (expr, 0), TREE_OPERAND (expr, 1));
2461 return fold_build2 (NE_EXPR, truthvalue_type_node,
2462 TREE_OPERAND (expr, 0),
2463 fold_convert (TREE_TYPE (TREE_OPERAND (expr, 0)),
2464 TREE_OPERAND (expr, 1)));
2466 case BIT_AND_EXPR:
2467 if (integer_onep (TREE_OPERAND (expr, 1))
2468 && TREE_TYPE (expr) != truthvalue_type_node)
2469 /* Using convert here would cause infinite recursion. */
2470 return build1 (NOP_EXPR, truthvalue_type_node, expr);
2471 break;
2473 case MODIFY_EXPR:
2474 if (!TREE_NO_WARNING (expr))
2475 warning (OPT_Wparentheses,
2476 "suggest parentheses around assignment used as truth value");
2477 break;
2479 default:
2480 break;
2483 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
2485 tree t = save_expr (expr);
2486 return (build_binary_op
2487 ((TREE_SIDE_EFFECTS (expr)
2488 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2489 c_common_truthvalue_conversion (build_unary_op (REALPART_EXPR, t, 0)),
2490 c_common_truthvalue_conversion (build_unary_op (IMAGPART_EXPR, t, 0)),
2491 0));
2494 return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
2497 static void def_builtin_1 (enum built_in_function fncode,
2498 const char *name,
2499 enum built_in_class fnclass,
2500 tree fntype, tree libtype,
2501 bool both_p, bool fallback_p, bool nonansi_p,
2502 tree fnattrs, bool implicit_p);
2504 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2505 down to the element type of an array. */
2507 tree
2508 c_build_qualified_type (tree type, int type_quals)
2510 if (type == error_mark_node)
2511 return type;
2513 if (TREE_CODE (type) == ARRAY_TYPE)
2515 tree t;
2516 tree element_type = c_build_qualified_type (TREE_TYPE (type),
2517 type_quals);
2519 /* See if we already have an identically qualified type. */
2520 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
2522 if (TYPE_QUALS (strip_array_types (t)) == type_quals
2523 && TYPE_NAME (t) == TYPE_NAME (type)
2524 && TYPE_CONTEXT (t) == TYPE_CONTEXT (type)
2525 && attribute_list_equal (TYPE_ATTRIBUTES (t),
2526 TYPE_ATTRIBUTES (type)))
2527 break;
2529 if (!t)
2531 t = build_variant_type_copy (type);
2532 TREE_TYPE (t) = element_type;
2534 return t;
2537 /* A restrict-qualified pointer type must be a pointer to object or
2538 incomplete type. Note that the use of POINTER_TYPE_P also allows
2539 REFERENCE_TYPEs, which is appropriate for C++. */
2540 if ((type_quals & TYPE_QUAL_RESTRICT)
2541 && (!POINTER_TYPE_P (type)
2542 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
2544 error ("invalid use of %<restrict%>");
2545 type_quals &= ~TYPE_QUAL_RESTRICT;
2548 return build_qualified_type (type, type_quals);
2551 /* Apply the TYPE_QUALS to the new DECL. */
2553 void
2554 c_apply_type_quals_to_decl (int type_quals, tree decl)
2556 tree type = TREE_TYPE (decl);
2558 if (type == error_mark_node)
2559 return;
2561 if (((type_quals & TYPE_QUAL_CONST)
2562 || (type && TREE_CODE (type) == REFERENCE_TYPE))
2563 /* An object declared 'const' is only readonly after it is
2564 initialized. We don't have any way of expressing this currently,
2565 so we need to be conservative and unset TREE_READONLY for types
2566 with constructors. Otherwise aliasing code will ignore stores in
2567 an inline constructor. */
2568 && !(type && TYPE_NEEDS_CONSTRUCTING (type)))
2569 TREE_READONLY (decl) = 1;
2570 if (type_quals & TYPE_QUAL_VOLATILE)
2572 TREE_SIDE_EFFECTS (decl) = 1;
2573 TREE_THIS_VOLATILE (decl) = 1;
2575 if (type_quals & TYPE_QUAL_RESTRICT)
2577 while (type && TREE_CODE (type) == ARRAY_TYPE)
2578 /* Allow 'restrict' on arrays of pointers.
2579 FIXME currently we just ignore it. */
2580 type = TREE_TYPE (type);
2581 if (!type
2582 || !POINTER_TYPE_P (type)
2583 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type)))
2584 error ("invalid use of %<restrict%>");
2585 else if (flag_strict_aliasing && type == TREE_TYPE (decl))
2586 /* Indicate we need to make a unique alias set for this pointer.
2587 We can't do it here because it might be pointing to an
2588 incomplete type. */
2589 DECL_POINTER_ALIAS_SET (decl) = -2;
2593 /* Hash function for the problem of multiple type definitions in
2594 different files. This must hash all types that will compare
2595 equal via comptypes to the same value. In practice it hashes
2596 on some of the simple stuff and leaves the details to comptypes. */
2598 static hashval_t
2599 c_type_hash (const void *p)
2601 int i = 0;
2602 int shift, size;
2603 tree t = (tree) p;
2604 tree t2;
2605 switch (TREE_CODE (t))
2607 /* For pointers, hash on pointee type plus some swizzling. */
2608 case POINTER_TYPE:
2609 return c_type_hash (TREE_TYPE (t)) ^ 0x3003003;
2610 /* Hash on number of elements and total size. */
2611 case ENUMERAL_TYPE:
2612 shift = 3;
2613 t2 = TYPE_VALUES (t);
2614 break;
2615 case RECORD_TYPE:
2616 shift = 0;
2617 t2 = TYPE_FIELDS (t);
2618 break;
2619 case QUAL_UNION_TYPE:
2620 shift = 1;
2621 t2 = TYPE_FIELDS (t);
2622 break;
2623 case UNION_TYPE:
2624 shift = 2;
2625 t2 = TYPE_FIELDS (t);
2626 break;
2627 default:
2628 gcc_unreachable ();
2630 for (; t2; t2 = TREE_CHAIN (t2))
2631 i++;
2632 size = TREE_INT_CST_LOW (TYPE_SIZE (t));
2633 return ((size << 24) | (i << shift));
2636 static GTY((param_is (union tree_node))) htab_t type_hash_table;
2638 /* Return the typed-based alias set for T, which may be an expression
2639 or a type. Return -1 if we don't do anything special. */
2641 HOST_WIDE_INT
2642 c_common_get_alias_set (tree t)
2644 tree u;
2645 PTR *slot;
2647 /* Permit type-punning when accessing a union, provided the access
2648 is directly through the union. For example, this code does not
2649 permit taking the address of a union member and then storing
2650 through it. Even the type-punning allowed here is a GCC
2651 extension, albeit a common and useful one; the C standard says
2652 that such accesses have implementation-defined behavior. */
2653 for (u = t;
2654 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
2655 u = TREE_OPERAND (u, 0))
2656 if (TREE_CODE (u) == COMPONENT_REF
2657 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
2658 return 0;
2660 /* That's all the expressions we handle specially. */
2661 if (!TYPE_P (t))
2662 return -1;
2664 /* The C standard guarantees that any object may be accessed via an
2665 lvalue that has character type. */
2666 if (t == char_type_node
2667 || t == signed_char_type_node
2668 || t == unsigned_char_type_node)
2669 return 0;
2671 /* If it has the may_alias attribute, it can alias anything. */
2672 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (t)))
2673 return 0;
2675 /* The C standard specifically allows aliasing between signed and
2676 unsigned variants of the same type. We treat the signed
2677 variant as canonical. */
2678 if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
2680 tree t1 = c_common_signed_type (t);
2682 /* t1 == t can happen for boolean nodes which are always unsigned. */
2683 if (t1 != t)
2684 return get_alias_set (t1);
2686 else if (POINTER_TYPE_P (t))
2688 tree t1;
2690 /* Unfortunately, there is no canonical form of a pointer type.
2691 In particular, if we have `typedef int I', then `int *', and
2692 `I *' are different types. So, we have to pick a canonical
2693 representative. We do this below.
2695 Technically, this approach is actually more conservative that
2696 it needs to be. In particular, `const int *' and `int *'
2697 should be in different alias sets, according to the C and C++
2698 standard, since their types are not the same, and so,
2699 technically, an `int **' and `const int **' cannot point at
2700 the same thing.
2702 But, the standard is wrong. In particular, this code is
2703 legal C++:
2705 int *ip;
2706 int **ipp = &ip;
2707 const int* const* cipp = ipp;
2709 And, it doesn't make sense for that to be legal unless you
2710 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
2711 the pointed-to types. This issue has been reported to the
2712 C++ committee. */
2713 t1 = build_type_no_quals (t);
2714 if (t1 != t)
2715 return get_alias_set (t1);
2718 /* Handle the case of multiple type nodes referring to "the same" type,
2719 which occurs with IMA. These share an alias set. FIXME: Currently only
2720 C90 is handled. (In C99 type compatibility is not transitive, which
2721 complicates things mightily. The alias set splay trees can theoretically
2722 represent this, but insertion is tricky when you consider all the
2723 different orders things might arrive in.) */
2725 if (c_language != clk_c || flag_isoc99)
2726 return -1;
2728 /* Save time if there's only one input file. */
2729 if (num_in_fnames == 1)
2730 return -1;
2732 /* Pointers need special handling if they point to any type that
2733 needs special handling (below). */
2734 if (TREE_CODE (t) == POINTER_TYPE)
2736 tree t2;
2737 /* Find bottom type under any nested POINTERs. */
2738 for (t2 = TREE_TYPE (t);
2739 TREE_CODE (t2) == POINTER_TYPE;
2740 t2 = TREE_TYPE (t2))
2742 if (TREE_CODE (t2) != RECORD_TYPE
2743 && TREE_CODE (t2) != ENUMERAL_TYPE
2744 && TREE_CODE (t2) != QUAL_UNION_TYPE
2745 && TREE_CODE (t2) != UNION_TYPE)
2746 return -1;
2747 if (TYPE_SIZE (t2) == 0)
2748 return -1;
2750 /* These are the only cases that need special handling. */
2751 if (TREE_CODE (t) != RECORD_TYPE
2752 && TREE_CODE (t) != ENUMERAL_TYPE
2753 && TREE_CODE (t) != QUAL_UNION_TYPE
2754 && TREE_CODE (t) != UNION_TYPE
2755 && TREE_CODE (t) != POINTER_TYPE)
2756 return -1;
2757 /* Undefined? */
2758 if (TYPE_SIZE (t) == 0)
2759 return -1;
2761 /* Look up t in hash table. Only one of the compatible types within each
2762 alias set is recorded in the table. */
2763 if (!type_hash_table)
2764 type_hash_table = htab_create_ggc (1021, c_type_hash,
2765 (htab_eq) lang_hooks.types_compatible_p,
2766 NULL);
2767 slot = htab_find_slot (type_hash_table, t, INSERT);
2768 if (*slot != NULL)
2770 TYPE_ALIAS_SET (t) = TYPE_ALIAS_SET ((tree)*slot);
2771 return TYPE_ALIAS_SET ((tree)*slot);
2773 else
2774 /* Our caller will assign and record (in t) a new alias set; all we need
2775 to do is remember t in the hash table. */
2776 *slot = t;
2778 return -1;
2781 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
2782 second parameter indicates which OPERATOR is being applied. The COMPLAIN
2783 flag controls whether we should diagnose possibly ill-formed
2784 constructs or not. */
2786 tree
2787 c_sizeof_or_alignof_type (tree type, bool is_sizeof, int complain)
2789 const char *op_name;
2790 tree value = NULL;
2791 enum tree_code type_code = TREE_CODE (type);
2793 op_name = is_sizeof ? "sizeof" : "__alignof__";
2795 if (type_code == FUNCTION_TYPE)
2797 if (is_sizeof)
2799 if (complain && (pedantic || warn_pointer_arith))
2800 pedwarn ("invalid application of %<sizeof%> to a function type");
2801 value = size_one_node;
2803 else
2804 value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
2806 else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
2808 if (type_code == VOID_TYPE
2809 && complain && (pedantic || warn_pointer_arith))
2810 pedwarn ("invalid application of %qs to a void type", op_name);
2811 value = size_one_node;
2813 else if (!COMPLETE_TYPE_P (type))
2815 if (complain)
2816 error ("invalid application of %qs to incomplete type %qT ",
2817 op_name, type);
2818 value = size_zero_node;
2820 else
2822 if (is_sizeof)
2823 /* Convert in case a char is more than one unit. */
2824 value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
2825 size_int (TYPE_PRECISION (char_type_node)
2826 / BITS_PER_UNIT));
2827 else
2828 value = size_int (TYPE_ALIGN_UNIT (type));
2831 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
2832 TYPE_IS_SIZETYPE means that certain things (like overflow) will
2833 never happen. However, this node should really have type
2834 `size_t', which is just a typedef for an ordinary integer type. */
2835 value = fold_build1 (NOP_EXPR, size_type_node, value);
2836 gcc_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)));
2838 return value;
2841 /* Implement the __alignof keyword: Return the minimum required
2842 alignment of EXPR, measured in bytes. For VAR_DECL's and
2843 FIELD_DECL's return DECL_ALIGN (which can be set from an
2844 "aligned" __attribute__ specification). */
2846 tree
2847 c_alignof_expr (tree expr)
2849 tree t;
2851 if (TREE_CODE (expr) == VAR_DECL)
2852 t = size_int (DECL_ALIGN_UNIT (expr));
2854 else if (TREE_CODE (expr) == COMPONENT_REF
2855 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
2857 error ("%<__alignof%> applied to a bit-field");
2858 t = size_one_node;
2860 else if (TREE_CODE (expr) == COMPONENT_REF
2861 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
2862 t = size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr, 1)));
2864 else if (TREE_CODE (expr) == INDIRECT_REF)
2866 tree t = TREE_OPERAND (expr, 0);
2867 tree best = t;
2868 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
2870 while (TREE_CODE (t) == NOP_EXPR
2871 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
2873 int thisalign;
2875 t = TREE_OPERAND (t, 0);
2876 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
2877 if (thisalign > bestalign)
2878 best = t, bestalign = thisalign;
2880 return c_alignof (TREE_TYPE (TREE_TYPE (best)));
2882 else
2883 return c_alignof (TREE_TYPE (expr));
2885 return fold_build1 (NOP_EXPR, size_type_node, t);
2888 /* Handle C and C++ default attributes. */
2890 enum built_in_attribute
2892 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
2893 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
2894 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
2895 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
2896 #include "builtin-attrs.def"
2897 #undef DEF_ATTR_NULL_TREE
2898 #undef DEF_ATTR_INT
2899 #undef DEF_ATTR_IDENT
2900 #undef DEF_ATTR_TREE_LIST
2901 ATTR_LAST
2904 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
2906 static void c_init_attributes (void);
2908 /* Build tree nodes and builtin functions common to both C and C++ language
2909 frontends. */
2911 void
2912 c_common_nodes_and_builtins (void)
2914 enum builtin_type
2916 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
2917 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
2918 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
2919 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
2920 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
2921 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
2922 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
2923 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) \
2924 NAME,
2925 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
2926 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
2927 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
2928 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
2929 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
2930 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
2931 NAME,
2932 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
2933 #include "builtin-types.def"
2934 #undef DEF_PRIMITIVE_TYPE
2935 #undef DEF_FUNCTION_TYPE_0
2936 #undef DEF_FUNCTION_TYPE_1
2937 #undef DEF_FUNCTION_TYPE_2
2938 #undef DEF_FUNCTION_TYPE_3
2939 #undef DEF_FUNCTION_TYPE_4
2940 #undef DEF_FUNCTION_TYPE_5
2941 #undef DEF_FUNCTION_TYPE_6
2942 #undef DEF_FUNCTION_TYPE_VAR_0
2943 #undef DEF_FUNCTION_TYPE_VAR_1
2944 #undef DEF_FUNCTION_TYPE_VAR_2
2945 #undef DEF_FUNCTION_TYPE_VAR_3
2946 #undef DEF_FUNCTION_TYPE_VAR_4
2947 #undef DEF_FUNCTION_TYPE_VAR_5
2948 #undef DEF_POINTER_TYPE
2949 BT_LAST
2952 typedef enum builtin_type builtin_type;
2954 tree builtin_types[(int) BT_LAST + 1];
2955 int wchar_type_size;
2956 tree array_domain_type;
2957 tree va_list_ref_type_node;
2958 tree va_list_arg_type_node;
2960 /* Define `int' and `char' first so that dbx will output them first. */
2961 record_builtin_type (RID_INT, NULL, integer_type_node);
2962 record_builtin_type (RID_CHAR, "char", char_type_node);
2964 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
2965 "unsigned long", "long long unsigned" and "unsigned short" were in C++
2966 but not C. Are the conditionals here needed? */
2967 if (c_dialect_cxx ())
2968 record_builtin_type (RID_SIGNED, NULL, integer_type_node);
2969 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
2970 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
2971 record_builtin_type (RID_MAX, "long unsigned int",
2972 long_unsigned_type_node);
2973 if (c_dialect_cxx ())
2974 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
2975 record_builtin_type (RID_MAX, "long long int",
2976 long_long_integer_type_node);
2977 record_builtin_type (RID_MAX, "long long unsigned int",
2978 long_long_unsigned_type_node);
2979 if (c_dialect_cxx ())
2980 record_builtin_type (RID_MAX, "long long unsigned",
2981 long_long_unsigned_type_node);
2982 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
2983 record_builtin_type (RID_MAX, "short unsigned int",
2984 short_unsigned_type_node);
2985 if (c_dialect_cxx ())
2986 record_builtin_type (RID_MAX, "unsigned short",
2987 short_unsigned_type_node);
2989 /* Define both `signed char' and `unsigned char'. */
2990 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
2991 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
2993 /* These are types that c_common_type_for_size and
2994 c_common_type_for_mode use. */
2995 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2996 intQI_type_node));
2997 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2998 intHI_type_node));
2999 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3000 intSI_type_node));
3001 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3002 intDI_type_node));
3003 #if HOST_BITS_PER_WIDE_INT >= 64
3004 if (targetm.scalar_mode_supported_p (TImode))
3005 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3006 get_identifier ("__int128_t"),
3007 intTI_type_node));
3008 #endif
3009 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3010 unsigned_intQI_type_node));
3011 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3012 unsigned_intHI_type_node));
3013 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3014 unsigned_intSI_type_node));
3015 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3016 unsigned_intDI_type_node));
3017 #if HOST_BITS_PER_WIDE_INT >= 64
3018 if (targetm.scalar_mode_supported_p (TImode))
3019 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3020 get_identifier ("__uint128_t"),
3021 unsigned_intTI_type_node));
3022 #endif
3024 /* Create the widest literal types. */
3025 widest_integer_literal_type_node
3026 = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
3027 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3028 widest_integer_literal_type_node));
3030 widest_unsigned_literal_type_node
3031 = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
3032 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3033 widest_unsigned_literal_type_node));
3035 /* `unsigned long' is the standard type for sizeof.
3036 Note that stddef.h uses `unsigned long',
3037 and this must agree, even if long and int are the same size. */
3038 size_type_node =
3039 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
3040 signed_size_type_node = c_common_signed_type (size_type_node);
3041 set_sizetype (size_type_node);
3043 pid_type_node =
3044 TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE)));
3046 build_common_tree_nodes_2 (flag_short_double);
3048 record_builtin_type (RID_FLOAT, NULL, float_type_node);
3049 record_builtin_type (RID_DOUBLE, NULL, double_type_node);
3050 record_builtin_type (RID_MAX, "long double", long_double_type_node);
3052 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3053 get_identifier ("complex int"),
3054 complex_integer_type_node));
3055 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3056 get_identifier ("complex float"),
3057 complex_float_type_node));
3058 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3059 get_identifier ("complex double"),
3060 complex_double_type_node));
3061 lang_hooks.decls.pushdecl
3062 (build_decl (TYPE_DECL, get_identifier ("complex long double"),
3063 complex_long_double_type_node));
3065 if (c_dialect_cxx ())
3066 /* For C++, make fileptr_type_node a distinct void * type until
3067 FILE type is defined. */
3068 fileptr_type_node = build_variant_type_copy (ptr_type_node);
3070 record_builtin_type (RID_VOID, NULL, void_type_node);
3072 /* This node must not be shared. */
3073 void_zero_node = make_node (INTEGER_CST);
3074 TREE_TYPE (void_zero_node) = void_type_node;
3076 void_list_node = build_void_list_node ();
3078 /* Make a type to be the domain of a few array types
3079 whose domains don't really matter.
3080 200 is small enough that it always fits in size_t
3081 and large enough that it can hold most function names for the
3082 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
3083 array_domain_type = build_index_type (size_int (200));
3085 /* Make a type for arrays of characters.
3086 With luck nothing will ever really depend on the length of this
3087 array type. */
3088 char_array_type_node
3089 = build_array_type (char_type_node, array_domain_type);
3091 /* Likewise for arrays of ints. */
3092 int_array_type_node
3093 = build_array_type (integer_type_node, array_domain_type);
3095 string_type_node = build_pointer_type (char_type_node);
3096 const_string_type_node
3097 = build_pointer_type (build_qualified_type
3098 (char_type_node, TYPE_QUAL_CONST));
3100 /* This is special for C++ so functions can be overloaded. */
3101 wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
3102 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
3103 wchar_type_size = TYPE_PRECISION (wchar_type_node);
3104 if (c_dialect_cxx ())
3106 if (TYPE_UNSIGNED (wchar_type_node))
3107 wchar_type_node = make_unsigned_type (wchar_type_size);
3108 else
3109 wchar_type_node = make_signed_type (wchar_type_size);
3110 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
3112 else
3114 signed_wchar_type_node = c_common_signed_type (wchar_type_node);
3115 unsigned_wchar_type_node = c_common_unsigned_type (wchar_type_node);
3118 /* This is for wide string constants. */
3119 wchar_array_type_node
3120 = build_array_type (wchar_type_node, array_domain_type);
3122 wint_type_node =
3123 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
3125 intmax_type_node =
3126 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
3127 uintmax_type_node =
3128 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
3130 default_function_type = build_function_type (integer_type_node, NULL_TREE);
3131 ptrdiff_type_node
3132 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
3133 unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
3135 lang_hooks.decls.pushdecl
3136 (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
3137 va_list_type_node));
3139 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
3141 va_list_arg_type_node = va_list_ref_type_node =
3142 build_pointer_type (TREE_TYPE (va_list_type_node));
3144 else
3146 va_list_arg_type_node = va_list_type_node;
3147 va_list_ref_type_node = build_reference_type (va_list_type_node);
3150 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3151 builtin_types[(int) ENUM] = VALUE;
3152 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
3153 builtin_types[(int) ENUM] \
3154 = build_function_type (builtin_types[(int) RETURN], \
3155 void_list_node);
3156 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
3157 builtin_types[(int) ENUM] \
3158 = build_function_type (builtin_types[(int) RETURN], \
3159 tree_cons (NULL_TREE, \
3160 builtin_types[(int) ARG1], \
3161 void_list_node));
3162 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
3163 builtin_types[(int) ENUM] \
3164 = build_function_type \
3165 (builtin_types[(int) RETURN], \
3166 tree_cons (NULL_TREE, \
3167 builtin_types[(int) ARG1], \
3168 tree_cons (NULL_TREE, \
3169 builtin_types[(int) ARG2], \
3170 void_list_node)));
3171 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3172 builtin_types[(int) ENUM] \
3173 = build_function_type \
3174 (builtin_types[(int) RETURN], \
3175 tree_cons (NULL_TREE, \
3176 builtin_types[(int) ARG1], \
3177 tree_cons (NULL_TREE, \
3178 builtin_types[(int) ARG2], \
3179 tree_cons (NULL_TREE, \
3180 builtin_types[(int) ARG3], \
3181 void_list_node))));
3182 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3183 builtin_types[(int) ENUM] \
3184 = build_function_type \
3185 (builtin_types[(int) RETURN], \
3186 tree_cons (NULL_TREE, \
3187 builtin_types[(int) ARG1], \
3188 tree_cons (NULL_TREE, \
3189 builtin_types[(int) ARG2], \
3190 tree_cons \
3191 (NULL_TREE, \
3192 builtin_types[(int) ARG3], \
3193 tree_cons (NULL_TREE, \
3194 builtin_types[(int) ARG4], \
3195 void_list_node)))));
3196 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
3197 builtin_types[(int) ENUM] \
3198 = build_function_type \
3199 (builtin_types[(int) RETURN], \
3200 tree_cons (NULL_TREE, \
3201 builtin_types[(int) ARG1], \
3202 tree_cons (NULL_TREE, \
3203 builtin_types[(int) ARG2], \
3204 tree_cons \
3205 (NULL_TREE, \
3206 builtin_types[(int) ARG3], \
3207 tree_cons (NULL_TREE, \
3208 builtin_types[(int) ARG4], \
3209 tree_cons (NULL_TREE, \
3210 builtin_types[(int) ARG5],\
3211 void_list_node))))));
3212 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3213 ARG6) \
3214 builtin_types[(int) ENUM] \
3215 = build_function_type \
3216 (builtin_types[(int) RETURN], \
3217 tree_cons (NULL_TREE, \
3218 builtin_types[(int) ARG1], \
3219 tree_cons (NULL_TREE, \
3220 builtin_types[(int) ARG2], \
3221 tree_cons \
3222 (NULL_TREE, \
3223 builtin_types[(int) ARG3], \
3224 tree_cons \
3225 (NULL_TREE, \
3226 builtin_types[(int) ARG4], \
3227 tree_cons (NULL_TREE, \
3228 builtin_types[(int) ARG5], \
3229 tree_cons (NULL_TREE, \
3230 builtin_types[(int) ARG6],\
3231 void_list_node)))))));
3232 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
3233 builtin_types[(int) ENUM] \
3234 = build_function_type (builtin_types[(int) RETURN], NULL_TREE);
3235 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
3236 builtin_types[(int) ENUM] \
3237 = build_function_type (builtin_types[(int) RETURN], \
3238 tree_cons (NULL_TREE, \
3239 builtin_types[(int) ARG1], \
3240 NULL_TREE));
3242 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
3243 builtin_types[(int) ENUM] \
3244 = build_function_type \
3245 (builtin_types[(int) RETURN], \
3246 tree_cons (NULL_TREE, \
3247 builtin_types[(int) ARG1], \
3248 tree_cons (NULL_TREE, \
3249 builtin_types[(int) ARG2], \
3250 NULL_TREE)));
3252 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3253 builtin_types[(int) ENUM] \
3254 = build_function_type \
3255 (builtin_types[(int) RETURN], \
3256 tree_cons (NULL_TREE, \
3257 builtin_types[(int) ARG1], \
3258 tree_cons (NULL_TREE, \
3259 builtin_types[(int) ARG2], \
3260 tree_cons (NULL_TREE, \
3261 builtin_types[(int) ARG3], \
3262 NULL_TREE))));
3264 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3265 builtin_types[(int) ENUM] \
3266 = build_function_type \
3267 (builtin_types[(int) RETURN], \
3268 tree_cons (NULL_TREE, \
3269 builtin_types[(int) ARG1], \
3270 tree_cons (NULL_TREE, \
3271 builtin_types[(int) ARG2], \
3272 tree_cons (NULL_TREE, \
3273 builtin_types[(int) ARG3], \
3274 tree_cons (NULL_TREE, \
3275 builtin_types[(int) ARG4],\
3276 NULL_TREE)))));
3278 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, \
3279 ARG5) \
3280 builtin_types[(int) ENUM] \
3281 = build_function_type \
3282 (builtin_types[(int) RETURN], \
3283 tree_cons (NULL_TREE, \
3284 builtin_types[(int) ARG1], \
3285 tree_cons (NULL_TREE, \
3286 builtin_types[(int) ARG2], \
3287 tree_cons \
3288 (NULL_TREE, \
3289 builtin_types[(int) ARG3], \
3290 tree_cons (NULL_TREE, \
3291 builtin_types[(int) ARG4], \
3292 tree_cons (NULL_TREE, \
3293 builtin_types[(int) ARG5],\
3294 NULL_TREE))))));
3296 #define DEF_POINTER_TYPE(ENUM, TYPE) \
3297 builtin_types[(int) ENUM] \
3298 = build_pointer_type (builtin_types[(int) TYPE]);
3299 #include "builtin-types.def"
3300 #undef DEF_PRIMITIVE_TYPE
3301 #undef DEF_FUNCTION_TYPE_1
3302 #undef DEF_FUNCTION_TYPE_2
3303 #undef DEF_FUNCTION_TYPE_3
3304 #undef DEF_FUNCTION_TYPE_4
3305 #undef DEF_FUNCTION_TYPE_5
3306 #undef DEF_FUNCTION_TYPE_6
3307 #undef DEF_FUNCTION_TYPE_VAR_0
3308 #undef DEF_FUNCTION_TYPE_VAR_1
3309 #undef DEF_FUNCTION_TYPE_VAR_2
3310 #undef DEF_FUNCTION_TYPE_VAR_3
3311 #undef DEF_FUNCTION_TYPE_VAR_4
3312 #undef DEF_FUNCTION_TYPE_VAR_5
3313 #undef DEF_POINTER_TYPE
3314 builtin_types[(int) BT_LAST] = NULL_TREE;
3316 c_init_attributes ();
3318 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
3319 NONANSI_P, ATTRS, IMPLICIT, COND) \
3320 if (NAME && COND) \
3321 def_builtin_1 (ENUM, NAME, CLASS, \
3322 builtin_types[(int) TYPE], \
3323 builtin_types[(int) LIBTYPE], \
3324 BOTH_P, FALLBACK_P, NONANSI_P, \
3325 built_in_attributes[(int) ATTRS], IMPLICIT);
3326 #include "builtins.def"
3327 #undef DEF_BUILTIN
3329 build_common_builtin_nodes ();
3331 targetm.init_builtins ();
3332 if (flag_mudflap)
3333 mudflap_init ();
3335 main_identifier_node = get_identifier ("main");
3337 /* Create the built-in __null node. It is important that this is
3338 not shared. */
3339 null_node = make_node (INTEGER_CST);
3340 TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0);
3343 /* Look up the function in built_in_decls that corresponds to DECL
3344 and set ASMSPEC as its user assembler name. DECL must be a
3345 function decl that declares a builtin. */
3347 void
3348 set_builtin_user_assembler_name (tree decl, const char *asmspec)
3350 tree builtin;
3351 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
3352 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
3353 && asmspec != 0);
3355 builtin = built_in_decls [DECL_FUNCTION_CODE (decl)];
3356 set_user_assembler_name (builtin, asmspec);
3357 if (DECL_FUNCTION_CODE (decl) == BUILT_IN_MEMCPY)
3358 init_block_move_fn (asmspec);
3359 else if (DECL_FUNCTION_CODE (decl) == BUILT_IN_MEMSET)
3360 init_block_clear_fn (asmspec);
3363 tree
3364 build_va_arg (tree expr, tree type)
3366 return build1 (VA_ARG_EXPR, type, expr);
3370 /* Linked list of disabled built-in functions. */
3372 typedef struct disabled_builtin
3374 const char *name;
3375 struct disabled_builtin *next;
3376 } disabled_builtin;
3377 static disabled_builtin *disabled_builtins = NULL;
3379 static bool builtin_function_disabled_p (const char *);
3381 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
3382 begins with "__builtin_", give an error. */
3384 void
3385 disable_builtin_function (const char *name)
3387 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
3388 error ("cannot disable built-in function %qs", name);
3389 else
3391 disabled_builtin *new_disabled_builtin = XNEW (disabled_builtin);
3392 new_disabled_builtin->name = name;
3393 new_disabled_builtin->next = disabled_builtins;
3394 disabled_builtins = new_disabled_builtin;
3399 /* Return true if the built-in function NAME has been disabled, false
3400 otherwise. */
3402 static bool
3403 builtin_function_disabled_p (const char *name)
3405 disabled_builtin *p;
3406 for (p = disabled_builtins; p != NULL; p = p->next)
3408 if (strcmp (name, p->name) == 0)
3409 return true;
3411 return false;
3415 /* Worker for DEF_BUILTIN.
3416 Possibly define a builtin function with one or two names.
3417 Does not declare a non-__builtin_ function if flag_no_builtin, or if
3418 nonansi_p and flag_no_nonansi_builtin. */
3420 static void
3421 def_builtin_1 (enum built_in_function fncode,
3422 const char *name,
3423 enum built_in_class fnclass,
3424 tree fntype, tree libtype,
3425 bool both_p, bool fallback_p, bool nonansi_p,
3426 tree fnattrs, bool implicit_p)
3428 tree decl;
3429 const char *libname;
3431 gcc_assert ((!both_p && !fallback_p)
3432 || !strncmp (name, "__builtin_",
3433 strlen ("__builtin_")));
3435 libname = name + strlen ("__builtin_");
3436 decl = lang_hooks.builtin_function (name, fntype, fncode, fnclass,
3437 (fallback_p ? libname : NULL),
3438 fnattrs);
3439 if (both_p
3440 && !flag_no_builtin && !builtin_function_disabled_p (libname)
3441 && !(nonansi_p && flag_no_nonansi_builtin))
3442 lang_hooks.builtin_function (libname, libtype, fncode, fnclass,
3443 NULL, fnattrs);
3445 built_in_decls[(int) fncode] = decl;
3446 if (implicit_p)
3447 implicit_built_in_decls[(int) fncode] = decl;
3450 /* Nonzero if the type T promotes to int. This is (nearly) the
3451 integral promotions defined in ISO C99 6.3.1.1/2. */
3453 bool
3454 c_promoting_integer_type_p (tree t)
3456 switch (TREE_CODE (t))
3458 case INTEGER_TYPE:
3459 return (TYPE_MAIN_VARIANT (t) == char_type_node
3460 || TYPE_MAIN_VARIANT (t) == signed_char_type_node
3461 || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
3462 || TYPE_MAIN_VARIANT (t) == short_integer_type_node
3463 || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
3464 || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
3466 case ENUMERAL_TYPE:
3467 /* ??? Technically all enumerations not larger than an int
3468 promote to an int. But this is used along code paths
3469 that only want to notice a size change. */
3470 return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
3472 case BOOLEAN_TYPE:
3473 return 1;
3475 default:
3476 return 0;
3480 /* Return 1 if PARMS specifies a fixed number of parameters
3481 and none of their types is affected by default promotions. */
3484 self_promoting_args_p (tree parms)
3486 tree t;
3487 for (t = parms; t; t = TREE_CHAIN (t))
3489 tree type = TREE_VALUE (t);
3491 if (TREE_CHAIN (t) == 0 && type != void_type_node)
3492 return 0;
3494 if (type == 0)
3495 return 0;
3497 if (TYPE_MAIN_VARIANT (type) == float_type_node)
3498 return 0;
3500 if (c_promoting_integer_type_p (type))
3501 return 0;
3503 return 1;
3506 /* Recursively examines the array elements of TYPE, until a non-array
3507 element type is found. */
3509 tree
3510 strip_array_types (tree type)
3512 while (TREE_CODE (type) == ARRAY_TYPE)
3513 type = TREE_TYPE (type);
3515 return type;
3518 /* Recursively remove any '*' or '&' operator from TYPE. */
3519 tree
3520 strip_pointer_operator (tree t)
3522 while (POINTER_TYPE_P (t))
3523 t = TREE_TYPE (t);
3524 return t;
3527 /* Used to compare case labels. K1 and K2 are actually tree nodes
3528 representing case labels, or NULL_TREE for a `default' label.
3529 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3530 K2, and 0 if K1 and K2 are equal. */
3533 case_compare (splay_tree_key k1, splay_tree_key k2)
3535 /* Consider a NULL key (such as arises with a `default' label) to be
3536 smaller than anything else. */
3537 if (!k1)
3538 return k2 ? -1 : 0;
3539 else if (!k2)
3540 return k1 ? 1 : 0;
3542 return tree_int_cst_compare ((tree) k1, (tree) k2);
3545 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
3546 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3547 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
3548 case label was declared using the usual C/C++ syntax, rather than
3549 the GNU case range extension. CASES is a tree containing all the
3550 case ranges processed so far; COND is the condition for the
3551 switch-statement itself. Returns the CASE_LABEL_EXPR created, or
3552 ERROR_MARK_NODE if no CASE_LABEL_EXPR is created. */
3554 tree
3555 c_add_case_label (splay_tree cases, tree cond, tree orig_type,
3556 tree low_value, tree high_value)
3558 tree type;
3559 tree label;
3560 tree case_label;
3561 splay_tree_node node;
3563 /* Create the LABEL_DECL itself. */
3564 label = create_artificial_label ();
3566 /* If there was an error processing the switch condition, bail now
3567 before we get more confused. */
3568 if (!cond || cond == error_mark_node)
3569 goto error_out;
3571 if ((low_value && TREE_TYPE (low_value)
3572 && POINTER_TYPE_P (TREE_TYPE (low_value)))
3573 || (high_value && TREE_TYPE (high_value)
3574 && POINTER_TYPE_P (TREE_TYPE (high_value))))
3576 error ("pointers are not permitted as case values");
3577 goto error_out;
3580 /* Case ranges are a GNU extension. */
3581 if (high_value && pedantic)
3582 pedwarn ("range expressions in switch statements are non-standard");
3584 type = TREE_TYPE (cond);
3585 if (low_value)
3587 low_value = check_case_value (low_value);
3588 low_value = convert_and_check (type, low_value);
3590 if (high_value)
3592 high_value = check_case_value (high_value);
3593 high_value = convert_and_check (type, high_value);
3596 /* If an error has occurred, bail out now. */
3597 if (low_value == error_mark_node || high_value == error_mark_node)
3598 goto error_out;
3600 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
3601 really a case range, even though it was written that way. Remove
3602 the HIGH_VALUE to simplify later processing. */
3603 if (tree_int_cst_equal (low_value, high_value))
3604 high_value = NULL_TREE;
3605 if (low_value && high_value
3606 && !tree_int_cst_lt (low_value, high_value))
3607 warning (0, "empty range specified");
3609 /* See if the case is in range of the type of the original testing
3610 expression. If both low_value and high_value are out of range,
3611 don't insert the case label and return NULL_TREE. */
3612 if (low_value
3613 && !check_case_bounds (type, orig_type,
3614 &low_value, high_value ? &high_value : NULL))
3615 return NULL_TREE;
3617 /* Look up the LOW_VALUE in the table of case labels we already
3618 have. */
3619 node = splay_tree_lookup (cases, (splay_tree_key) low_value);
3620 /* If there was not an exact match, check for overlapping ranges.
3621 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
3622 that's a `default' label and the only overlap is an exact match. */
3623 if (!node && (low_value || high_value))
3625 splay_tree_node low_bound;
3626 splay_tree_node high_bound;
3628 /* Even though there wasn't an exact match, there might be an
3629 overlap between this case range and another case range.
3630 Since we've (inductively) not allowed any overlapping case
3631 ranges, we simply need to find the greatest low case label
3632 that is smaller that LOW_VALUE, and the smallest low case
3633 label that is greater than LOW_VALUE. If there is an overlap
3634 it will occur in one of these two ranges. */
3635 low_bound = splay_tree_predecessor (cases,
3636 (splay_tree_key) low_value);
3637 high_bound = splay_tree_successor (cases,
3638 (splay_tree_key) low_value);
3640 /* Check to see if the LOW_BOUND overlaps. It is smaller than
3641 the LOW_VALUE, so there is no need to check unless the
3642 LOW_BOUND is in fact itself a case range. */
3643 if (low_bound
3644 && CASE_HIGH ((tree) low_bound->value)
3645 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
3646 low_value) >= 0)
3647 node = low_bound;
3648 /* Check to see if the HIGH_BOUND overlaps. The low end of that
3649 range is bigger than the low end of the current range, so we
3650 are only interested if the current range is a real range, and
3651 not an ordinary case label. */
3652 else if (high_bound
3653 && high_value
3654 && (tree_int_cst_compare ((tree) high_bound->key,
3655 high_value)
3656 <= 0))
3657 node = high_bound;
3659 /* If there was an overlap, issue an error. */
3660 if (node)
3662 tree duplicate = CASE_LABEL ((tree) node->value);
3664 if (high_value)
3666 error ("duplicate (or overlapping) case value");
3667 error ("%Jthis is the first entry overlapping that value", duplicate);
3669 else if (low_value)
3671 error ("duplicate case value") ;
3672 error ("%Jpreviously used here", duplicate);
3674 else
3676 error ("multiple default labels in one switch");
3677 error ("%Jthis is the first default label", duplicate);
3679 goto error_out;
3682 /* Add a CASE_LABEL to the statement-tree. */
3683 case_label = add_stmt (build_case_label (low_value, high_value, label));
3684 /* Register this case label in the splay tree. */
3685 splay_tree_insert (cases,
3686 (splay_tree_key) low_value,
3687 (splay_tree_value) case_label);
3689 return case_label;
3691 error_out:
3692 /* Add a label so that the back-end doesn't think that the beginning of
3693 the switch is unreachable. Note that we do not add a case label, as
3694 that just leads to duplicates and thence to failure later on. */
3695 if (!cases->root)
3697 tree t = create_artificial_label ();
3698 add_stmt (build_stmt (LABEL_EXPR, t));
3700 return error_mark_node;
3703 /* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
3704 Used to verify that case values match up with enumerator values. */
3706 static void
3707 match_case_to_enum_1 (tree key, tree type, tree label)
3709 char buf[2 + 2*HOST_BITS_PER_WIDE_INT/4 + 1];
3711 /* ??? Not working too hard to print the double-word value.
3712 Should perhaps be done with %lwd in the diagnostic routines? */
3713 if (TREE_INT_CST_HIGH (key) == 0)
3714 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_UNSIGNED,
3715 TREE_INT_CST_LOW (key));
3716 else if (!TYPE_UNSIGNED (type)
3717 && TREE_INT_CST_HIGH (key) == -1
3718 && TREE_INT_CST_LOW (key) != 0)
3719 snprintf (buf, sizeof (buf), "-" HOST_WIDE_INT_PRINT_UNSIGNED,
3720 -TREE_INT_CST_LOW (key));
3721 else
3722 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_DOUBLE_HEX,
3723 TREE_INT_CST_HIGH (key), TREE_INT_CST_LOW (key));
3725 if (TYPE_NAME (type) == 0)
3726 warning (0, "%Jcase value %qs not in enumerated type",
3727 CASE_LABEL (label), buf);
3728 else
3729 warning (0, "%Jcase value %qs not in enumerated type %qT",
3730 CASE_LABEL (label), buf, type);
3733 static int
3734 match_case_to_enum (splay_tree_node node, void *data)
3736 tree label = (tree) node->value;
3737 tree type = (tree) data;
3739 /* Skip default case. */
3740 if (!CASE_LOW (label))
3741 return 0;
3743 /* If TREE_ADDRESSABLE is not set, that means CASE_LOW did not appear
3744 when we did our enum->case scan. Reset our scratch bit after. */
3745 if (!TREE_ADDRESSABLE (label))
3746 match_case_to_enum_1 (CASE_LOW (label), type, label);
3747 else
3748 TREE_ADDRESSABLE (label) = 0;
3750 /* If CASE_HIGH is non-null, we have a range. Here we must search.
3751 Note that the old code in stmt.c did not check for the values in
3752 the range either, just the endpoints. */
3753 if (CASE_HIGH (label))
3755 tree chain, key = CASE_HIGH (label);
3757 for (chain = TYPE_VALUES (type);
3758 chain && !tree_int_cst_equal (key, TREE_VALUE (chain));
3759 chain = TREE_CHAIN (chain))
3760 continue;
3761 if (!chain)
3762 match_case_to_enum_1 (key, type, label);
3765 return 0;
3768 /* Handle -Wswitch*. Called from the front end after parsing the
3769 switch construct. */
3770 /* ??? Should probably be somewhere generic, since other languages
3771 besides C and C++ would want this. At the moment, however, C/C++
3772 are the only tree-ssa languages that support enumerations at all,
3773 so the point is moot. */
3775 void
3776 c_do_switch_warnings (splay_tree cases, location_t switch_location,
3777 tree type, tree cond)
3779 splay_tree_node default_node;
3781 if (!warn_switch && !warn_switch_enum && !warn_switch_default)
3782 return;
3784 default_node = splay_tree_lookup (cases, (splay_tree_key) NULL);
3785 if (!default_node)
3786 warning (OPT_Wswitch_default, "%Hswitch missing default case",
3787 &switch_location);
3789 /* If the switch expression was an enumerated type, check that
3790 exactly all enumeration literals are covered by the cases.
3791 The check is made when -Wswitch was specified and there is no
3792 default case, or when -Wswitch-enum was specified. */
3793 if (((warn_switch && !default_node) || warn_switch_enum)
3794 && type && TREE_CODE (type) == ENUMERAL_TYPE
3795 && TREE_CODE (cond) != INTEGER_CST)
3797 tree chain;
3799 /* The time complexity here is O(N*lg(N)) worst case, but for the
3800 common case of monotonically increasing enumerators, it is
3801 O(N), since the nature of the splay tree will keep the next
3802 element adjacent to the root at all times. */
3804 for (chain = TYPE_VALUES (type); chain; chain = TREE_CHAIN (chain))
3806 splay_tree_node node
3807 = splay_tree_lookup (cases, (splay_tree_key) TREE_VALUE (chain));
3808 if (!node)
3810 tree low_value = TREE_VALUE (chain);
3811 splay_tree_node low_bound;
3812 splay_tree_node high_bound;
3813 /* Even though there wasn't an exact match, there might be a
3814 case range which includes the enumator's value. */
3815 low_bound = splay_tree_predecessor (cases,
3816 (splay_tree_key) low_value);
3817 high_bound = splay_tree_successor (cases,
3818 (splay_tree_key) low_value);
3820 /* It is smaller than the LOW_VALUE, so there is no need to check
3821 unless the LOW_BOUND is in fact itself a case range. */
3822 if (low_bound
3823 && CASE_HIGH ((tree) low_bound->value)
3824 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
3825 low_value) >= 0)
3826 node = low_bound;
3827 /* The low end of that range is bigger than the current value. */
3828 else if (high_bound
3829 && (tree_int_cst_compare ((tree) high_bound->key,
3830 low_value)
3831 <= 0))
3832 node = high_bound;
3834 if (node)
3836 /* Mark the CASE_LOW part of the case entry as seen, so
3837 that we save time later. Choose TREE_ADDRESSABLE
3838 randomly as a bit that won't have been set to-date. */
3839 tree label = (tree) node->value;
3840 TREE_ADDRESSABLE (label) = 1;
3842 else
3844 /* Warn if there are enumerators that don't correspond to
3845 case expressions. */
3846 warning (0, "%Henumeration value %qE not handled in switch",
3847 &switch_location, TREE_PURPOSE (chain));
3851 /* Warn if there are case expressions that don't correspond to
3852 enumerators. This can occur since C and C++ don't enforce
3853 type-checking of assignments to enumeration variables.
3855 The time complexity here is O(N**2) worst case, since we've
3856 not sorted the enumeration values. However, in the absence
3857 of case ranges this is O(N), since all single cases that
3858 corresponded to enumerations have been marked above. */
3860 splay_tree_foreach (cases, match_case_to_enum, type);
3864 /* Finish an expression taking the address of LABEL (an
3865 IDENTIFIER_NODE). Returns an expression for the address. */
3867 tree
3868 finish_label_address_expr (tree label)
3870 tree result;
3872 if (pedantic)
3873 pedwarn ("taking the address of a label is non-standard");
3875 if (label == error_mark_node)
3876 return error_mark_node;
3878 label = lookup_label (label);
3879 if (label == NULL_TREE)
3880 result = null_pointer_node;
3881 else
3883 TREE_USED (label) = 1;
3884 result = build1 (ADDR_EXPR, ptr_type_node, label);
3885 /* The current function in not necessarily uninlinable.
3886 Computed gotos are incompatible with inlining, but the value
3887 here could be used only in a diagnostic, for example. */
3890 return result;
3893 /* Hook used by expand_expr to expand language-specific tree codes. */
3894 /* The only things that should go here are bits needed to expand
3895 constant initializers. Everything else should be handled by the
3896 gimplification routines. */
3899 c_expand_expr (tree exp, rtx target, enum machine_mode tmode,
3900 int modifier /* Actually enum_modifier. */,
3901 rtx *alt_rtl)
3903 switch (TREE_CODE (exp))
3905 case COMPOUND_LITERAL_EXPR:
3907 /* Initialize the anonymous variable declared in the compound
3908 literal, then return the variable. */
3909 tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
3910 emit_local_var (decl);
3911 return expand_expr_real (decl, target, tmode, modifier, alt_rtl);
3914 default:
3915 gcc_unreachable ();
3919 /* Hook used by staticp to handle language-specific tree codes. */
3921 tree
3922 c_staticp (tree exp)
3924 return (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR
3925 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp))
3926 ? exp : NULL);
3930 /* Given a boolean expression ARG, return a tree representing an increment
3931 or decrement (as indicated by CODE) of ARG. The front end must check for
3932 invalid cases (e.g., decrement in C++). */
3933 tree
3934 boolean_increment (enum tree_code code, tree arg)
3936 tree val;
3937 tree true_res = boolean_true_node;
3939 arg = stabilize_reference (arg);
3940 switch (code)
3942 case PREINCREMENT_EXPR:
3943 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
3944 break;
3945 case POSTINCREMENT_EXPR:
3946 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
3947 arg = save_expr (arg);
3948 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
3949 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
3950 break;
3951 case PREDECREMENT_EXPR:
3952 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
3953 invert_truthvalue (arg));
3954 break;
3955 case POSTDECREMENT_EXPR:
3956 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
3957 invert_truthvalue (arg));
3958 arg = save_expr (arg);
3959 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
3960 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
3961 break;
3962 default:
3963 gcc_unreachable ();
3965 TREE_SIDE_EFFECTS (val) = 1;
3966 return val;
3969 /* Built-in macros for stddef.h, that require macros defined in this
3970 file. */
3971 void
3972 c_stddef_cpp_builtins(void)
3974 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
3975 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
3976 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
3977 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
3978 builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE, 0);
3979 builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE, 0);
3982 static void
3983 c_init_attributes (void)
3985 /* Fill in the built_in_attributes array. */
3986 #define DEF_ATTR_NULL_TREE(ENUM) \
3987 built_in_attributes[(int) ENUM] = NULL_TREE;
3988 #define DEF_ATTR_INT(ENUM, VALUE) \
3989 built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
3990 #define DEF_ATTR_IDENT(ENUM, STRING) \
3991 built_in_attributes[(int) ENUM] = get_identifier (STRING);
3992 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
3993 built_in_attributes[(int) ENUM] \
3994 = tree_cons (built_in_attributes[(int) PURPOSE], \
3995 built_in_attributes[(int) VALUE], \
3996 built_in_attributes[(int) CHAIN]);
3997 #include "builtin-attrs.def"
3998 #undef DEF_ATTR_NULL_TREE
3999 #undef DEF_ATTR_INT
4000 #undef DEF_ATTR_IDENT
4001 #undef DEF_ATTR_TREE_LIST
4004 /* Attribute handlers common to C front ends. */
4006 /* Handle a "packed" attribute; arguments as in
4007 struct attribute_spec.handler. */
4009 static tree
4010 handle_packed_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4011 int flags, bool *no_add_attrs)
4013 if (TYPE_P (*node))
4015 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4016 *node = build_variant_type_copy (*node);
4017 TYPE_PACKED (*node) = 1;
4018 if (TYPE_MAIN_VARIANT (*node) == *node)
4020 /* If it is the main variant, then pack the other variants
4021 too. This happens in,
4023 struct Foo {
4024 struct Foo const *ptr; // creates a variant w/o packed flag
4025 } __ attribute__((packed)); // packs it now.
4027 tree probe;
4029 for (probe = *node; probe; probe = TYPE_NEXT_VARIANT (probe))
4030 TYPE_PACKED (probe) = 1;
4034 else if (TREE_CODE (*node) == FIELD_DECL)
4035 DECL_PACKED (*node) = 1;
4036 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
4037 used for DECL_REGISTER. It wouldn't mean anything anyway.
4038 We can't set DECL_PACKED on the type of a TYPE_DECL, because
4039 that changes what the typedef is typing. */
4040 else
4042 warning (OPT_Wattributes, "%qE attribute ignored", name);
4043 *no_add_attrs = true;
4046 return NULL_TREE;
4049 /* Handle a "nocommon" attribute; arguments as in
4050 struct attribute_spec.handler. */
4052 static tree
4053 handle_nocommon_attribute (tree *node, tree name,
4054 tree ARG_UNUSED (args),
4055 int ARG_UNUSED (flags), bool *no_add_attrs)
4057 if (TREE_CODE (*node) == VAR_DECL)
4058 DECL_COMMON (*node) = 0;
4059 else
4061 warning (OPT_Wattributes, "%qE attribute ignored", name);
4062 *no_add_attrs = true;
4065 return NULL_TREE;
4068 /* Handle a "common" attribute; arguments as in
4069 struct attribute_spec.handler. */
4071 static tree
4072 handle_common_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4073 int ARG_UNUSED (flags), bool *no_add_attrs)
4075 if (TREE_CODE (*node) == VAR_DECL)
4076 DECL_COMMON (*node) = 1;
4077 else
4079 warning (OPT_Wattributes, "%qE attribute ignored", name);
4080 *no_add_attrs = true;
4083 return NULL_TREE;
4086 /* Handle a "noreturn" attribute; arguments as in
4087 struct attribute_spec.handler. */
4089 static tree
4090 handle_noreturn_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4091 int ARG_UNUSED (flags), bool *no_add_attrs)
4093 tree type = TREE_TYPE (*node);
4095 /* See FIXME comment in c_common_attribute_table. */
4096 if (TREE_CODE (*node) == FUNCTION_DECL)
4097 TREE_THIS_VOLATILE (*node) = 1;
4098 else if (TREE_CODE (type) == POINTER_TYPE
4099 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4100 TREE_TYPE (*node)
4101 = build_pointer_type
4102 (build_type_variant (TREE_TYPE (type),
4103 TYPE_READONLY (TREE_TYPE (type)), 1));
4104 else
4106 warning (OPT_Wattributes, "%qE attribute ignored", name);
4107 *no_add_attrs = true;
4110 return NULL_TREE;
4113 /* Handle a "noinline" attribute; arguments as in
4114 struct attribute_spec.handler. */
4116 static tree
4117 handle_noinline_attribute (tree *node, tree name,
4118 tree ARG_UNUSED (args),
4119 int ARG_UNUSED (flags), bool *no_add_attrs)
4121 if (TREE_CODE (*node) == FUNCTION_DECL)
4122 DECL_UNINLINABLE (*node) = 1;
4123 else
4125 warning (OPT_Wattributes, "%qE attribute ignored", name);
4126 *no_add_attrs = true;
4129 return NULL_TREE;
4132 /* Handle a "always_inline" attribute; arguments as in
4133 struct attribute_spec.handler. */
4135 static tree
4136 handle_always_inline_attribute (tree *node, tree name,
4137 tree ARG_UNUSED (args),
4138 int ARG_UNUSED (flags),
4139 bool *no_add_attrs)
4141 if (TREE_CODE (*node) == FUNCTION_DECL)
4143 /* Do nothing else, just set the attribute. We'll get at
4144 it later with lookup_attribute. */
4146 else
4148 warning (OPT_Wattributes, "%qE attribute ignored", name);
4149 *no_add_attrs = true;
4152 return NULL_TREE;
4155 /* Handle a "flatten" attribute; arguments as in
4156 struct attribute_spec.handler. */
4158 static tree
4159 handle_flatten_attribute (tree *node, tree name,
4160 tree args ATTRIBUTE_UNUSED,
4161 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4163 if (TREE_CODE (*node) == FUNCTION_DECL)
4164 /* Do nothing else, just set the attribute. We'll get at
4165 it later with lookup_attribute. */
4167 else
4169 warning (OPT_Wattributes, "%qE attribute ignored", name);
4170 *no_add_attrs = true;
4173 return NULL_TREE;
4177 /* Handle a "used" attribute; arguments as in
4178 struct attribute_spec.handler. */
4180 static tree
4181 handle_used_attribute (tree *pnode, tree name, tree ARG_UNUSED (args),
4182 int ARG_UNUSED (flags), bool *no_add_attrs)
4184 tree node = *pnode;
4186 if (TREE_CODE (node) == FUNCTION_DECL
4187 || (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node)))
4189 TREE_USED (node) = 1;
4190 DECL_PRESERVE_P (node) = 1;
4192 else
4194 warning (OPT_Wattributes, "%qE attribute ignored", name);
4195 *no_add_attrs = true;
4198 return NULL_TREE;
4201 /* Handle a "unused" attribute; arguments as in
4202 struct attribute_spec.handler. */
4204 static tree
4205 handle_unused_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4206 int flags, bool *no_add_attrs)
4208 if (DECL_P (*node))
4210 tree decl = *node;
4212 if (TREE_CODE (decl) == PARM_DECL
4213 || TREE_CODE (decl) == VAR_DECL
4214 || TREE_CODE (decl) == FUNCTION_DECL
4215 || TREE_CODE (decl) == LABEL_DECL
4216 || TREE_CODE (decl) == TYPE_DECL)
4217 TREE_USED (decl) = 1;
4218 else
4220 warning (OPT_Wattributes, "%qE attribute ignored", name);
4221 *no_add_attrs = true;
4224 else
4226 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4227 *node = build_variant_type_copy (*node);
4228 TREE_USED (*node) = 1;
4231 return NULL_TREE;
4234 /* Handle a "externally_visible" attribute; arguments as in
4235 struct attribute_spec.handler. */
4237 static tree
4238 handle_externally_visible_attribute (tree *pnode, tree name,
4239 tree ARG_UNUSED (args),
4240 int ARG_UNUSED (flags),
4241 bool *no_add_attrs)
4243 tree node = *pnode;
4245 if ((!TREE_STATIC (node) && TREE_CODE (node) != FUNCTION_DECL)
4246 || !TREE_PUBLIC (node))
4248 warning (OPT_Wattributes,
4249 "%qE attribute have effect only on public objects", name);
4250 *no_add_attrs = true;
4252 else if (TREE_CODE (node) == FUNCTION_DECL)
4254 struct cgraph_node *n = cgraph_node (node);
4255 n->local.externally_visible = true;
4256 if (n->local.finalized)
4257 cgraph_mark_needed_node (n);
4259 else if (TREE_CODE (node) == VAR_DECL)
4261 struct cgraph_varpool_node *n = cgraph_varpool_node (node);
4262 n->externally_visible = true;
4263 if (n->finalized)
4264 cgraph_varpool_mark_needed_node (n);
4266 else
4268 warning (OPT_Wattributes, "%qE attribute ignored", name);
4269 *no_add_attrs = true;
4272 return NULL_TREE;
4275 /* Handle a "const" attribute; arguments as in
4276 struct attribute_spec.handler. */
4278 static tree
4279 handle_const_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4280 int ARG_UNUSED (flags), bool *no_add_attrs)
4282 tree type = TREE_TYPE (*node);
4284 /* See FIXME comment on noreturn in c_common_attribute_table. */
4285 if (TREE_CODE (*node) == FUNCTION_DECL)
4286 TREE_READONLY (*node) = 1;
4287 else if (TREE_CODE (type) == POINTER_TYPE
4288 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4289 TREE_TYPE (*node)
4290 = build_pointer_type
4291 (build_type_variant (TREE_TYPE (type), 1,
4292 TREE_THIS_VOLATILE (TREE_TYPE (type))));
4293 else
4295 warning (OPT_Wattributes, "%qE attribute ignored", name);
4296 *no_add_attrs = true;
4299 return NULL_TREE;
4302 /* Handle a "transparent_union" attribute; arguments as in
4303 struct attribute_spec.handler. */
4305 static tree
4306 handle_transparent_union_attribute (tree *node, tree name,
4307 tree ARG_UNUSED (args), int flags,
4308 bool *no_add_attrs)
4310 tree decl = NULL_TREE;
4311 tree *type = NULL;
4312 int is_type = 0;
4314 if (DECL_P (*node))
4316 decl = *node;
4317 type = &TREE_TYPE (decl);
4318 is_type = TREE_CODE (*node) == TYPE_DECL;
4320 else if (TYPE_P (*node))
4321 type = node, is_type = 1;
4323 if (is_type
4324 && TREE_CODE (*type) == UNION_TYPE
4325 && (decl == 0
4326 || (TYPE_FIELDS (*type) != 0
4327 && TYPE_MODE (*type) == DECL_MODE (TYPE_FIELDS (*type)))))
4329 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4330 *type = build_variant_type_copy (*type);
4331 TYPE_TRANSPARENT_UNION (*type) = 1;
4333 else if (decl != 0 && TREE_CODE (decl) == PARM_DECL
4334 && TREE_CODE (*type) == UNION_TYPE
4335 && TYPE_MODE (*type) == DECL_MODE (TYPE_FIELDS (*type)))
4336 DECL_TRANSPARENT_UNION (decl) = 1;
4337 else
4339 warning (OPT_Wattributes, "%qE attribute ignored", name);
4340 *no_add_attrs = true;
4343 return NULL_TREE;
4346 /* Handle a "constructor" attribute; arguments as in
4347 struct attribute_spec.handler. */
4349 static tree
4350 handle_constructor_attribute (tree *node, tree name,
4351 tree ARG_UNUSED (args),
4352 int ARG_UNUSED (flags),
4353 bool *no_add_attrs)
4355 tree decl = *node;
4356 tree type = TREE_TYPE (decl);
4358 if (TREE_CODE (decl) == FUNCTION_DECL
4359 && TREE_CODE (type) == FUNCTION_TYPE
4360 && decl_function_context (decl) == 0)
4362 DECL_STATIC_CONSTRUCTOR (decl) = 1;
4363 TREE_USED (decl) = 1;
4365 else
4367 warning (OPT_Wattributes, "%qE attribute ignored", name);
4368 *no_add_attrs = true;
4371 return NULL_TREE;
4374 /* Handle a "destructor" attribute; arguments as in
4375 struct attribute_spec.handler. */
4377 static tree
4378 handle_destructor_attribute (tree *node, tree name,
4379 tree ARG_UNUSED (args),
4380 int ARG_UNUSED (flags),
4381 bool *no_add_attrs)
4383 tree decl = *node;
4384 tree type = TREE_TYPE (decl);
4386 if (TREE_CODE (decl) == FUNCTION_DECL
4387 && TREE_CODE (type) == FUNCTION_TYPE
4388 && decl_function_context (decl) == 0)
4390 DECL_STATIC_DESTRUCTOR (decl) = 1;
4391 TREE_USED (decl) = 1;
4393 else
4395 warning (OPT_Wattributes, "%qE attribute ignored", name);
4396 *no_add_attrs = true;
4399 return NULL_TREE;
4402 /* Handle a "mode" attribute; arguments as in
4403 struct attribute_spec.handler. */
4405 static tree
4406 handle_mode_attribute (tree *node, tree name, tree args,
4407 int ARG_UNUSED (flags), bool *no_add_attrs)
4409 tree type = *node;
4411 *no_add_attrs = true;
4413 if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
4414 warning (OPT_Wattributes, "%qE attribute ignored", name);
4415 else
4417 int j;
4418 const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
4419 int len = strlen (p);
4420 enum machine_mode mode = VOIDmode;
4421 tree typefm;
4422 bool valid_mode;
4424 if (len > 4 && p[0] == '_' && p[1] == '_'
4425 && p[len - 1] == '_' && p[len - 2] == '_')
4427 char *newp = (char *) alloca (len - 1);
4429 strcpy (newp, &p[2]);
4430 newp[len - 4] = '\0';
4431 p = newp;
4434 /* Change this type to have a type with the specified mode.
4435 First check for the special modes. */
4436 if (!strcmp (p, "byte"))
4437 mode = byte_mode;
4438 else if (!strcmp (p, "word"))
4439 mode = word_mode;
4440 else if (!strcmp (p, "pointer"))
4441 mode = ptr_mode;
4442 else
4443 for (j = 0; j < NUM_MACHINE_MODES; j++)
4444 if (!strcmp (p, GET_MODE_NAME (j)))
4446 mode = (enum machine_mode) j;
4447 break;
4450 if (mode == VOIDmode)
4452 error ("unknown machine mode %qs", p);
4453 return NULL_TREE;
4456 valid_mode = false;
4457 switch (GET_MODE_CLASS (mode))
4459 case MODE_INT:
4460 case MODE_PARTIAL_INT:
4461 case MODE_FLOAT:
4462 valid_mode = targetm.scalar_mode_supported_p (mode);
4463 break;
4465 case MODE_COMPLEX_INT:
4466 case MODE_COMPLEX_FLOAT:
4467 valid_mode = targetm.scalar_mode_supported_p (GET_MODE_INNER (mode));
4468 break;
4470 case MODE_VECTOR_INT:
4471 case MODE_VECTOR_FLOAT:
4472 warning (OPT_Wattributes, "specifying vector types with "
4473 "__attribute__ ((mode)) is deprecated");
4474 warning (OPT_Wattributes,
4475 "use __attribute__ ((vector_size)) instead");
4476 valid_mode = vector_mode_valid_p (mode);
4477 break;
4479 default:
4480 break;
4482 if (!valid_mode)
4484 error ("unable to emulate %qs", p);
4485 return NULL_TREE;
4488 if (POINTER_TYPE_P (type))
4490 tree (*fn)(tree, enum machine_mode, bool);
4492 if (!targetm.valid_pointer_mode (mode))
4494 error ("invalid pointer mode %qs", p);
4495 return NULL_TREE;
4498 if (TREE_CODE (type) == POINTER_TYPE)
4499 fn = build_pointer_type_for_mode;
4500 else
4501 fn = build_reference_type_for_mode;
4502 typefm = fn (TREE_TYPE (type), mode, false);
4504 else
4505 typefm = lang_hooks.types.type_for_mode (mode, TYPE_UNSIGNED (type));
4507 if (typefm == NULL_TREE)
4509 error ("no data type for mode %qs", p);
4510 return NULL_TREE;
4512 else if (TREE_CODE (type) == ENUMERAL_TYPE)
4514 /* For enumeral types, copy the precision from the integer
4515 type returned above. If not an INTEGER_TYPE, we can't use
4516 this mode for this type. */
4517 if (TREE_CODE (typefm) != INTEGER_TYPE)
4519 error ("cannot use mode %qs for enumeral types", p);
4520 return NULL_TREE;
4523 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4524 type = build_variant_type_copy (type);
4526 /* We cannot use layout_type here, because that will attempt
4527 to re-layout all variants, corrupting our original. */
4528 TYPE_PRECISION (type) = TYPE_PRECISION (typefm);
4529 TYPE_MIN_VALUE (type) = TYPE_MIN_VALUE (typefm);
4530 TYPE_MAX_VALUE (type) = TYPE_MAX_VALUE (typefm);
4531 TYPE_SIZE (type) = TYPE_SIZE (typefm);
4532 TYPE_SIZE_UNIT (type) = TYPE_SIZE_UNIT (typefm);
4533 TYPE_MODE (type) = TYPE_MODE (typefm);
4534 if (!TYPE_USER_ALIGN (type))
4535 TYPE_ALIGN (type) = TYPE_ALIGN (typefm);
4537 typefm = type;
4539 else if (VECTOR_MODE_P (mode)
4540 ? TREE_CODE (type) != TREE_CODE (TREE_TYPE (typefm))
4541 : TREE_CODE (type) != TREE_CODE (typefm))
4543 error ("mode %qs applied to inappropriate type", p);
4544 return NULL_TREE;
4547 *node = typefm;
4550 return NULL_TREE;
4553 /* Handle a "section" attribute; arguments as in
4554 struct attribute_spec.handler. */
4556 static tree
4557 handle_section_attribute (tree *node, tree ARG_UNUSED (name), tree args,
4558 int ARG_UNUSED (flags), bool *no_add_attrs)
4560 tree decl = *node;
4562 if (targetm.have_named_sections)
4564 user_defined_section_attribute = true;
4566 if ((TREE_CODE (decl) == FUNCTION_DECL
4567 || TREE_CODE (decl) == VAR_DECL)
4568 && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
4570 if (TREE_CODE (decl) == VAR_DECL
4571 && current_function_decl != NULL_TREE
4572 && !TREE_STATIC (decl))
4574 error ("%Jsection attribute cannot be specified for "
4575 "local variables", decl);
4576 *no_add_attrs = true;
4579 /* The decl may have already been given a section attribute
4580 from a previous declaration. Ensure they match. */
4581 else if (DECL_SECTION_NAME (decl) != NULL_TREE
4582 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
4583 TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
4585 error ("section of %q+D conflicts with previous declaration",
4586 *node);
4587 *no_add_attrs = true;
4589 else
4590 DECL_SECTION_NAME (decl) = TREE_VALUE (args);
4592 else
4594 error ("section attribute not allowed for %q+D", *node);
4595 *no_add_attrs = true;
4598 else
4600 error ("%Jsection attributes are not supported for this target", *node);
4601 *no_add_attrs = true;
4604 return NULL_TREE;
4607 /* Handle a "aligned" attribute; arguments as in
4608 struct attribute_spec.handler. */
4610 static tree
4611 handle_aligned_attribute (tree *node, tree ARG_UNUSED (name), tree args,
4612 int flags, bool *no_add_attrs)
4614 tree decl = NULL_TREE;
4615 tree *type = NULL;
4616 int is_type = 0;
4617 tree align_expr = (args ? TREE_VALUE (args)
4618 : size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
4619 int i;
4621 if (DECL_P (*node))
4623 decl = *node;
4624 type = &TREE_TYPE (decl);
4625 is_type = TREE_CODE (*node) == TYPE_DECL;
4627 else if (TYPE_P (*node))
4628 type = node, is_type = 1;
4630 if (TREE_CODE (align_expr) != INTEGER_CST)
4632 error ("requested alignment is not a constant");
4633 *no_add_attrs = true;
4635 else if ((i = tree_log2 (align_expr)) == -1)
4637 error ("requested alignment is not a power of 2");
4638 *no_add_attrs = true;
4640 else if (i > HOST_BITS_PER_INT - 2)
4642 error ("requested alignment is too large");
4643 *no_add_attrs = true;
4645 else if (is_type)
4647 /* If we have a TYPE_DECL, then copy the type, so that we
4648 don't accidentally modify a builtin type. See pushdecl. */
4649 if (decl && TREE_TYPE (decl) != error_mark_node
4650 && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
4652 tree tt = TREE_TYPE (decl);
4653 *type = build_variant_type_copy (*type);
4654 DECL_ORIGINAL_TYPE (decl) = tt;
4655 TYPE_NAME (*type) = decl;
4656 TREE_USED (*type) = TREE_USED (decl);
4657 TREE_TYPE (decl) = *type;
4659 else if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4660 *type = build_variant_type_copy (*type);
4662 TYPE_ALIGN (*type) = (1 << i) * BITS_PER_UNIT;
4663 TYPE_USER_ALIGN (*type) = 1;
4665 else if (TREE_CODE (decl) != VAR_DECL
4666 && TREE_CODE (decl) != FIELD_DECL)
4668 error ("alignment may not be specified for %q+D", decl);
4669 *no_add_attrs = true;
4671 else
4673 DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
4674 DECL_USER_ALIGN (decl) = 1;
4677 return NULL_TREE;
4680 /* Handle a "weak" attribute; arguments as in
4681 struct attribute_spec.handler. */
4683 static tree
4684 handle_weak_attribute (tree *node, tree ARG_UNUSED (name),
4685 tree ARG_UNUSED (args),
4686 int ARG_UNUSED (flags),
4687 bool * ARG_UNUSED (no_add_attrs))
4689 declare_weak (*node);
4691 return NULL_TREE;
4694 /* Handle an "alias" attribute; arguments as in
4695 struct attribute_spec.handler. */
4697 static tree
4698 handle_alias_attribute (tree *node, tree name, tree args,
4699 int ARG_UNUSED (flags), bool *no_add_attrs)
4701 tree decl = *node;
4703 if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
4704 || (TREE_CODE (decl) != FUNCTION_DECL && !DECL_EXTERNAL (decl)))
4706 error ("%q+D defined both normally and as an alias", decl);
4707 *no_add_attrs = true;
4710 /* Note that the very first time we process a nested declaration,
4711 decl_function_context will not be set. Indeed, *would* never
4712 be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
4713 we do below. After such frobbery, pushdecl would set the context.
4714 In any case, this is never what we want. */
4715 else if (decl_function_context (decl) == 0 && current_function_decl == NULL)
4717 tree id;
4719 id = TREE_VALUE (args);
4720 if (TREE_CODE (id) != STRING_CST)
4722 error ("alias argument not a string");
4723 *no_add_attrs = true;
4724 return NULL_TREE;
4726 id = get_identifier (TREE_STRING_POINTER (id));
4727 /* This counts as a use of the object pointed to. */
4728 TREE_USED (id) = 1;
4730 if (TREE_CODE (decl) == FUNCTION_DECL)
4731 DECL_INITIAL (decl) = error_mark_node;
4732 else
4734 DECL_EXTERNAL (decl) = 0;
4735 TREE_STATIC (decl) = 1;
4738 else
4740 warning (OPT_Wattributes, "%qE attribute ignored", name);
4741 *no_add_attrs = true;
4744 return NULL_TREE;
4747 /* Handle an "visibility" attribute; arguments as in
4748 struct attribute_spec.handler. */
4750 static tree
4751 handle_visibility_attribute (tree *node, tree name, tree args,
4752 int ARG_UNUSED (flags),
4753 bool *no_add_attrs)
4755 tree decl = *node;
4756 tree id = TREE_VALUE (args);
4758 *no_add_attrs = true;
4760 if (TYPE_P (*node))
4762 if (TREE_CODE (*node) != RECORD_TYPE && TREE_CODE (*node) != UNION_TYPE)
4764 warning (OPT_Wattributes, "%qE attribute ignored on non-class types",
4765 name);
4766 return NULL_TREE;
4769 else if (decl_function_context (decl) != 0 || !TREE_PUBLIC (decl))
4771 warning (OPT_Wattributes, "%qE attribute ignored", name);
4772 return NULL_TREE;
4775 if (TREE_CODE (id) != STRING_CST)
4777 error ("visibility argument not a string");
4778 return NULL_TREE;
4781 /* If this is a type, set the visibility on the type decl. */
4782 if (TYPE_P (decl))
4784 decl = TYPE_NAME (decl);
4785 if (!decl)
4786 return NULL_TREE;
4787 if (TREE_CODE (decl) == IDENTIFIER_NODE)
4789 warning (OPT_Wattributes, "%qE attribute ignored on types",
4790 name);
4791 return NULL_TREE;
4795 if (strcmp (TREE_STRING_POINTER (id), "default") == 0)
4796 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
4797 else if (strcmp (TREE_STRING_POINTER (id), "internal") == 0)
4798 DECL_VISIBILITY (decl) = VISIBILITY_INTERNAL;
4799 else if (strcmp (TREE_STRING_POINTER (id), "hidden") == 0)
4800 DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
4801 else if (strcmp (TREE_STRING_POINTER (id), "protected") == 0)
4802 DECL_VISIBILITY (decl) = VISIBILITY_PROTECTED;
4803 else
4804 error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
4805 DECL_VISIBILITY_SPECIFIED (decl) = 1;
4807 /* For decls only, go ahead and attach the attribute to the node as well.
4808 This is needed so we can determine whether we have VISIBILITY_DEFAULT
4809 because the visibility was not specified, or because it was explicitly
4810 overridden from the class visibility. */
4811 if (DECL_P (*node))
4812 *no_add_attrs = false;
4814 return NULL_TREE;
4817 /* Determine the ELF symbol visibility for DECL, which is either a
4818 variable or a function. It is an error to use this function if a
4819 definition of DECL is not available in this translation unit.
4820 Returns true if the final visibility has been determined by this
4821 function; false if the caller is free to make additional
4822 modifications. */
4824 bool
4825 c_determine_visibility (tree decl)
4827 gcc_assert (TREE_CODE (decl) == VAR_DECL
4828 || TREE_CODE (decl) == FUNCTION_DECL);
4830 /* If the user explicitly specified the visibility with an
4831 attribute, honor that. DECL_VISIBILITY will have been set during
4832 the processing of the attribute. We check for an explicit
4833 attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
4834 to distinguish the use of an attribute from the use of a "#pragma
4835 GCC visibility push(...)"; in the latter case we still want other
4836 considerations to be able to overrule the #pragma. */
4837 if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl)))
4838 return true;
4840 /* Anything that is exported must have default visibility. */
4841 if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
4842 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))
4844 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
4845 DECL_VISIBILITY_SPECIFIED (decl) = 1;
4846 return true;
4849 return false;
4852 /* Handle an "tls_model" attribute; arguments as in
4853 struct attribute_spec.handler. */
4855 static tree
4856 handle_tls_model_attribute (tree *node, tree name, tree args,
4857 int ARG_UNUSED (flags), bool *no_add_attrs)
4859 tree id;
4860 tree decl = *node;
4861 enum tls_model kind;
4863 *no_add_attrs = true;
4865 if (!DECL_THREAD_LOCAL_P (decl))
4867 warning (OPT_Wattributes, "%qE attribute ignored", name);
4868 return NULL_TREE;
4871 kind = DECL_TLS_MODEL (decl);
4872 id = TREE_VALUE (args);
4873 if (TREE_CODE (id) != STRING_CST)
4875 error ("tls_model argument not a string");
4876 return NULL_TREE;
4879 if (!strcmp (TREE_STRING_POINTER (id), "local-exec"))
4880 kind = TLS_MODEL_LOCAL_EXEC;
4881 else if (!strcmp (TREE_STRING_POINTER (id), "initial-exec"))
4882 kind = TLS_MODEL_INITIAL_EXEC;
4883 else if (!strcmp (TREE_STRING_POINTER (id), "local-dynamic"))
4884 kind = optimize ? TLS_MODEL_LOCAL_DYNAMIC : TLS_MODEL_GLOBAL_DYNAMIC;
4885 else if (!strcmp (TREE_STRING_POINTER (id), "global-dynamic"))
4886 kind = TLS_MODEL_GLOBAL_DYNAMIC;
4887 else
4888 error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
4890 DECL_TLS_MODEL (decl) = kind;
4891 return NULL_TREE;
4894 /* Handle a "no_instrument_function" attribute; arguments as in
4895 struct attribute_spec.handler. */
4897 static tree
4898 handle_no_instrument_function_attribute (tree *node, tree name,
4899 tree ARG_UNUSED (args),
4900 int ARG_UNUSED (flags),
4901 bool *no_add_attrs)
4903 tree decl = *node;
4905 if (TREE_CODE (decl) != FUNCTION_DECL)
4907 error ("%J%qE attribute applies only to functions", decl, name);
4908 *no_add_attrs = true;
4910 else if (DECL_INITIAL (decl))
4912 error ("%Jcan%'t set %qE attribute after definition", decl, name);
4913 *no_add_attrs = true;
4915 else
4916 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
4918 return NULL_TREE;
4921 /* Handle a "malloc" attribute; arguments as in
4922 struct attribute_spec.handler. */
4924 static tree
4925 handle_malloc_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4926 int ARG_UNUSED (flags), bool *no_add_attrs)
4928 if (TREE_CODE (*node) == FUNCTION_DECL
4929 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node))))
4930 DECL_IS_MALLOC (*node) = 1;
4931 else
4933 warning (OPT_Wattributes, "%qE attribute ignored", name);
4934 *no_add_attrs = true;
4937 return NULL_TREE;
4940 /* Handle a "returns_twice" attribute; arguments as in
4941 struct attribute_spec.handler. */
4943 static tree
4944 handle_returns_twice_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4945 int ARG_UNUSED (flags), bool *no_add_attrs)
4947 if (TREE_CODE (*node) == FUNCTION_DECL)
4948 DECL_IS_RETURNS_TWICE (*node) = 1;
4949 else
4951 warning (OPT_Wattributes, "%qE attribute ignored", name);
4952 *no_add_attrs = true;
4955 return NULL_TREE;
4958 /* Handle a "no_limit_stack" attribute; arguments as in
4959 struct attribute_spec.handler. */
4961 static tree
4962 handle_no_limit_stack_attribute (tree *node, tree name,
4963 tree ARG_UNUSED (args),
4964 int ARG_UNUSED (flags),
4965 bool *no_add_attrs)
4967 tree decl = *node;
4969 if (TREE_CODE (decl) != FUNCTION_DECL)
4971 error ("%J%qE attribute applies only to functions", decl, name);
4972 *no_add_attrs = true;
4974 else if (DECL_INITIAL (decl))
4976 error ("%Jcan%'t set %qE attribute after definition", decl, name);
4977 *no_add_attrs = true;
4979 else
4980 DECL_NO_LIMIT_STACK (decl) = 1;
4982 return NULL_TREE;
4985 /* Handle a "pure" attribute; arguments as in
4986 struct attribute_spec.handler. */
4988 static tree
4989 handle_pure_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4990 int ARG_UNUSED (flags), bool *no_add_attrs)
4992 if (TREE_CODE (*node) == FUNCTION_DECL)
4993 DECL_IS_PURE (*node) = 1;
4994 /* ??? TODO: Support types. */
4995 else
4997 warning (OPT_Wattributes, "%qE attribute ignored", name);
4998 *no_add_attrs = true;
5001 return NULL_TREE;
5004 /* Handle a "no vops" attribute; arguments as in
5005 struct attribute_spec.handler. */
5007 static tree
5008 handle_novops_attribute (tree *node, tree ARG_UNUSED (name),
5009 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
5010 bool *ARG_UNUSED (no_add_attrs))
5012 gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
5013 DECL_IS_NOVOPS (*node) = 1;
5014 return NULL_TREE;
5017 /* Handle a "deprecated" attribute; arguments as in
5018 struct attribute_spec.handler. */
5020 static tree
5021 handle_deprecated_attribute (tree *node, tree name,
5022 tree ARG_UNUSED (args), int flags,
5023 bool *no_add_attrs)
5025 tree type = NULL_TREE;
5026 int warn = 0;
5027 tree what = NULL_TREE;
5029 if (DECL_P (*node))
5031 tree decl = *node;
5032 type = TREE_TYPE (decl);
5034 if (TREE_CODE (decl) == TYPE_DECL
5035 || TREE_CODE (decl) == PARM_DECL
5036 || TREE_CODE (decl) == VAR_DECL
5037 || TREE_CODE (decl) == FUNCTION_DECL
5038 || TREE_CODE (decl) == FIELD_DECL)
5039 TREE_DEPRECATED (decl) = 1;
5040 else
5041 warn = 1;
5043 else if (TYPE_P (*node))
5045 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5046 *node = build_variant_type_copy (*node);
5047 TREE_DEPRECATED (*node) = 1;
5048 type = *node;
5050 else
5051 warn = 1;
5053 if (warn)
5055 *no_add_attrs = true;
5056 if (type && TYPE_NAME (type))
5058 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
5059 what = TYPE_NAME (*node);
5060 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
5061 && DECL_NAME (TYPE_NAME (type)))
5062 what = DECL_NAME (TYPE_NAME (type));
5064 if (what)
5065 warning (OPT_Wattributes, "%qE attribute ignored for %qE", name, what);
5066 else
5067 warning (OPT_Wattributes, "%qE attribute ignored", name);
5070 return NULL_TREE;
5073 /* Handle a "vector_size" attribute; arguments as in
5074 struct attribute_spec.handler. */
5076 static tree
5077 handle_vector_size_attribute (tree *node, tree name, tree args,
5078 int ARG_UNUSED (flags),
5079 bool *no_add_attrs)
5081 unsigned HOST_WIDE_INT vecsize, nunits;
5082 enum machine_mode orig_mode;
5083 tree type = *node, new_type, size;
5085 *no_add_attrs = true;
5087 size = TREE_VALUE (args);
5089 if (!host_integerp (size, 1))
5091 warning (OPT_Wattributes, "%qE attribute ignored", name);
5092 return NULL_TREE;
5095 /* Get the vector size (in bytes). */
5096 vecsize = tree_low_cst (size, 1);
5098 /* We need to provide for vector pointers, vector arrays, and
5099 functions returning vectors. For example:
5101 __attribute__((vector_size(16))) short *foo;
5103 In this case, the mode is SI, but the type being modified is
5104 HI, so we need to look further. */
5106 while (POINTER_TYPE_P (type)
5107 || TREE_CODE (type) == FUNCTION_TYPE
5108 || TREE_CODE (type) == METHOD_TYPE
5109 || TREE_CODE (type) == ARRAY_TYPE)
5110 type = TREE_TYPE (type);
5112 /* Get the mode of the type being modified. */
5113 orig_mode = TYPE_MODE (type);
5115 if (TREE_CODE (type) == RECORD_TYPE
5116 || (GET_MODE_CLASS (orig_mode) != MODE_FLOAT
5117 && GET_MODE_CLASS (orig_mode) != MODE_INT)
5118 || !host_integerp (TYPE_SIZE_UNIT (type), 1))
5120 error ("invalid vector type for attribute %qE", name);
5121 return NULL_TREE;
5124 /* Calculate how many units fit in the vector. */
5125 nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
5126 if (nunits & (nunits - 1))
5128 error ("number of components of the vector not a power of two");
5129 return NULL_TREE;
5132 new_type = build_vector_type (type, nunits);
5134 /* Build back pointers if needed. */
5135 *node = reconstruct_complex_type (*node, new_type);
5137 return NULL_TREE;
5140 /* Handle the "nonnull" attribute. */
5141 static tree
5142 handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
5143 tree args, int ARG_UNUSED (flags),
5144 bool *no_add_attrs)
5146 tree type = *node;
5147 unsigned HOST_WIDE_INT attr_arg_num;
5149 /* If no arguments are specified, all pointer arguments should be
5150 non-null. Verify a full prototype is given so that the arguments
5151 will have the correct types when we actually check them later. */
5152 if (!args)
5154 if (!TYPE_ARG_TYPES (type))
5156 error ("nonnull attribute without arguments on a non-prototype");
5157 *no_add_attrs = true;
5159 return NULL_TREE;
5162 /* Argument list specified. Verify that each argument number references
5163 a pointer argument. */
5164 for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
5166 tree argument;
5167 unsigned HOST_WIDE_INT arg_num = 0, ck_num;
5169 if (!get_nonnull_operand (TREE_VALUE (args), &arg_num))
5171 error ("nonnull argument has invalid operand number (argument %lu)",
5172 (unsigned long) attr_arg_num);
5173 *no_add_attrs = true;
5174 return NULL_TREE;
5177 argument = TYPE_ARG_TYPES (type);
5178 if (argument)
5180 for (ck_num = 1; ; ck_num++)
5182 if (!argument || ck_num == arg_num)
5183 break;
5184 argument = TREE_CHAIN (argument);
5187 if (!argument
5188 || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
5190 error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
5191 (unsigned long) attr_arg_num, (unsigned long) arg_num);
5192 *no_add_attrs = true;
5193 return NULL_TREE;
5196 if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
5198 error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
5199 (unsigned long) attr_arg_num, (unsigned long) arg_num);
5200 *no_add_attrs = true;
5201 return NULL_TREE;
5206 return NULL_TREE;
5209 /* Check the argument list of a function call for null in argument slots
5210 that are marked as requiring a non-null pointer argument. */
5212 static void
5213 check_function_nonnull (tree attrs, tree params)
5215 tree a, args, param;
5216 int param_num;
5218 for (a = attrs; a; a = TREE_CHAIN (a))
5220 if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
5222 args = TREE_VALUE (a);
5224 /* Walk the argument list. If we encounter an argument number we
5225 should check for non-null, do it. If the attribute has no args,
5226 then every pointer argument is checked (in which case the check
5227 for pointer type is done in check_nonnull_arg). */
5228 for (param = params, param_num = 1; ;
5229 param_num++, param = TREE_CHAIN (param))
5231 if (!param)
5232 break;
5233 if (!args || nonnull_check_p (args, param_num))
5234 check_function_arguments_recurse (check_nonnull_arg, NULL,
5235 TREE_VALUE (param),
5236 param_num);
5242 /* Check that the Nth argument of a function call (counting backwards
5243 from the end) is a (pointer)0. */
5245 static void
5246 check_function_sentinel (tree attrs, tree params, tree typelist)
5248 tree attr = lookup_attribute ("sentinel", attrs);
5250 if (attr)
5252 /* Skip over the named arguments. */
5253 while (typelist && params)
5255 typelist = TREE_CHAIN (typelist);
5256 params = TREE_CHAIN (params);
5259 if (typelist || !params)
5260 warning (OPT_Wformat,
5261 "not enough variable arguments to fit a sentinel");
5262 else
5264 tree sentinel, end;
5265 unsigned pos = 0;
5267 if (TREE_VALUE (attr))
5269 tree p = TREE_VALUE (TREE_VALUE (attr));
5270 pos = TREE_INT_CST_LOW (p);
5273 sentinel = end = params;
5275 /* Advance `end' ahead of `sentinel' by `pos' positions. */
5276 while (pos > 0 && TREE_CHAIN (end))
5278 pos--;
5279 end = TREE_CHAIN (end);
5281 if (pos > 0)
5283 warning (OPT_Wformat,
5284 "not enough variable arguments to fit a sentinel");
5285 return;
5288 /* Now advance both until we find the last parameter. */
5289 while (TREE_CHAIN (end))
5291 end = TREE_CHAIN (end);
5292 sentinel = TREE_CHAIN (sentinel);
5295 /* Validate the sentinel. */
5296 if ((!POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (sentinel)))
5297 || !integer_zerop (TREE_VALUE (sentinel)))
5298 /* Although __null (in C++) is only an integer we allow it
5299 nevertheless, as we are guaranteed that it's exactly
5300 as wide as a pointer, and we don't want to force
5301 users to cast the NULL they have written there.
5302 We warn with -Wstrict-null-sentinel, though. */
5303 && (warn_strict_null_sentinel
5304 || null_node != TREE_VALUE (sentinel)))
5305 warning (OPT_Wformat, "missing sentinel in function call");
5310 /* Helper for check_function_nonnull; given a list of operands which
5311 must be non-null in ARGS, determine if operand PARAM_NUM should be
5312 checked. */
5314 static bool
5315 nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num)
5317 unsigned HOST_WIDE_INT arg_num = 0;
5319 for (; args; args = TREE_CHAIN (args))
5321 bool found = get_nonnull_operand (TREE_VALUE (args), &arg_num);
5323 gcc_assert (found);
5325 if (arg_num == param_num)
5326 return true;
5328 return false;
5331 /* Check that the function argument PARAM (which is operand number
5332 PARAM_NUM) is non-null. This is called by check_function_nonnull
5333 via check_function_arguments_recurse. */
5335 static void
5336 check_nonnull_arg (void * ARG_UNUSED (ctx), tree param,
5337 unsigned HOST_WIDE_INT param_num)
5339 /* Just skip checking the argument if it's not a pointer. This can
5340 happen if the "nonnull" attribute was given without an operand
5341 list (which means to check every pointer argument). */
5343 if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
5344 return;
5346 if (integer_zerop (param))
5347 warning (OPT_Wnonnull, "null argument where non-null required "
5348 "(argument %lu)", (unsigned long) param_num);
5351 /* Helper for nonnull attribute handling; fetch the operand number
5352 from the attribute argument list. */
5354 static bool
5355 get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
5357 /* Verify the arg number is a constant. */
5358 if (TREE_CODE (arg_num_expr) != INTEGER_CST
5359 || TREE_INT_CST_HIGH (arg_num_expr) != 0)
5360 return false;
5362 *valp = TREE_INT_CST_LOW (arg_num_expr);
5363 return true;
5366 /* Handle a "nothrow" attribute; arguments as in
5367 struct attribute_spec.handler. */
5369 static tree
5370 handle_nothrow_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5371 int ARG_UNUSED (flags), bool *no_add_attrs)
5373 if (TREE_CODE (*node) == FUNCTION_DECL)
5374 TREE_NOTHROW (*node) = 1;
5375 /* ??? TODO: Support types. */
5376 else
5378 warning (OPT_Wattributes, "%qE attribute ignored", name);
5379 *no_add_attrs = true;
5382 return NULL_TREE;
5385 /* Handle a "cleanup" attribute; arguments as in
5386 struct attribute_spec.handler. */
5388 static tree
5389 handle_cleanup_attribute (tree *node, tree name, tree args,
5390 int ARG_UNUSED (flags), bool *no_add_attrs)
5392 tree decl = *node;
5393 tree cleanup_id, cleanup_decl;
5395 /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
5396 for global destructors in C++. This requires infrastructure that
5397 we don't have generically at the moment. It's also not a feature
5398 we'd be missing too much, since we do have attribute constructor. */
5399 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
5401 warning (OPT_Wattributes, "%qE attribute ignored", name);
5402 *no_add_attrs = true;
5403 return NULL_TREE;
5406 /* Verify that the argument is a function in scope. */
5407 /* ??? We could support pointers to functions here as well, if
5408 that was considered desirable. */
5409 cleanup_id = TREE_VALUE (args);
5410 if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE)
5412 error ("cleanup argument not an identifier");
5413 *no_add_attrs = true;
5414 return NULL_TREE;
5416 cleanup_decl = lookup_name (cleanup_id);
5417 if (!cleanup_decl || TREE_CODE (cleanup_decl) != FUNCTION_DECL)
5419 error ("cleanup argument not a function");
5420 *no_add_attrs = true;
5421 return NULL_TREE;
5424 /* That the function has proper type is checked with the
5425 eventual call to build_function_call. */
5427 return NULL_TREE;
5430 /* Handle a "warn_unused_result" attribute. No special handling. */
5432 static tree
5433 handle_warn_unused_result_attribute (tree *node, tree name,
5434 tree ARG_UNUSED (args),
5435 int ARG_UNUSED (flags), bool *no_add_attrs)
5437 /* Ignore the attribute for functions not returning any value. */
5438 if (VOID_TYPE_P (TREE_TYPE (*node)))
5440 warning (OPT_Wattributes, "%qE attribute ignored", name);
5441 *no_add_attrs = true;
5444 return NULL_TREE;
5447 /* Handle a "sentinel" attribute. */
5449 static tree
5450 handle_sentinel_attribute (tree *node, tree name, tree args,
5451 int ARG_UNUSED (flags), bool *no_add_attrs)
5453 tree params = TYPE_ARG_TYPES (*node);
5455 if (!params)
5457 warning (OPT_Wattributes,
5458 "%qE attribute requires prototypes with named arguments", name);
5459 *no_add_attrs = true;
5461 else
5463 while (TREE_CHAIN (params))
5464 params = TREE_CHAIN (params);
5466 if (VOID_TYPE_P (TREE_VALUE (params)))
5468 warning (OPT_Wattributes,
5469 "%qE attribute only applies to variadic functions", name);
5470 *no_add_attrs = true;
5474 if (args)
5476 tree position = TREE_VALUE (args);
5478 if (TREE_CODE (position) != INTEGER_CST)
5480 warning (0, "requested position is not an integer constant");
5481 *no_add_attrs = true;
5483 else
5485 if (tree_int_cst_lt (position, integer_zero_node))
5487 warning (0, "requested position is less than zero");
5488 *no_add_attrs = true;
5493 return NULL_TREE;
5496 /* Check for valid arguments being passed to a function. */
5497 void
5498 check_function_arguments (tree attrs, tree params, tree typelist)
5500 /* Check for null being passed in a pointer argument that must be
5501 non-null. We also need to do this if format checking is enabled. */
5503 if (warn_nonnull)
5504 check_function_nonnull (attrs, params);
5506 /* Check for errors in format strings. */
5508 if (warn_format || warn_missing_format_attribute)
5509 check_function_format (attrs, params);
5511 if (warn_format)
5512 check_function_sentinel (attrs, params, typelist);
5515 /* Generic argument checking recursion routine. PARAM is the argument to
5516 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
5517 once the argument is resolved. CTX is context for the callback. */
5518 void
5519 check_function_arguments_recurse (void (*callback)
5520 (void *, tree, unsigned HOST_WIDE_INT),
5521 void *ctx, tree param,
5522 unsigned HOST_WIDE_INT param_num)
5524 if (TREE_CODE (param) == NOP_EXPR)
5526 /* Strip coercion. */
5527 check_function_arguments_recurse (callback, ctx,
5528 TREE_OPERAND (param, 0), param_num);
5529 return;
5532 if (TREE_CODE (param) == CALL_EXPR)
5534 tree type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (param, 0)));
5535 tree attrs;
5536 bool found_format_arg = false;
5538 /* See if this is a call to a known internationalization function
5539 that modifies a format arg. Such a function may have multiple
5540 format_arg attributes (for example, ngettext). */
5542 for (attrs = TYPE_ATTRIBUTES (type);
5543 attrs;
5544 attrs = TREE_CHAIN (attrs))
5545 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
5547 tree inner_args;
5548 tree format_num_expr;
5549 int format_num;
5550 int i;
5552 /* Extract the argument number, which was previously checked
5553 to be valid. */
5554 format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
5556 gcc_assert (TREE_CODE (format_num_expr) == INTEGER_CST
5557 && !TREE_INT_CST_HIGH (format_num_expr));
5559 format_num = TREE_INT_CST_LOW (format_num_expr);
5561 for (inner_args = TREE_OPERAND (param, 1), i = 1;
5562 inner_args != 0;
5563 inner_args = TREE_CHAIN (inner_args), i++)
5564 if (i == format_num)
5566 check_function_arguments_recurse (callback, ctx,
5567 TREE_VALUE (inner_args),
5568 param_num);
5569 found_format_arg = true;
5570 break;
5574 /* If we found a format_arg attribute and did a recursive check,
5575 we are done with checking this argument. Otherwise, we continue
5576 and this will be considered a non-literal. */
5577 if (found_format_arg)
5578 return;
5581 if (TREE_CODE (param) == COND_EXPR)
5583 /* Check both halves of the conditional expression. */
5584 check_function_arguments_recurse (callback, ctx,
5585 TREE_OPERAND (param, 1), param_num);
5586 check_function_arguments_recurse (callback, ctx,
5587 TREE_OPERAND (param, 2), param_num);
5588 return;
5591 (*callback) (ctx, param, param_num);
5594 /* Function to help qsort sort FIELD_DECLs by name order. */
5597 field_decl_cmp (const void *x_p, const void *y_p)
5599 const tree *const x = (const tree *const) x_p;
5600 const tree *const y = (const tree *const) y_p;
5602 if (DECL_NAME (*x) == DECL_NAME (*y))
5603 /* A nontype is "greater" than a type. */
5604 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
5605 if (DECL_NAME (*x) == NULL_TREE)
5606 return -1;
5607 if (DECL_NAME (*y) == NULL_TREE)
5608 return 1;
5609 if (DECL_NAME (*x) < DECL_NAME (*y))
5610 return -1;
5611 return 1;
5614 static struct {
5615 gt_pointer_operator new_value;
5616 void *cookie;
5617 } resort_data;
5619 /* This routine compares two fields like field_decl_cmp but using the
5620 pointer operator in resort_data. */
5622 static int
5623 resort_field_decl_cmp (const void *x_p, const void *y_p)
5625 const tree *const x = (const tree *const) x_p;
5626 const tree *const y = (const tree *const) y_p;
5628 if (DECL_NAME (*x) == DECL_NAME (*y))
5629 /* A nontype is "greater" than a type. */
5630 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
5631 if (DECL_NAME (*x) == NULL_TREE)
5632 return -1;
5633 if (DECL_NAME (*y) == NULL_TREE)
5634 return 1;
5636 tree d1 = DECL_NAME (*x);
5637 tree d2 = DECL_NAME (*y);
5638 resort_data.new_value (&d1, resort_data.cookie);
5639 resort_data.new_value (&d2, resort_data.cookie);
5640 if (d1 < d2)
5641 return -1;
5643 return 1;
5646 /* Resort DECL_SORTED_FIELDS because pointers have been reordered. */
5648 void
5649 resort_sorted_fields (void *obj,
5650 void * ARG_UNUSED (orig_obj),
5651 gt_pointer_operator new_value,
5652 void *cookie)
5654 struct sorted_fields_type *sf = (struct sorted_fields_type *) obj;
5655 resort_data.new_value = new_value;
5656 resort_data.cookie = cookie;
5657 qsort (&sf->elts[0], sf->len, sizeof (tree),
5658 resort_field_decl_cmp);
5661 /* Subroutine of c_parse_error.
5662 Return the result of concatenating LHS and RHS. RHS is really
5663 a string literal, its first character is indicated by RHS_START and
5664 RHS_SIZE is its length (including the terminating NUL character).
5666 The caller is responsible for deleting the returned pointer. */
5668 static char *
5669 catenate_strings (const char *lhs, const char *rhs_start, int rhs_size)
5671 const int lhs_size = strlen (lhs);
5672 char *result = XNEWVEC (char, lhs_size + rhs_size);
5673 strncpy (result, lhs, lhs_size);
5674 strncpy (result + lhs_size, rhs_start, rhs_size);
5675 return result;
5678 /* Issue the error given by GMSGID, indicating that it occurred before
5679 TOKEN, which had the associated VALUE. */
5681 void
5682 c_parse_error (const char *gmsgid, enum cpp_ttype token, tree value)
5684 #define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
5686 char *message = NULL;
5688 if (token == CPP_EOF)
5689 message = catenate_messages (gmsgid, " at end of input");
5690 else if (token == CPP_CHAR || token == CPP_WCHAR)
5692 unsigned int val = TREE_INT_CST_LOW (value);
5693 const char *const ell = (token == CPP_CHAR) ? "" : "L";
5694 if (val <= UCHAR_MAX && ISGRAPH (val))
5695 message = catenate_messages (gmsgid, " before %s'%c'");
5696 else
5697 message = catenate_messages (gmsgid, " before %s'\\x%x'");
5699 error (message, ell, val);
5700 free (message);
5701 message = NULL;
5703 else if (token == CPP_STRING || token == CPP_WSTRING)
5704 message = catenate_messages (gmsgid, " before string constant");
5705 else if (token == CPP_NUMBER)
5706 message = catenate_messages (gmsgid, " before numeric constant");
5707 else if (token == CPP_NAME)
5709 message = catenate_messages (gmsgid, " before %qE");
5710 error (message, value);
5711 free (message);
5712 message = NULL;
5714 else if (token < N_TTYPES)
5716 message = catenate_messages (gmsgid, " before %qs token");
5717 error (message, cpp_type2name (token));
5718 free (message);
5719 message = NULL;
5721 else
5722 error (gmsgid);
5724 if (message)
5726 error (message);
5727 free (message);
5729 #undef catenate_messages
5732 /* Walk a gimplified function and warn for functions whose return value is
5733 ignored and attribute((warn_unused_result)) is set. This is done before
5734 inlining, so we don't have to worry about that. */
5736 void
5737 c_warn_unused_result (tree *top_p)
5739 tree t = *top_p;
5740 tree_stmt_iterator i;
5741 tree fdecl, ftype;
5743 switch (TREE_CODE (t))
5745 case STATEMENT_LIST:
5746 for (i = tsi_start (*top_p); !tsi_end_p (i); tsi_next (&i))
5747 c_warn_unused_result (tsi_stmt_ptr (i));
5748 break;
5750 case COND_EXPR:
5751 c_warn_unused_result (&COND_EXPR_THEN (t));
5752 c_warn_unused_result (&COND_EXPR_ELSE (t));
5753 break;
5754 case BIND_EXPR:
5755 c_warn_unused_result (&BIND_EXPR_BODY (t));
5756 break;
5757 case TRY_FINALLY_EXPR:
5758 case TRY_CATCH_EXPR:
5759 c_warn_unused_result (&TREE_OPERAND (t, 0));
5760 c_warn_unused_result (&TREE_OPERAND (t, 1));
5761 break;
5762 case CATCH_EXPR:
5763 c_warn_unused_result (&CATCH_BODY (t));
5764 break;
5765 case EH_FILTER_EXPR:
5766 c_warn_unused_result (&EH_FILTER_FAILURE (t));
5767 break;
5769 case CALL_EXPR:
5770 if (TREE_USED (t))
5771 break;
5773 /* This is a naked call, as opposed to a CALL_EXPR nested inside
5774 a MODIFY_EXPR. All calls whose value is ignored should be
5775 represented like this. Look for the attribute. */
5776 fdecl = get_callee_fndecl (t);
5777 if (fdecl)
5778 ftype = TREE_TYPE (fdecl);
5779 else
5781 ftype = TREE_TYPE (TREE_OPERAND (t, 0));
5782 /* Look past pointer-to-function to the function type itself. */
5783 ftype = TREE_TYPE (ftype);
5786 if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype)))
5788 if (fdecl)
5789 warning (0, "%Hignoring return value of %qD, "
5790 "declared with attribute warn_unused_result",
5791 EXPR_LOCUS (t), fdecl);
5792 else
5793 warning (0, "%Hignoring return value of function "
5794 "declared with attribute warn_unused_result",
5795 EXPR_LOCUS (t));
5797 break;
5799 default:
5800 /* Not a container, not a call, or a call whose value is used. */
5801 break;
5805 /* Convert a character from the host to the target execution character
5806 set. cpplib handles this, mostly. */
5808 HOST_WIDE_INT
5809 c_common_to_target_charset (HOST_WIDE_INT c)
5811 /* Character constants in GCC proper are sign-extended under -fsigned-char,
5812 zero-extended under -fno-signed-char. cpplib insists that characters
5813 and character constants are always unsigned. Hence we must convert
5814 back and forth. */
5815 cppchar_t uc = ((cppchar_t)c) & ((((cppchar_t)1) << CHAR_BIT)-1);
5817 uc = cpp_host_to_exec_charset (parse_in, uc);
5819 if (flag_signed_char)
5820 return ((HOST_WIDE_INT)uc) << (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE)
5821 >> (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE);
5822 else
5823 return uc;
5826 /* Build the result of __builtin_offsetof. EXPR is a nested sequence of
5827 component references, with an INDIRECT_REF at the bottom; much like
5828 the traditional rendering of offsetof as a macro. Returns the folded
5829 and properly cast result. */
5831 static tree
5832 fold_offsetof_1 (tree expr)
5834 enum tree_code code = PLUS_EXPR;
5835 tree base, off, t;
5837 switch (TREE_CODE (expr))
5839 case ERROR_MARK:
5840 return expr;
5842 case INDIRECT_REF:
5843 return size_zero_node;
5845 case COMPONENT_REF:
5846 base = fold_offsetof_1 (TREE_OPERAND (expr, 0));
5847 if (base == error_mark_node)
5848 return base;
5850 t = TREE_OPERAND (expr, 1);
5851 if (DECL_C_BIT_FIELD (t))
5853 error ("attempt to take address of bit-field structure "
5854 "member %qD", t);
5855 return error_mark_node;
5857 off = size_binop (PLUS_EXPR, DECL_FIELD_OFFSET (t),
5858 size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t), 1)
5859 / BITS_PER_UNIT));
5860 break;
5862 case ARRAY_REF:
5863 base = fold_offsetof_1 (TREE_OPERAND (expr, 0));
5864 if (base == error_mark_node)
5865 return base;
5867 t = TREE_OPERAND (expr, 1);
5868 if (TREE_CODE (t) == INTEGER_CST && tree_int_cst_sgn (t) < 0)
5870 code = MINUS_EXPR;
5871 t = fold_build1 (NEGATE_EXPR, TREE_TYPE (t), t);
5873 t = convert (sizetype, t);
5874 off = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (TREE_TYPE (expr)), t);
5875 break;
5877 default:
5878 gcc_unreachable ();
5881 return size_binop (code, base, off);
5884 tree
5885 fold_offsetof (tree expr)
5887 /* Convert back from the internal sizetype to size_t. */
5888 return convert (size_type_node, fold_offsetof_1 (expr));
5891 /* Print an error message for an invalid lvalue. USE says
5892 how the lvalue is being used and so selects the error message. */
5894 void
5895 lvalue_error (enum lvalue_use use)
5897 switch (use)
5899 case lv_assign:
5900 error ("invalid lvalue in assignment");
5901 break;
5902 case lv_increment:
5903 error ("invalid lvalue in increment");
5904 break;
5905 case lv_decrement:
5906 error ("invalid lvalue in decrement");
5907 break;
5908 case lv_addressof:
5909 error ("invalid lvalue in unary %<&%>");
5910 break;
5911 case lv_asm:
5912 error ("invalid lvalue in asm statement");
5913 break;
5914 default:
5915 gcc_unreachable ();
5919 /* *PTYPE is an incomplete array. Complete it with a domain based on
5920 INITIAL_VALUE. If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
5921 is true. Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
5922 2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty. */
5925 complete_array_type (tree *ptype, tree initial_value, bool do_default)
5927 tree maxindex, type, main_type, elt, unqual_elt;
5928 int failure = 0, quals;
5930 maxindex = size_zero_node;
5931 if (initial_value)
5933 if (TREE_CODE (initial_value) == STRING_CST)
5935 int eltsize
5936 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
5937 maxindex = size_int (TREE_STRING_LENGTH (initial_value)/eltsize - 1);
5939 else if (TREE_CODE (initial_value) == CONSTRUCTOR)
5941 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
5943 if (VEC_empty (constructor_elt, v))
5945 if (pedantic)
5946 failure = 3;
5947 maxindex = integer_minus_one_node;
5949 else
5951 tree curindex;
5952 unsigned HOST_WIDE_INT cnt;
5953 constructor_elt *ce;
5955 if (VEC_index (constructor_elt, v, 0)->index)
5956 maxindex = fold_convert (sizetype,
5957 VEC_index (constructor_elt,
5958 v, 0)->index);
5959 curindex = maxindex;
5961 for (cnt = 1;
5962 VEC_iterate (constructor_elt, v, cnt, ce);
5963 cnt++)
5965 if (ce->index)
5966 curindex = fold_convert (sizetype, ce->index);
5967 else
5968 curindex = size_binop (PLUS_EXPR, curindex, size_one_node);
5970 if (tree_int_cst_lt (maxindex, curindex))
5971 maxindex = curindex;
5975 else
5977 /* Make an error message unless that happened already. */
5978 if (initial_value != error_mark_node)
5979 failure = 1;
5982 else
5984 failure = 2;
5985 if (!do_default)
5986 return failure;
5989 type = *ptype;
5990 elt = TREE_TYPE (type);
5991 quals = TYPE_QUALS (strip_array_types (elt));
5992 if (quals == 0)
5993 unqual_elt = elt;
5994 else
5995 unqual_elt = c_build_qualified_type (elt, TYPE_UNQUALIFIED);
5997 /* Using build_distinct_type_copy and modifying things afterward instead
5998 of using build_array_type to create a new type preserves all of the
5999 TYPE_LANG_FLAG_? bits that the front end may have set. */
6000 main_type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
6001 TREE_TYPE (main_type) = unqual_elt;
6002 TYPE_DOMAIN (main_type) = build_index_type (maxindex);
6003 layout_type (main_type);
6005 if (quals == 0)
6006 type = main_type;
6007 else
6008 type = c_build_qualified_type (main_type, quals);
6010 *ptype = type;
6011 return failure;
6015 /* Used to help initialize the builtin-types.def table. When a type of
6016 the correct size doesn't exist, use error_mark_node instead of NULL.
6017 The later results in segfaults even when a decl using the type doesn't
6018 get invoked. */
6020 tree
6021 builtin_type_for_size (int size, bool unsignedp)
6023 tree type = lang_hooks.types.type_for_size (size, unsignedp);
6024 return type ? type : error_mark_node;
6027 /* A helper function for resolve_overloaded_builtin in resolving the
6028 overloaded __sync_ builtins. Returns a positive power of 2 if the
6029 first operand of PARAMS is a pointer to a supported data type.
6030 Returns 0 if an error is encountered. */
6032 static int
6033 sync_resolve_size (tree function, tree params)
6035 tree type;
6036 int size;
6038 if (params == NULL)
6040 error ("too few arguments to function %qE", function);
6041 return 0;
6044 type = TREE_TYPE (TREE_VALUE (params));
6045 if (TREE_CODE (type) != POINTER_TYPE)
6046 goto incompatible;
6048 type = TREE_TYPE (type);
6049 if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
6050 goto incompatible;
6052 size = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
6053 if (size == 1 || size == 2 || size == 4 || size == 8)
6054 return size;
6056 incompatible:
6057 error ("incompatible type for argument %d of %qE", 1, function);
6058 return 0;
6061 /* A helper function for resolve_overloaded_builtin. Adds casts to
6062 PARAMS to make arguments match up with those of FUNCTION. Drops
6063 the variadic arguments at the end. Returns false if some error
6064 was encountered; true on success. */
6066 static bool
6067 sync_resolve_params (tree orig_function, tree function, tree params)
6069 tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (function));
6070 tree ptype;
6071 int number;
6073 /* We've declared the implementation functions to use "volatile void *"
6074 as the pointer parameter, so we shouldn't get any complaints from the
6075 call to check_function_arguments what ever type the user used. */
6076 arg_types = TREE_CHAIN (arg_types);
6077 ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params)));
6078 number = 2;
6080 /* For the rest of the values, we need to cast these to FTYPE, so that we
6081 don't get warnings for passing pointer types, etc. */
6082 while (arg_types != void_list_node)
6084 tree val;
6086 params = TREE_CHAIN (params);
6087 if (params == NULL)
6089 error ("too few arguments to function %qE", orig_function);
6090 return false;
6093 /* ??? Ideally for the first conversion we'd use convert_for_assignment
6094 so that we get warnings for anything that doesn't match the pointer
6095 type. This isn't portable across the C and C++ front ends atm. */
6096 val = TREE_VALUE (params);
6097 val = convert (ptype, val);
6098 val = convert (TREE_VALUE (arg_types), val);
6099 TREE_VALUE (params) = val;
6101 arg_types = TREE_CHAIN (arg_types);
6102 number++;
6105 /* The definition of these primitives is variadic, with the remaining
6106 being "an optional list of variables protected by the memory barrier".
6107 No clue what that's supposed to mean, precisely, but we consider all
6108 call-clobbered variables to be protected so we're safe. */
6109 TREE_CHAIN (params) = NULL;
6111 return true;
6114 /* A helper function for resolve_overloaded_builtin. Adds a cast to
6115 RESULT to make it match the type of the first pointer argument in
6116 PARAMS. */
6118 static tree
6119 sync_resolve_return (tree params, tree result)
6121 tree ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params)));
6122 return convert (ptype, result);
6125 /* Some builtin functions are placeholders for other expressions. This
6126 function should be called immediately after parsing the call expression
6127 before surrounding code has committed to the type of the expression.
6129 FUNCTION is the DECL that has been invoked; it is known to be a builtin.
6130 PARAMS is the argument list for the call. The return value is non-null
6131 when expansion is complete, and null if normal processing should
6132 continue. */
6134 tree
6135 resolve_overloaded_builtin (tree function, tree params)
6137 enum built_in_function orig_code = DECL_FUNCTION_CODE (function);
6138 switch (DECL_BUILT_IN_CLASS (function))
6140 case BUILT_IN_NORMAL:
6141 break;
6142 case BUILT_IN_MD:
6143 if (targetm.resolve_overloaded_builtin)
6144 return targetm.resolve_overloaded_builtin (function, params);
6145 else
6146 return NULL_TREE;
6147 default:
6148 return NULL_TREE;
6151 /* Handle BUILT_IN_NORMAL here. */
6152 switch (orig_code)
6154 case BUILT_IN_FETCH_AND_ADD_N:
6155 case BUILT_IN_FETCH_AND_SUB_N:
6156 case BUILT_IN_FETCH_AND_OR_N:
6157 case BUILT_IN_FETCH_AND_AND_N:
6158 case BUILT_IN_FETCH_AND_XOR_N:
6159 case BUILT_IN_FETCH_AND_NAND_N:
6160 case BUILT_IN_ADD_AND_FETCH_N:
6161 case BUILT_IN_SUB_AND_FETCH_N:
6162 case BUILT_IN_OR_AND_FETCH_N:
6163 case BUILT_IN_AND_AND_FETCH_N:
6164 case BUILT_IN_XOR_AND_FETCH_N:
6165 case BUILT_IN_NAND_AND_FETCH_N:
6166 case BUILT_IN_BOOL_COMPARE_AND_SWAP_N:
6167 case BUILT_IN_VAL_COMPARE_AND_SWAP_N:
6168 case BUILT_IN_LOCK_TEST_AND_SET_N:
6169 case BUILT_IN_LOCK_RELEASE_N:
6171 int n = sync_resolve_size (function, params);
6172 tree new_function, result;
6174 if (n == 0)
6175 return error_mark_node;
6177 new_function = built_in_decls[orig_code + exact_log2 (n) + 1];
6178 if (!sync_resolve_params (function, new_function, params))
6179 return error_mark_node;
6181 result = build_function_call (new_function, params);
6182 if (orig_code != BUILT_IN_BOOL_COMPARE_AND_SWAP_N
6183 && orig_code != BUILT_IN_LOCK_RELEASE_N)
6184 result = sync_resolve_return (params, result);
6186 return result;
6189 default:
6190 return NULL_TREE;
6194 /* Ignoring their sign, return true if two scalar types are the same. */
6195 bool
6196 same_scalar_type_ignoring_signedness (tree t1, tree t2)
6198 enum tree_code c1 = TREE_CODE (t1), c2 = TREE_CODE (t2);
6200 gcc_assert ((c1 == INTEGER_TYPE || c1 == REAL_TYPE)
6201 && (c2 == INTEGER_TYPE || c2 == REAL_TYPE));
6203 /* Equality works here because c_common_signed_type uses
6204 TYPE_MAIN_VARIANT. */
6205 return lang_hooks.types.signed_type (t1)
6206 == lang_hooks.types.signed_type (t2);
6209 /* Check for missing format attributes on function pointers. LTYPE is
6210 the new type or left-hand side type. RTYPE is the old type or
6211 right-hand side type. Returns TRUE if LTYPE is missing the desired
6212 attribute. */
6214 bool
6215 check_missing_format_attribute (tree ltype, tree rtype)
6217 tree const ttr = TREE_TYPE (rtype), ttl = TREE_TYPE (ltype);
6218 tree ra;
6220 for (ra = TYPE_ATTRIBUTES (ttr); ra; ra = TREE_CHAIN (ra))
6221 if (is_attribute_p ("format", TREE_PURPOSE (ra)))
6222 break;
6223 if (ra)
6225 tree la;
6226 for (la = TYPE_ATTRIBUTES (ttl); la; la = TREE_CHAIN (la))
6227 if (is_attribute_p ("format", TREE_PURPOSE (la)))
6228 break;
6229 return !la;
6231 else
6232 return false;
6235 #include "gt-c-common.h"