1 /* Language-dependent hooks for LTO.
2 Copyright 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
3 Contributed by CodeSourcery, 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 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
28 #include "langhooks.h"
29 #include "langhooks-def.h"
33 #include "tree-inline.h"
35 #include "diagnostic-core.h"
37 #include "lto-streamer.h"
39 static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
40 static tree handle_leaf_attribute (tree *, tree, tree, int, bool *);
41 static tree handle_const_attribute (tree *, tree, tree, int, bool *);
42 static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);
43 static tree handle_pure_attribute (tree *, tree, tree, int, bool *);
44 static tree handle_novops_attribute (tree *, tree, tree, int, bool *);
45 static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
46 static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
47 static tree handle_sentinel_attribute (tree *, tree, tree, int, bool *);
48 static tree handle_type_generic_attribute (tree *, tree, tree, int, bool *);
49 static tree handle_transaction_pure_attribute (tree *, tree, tree, int, bool *);
50 static tree handle_returns_twice_attribute (tree *, tree, tree, int, bool *);
51 static tree ignore_attribute (tree *, tree, tree, int, bool *);
53 static tree handle_format_attribute (tree *, tree, tree, int, bool *);
54 static tree handle_format_arg_attribute (tree *, tree, tree, int, bool *);
56 /* Table of machine-independent attributes supported in GIMPLE. */
57 const struct attribute_spec lto_attribute_table[] =
59 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler,
61 { "noreturn", 0, 0, true, false, false,
62 handle_noreturn_attribute, false },
63 { "leaf", 0, 0, true, false, false,
64 handle_leaf_attribute, false },
65 /* The same comments as for noreturn attributes apply to const ones. */
66 { "const", 0, 0, true, false, false,
67 handle_const_attribute, false },
68 { "malloc", 0, 0, true, false, false,
69 handle_malloc_attribute, false },
70 { "pure", 0, 0, true, false, false,
71 handle_pure_attribute, false },
72 { "no vops", 0, 0, true, false, false,
73 handle_novops_attribute, false },
74 { "nonnull", 0, -1, false, true, true,
75 handle_nonnull_attribute, false },
76 { "nothrow", 0, 0, true, false, false,
77 handle_nothrow_attribute, false },
78 { "returns_twice", 0, 0, true, false, false,
79 handle_returns_twice_attribute, false },
80 { "sentinel", 0, 1, false, true, true,
81 handle_sentinel_attribute, false },
82 { "type generic", 0, 0, false, true, true,
83 handle_type_generic_attribute, false },
84 { "transaction_pure", 0, 0, false, true, true,
85 handle_transaction_pure_attribute, false },
86 /* For internal use only. The leading '*' both prevents its usage in
87 source code and signals that it may be overridden by machine tables. */
88 { "*tm regparm", 0, 0, false, true, true,
89 ignore_attribute, false },
90 { NULL, 0, 0, false, false, false, NULL, false }
93 /* Give the specifications for the format attributes, used by C and all
96 const struct attribute_spec lto_format_attribute_table[] =
98 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler,
99 affects_type_identity } */
100 { "format", 3, 3, false, true, true,
101 handle_format_attribute, false },
102 { "format_arg", 1, 1, false, true, true,
103 handle_format_arg_attribute, false },
104 { NULL, 0, 0, false, false, false, NULL, false }
107 enum built_in_attribute
109 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
110 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
111 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
112 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
113 #include "builtin-attrs.def"
114 #undef DEF_ATTR_NULL_TREE
116 #undef DEF_ATTR_IDENT
117 #undef DEF_ATTR_TREE_LIST
121 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
125 enum lto_builtin_type
127 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
128 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
129 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
130 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
131 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
132 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
133 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
134 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME,
135 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME,
136 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
137 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
138 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
139 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
140 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
141 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
143 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
144 #include "builtin-types.def"
145 #undef DEF_PRIMITIVE_TYPE
146 #undef DEF_FUNCTION_TYPE_0
147 #undef DEF_FUNCTION_TYPE_1
148 #undef DEF_FUNCTION_TYPE_2
149 #undef DEF_FUNCTION_TYPE_3
150 #undef DEF_FUNCTION_TYPE_4
151 #undef DEF_FUNCTION_TYPE_5
152 #undef DEF_FUNCTION_TYPE_6
153 #undef DEF_FUNCTION_TYPE_7
154 #undef DEF_FUNCTION_TYPE_VAR_0
155 #undef DEF_FUNCTION_TYPE_VAR_1
156 #undef DEF_FUNCTION_TYPE_VAR_2
157 #undef DEF_FUNCTION_TYPE_VAR_3
158 #undef DEF_FUNCTION_TYPE_VAR_4
159 #undef DEF_FUNCTION_TYPE_VAR_5
160 #undef DEF_POINTER_TYPE
164 typedef enum lto_builtin_type builtin_type;
166 static GTY(()) tree builtin_types[(int) BT_LAST + 1];
168 static GTY(()) tree string_type_node;
169 static GTY(()) tree const_string_type_node;
170 static GTY(()) tree wint_type_node;
171 static GTY(()) tree intmax_type_node;
172 static GTY(()) tree uintmax_type_node;
173 static GTY(()) tree signed_size_type_node;
175 /* Flags needed to process builtins.def. */
179 /* Attribute handlers. */
181 /* Handle a "noreturn" attribute; arguments as in
182 struct attribute_spec.handler. */
185 handle_noreturn_attribute (tree *node, tree ARG_UNUSED (name),
186 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
187 bool * ARG_UNUSED (no_add_attrs))
189 tree type = TREE_TYPE (*node);
191 if (TREE_CODE (*node) == FUNCTION_DECL)
192 TREE_THIS_VOLATILE (*node) = 1;
193 else if (TREE_CODE (type) == POINTER_TYPE
194 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
197 (build_type_variant (TREE_TYPE (type),
198 TYPE_READONLY (TREE_TYPE (type)), 1));
205 /* Handle a "leaf" attribute; arguments as in
206 struct attribute_spec.handler. */
209 handle_leaf_attribute (tree *node, tree name,
210 tree ARG_UNUSED (args),
211 int ARG_UNUSED (flags), bool *no_add_attrs)
213 if (TREE_CODE (*node) != FUNCTION_DECL)
215 warning (OPT_Wattributes, "%qE attribute ignored", name);
216 *no_add_attrs = true;
218 if (!TREE_PUBLIC (*node))
220 warning (OPT_Wattributes, "%qE attribute has no effect on unit local functions", name);
221 *no_add_attrs = true;
227 /* Handle a "const" attribute; arguments as in
228 struct attribute_spec.handler. */
231 handle_const_attribute (tree *node, tree ARG_UNUSED (name),
232 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
233 bool * ARG_UNUSED (no_add_attrs))
235 tree type = TREE_TYPE (*node);
237 /* See FIXME comment on noreturn in c_common_attribute_table. */
238 if (TREE_CODE (*node) == FUNCTION_DECL)
239 TREE_READONLY (*node) = 1;
240 else if (TREE_CODE (type) == POINTER_TYPE
241 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
244 (build_type_variant (TREE_TYPE (type), 1,
245 TREE_THIS_VOLATILE (TREE_TYPE (type))));
253 /* Handle a "malloc" attribute; arguments as in
254 struct attribute_spec.handler. */
257 handle_malloc_attribute (tree *node, tree ARG_UNUSED (name),
258 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
259 bool * ARG_UNUSED (no_add_attrs))
261 if (TREE_CODE (*node) == FUNCTION_DECL
262 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node))))
263 DECL_IS_MALLOC (*node) = 1;
271 /* Handle a "pure" attribute; arguments as in
272 struct attribute_spec.handler. */
275 handle_pure_attribute (tree *node, tree ARG_UNUSED (name),
276 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
277 bool * ARG_UNUSED (no_add_attrs))
279 if (TREE_CODE (*node) == FUNCTION_DECL)
280 DECL_PURE_P (*node) = 1;
288 /* Handle a "no vops" attribute; arguments as in
289 struct attribute_spec.handler. */
292 handle_novops_attribute (tree *node, tree ARG_UNUSED (name),
293 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
294 bool *ARG_UNUSED (no_add_attrs))
296 gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
297 DECL_IS_NOVOPS (*node) = 1;
302 /* Helper for nonnull attribute handling; fetch the operand number
303 from the attribute argument list. */
306 get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
308 /* Verify the arg number is a constant. */
309 if (TREE_CODE (arg_num_expr) != INTEGER_CST
310 || TREE_INT_CST_HIGH (arg_num_expr) != 0)
313 *valp = TREE_INT_CST_LOW (arg_num_expr);
317 /* Handle the "nonnull" attribute. */
320 handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
321 tree args, int ARG_UNUSED (flags),
322 bool * ARG_UNUSED (no_add_attrs))
326 /* If no arguments are specified, all pointer arguments should be
327 non-null. Verify a full prototype is given so that the arguments
328 will have the correct types when we actually check them later. */
331 gcc_assert (prototype_p (type));
335 /* Argument list specified. Verify that each argument number references
336 a pointer argument. */
337 for (; args; args = TREE_CHAIN (args))
340 unsigned HOST_WIDE_INT arg_num = 0, ck_num;
342 if (!get_nonnull_operand (TREE_VALUE (args), &arg_num))
345 argument = TYPE_ARG_TYPES (type);
348 for (ck_num = 1; ; ck_num++)
350 if (!argument || ck_num == arg_num)
352 argument = TREE_CHAIN (argument);
356 && TREE_CODE (TREE_VALUE (argument)) == POINTER_TYPE);
364 /* Handle a "nothrow" attribute; arguments as in
365 struct attribute_spec.handler. */
368 handle_nothrow_attribute (tree *node, tree ARG_UNUSED (name),
369 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
370 bool * ARG_UNUSED (no_add_attrs))
372 if (TREE_CODE (*node) == FUNCTION_DECL)
373 TREE_NOTHROW (*node) = 1;
381 /* Handle a "sentinel" attribute. */
384 handle_sentinel_attribute (tree *node, tree ARG_UNUSED (name), tree args,
385 int ARG_UNUSED (flags),
386 bool * ARG_UNUSED (no_add_attrs))
388 gcc_assert (stdarg_p (*node));
392 tree position = TREE_VALUE (args);
393 gcc_assert (TREE_CODE (position) == INTEGER_CST);
394 if (tree_int_cst_lt (position, integer_zero_node))
401 /* Handle a "type_generic" attribute. */
404 handle_type_generic_attribute (tree *node, tree ARG_UNUSED (name),
405 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
406 bool * ARG_UNUSED (no_add_attrs))
408 /* Ensure we have a function type. */
409 gcc_assert (TREE_CODE (*node) == FUNCTION_TYPE);
411 /* Ensure we have a variadic function. */
412 gcc_assert (!prototype_p (*node) || stdarg_p (*node));
417 /* Handle a "transaction_pure" attribute. */
420 handle_transaction_pure_attribute (tree *node, tree ARG_UNUSED (name),
421 tree ARG_UNUSED (args),
422 int ARG_UNUSED (flags),
423 bool * ARG_UNUSED (no_add_attrs))
425 /* Ensure we have a function type. */
426 gcc_assert (TREE_CODE (*node) == FUNCTION_TYPE);
431 /* Handle a "returns_twice" attribute. */
434 handle_returns_twice_attribute (tree *node, tree ARG_UNUSED (name),
435 tree ARG_UNUSED (args),
436 int ARG_UNUSED (flags),
437 bool * ARG_UNUSED (no_add_attrs))
439 gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
441 DECL_IS_RETURNS_TWICE (*node) = 1;
446 /* Ignore the given attribute. Used when this attribute may be usefully
447 overridden by the target, but is not used generically. */
450 ignore_attribute (tree * ARG_UNUSED (node), tree ARG_UNUSED (name),
451 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
454 *no_add_attrs = true;
458 /* Handle a "format" attribute; arguments as in
459 struct attribute_spec.handler. */
462 handle_format_attribute (tree * ARG_UNUSED (node), tree ARG_UNUSED (name),
463 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
466 *no_add_attrs = true;
471 /* Handle a "format_arg" attribute; arguments as in
472 struct attribute_spec.handler. */
475 handle_format_arg_attribute (tree * ARG_UNUSED (node), tree ARG_UNUSED (name),
476 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
479 *no_add_attrs = true;
484 /* Cribbed from c-common.c. */
487 def_fn_type (builtin_type def, builtin_type ret, bool var, int n, ...)
490 tree *args = XALLOCAVEC (tree, n);
495 for (i = 0; i < n; ++i)
497 builtin_type a = (builtin_type) va_arg (list, int);
498 t = builtin_types[a];
499 if (t == error_mark_node)
505 t = builtin_types[ret];
506 if (t == error_mark_node)
509 t = build_varargs_function_type_array (t, n, args);
511 t = build_function_type_array (t, n, args);
514 builtin_types[def] = t;
518 /* Used to help initialize the builtin-types.def table. When a type of
519 the correct size doesn't exist, use error_mark_node instead of NULL.
520 The later results in segfaults even when a decl using the type doesn't
524 builtin_type_for_size (int size, bool unsignedp)
526 tree type = lang_hooks.types.type_for_size (size, unsignedp);
527 return type ? type : error_mark_node;
530 /* Support for DEF_BUILTIN. */
533 def_builtin_1 (enum built_in_function fncode, const char *name,
534 enum built_in_class fnclass, tree fntype, tree libtype,
535 bool both_p, bool fallback_p, bool nonansi_p,
536 tree fnattrs, bool implicit_p)
541 if (fntype == error_mark_node)
544 libname = name + strlen ("__builtin_");
545 decl = add_builtin_function (name, fntype, fncode, fnclass,
546 (fallback_p ? libname : NULL),
551 && !(nonansi_p && flag_no_nonansi_builtin))
552 add_builtin_function (libname, libtype, fncode, fnclass,
555 set_builtin_decl (fncode, decl, implicit_p);
559 /* Initialize the attribute table for all the supported builtins. */
562 lto_init_attributes (void)
564 /* Fill in the built_in_attributes array. */
565 #define DEF_ATTR_NULL_TREE(ENUM) \
566 built_in_attributes[(int) ENUM] = NULL_TREE;
567 #define DEF_ATTR_INT(ENUM, VALUE) \
568 built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
569 #define DEF_ATTR_IDENT(ENUM, STRING) \
570 built_in_attributes[(int) ENUM] = get_identifier (STRING);
571 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
572 built_in_attributes[(int) ENUM] \
573 = tree_cons (built_in_attributes[(int) PURPOSE], \
574 built_in_attributes[(int) VALUE], \
575 built_in_attributes[(int) CHAIN]);
576 #include "builtin-attrs.def"
577 #undef DEF_ATTR_NULL_TREE
579 #undef DEF_ATTR_IDENT
580 #undef DEF_ATTR_TREE_LIST
583 /* Create builtin types and functions. VA_LIST_REF_TYPE_NODE and
584 VA_LIST_ARG_TYPE_NODE are used in builtin-types.def. */
587 lto_define_builtins (tree va_list_ref_type_node ATTRIBUTE_UNUSED,
588 tree va_list_arg_type_node ATTRIBUTE_UNUSED)
590 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
591 builtin_types[ENUM] = VALUE;
592 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
593 def_fn_type (ENUM, RETURN, 0, 0);
594 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
595 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
596 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
597 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
598 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
599 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
600 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
601 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
602 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
603 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
604 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
606 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
607 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
609 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
610 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
611 def_fn_type (ENUM, RETURN, 1, 0);
612 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
613 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
614 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
615 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
616 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
617 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
618 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
619 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
620 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
621 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
622 #define DEF_POINTER_TYPE(ENUM, TYPE) \
623 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
625 #include "builtin-types.def"
627 #undef DEF_PRIMITIVE_TYPE
628 #undef DEF_FUNCTION_TYPE_1
629 #undef DEF_FUNCTION_TYPE_2
630 #undef DEF_FUNCTION_TYPE_3
631 #undef DEF_FUNCTION_TYPE_4
632 #undef DEF_FUNCTION_TYPE_5
633 #undef DEF_FUNCTION_TYPE_6
634 #undef DEF_FUNCTION_TYPE_VAR_0
635 #undef DEF_FUNCTION_TYPE_VAR_1
636 #undef DEF_FUNCTION_TYPE_VAR_2
637 #undef DEF_FUNCTION_TYPE_VAR_3
638 #undef DEF_FUNCTION_TYPE_VAR_4
639 #undef DEF_FUNCTION_TYPE_VAR_5
640 #undef DEF_POINTER_TYPE
641 builtin_types[(int) BT_LAST] = NULL_TREE;
643 lto_init_attributes ();
645 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P,\
646 NONANSI_P, ATTRS, IMPLICIT, COND) \
648 def_builtin_1 (ENUM, NAME, CLASS, builtin_types[(int) TYPE], \
649 builtin_types[(int) LIBTYPE], BOTH_P, FALLBACK_P, \
650 NONANSI_P, built_in_attributes[(int) ATTRS], IMPLICIT);
651 #include "builtins.def"
655 static GTY(()) tree registered_builtin_types;
657 /* Language hooks. */
660 lto_option_lang_mask (void)
666 lto_complain_wrong_lang_p (const struct cl_option *option ATTRIBUTE_UNUSED)
668 /* The LTO front end inherits all the options from the first front
669 end that was used. However, not all the original front end
670 options make sense in LTO.
672 A real solution would be to filter this in collect2, but collect2
673 does not have access to all the option attributes to know what to
674 filter. So, in lto1 we silently accept inherited flags and do
680 lto_init_options_struct (struct gcc_options *opts)
682 /* By default, C99-like requirements for complex multiply and divide.
683 ??? Until the complex method is encoded in the IL this is the only
684 safe choice. This will pessimize Fortran code with LTO unless
685 people specify a complex method manually or use -ffast-math. */
686 opts->x_flag_complex_method = 2;
689 /* Handle command-line option SCODE. If the option takes an argument, it is
690 stored in ARG, which is otherwise NULL. VALUE holds either a numerical
691 argument or a binary value indicating whether the positive or negative form
692 of the option was supplied. */
694 const char *resolution_file_name;
696 lto_handle_option (size_t scode, const char *arg,
697 int value ATTRIBUTE_UNUSED, int kind ATTRIBUTE_UNUSED,
698 location_t loc ATTRIBUTE_UNUSED,
699 const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED)
701 enum opt_code code = (enum opt_code) scode;
706 case OPT_fresolution_:
707 resolution_file_name = arg;
721 /* Perform post-option processing. Does additional initialization based on
722 command-line options. PFILENAME is the main input filename. Returns false
723 to enable subsequent back-end initialization. */
726 lto_post_options (const char **pfilename ATTRIBUTE_UNUSED)
728 /* -fltrans and -fwpa are mutually exclusive. Check for that here. */
729 if (flag_wpa && flag_ltrans)
730 error ("-fwpa and -fltrans are mutually exclusive");
734 flag_generate_lto = 0;
736 /* During LTRANS, we are not looking at the whole program, only
737 a subset of the whole callgraph. */
738 flag_whole_program = 0;
742 flag_generate_lto = 1;
744 /* Excess precision other than "fast" requires front-end
746 flag_excess_precision_cmdline = EXCESS_PRECISION_FAST;
748 /* Initialize the compiler back end. */
752 /* Return an integer type with PRECISION bits of precision,
753 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
756 lto_type_for_size (unsigned precision, int unsignedp)
758 if (precision == TYPE_PRECISION (integer_type_node))
759 return unsignedp ? unsigned_type_node : integer_type_node;
761 if (precision == TYPE_PRECISION (signed_char_type_node))
762 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
764 if (precision == TYPE_PRECISION (short_integer_type_node))
765 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
767 if (precision == TYPE_PRECISION (long_integer_type_node))
768 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
770 if (precision == TYPE_PRECISION (long_long_integer_type_node))
772 ? long_long_unsigned_type_node
773 : long_long_integer_type_node;
775 if (precision <= TYPE_PRECISION (intQI_type_node))
776 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
778 if (precision <= TYPE_PRECISION (intHI_type_node))
779 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
781 if (precision <= TYPE_PRECISION (intSI_type_node))
782 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
784 if (precision <= TYPE_PRECISION (intDI_type_node))
785 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
787 if (precision <= TYPE_PRECISION (intTI_type_node))
788 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
794 /* Return a data type that has machine mode MODE.
795 If the mode is an integer,
796 then UNSIGNEDP selects between signed and unsigned types.
797 If the mode is a fixed-point mode,
798 then UNSIGNEDP selects between saturating and nonsaturating types. */
801 lto_type_for_mode (enum machine_mode mode, int unsigned_p)
805 if (mode == TYPE_MODE (integer_type_node))
806 return unsigned_p ? unsigned_type_node : integer_type_node;
808 if (mode == TYPE_MODE (signed_char_type_node))
809 return unsigned_p ? unsigned_char_type_node : signed_char_type_node;
811 if (mode == TYPE_MODE (short_integer_type_node))
812 return unsigned_p ? short_unsigned_type_node : short_integer_type_node;
814 if (mode == TYPE_MODE (long_integer_type_node))
815 return unsigned_p ? long_unsigned_type_node : long_integer_type_node;
817 if (mode == TYPE_MODE (long_long_integer_type_node))
818 return unsigned_p ? long_long_unsigned_type_node : long_long_integer_type_node;
821 return unsigned_p ? unsigned_intQI_type_node : intQI_type_node;
824 return unsigned_p ? unsigned_intHI_type_node : intHI_type_node;
827 return unsigned_p ? unsigned_intSI_type_node : intSI_type_node;
830 return unsigned_p ? unsigned_intDI_type_node : intDI_type_node;
832 #if HOST_BITS_PER_WIDE_INT >= 64
833 if (mode == TYPE_MODE (intTI_type_node))
834 return unsigned_p ? unsigned_intTI_type_node : intTI_type_node;
837 if (mode == TYPE_MODE (float_type_node))
838 return float_type_node;
840 if (mode == TYPE_MODE (double_type_node))
841 return double_type_node;
843 if (mode == TYPE_MODE (long_double_type_node))
844 return long_double_type_node;
846 if (mode == TYPE_MODE (void_type_node))
847 return void_type_node;
849 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
851 ? make_unsigned_type (GET_MODE_PRECISION (mode))
852 : make_signed_type (GET_MODE_PRECISION (mode)));
854 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
856 ? make_unsigned_type (GET_MODE_PRECISION (mode))
857 : make_signed_type (GET_MODE_PRECISION (mode)));
859 if (COMPLEX_MODE_P (mode))
861 enum machine_mode inner_mode;
864 if (mode == TYPE_MODE (complex_float_type_node))
865 return complex_float_type_node;
866 if (mode == TYPE_MODE (complex_double_type_node))
867 return complex_double_type_node;
868 if (mode == TYPE_MODE (complex_long_double_type_node))
869 return complex_long_double_type_node;
871 if (mode == TYPE_MODE (complex_integer_type_node) && !unsigned_p)
872 return complex_integer_type_node;
874 inner_mode = GET_MODE_INNER (mode);
875 inner_type = lto_type_for_mode (inner_mode, unsigned_p);
876 if (inner_type != NULL_TREE)
877 return build_complex_type (inner_type);
879 else if (VECTOR_MODE_P (mode))
881 enum machine_mode inner_mode = GET_MODE_INNER (mode);
882 tree inner_type = lto_type_for_mode (inner_mode, unsigned_p);
883 if (inner_type != NULL_TREE)
884 return build_vector_type_for_mode (inner_type, mode);
887 if (mode == TYPE_MODE (dfloat32_type_node))
888 return dfloat32_type_node;
889 if (mode == TYPE_MODE (dfloat64_type_node))
890 return dfloat64_type_node;
891 if (mode == TYPE_MODE (dfloat128_type_node))
892 return dfloat128_type_node;
894 if (ALL_SCALAR_FIXED_POINT_MODE_P (mode))
896 if (mode == TYPE_MODE (short_fract_type_node))
897 return unsigned_p ? sat_short_fract_type_node : short_fract_type_node;
898 if (mode == TYPE_MODE (fract_type_node))
899 return unsigned_p ? sat_fract_type_node : fract_type_node;
900 if (mode == TYPE_MODE (long_fract_type_node))
901 return unsigned_p ? sat_long_fract_type_node : long_fract_type_node;
902 if (mode == TYPE_MODE (long_long_fract_type_node))
903 return unsigned_p ? sat_long_long_fract_type_node
904 : long_long_fract_type_node;
906 if (mode == TYPE_MODE (unsigned_short_fract_type_node))
907 return unsigned_p ? sat_unsigned_short_fract_type_node
908 : unsigned_short_fract_type_node;
909 if (mode == TYPE_MODE (unsigned_fract_type_node))
910 return unsigned_p ? sat_unsigned_fract_type_node
911 : unsigned_fract_type_node;
912 if (mode == TYPE_MODE (unsigned_long_fract_type_node))
913 return unsigned_p ? sat_unsigned_long_fract_type_node
914 : unsigned_long_fract_type_node;
915 if (mode == TYPE_MODE (unsigned_long_long_fract_type_node))
916 return unsigned_p ? sat_unsigned_long_long_fract_type_node
917 : unsigned_long_long_fract_type_node;
919 if (mode == TYPE_MODE (short_accum_type_node))
920 return unsigned_p ? sat_short_accum_type_node : short_accum_type_node;
921 if (mode == TYPE_MODE (accum_type_node))
922 return unsigned_p ? sat_accum_type_node : accum_type_node;
923 if (mode == TYPE_MODE (long_accum_type_node))
924 return unsigned_p ? sat_long_accum_type_node : long_accum_type_node;
925 if (mode == TYPE_MODE (long_long_accum_type_node))
926 return unsigned_p ? sat_long_long_accum_type_node
927 : long_long_accum_type_node;
929 if (mode == TYPE_MODE (unsigned_short_accum_type_node))
930 return unsigned_p ? sat_unsigned_short_accum_type_node
931 : unsigned_short_accum_type_node;
932 if (mode == TYPE_MODE (unsigned_accum_type_node))
933 return unsigned_p ? sat_unsigned_accum_type_node
934 : unsigned_accum_type_node;
935 if (mode == TYPE_MODE (unsigned_long_accum_type_node))
936 return unsigned_p ? sat_unsigned_long_accum_type_node
937 : unsigned_long_accum_type_node;
938 if (mode == TYPE_MODE (unsigned_long_long_accum_type_node))
939 return unsigned_p ? sat_unsigned_long_long_accum_type_node
940 : unsigned_long_long_accum_type_node;
943 return unsigned_p ? sat_qq_type_node : qq_type_node;
945 return unsigned_p ? sat_hq_type_node : hq_type_node;
947 return unsigned_p ? sat_sq_type_node : sq_type_node;
949 return unsigned_p ? sat_dq_type_node : dq_type_node;
951 return unsigned_p ? sat_tq_type_node : tq_type_node;
954 return unsigned_p ? sat_uqq_type_node : uqq_type_node;
956 return unsigned_p ? sat_uhq_type_node : uhq_type_node;
958 return unsigned_p ? sat_usq_type_node : usq_type_node;
960 return unsigned_p ? sat_udq_type_node : udq_type_node;
962 return unsigned_p ? sat_utq_type_node : utq_type_node;
965 return unsigned_p ? sat_ha_type_node : ha_type_node;
967 return unsigned_p ? sat_sa_type_node : sa_type_node;
969 return unsigned_p ? sat_da_type_node : da_type_node;
971 return unsigned_p ? sat_ta_type_node : ta_type_node;
974 return unsigned_p ? sat_uha_type_node : uha_type_node;
976 return unsigned_p ? sat_usa_type_node : usa_type_node;
978 return unsigned_p ? sat_uda_type_node : uda_type_node;
980 return unsigned_p ? sat_uta_type_node : uta_type_node;
983 for (t = registered_builtin_types; t; t = TREE_CHAIN (t))
984 if (TYPE_MODE (TREE_VALUE (t)) == mode)
985 return TREE_VALUE (t);
990 /* Return true if we are in the global binding level. */
993 lto_global_bindings_p (void)
999 lto_set_decl_assembler_name (tree decl)
1001 /* This is almost the same as lhd_set_decl_assembler_name, except that
1002 we need to uniquify file-scope names, even if they are not
1003 TREE_PUBLIC, to avoid conflicts between individual files. */
1006 if (TREE_PUBLIC (decl))
1007 id = targetm.mangle_decl_assembler_name (decl, DECL_NAME (decl));
1010 const char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
1013 ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
1014 id = get_identifier (label);
1017 SET_DECL_ASSEMBLER_NAME (decl, id);
1021 lto_pushdecl (tree t ATTRIBUTE_UNUSED)
1023 /* Do nothing, since we get all information from DWARF and LTO
1031 /* We have our own write_globals langhook, hence the getdecls
1032 langhook shouldn't be used, except by dbxout.c, so we can't
1038 lto_write_globals (void)
1040 tree *vec = VEC_address (tree, lto_global_var_decls);
1041 int len = VEC_length (tree, lto_global_var_decls);
1042 wrapup_global_declarations (vec, len);
1043 emit_debug_global_declarations (vec, len);
1044 VEC_free (tree, gc, lto_global_var_decls);
1048 lto_builtin_function (tree decl)
1054 lto_register_builtin_type (tree type, const char *name)
1058 decl = build_decl (UNKNOWN_LOCATION, TYPE_DECL, get_identifier (name), type);
1059 DECL_ARTIFICIAL (decl) = 1;
1060 if (!TYPE_NAME (type))
1061 TYPE_NAME (type) = decl;
1063 registered_builtin_types = tree_cons (0, type, registered_builtin_types);
1066 /* Build nodes that would have be created by the C front-end; necessary
1067 for including builtin-types.def and ultimately builtins.def. */
1070 lto_build_c_type_nodes (void)
1072 gcc_assert (void_type_node);
1074 void_list_node = build_tree_list (NULL_TREE, void_type_node);
1075 string_type_node = build_pointer_type (char_type_node);
1076 const_string_type_node
1077 = build_pointer_type (build_qualified_type (char_type_node, TYPE_QUAL_CONST));
1079 if (strcmp (SIZE_TYPE, "unsigned int") == 0)
1081 intmax_type_node = integer_type_node;
1082 uintmax_type_node = unsigned_type_node;
1083 signed_size_type_node = integer_type_node;
1085 else if (strcmp (SIZE_TYPE, "long unsigned int") == 0)
1087 intmax_type_node = long_integer_type_node;
1088 uintmax_type_node = long_unsigned_type_node;
1089 signed_size_type_node = long_integer_type_node;
1091 else if (strcmp (SIZE_TYPE, "long long unsigned int") == 0)
1093 intmax_type_node = long_long_integer_type_node;
1094 uintmax_type_node = long_long_unsigned_type_node;
1095 signed_size_type_node = long_long_integer_type_node;
1100 wint_type_node = unsigned_type_node;
1101 pid_type_node = integer_type_node;
1104 /* Re-compute TYPE_CANONICAL for NODE and related types. */
1107 lto_register_canonical_types (tree node)
1113 TYPE_CANONICAL (node) = NULL_TREE;
1114 TYPE_CANONICAL (node) = gimple_register_canonical_type (node);
1116 if (POINTER_TYPE_P (node)
1117 || TREE_CODE (node) == COMPLEX_TYPE
1118 || TREE_CODE (node) == ARRAY_TYPE)
1119 lto_register_canonical_types (TREE_TYPE (node));
1122 /* Perform LTO-specific initialization. */
1129 /* We need to generate LTO if running in WPA mode. */
1130 flag_generate_lto = flag_wpa;
1132 /* Initialize libcpp line maps for gcc_assert to work. */
1133 linemap_add (line_table, LC_ENTER, 0, NULL, 0);
1135 /* Create the basic integer types. */
1136 build_common_tree_nodes (flag_signed_char, /*short_double=*/false);
1138 /* The global tree for the main identifier is filled in by
1139 language-specific front-end initialization that is not run in the
1140 LTO back-end. It appears that all languages that perform such
1141 initialization currently do so in the same way, so we do it here. */
1142 if (main_identifier_node == NULL_TREE)
1143 main_identifier_node = get_identifier ("main");
1145 /* In the C++ front-end, fileptr_type_node is defined as a variant
1146 copy of of ptr_type_node, rather than ptr_node itself. The
1147 distinction should only be relevant to the front-end, so we
1148 always use the C definition here in lto1. */
1149 gcc_assert (fileptr_type_node == ptr_type_node);
1150 gcc_assert (TYPE_MAIN_VARIANT (fileptr_type_node) == ptr_type_node);
1152 ptrdiff_type_node = integer_type_node;
1154 lto_build_c_type_nodes ();
1155 gcc_assert (va_list_type_node);
1157 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
1159 tree x = build_pointer_type (TREE_TYPE (va_list_type_node));
1160 lto_define_builtins (x, x);
1164 lto_define_builtins (va_list_type_node,
1165 build_reference_type (va_list_type_node));
1168 targetm.init_builtins ();
1169 build_common_builtin_nodes ();
1171 /* Assign names to the builtin types, otherwise they'll end up
1172 as __unknown__ in debug info.
1173 ??? We simply need to stop pre-seeding the streamer cache.
1174 Below is modeled after from c-common.c:c_common_nodes_and_builtins */
1175 #define NAME_TYPE(t,n) \
1177 TYPE_NAME (t) = build_decl (UNKNOWN_LOCATION, TYPE_DECL, \
1178 get_identifier (n), t)
1179 NAME_TYPE (integer_type_node, "int");
1180 NAME_TYPE (char_type_node, "char");
1181 NAME_TYPE (long_integer_type_node, "long int");
1182 NAME_TYPE (unsigned_type_node, "unsigned int");
1183 NAME_TYPE (long_unsigned_type_node, "long unsigned int");
1184 NAME_TYPE (long_long_integer_type_node, "long long int");
1185 NAME_TYPE (long_long_unsigned_type_node, "long long unsigned int");
1186 NAME_TYPE (short_integer_type_node, "short int");
1187 NAME_TYPE (short_unsigned_type_node, "short unsigned int");
1188 if (signed_char_type_node != char_type_node)
1189 NAME_TYPE (signed_char_type_node, "signed char");
1190 if (unsigned_char_type_node != char_type_node)
1191 NAME_TYPE (unsigned_char_type_node, "unsigned char");
1192 NAME_TYPE (float_type_node, "float");
1193 NAME_TYPE (double_type_node, "double");
1194 NAME_TYPE (long_double_type_node, "long double");
1195 NAME_TYPE (void_type_node, "void");
1196 NAME_TYPE (boolean_type_node, "bool");
1199 /* Register the common node types with the canonical type machinery so
1200 we properly share alias-sets across languages and TUs. Do not
1201 expose the common nodes as type merge target - those that should be
1202 are already exposed so by pre-loading the LTO streamer caches. */
1203 for (i = 0; i < itk_none; ++i)
1204 lto_register_canonical_types (integer_types[i]);
1205 /* The sizetypes are not used to access data so we do not need to
1206 do anything about them. */
1207 for (i = 0; i < TI_MAX; ++i)
1208 lto_register_canonical_types (global_trees[i]);
1210 /* Initialize LTO-specific data structures. */
1211 lto_global_var_decls = VEC_alloc (tree, gc, 256);
1217 /* Initialize tree structures required by the LTO front end. */
1219 static void lto_init_ts (void)
1221 tree_contains_struct[NAMESPACE_DECL][TS_DECL_MINIMAL] = 1;
1224 #undef LANG_HOOKS_NAME
1225 #define LANG_HOOKS_NAME "GNU GIMPLE"
1226 #undef LANG_HOOKS_OPTION_LANG_MASK
1227 #define LANG_HOOKS_OPTION_LANG_MASK lto_option_lang_mask
1228 #undef LANG_HOOKS_COMPLAIN_WRONG_LANG_P
1229 #define LANG_HOOKS_COMPLAIN_WRONG_LANG_P lto_complain_wrong_lang_p
1230 #undef LANG_HOOKS_INIT_OPTIONS_STRUCT
1231 #define LANG_HOOKS_INIT_OPTIONS_STRUCT lto_init_options_struct
1232 #undef LANG_HOOKS_HANDLE_OPTION
1233 #define LANG_HOOKS_HANDLE_OPTION lto_handle_option
1234 #undef LANG_HOOKS_POST_OPTIONS
1235 #define LANG_HOOKS_POST_OPTIONS lto_post_options
1236 #undef LANG_HOOKS_GET_ALIAS_SET
1237 #define LANG_HOOKS_GET_ALIAS_SET gimple_get_alias_set
1238 #undef LANG_HOOKS_TYPE_FOR_MODE
1239 #define LANG_HOOKS_TYPE_FOR_MODE lto_type_for_mode
1240 #undef LANG_HOOKS_TYPE_FOR_SIZE
1241 #define LANG_HOOKS_TYPE_FOR_SIZE lto_type_for_size
1242 #undef LANG_HOOKS_SET_DECL_ASSEMBLER_NAME
1243 #define LANG_HOOKS_SET_DECL_ASSEMBLER_NAME lto_set_decl_assembler_name
1244 #undef LANG_HOOKS_GLOBAL_BINDINGS_P
1245 #define LANG_HOOKS_GLOBAL_BINDINGS_P lto_global_bindings_p
1246 #undef LANG_HOOKS_PUSHDECL
1247 #define LANG_HOOKS_PUSHDECL lto_pushdecl
1248 #undef LANG_HOOKS_GETDECLS
1249 #define LANG_HOOKS_GETDECLS lto_getdecls
1250 #undef LANG_HOOKS_WRITE_GLOBALS
1251 #define LANG_HOOKS_WRITE_GLOBALS lto_write_globals
1252 #undef LANG_HOOKS_REGISTER_BUILTIN_TYPE
1253 #define LANG_HOOKS_REGISTER_BUILTIN_TYPE lto_register_builtin_type
1254 #undef LANG_HOOKS_BUILTIN_FUNCTION
1255 #define LANG_HOOKS_BUILTIN_FUNCTION lto_builtin_function
1256 #undef LANG_HOOKS_INIT
1257 #define LANG_HOOKS_INIT lto_init
1258 #undef LANG_HOOKS_PARSE_FILE
1259 #define LANG_HOOKS_PARSE_FILE lto_main
1260 #undef LANG_HOOKS_CALLGRAPH_EXPAND_FUNCTION
1261 #define LANG_HOOKS_CALLGRAPH_EXPAND_FUNCTION tree_rest_of_compilation
1262 #undef LANG_HOOKS_REDUCE_BIT_FIELD_OPERATIONS
1263 #define LANG_HOOKS_REDUCE_BIT_FIELD_OPERATIONS true
1264 #undef LANG_HOOKS_TYPES_COMPATIBLE_P
1265 #define LANG_HOOKS_TYPES_COMPATIBLE_P NULL
1266 #undef LANG_HOOKS_EH_PERSONALITY
1267 #define LANG_HOOKS_EH_PERSONALITY lto_eh_personality
1269 /* Attribute hooks. */
1270 #undef LANG_HOOKS_COMMON_ATTRIBUTE_TABLE
1271 #define LANG_HOOKS_COMMON_ATTRIBUTE_TABLE lto_attribute_table
1272 #undef LANG_HOOKS_FORMAT_ATTRIBUTE_TABLE
1273 #define LANG_HOOKS_FORMAT_ATTRIBUTE_TABLE lto_format_attribute_table
1275 #undef LANG_HOOKS_BEGIN_SECTION
1276 #define LANG_HOOKS_BEGIN_SECTION lto_obj_begin_section
1277 #undef LANG_HOOKS_APPEND_DATA
1278 #define LANG_HOOKS_APPEND_DATA lto_obj_append_data
1279 #undef LANG_HOOKS_END_SECTION
1280 #define LANG_HOOKS_END_SECTION lto_obj_end_section
1282 #undef LANG_HOOKS_INIT_TS
1283 #define LANG_HOOKS_INIT_TS lto_init_ts
1285 struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER;
1287 /* Language hooks that are not part of lang_hooks. */
1290 convert (tree type ATTRIBUTE_UNUSED, tree expr ATTRIBUTE_UNUSED)
1295 /* Tree walking support. */
1297 static enum lto_tree_node_structure_enum
1298 lto_tree_node_structure (union lang_tree_node *t ATTRIBUTE_UNUSED)
1300 return TS_LTO_GENERIC;
1304 #include "gtype-lto.h"
1305 #include "gt-lto-lto-lang.h"