1 /* Language-dependent hooks for LTO.
2 Copyright 2009, 2010 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"
38 static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
39 static tree handle_leaf_attribute (tree *, tree, tree, int, bool *);
40 static tree handle_const_attribute (tree *, tree, tree, int, bool *);
41 static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);
42 static tree handle_pure_attribute (tree *, tree, tree, int, bool *);
43 static tree handle_novops_attribute (tree *, tree, tree, int, bool *);
44 static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
45 static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
46 static tree handle_sentinel_attribute (tree *, tree, tree, int, bool *);
47 static tree handle_type_generic_attribute (tree *, tree, tree, int, bool *);
48 static tree handle_format_attribute (tree *, tree, tree, int, bool *);
49 static tree handle_format_arg_attribute (tree *, tree, tree, int, bool *);
51 /* Table of machine-independent attributes supported in GIMPLE. */
52 const struct attribute_spec lto_attribute_table[] =
54 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
55 { "noreturn", 0, 0, true, false, false,
56 handle_noreturn_attribute },
57 { "leaf", 0, 0, true, false, false,
58 handle_leaf_attribute },
59 /* The same comments as for noreturn attributes apply to const ones. */
60 { "const", 0, 0, true, false, false,
61 handle_const_attribute },
62 { "malloc", 0, 0, true, false, false,
63 handle_malloc_attribute },
64 { "pure", 0, 0, true, false, false,
65 handle_pure_attribute },
66 { "no vops", 0, 0, true, false, false,
67 handle_novops_attribute },
68 { "nonnull", 0, -1, false, true, true,
69 handle_nonnull_attribute },
70 { "nothrow", 0, 0, true, false, false,
71 handle_nothrow_attribute },
72 { "sentinel", 0, 1, false, true, true,
73 handle_sentinel_attribute },
74 { "type generic", 0, 0, false, true, true,
75 handle_type_generic_attribute },
76 { NULL, 0, 0, false, false, false, NULL }
79 /* Give the specifications for the format attributes, used by C and all
82 const struct attribute_spec lto_format_attribute_table[] =
84 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
85 { "format", 3, 3, false, true, true,
86 handle_format_attribute },
87 { "format_arg", 1, 1, false, true, true,
88 handle_format_arg_attribute },
89 { NULL, 0, 0, false, false, false, NULL }
92 enum built_in_attribute
94 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
95 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
96 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
97 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
98 #include "builtin-attrs.def"
99 #undef DEF_ATTR_NULL_TREE
101 #undef DEF_ATTR_IDENT
102 #undef DEF_ATTR_TREE_LIST
106 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
110 enum lto_builtin_type
112 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
113 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
114 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
115 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
116 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
117 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
118 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
119 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME,
120 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME,
121 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
122 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
123 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
124 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
125 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
126 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
128 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
129 #include "builtin-types.def"
130 #undef DEF_PRIMITIVE_TYPE
131 #undef DEF_FUNCTION_TYPE_0
132 #undef DEF_FUNCTION_TYPE_1
133 #undef DEF_FUNCTION_TYPE_2
134 #undef DEF_FUNCTION_TYPE_3
135 #undef DEF_FUNCTION_TYPE_4
136 #undef DEF_FUNCTION_TYPE_5
137 #undef DEF_FUNCTION_TYPE_6
138 #undef DEF_FUNCTION_TYPE_7
139 #undef DEF_FUNCTION_TYPE_VAR_0
140 #undef DEF_FUNCTION_TYPE_VAR_1
141 #undef DEF_FUNCTION_TYPE_VAR_2
142 #undef DEF_FUNCTION_TYPE_VAR_3
143 #undef DEF_FUNCTION_TYPE_VAR_4
144 #undef DEF_FUNCTION_TYPE_VAR_5
145 #undef DEF_POINTER_TYPE
149 typedef enum lto_builtin_type builtin_type;
151 static GTY(()) tree builtin_types[(int) BT_LAST + 1];
153 static GTY(()) tree string_type_node;
154 static GTY(()) tree const_string_type_node;
155 static GTY(()) tree wint_type_node;
156 static GTY(()) tree intmax_type_node;
157 static GTY(()) tree uintmax_type_node;
158 static GTY(()) tree signed_size_type_node;
160 /* Flags needed to process builtins.def. */
164 /* Attribute handlers. */
166 /* Handle a "noreturn" attribute; arguments as in
167 struct attribute_spec.handler. */
170 handle_noreturn_attribute (tree *node, tree ARG_UNUSED (name),
171 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
172 bool * ARG_UNUSED (no_add_attrs))
174 tree type = TREE_TYPE (*node);
176 if (TREE_CODE (*node) == FUNCTION_DECL)
177 TREE_THIS_VOLATILE (*node) = 1;
178 else if (TREE_CODE (type) == POINTER_TYPE
179 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
182 (build_type_variant (TREE_TYPE (type),
183 TYPE_READONLY (TREE_TYPE (type)), 1));
190 /* Handle a "leaf" attribute; arguments as in
191 struct attribute_spec.handler. */
194 handle_leaf_attribute (tree *node, tree name,
195 tree ARG_UNUSED (args),
196 int ARG_UNUSED (flags), bool *no_add_attrs)
198 if (TREE_CODE (*node) != FUNCTION_DECL)
200 warning (OPT_Wattributes, "%qE attribute ignored", name);
201 *no_add_attrs = true;
203 if (!TREE_PUBLIC (*node))
205 warning (OPT_Wattributes, "%qE attribute has no effect on unit local functions", name);
206 *no_add_attrs = true;
212 /* Handle a "const" attribute; arguments as in
213 struct attribute_spec.handler. */
216 handle_const_attribute (tree *node, tree ARG_UNUSED (name),
217 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
218 bool * ARG_UNUSED (no_add_attrs))
220 tree type = TREE_TYPE (*node);
222 /* See FIXME comment on noreturn in c_common_attribute_table. */
223 if (TREE_CODE (*node) == FUNCTION_DECL)
224 TREE_READONLY (*node) = 1;
225 else if (TREE_CODE (type) == POINTER_TYPE
226 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
229 (build_type_variant (TREE_TYPE (type), 1,
230 TREE_THIS_VOLATILE (TREE_TYPE (type))));
238 /* Handle a "malloc" attribute; arguments as in
239 struct attribute_spec.handler. */
242 handle_malloc_attribute (tree *node, tree ARG_UNUSED (name),
243 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
244 bool * ARG_UNUSED (no_add_attrs))
246 if (TREE_CODE (*node) == FUNCTION_DECL
247 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node))))
248 DECL_IS_MALLOC (*node) = 1;
256 /* Handle a "pure" attribute; arguments as in
257 struct attribute_spec.handler. */
260 handle_pure_attribute (tree *node, tree ARG_UNUSED (name),
261 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
262 bool * ARG_UNUSED (no_add_attrs))
264 if (TREE_CODE (*node) == FUNCTION_DECL)
265 DECL_PURE_P (*node) = 1;
273 /* Handle a "no vops" attribute; arguments as in
274 struct attribute_spec.handler. */
277 handle_novops_attribute (tree *node, tree ARG_UNUSED (name),
278 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
279 bool *ARG_UNUSED (no_add_attrs))
281 gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
282 DECL_IS_NOVOPS (*node) = 1;
287 /* Helper for nonnull attribute handling; fetch the operand number
288 from the attribute argument list. */
291 get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
293 /* Verify the arg number is a constant. */
294 if (TREE_CODE (arg_num_expr) != INTEGER_CST
295 || TREE_INT_CST_HIGH (arg_num_expr) != 0)
298 *valp = TREE_INT_CST_LOW (arg_num_expr);
302 /* Handle the "nonnull" attribute. */
305 handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
306 tree args, int ARG_UNUSED (flags),
307 bool * ARG_UNUSED (no_add_attrs))
311 /* If no arguments are specified, all pointer arguments should be
312 non-null. Verify a full prototype is given so that the arguments
313 will have the correct types when we actually check them later. */
316 gcc_assert (TYPE_ARG_TYPES (type));
320 /* Argument list specified. Verify that each argument number references
321 a pointer argument. */
322 for (; args; args = TREE_CHAIN (args))
325 unsigned HOST_WIDE_INT arg_num = 0, ck_num;
327 if (!get_nonnull_operand (TREE_VALUE (args), &arg_num))
330 argument = TYPE_ARG_TYPES (type);
333 for (ck_num = 1; ; ck_num++)
335 if (!argument || ck_num == arg_num)
337 argument = TREE_CHAIN (argument);
341 && TREE_CODE (TREE_VALUE (argument)) == POINTER_TYPE);
349 /* Handle a "nothrow" attribute; arguments as in
350 struct attribute_spec.handler. */
353 handle_nothrow_attribute (tree *node, tree ARG_UNUSED (name),
354 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
355 bool * ARG_UNUSED (no_add_attrs))
357 if (TREE_CODE (*node) == FUNCTION_DECL)
358 TREE_NOTHROW (*node) = 1;
366 /* Handle a "sentinel" attribute. */
369 handle_sentinel_attribute (tree *node, tree ARG_UNUSED (name), tree args,
370 int ARG_UNUSED (flags),
371 bool * ARG_UNUSED (no_add_attrs))
373 tree params = TYPE_ARG_TYPES (*node);
376 while (TREE_CHAIN (params))
377 params = TREE_CHAIN (params);
379 gcc_assert (!VOID_TYPE_P (TREE_VALUE (params)));
383 tree position = TREE_VALUE (args);
384 gcc_assert (TREE_CODE (position) == INTEGER_CST);
385 if (tree_int_cst_lt (position, integer_zero_node))
392 /* Handle a "type_generic" attribute. */
395 handle_type_generic_attribute (tree *node, tree ARG_UNUSED (name),
396 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
397 bool * ARG_UNUSED (no_add_attrs))
401 /* Ensure we have a function type. */
402 gcc_assert (TREE_CODE (*node) == FUNCTION_TYPE);
404 params = TYPE_ARG_TYPES (*node);
405 while (params && ! VOID_TYPE_P (TREE_VALUE (params)))
406 params = TREE_CHAIN (params);
408 /* Ensure we have a variadic function. */
409 gcc_assert (!params);
414 /* Handle a "format" attribute; arguments as in
415 struct attribute_spec.handler. */
418 handle_format_attribute (tree * ARG_UNUSED (node), tree ARG_UNUSED (name),
419 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
422 *no_add_attrs = true;
427 /* Handle a "format_arg" attribute; arguments as in
428 struct attribute_spec.handler. */
431 handle_format_arg_attribute (tree * ARG_UNUSED (node), tree ARG_UNUSED (name),
432 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
435 *no_add_attrs = true;
440 /* Cribbed from c-common.c. */
443 def_fn_type (builtin_type def, builtin_type ret, bool var, int n, ...)
450 for (i = 0; i < n; ++i)
452 builtin_type a = (builtin_type) va_arg (list, int);
453 t = builtin_types[a];
454 if (t == error_mark_node)
456 args = tree_cons (NULL_TREE, t, args);
460 args = nreverse (args);
462 args = chainon (args, void_list_node);
464 t = builtin_types[ret];
465 if (t == error_mark_node)
467 t = build_function_type (t, args);
470 builtin_types[def] = t;
473 /* Used to help initialize the builtin-types.def table. When a type of
474 the correct size doesn't exist, use error_mark_node instead of NULL.
475 The later results in segfaults even when a decl using the type doesn't
479 builtin_type_for_size (int size, bool unsignedp)
481 tree type = lang_hooks.types.type_for_size (size, unsignedp);
482 return type ? type : error_mark_node;
485 /* Support for DEF_BUILTIN. */
488 def_builtin_1 (enum built_in_function fncode, const char *name,
489 enum built_in_class fnclass, tree fntype, tree libtype,
490 bool both_p, bool fallback_p, bool nonansi_p,
491 tree fnattrs, bool implicit_p)
496 if (fntype == error_mark_node)
499 libname = name + strlen ("__builtin_");
500 decl = add_builtin_function (name, fntype, fncode, fnclass,
501 (fallback_p ? libname : NULL),
506 && !(nonansi_p && flag_no_nonansi_builtin))
507 add_builtin_function (libname, libtype, fncode, fnclass,
510 built_in_decls[(int) fncode] = decl;
512 implicit_built_in_decls[(int) fncode] = decl;
516 /* Initialize the attribute table for all the supported builtins. */
519 lto_init_attributes (void)
521 /* Fill in the built_in_attributes array. */
522 #define DEF_ATTR_NULL_TREE(ENUM) \
523 built_in_attributes[(int) ENUM] = NULL_TREE;
524 #define DEF_ATTR_INT(ENUM, VALUE) \
525 built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
526 #define DEF_ATTR_IDENT(ENUM, STRING) \
527 built_in_attributes[(int) ENUM] = get_identifier (STRING);
528 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
529 built_in_attributes[(int) ENUM] \
530 = tree_cons (built_in_attributes[(int) PURPOSE], \
531 built_in_attributes[(int) VALUE], \
532 built_in_attributes[(int) CHAIN]);
533 #include "builtin-attrs.def"
534 #undef DEF_ATTR_NULL_TREE
536 #undef DEF_ATTR_IDENT
537 #undef DEF_ATTR_TREE_LIST
540 /* Create builtin types and functions. VA_LIST_REF_TYPE_NODE and
541 VA_LIST_ARG_TYPE_NODE are used in builtin-types.def. */
544 lto_define_builtins (tree va_list_ref_type_node ATTRIBUTE_UNUSED,
545 tree va_list_arg_type_node ATTRIBUTE_UNUSED)
547 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
548 builtin_types[ENUM] = VALUE;
549 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
550 def_fn_type (ENUM, RETURN, 0, 0);
551 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
552 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
553 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
554 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
555 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
556 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
557 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
558 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
559 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
560 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
561 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
563 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
564 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
566 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
567 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
568 def_fn_type (ENUM, RETURN, 1, 0);
569 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
570 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
571 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
572 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
573 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
574 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
575 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
576 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
577 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
578 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
579 #define DEF_POINTER_TYPE(ENUM, TYPE) \
580 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
582 #include "builtin-types.def"
584 #undef DEF_PRIMITIVE_TYPE
585 #undef DEF_FUNCTION_TYPE_1
586 #undef DEF_FUNCTION_TYPE_2
587 #undef DEF_FUNCTION_TYPE_3
588 #undef DEF_FUNCTION_TYPE_4
589 #undef DEF_FUNCTION_TYPE_5
590 #undef DEF_FUNCTION_TYPE_6
591 #undef DEF_FUNCTION_TYPE_VAR_0
592 #undef DEF_FUNCTION_TYPE_VAR_1
593 #undef DEF_FUNCTION_TYPE_VAR_2
594 #undef DEF_FUNCTION_TYPE_VAR_3
595 #undef DEF_FUNCTION_TYPE_VAR_4
596 #undef DEF_FUNCTION_TYPE_VAR_5
597 #undef DEF_POINTER_TYPE
598 builtin_types[(int) BT_LAST] = NULL_TREE;
600 lto_init_attributes ();
602 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P,\
603 NONANSI_P, ATTRS, IMPLICIT, COND) \
605 def_builtin_1 (ENUM, NAME, CLASS, builtin_types[(int) TYPE], \
606 builtin_types[(int) LIBTYPE], BOTH_P, FALLBACK_P, \
607 NONANSI_P, built_in_attributes[(int) ATTRS], IMPLICIT);
608 #include "builtins.def"
612 static GTY(()) tree registered_builtin_types;
614 /* A chain of builtin functions that we need to recognize. We will
615 assume that all other function names we see will be defined by the
617 static GTY(()) tree registered_builtin_fndecls;
619 /* Language hooks. */
622 lto_option_lang_mask (void)
628 lto_complain_wrong_lang_p (const struct cl_option *option ATTRIBUTE_UNUSED)
630 /* The LTO front end inherits all the options from the first front
631 end that was used. However, not all the original front end
632 options make sense in LTO.
634 A real solution would be to filter this in collect2, but collect2
635 does not have access to all the option attributes to know what to
636 filter. So, in lto1 we silently accept inherited flags and do
642 lto_init_options_struct (struct gcc_options *opts)
644 /* By default, C99-like requirements for complex multiply and divide.
645 ??? Until the complex method is encoded in the IL this is the only
646 safe choice. This will pessimize Fortran code with LTO unless
647 people specify a complex method manually or use -ffast-math. */
648 opts->x_flag_complex_method = 2;
651 /* Handle command-line option SCODE. If the option takes an argument, it is
652 stored in ARG, which is otherwise NULL. VALUE holds either a numerical
653 argument or a binary value indicating whether the positive or negative form
654 of the option was supplied. */
656 const char *resolution_file_name;
658 lto_handle_option (size_t scode, const char *arg,
659 int value ATTRIBUTE_UNUSED, int kind ATTRIBUTE_UNUSED,
660 const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED)
662 enum opt_code code = (enum opt_code) scode;
667 case OPT_fresolution_:
668 resolution_file_name = arg;
682 /* Perform post-option processing. Does additional initialization based on
683 command-line options. PFILENAME is the main input filename. Returns false
684 to enable subsequent back-end initialization. */
687 lto_post_options (const char **pfilename ATTRIBUTE_UNUSED)
689 /* -fltrans and -fwpa are mutually exclusive. Check for that here. */
690 if (flag_wpa && flag_ltrans)
691 error ("-fwpa and -fltrans are mutually exclusive");
695 flag_generate_lto = 0;
697 /* During LTRANS, we are not looking at the whole program, only
698 a subset of the whole callgraph. */
699 flag_whole_program = 0;
703 flag_generate_lto = 1;
705 /* Excess precision other than "fast" requires front-end
707 flag_excess_precision_cmdline = EXCESS_PRECISION_FAST;
709 lto_read_all_file_options ();
711 /* Initialize the compiler back end. */
715 /* Return an integer type with PRECISION bits of precision,
716 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
719 lto_type_for_size (unsigned precision, int unsignedp)
721 if (precision == TYPE_PRECISION (integer_type_node))
722 return unsignedp ? unsigned_type_node : integer_type_node;
724 if (precision == TYPE_PRECISION (signed_char_type_node))
725 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
727 if (precision == TYPE_PRECISION (short_integer_type_node))
728 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
730 if (precision == TYPE_PRECISION (long_integer_type_node))
731 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
733 if (precision == TYPE_PRECISION (long_long_integer_type_node))
735 ? long_long_unsigned_type_node
736 : long_long_integer_type_node;
738 if (precision <= TYPE_PRECISION (intQI_type_node))
739 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
741 if (precision <= TYPE_PRECISION (intHI_type_node))
742 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
744 if (precision <= TYPE_PRECISION (intSI_type_node))
745 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
747 if (precision <= TYPE_PRECISION (intDI_type_node))
748 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
750 if (precision <= TYPE_PRECISION (intTI_type_node))
751 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
757 /* Return a data type that has machine mode MODE.
758 If the mode is an integer,
759 then UNSIGNEDP selects between signed and unsigned types.
760 If the mode is a fixed-point mode,
761 then UNSIGNEDP selects between saturating and nonsaturating types. */
764 lto_type_for_mode (enum machine_mode mode, int unsigned_p)
768 if (mode == TYPE_MODE (integer_type_node))
769 return unsigned_p ? unsigned_type_node : integer_type_node;
771 if (mode == TYPE_MODE (signed_char_type_node))
772 return unsigned_p ? unsigned_char_type_node : signed_char_type_node;
774 if (mode == TYPE_MODE (short_integer_type_node))
775 return unsigned_p ? short_unsigned_type_node : short_integer_type_node;
777 if (mode == TYPE_MODE (long_integer_type_node))
778 return unsigned_p ? long_unsigned_type_node : long_integer_type_node;
780 if (mode == TYPE_MODE (long_long_integer_type_node))
781 return unsigned_p ? long_long_unsigned_type_node : long_long_integer_type_node;
784 return unsigned_p ? unsigned_intQI_type_node : intQI_type_node;
787 return unsigned_p ? unsigned_intHI_type_node : intHI_type_node;
790 return unsigned_p ? unsigned_intSI_type_node : intSI_type_node;
793 return unsigned_p ? unsigned_intDI_type_node : intDI_type_node;
795 #if HOST_BITS_PER_WIDE_INT >= 64
796 if (mode == TYPE_MODE (intTI_type_node))
797 return unsigned_p ? unsigned_intTI_type_node : intTI_type_node;
800 if (mode == TYPE_MODE (float_type_node))
801 return float_type_node;
803 if (mode == TYPE_MODE (double_type_node))
804 return double_type_node;
806 if (mode == TYPE_MODE (long_double_type_node))
807 return long_double_type_node;
809 if (mode == TYPE_MODE (void_type_node))
810 return void_type_node;
812 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
814 ? make_unsigned_type (GET_MODE_PRECISION (mode))
815 : make_signed_type (GET_MODE_PRECISION (mode)));
817 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
819 ? make_unsigned_type (GET_MODE_PRECISION (mode))
820 : make_signed_type (GET_MODE_PRECISION (mode)));
822 if (COMPLEX_MODE_P (mode))
824 enum machine_mode inner_mode;
827 if (mode == TYPE_MODE (complex_float_type_node))
828 return complex_float_type_node;
829 if (mode == TYPE_MODE (complex_double_type_node))
830 return complex_double_type_node;
831 if (mode == TYPE_MODE (complex_long_double_type_node))
832 return complex_long_double_type_node;
834 if (mode == TYPE_MODE (complex_integer_type_node) && !unsigned_p)
835 return complex_integer_type_node;
837 inner_mode = GET_MODE_INNER (mode);
838 inner_type = lto_type_for_mode (inner_mode, unsigned_p);
839 if (inner_type != NULL_TREE)
840 return build_complex_type (inner_type);
842 else if (VECTOR_MODE_P (mode))
844 enum machine_mode inner_mode = GET_MODE_INNER (mode);
845 tree inner_type = lto_type_for_mode (inner_mode, unsigned_p);
846 if (inner_type != NULL_TREE)
847 return build_vector_type_for_mode (inner_type, mode);
850 if (mode == TYPE_MODE (dfloat32_type_node))
851 return dfloat32_type_node;
852 if (mode == TYPE_MODE (dfloat64_type_node))
853 return dfloat64_type_node;
854 if (mode == TYPE_MODE (dfloat128_type_node))
855 return dfloat128_type_node;
857 if (ALL_SCALAR_FIXED_POINT_MODE_P (mode))
859 if (mode == TYPE_MODE (short_fract_type_node))
860 return unsigned_p ? sat_short_fract_type_node : short_fract_type_node;
861 if (mode == TYPE_MODE (fract_type_node))
862 return unsigned_p ? sat_fract_type_node : fract_type_node;
863 if (mode == TYPE_MODE (long_fract_type_node))
864 return unsigned_p ? sat_long_fract_type_node : long_fract_type_node;
865 if (mode == TYPE_MODE (long_long_fract_type_node))
866 return unsigned_p ? sat_long_long_fract_type_node
867 : long_long_fract_type_node;
869 if (mode == TYPE_MODE (unsigned_short_fract_type_node))
870 return unsigned_p ? sat_unsigned_short_fract_type_node
871 : unsigned_short_fract_type_node;
872 if (mode == TYPE_MODE (unsigned_fract_type_node))
873 return unsigned_p ? sat_unsigned_fract_type_node
874 : unsigned_fract_type_node;
875 if (mode == TYPE_MODE (unsigned_long_fract_type_node))
876 return unsigned_p ? sat_unsigned_long_fract_type_node
877 : unsigned_long_fract_type_node;
878 if (mode == TYPE_MODE (unsigned_long_long_fract_type_node))
879 return unsigned_p ? sat_unsigned_long_long_fract_type_node
880 : unsigned_long_long_fract_type_node;
882 if (mode == TYPE_MODE (short_accum_type_node))
883 return unsigned_p ? sat_short_accum_type_node : short_accum_type_node;
884 if (mode == TYPE_MODE (accum_type_node))
885 return unsigned_p ? sat_accum_type_node : accum_type_node;
886 if (mode == TYPE_MODE (long_accum_type_node))
887 return unsigned_p ? sat_long_accum_type_node : long_accum_type_node;
888 if (mode == TYPE_MODE (long_long_accum_type_node))
889 return unsigned_p ? sat_long_long_accum_type_node
890 : long_long_accum_type_node;
892 if (mode == TYPE_MODE (unsigned_short_accum_type_node))
893 return unsigned_p ? sat_unsigned_short_accum_type_node
894 : unsigned_short_accum_type_node;
895 if (mode == TYPE_MODE (unsigned_accum_type_node))
896 return unsigned_p ? sat_unsigned_accum_type_node
897 : unsigned_accum_type_node;
898 if (mode == TYPE_MODE (unsigned_long_accum_type_node))
899 return unsigned_p ? sat_unsigned_long_accum_type_node
900 : unsigned_long_accum_type_node;
901 if (mode == TYPE_MODE (unsigned_long_long_accum_type_node))
902 return unsigned_p ? sat_unsigned_long_long_accum_type_node
903 : unsigned_long_long_accum_type_node;
906 return unsigned_p ? sat_qq_type_node : qq_type_node;
908 return unsigned_p ? sat_hq_type_node : hq_type_node;
910 return unsigned_p ? sat_sq_type_node : sq_type_node;
912 return unsigned_p ? sat_dq_type_node : dq_type_node;
914 return unsigned_p ? sat_tq_type_node : tq_type_node;
917 return unsigned_p ? sat_uqq_type_node : uqq_type_node;
919 return unsigned_p ? sat_uhq_type_node : uhq_type_node;
921 return unsigned_p ? sat_usq_type_node : usq_type_node;
923 return unsigned_p ? sat_udq_type_node : udq_type_node;
925 return unsigned_p ? sat_utq_type_node : utq_type_node;
928 return unsigned_p ? sat_ha_type_node : ha_type_node;
930 return unsigned_p ? sat_sa_type_node : sa_type_node;
932 return unsigned_p ? sat_da_type_node : da_type_node;
934 return unsigned_p ? sat_ta_type_node : ta_type_node;
937 return unsigned_p ? sat_uha_type_node : uha_type_node;
939 return unsigned_p ? sat_usa_type_node : usa_type_node;
941 return unsigned_p ? sat_uda_type_node : uda_type_node;
943 return unsigned_p ? sat_uta_type_node : uta_type_node;
946 for (t = registered_builtin_types; t; t = TREE_CHAIN (t))
947 if (TYPE_MODE (TREE_VALUE (t)) == mode)
948 return TREE_VALUE (t);
954 lto_global_bindings_p (void)
960 lto_set_decl_assembler_name (tree decl)
962 /* This is almost the same as lhd_set_decl_assembler_name, except that
963 we need to uniquify file-scope names, even if they are not
964 TREE_PUBLIC, to avoid conflicts between individual files. */
967 if (TREE_PUBLIC (decl))
968 id = targetm.mangle_decl_assembler_name (decl, DECL_NAME (decl));
971 const char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
974 ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
975 id = get_identifier (label);
978 SET_DECL_ASSEMBLER_NAME (decl, id);
982 lto_pushdecl (tree t ATTRIBUTE_UNUSED)
984 /* Do nothing, since we get all information from DWARF and LTO
992 return registered_builtin_fndecls;
996 lto_write_globals (void)
998 tree *vec = VEC_address (tree, lto_global_var_decls);
999 int len = VEC_length (tree, lto_global_var_decls);
1000 wrapup_global_declarations (vec, len);
1001 emit_debug_global_declarations (vec, len);
1002 VEC_free (tree, gc, lto_global_var_decls);
1006 lto_builtin_function (tree decl)
1009 TREE_CHAIN (decl) = registered_builtin_fndecls;
1010 registered_builtin_fndecls = decl;
1016 lto_register_builtin_type (tree type, const char *name)
1020 decl = build_decl (UNKNOWN_LOCATION, TYPE_DECL, get_identifier (name), type);
1021 DECL_ARTIFICIAL (decl) = 1;
1022 if (!TYPE_NAME (type))
1023 TYPE_NAME (type) = decl;
1025 registered_builtin_types = tree_cons (0, type, registered_builtin_types);
1028 /* Build nodes that would have be created by the C front-end; necessary
1029 for including builtin-types.def and ultimately builtins.def. */
1032 lto_build_c_type_nodes (void)
1034 gcc_assert (void_type_node);
1036 void_list_node = build_tree_list (NULL_TREE, void_type_node);
1037 string_type_node = build_pointer_type (char_type_node);
1038 const_string_type_node
1039 = build_pointer_type (build_qualified_type (char_type_node, TYPE_QUAL_CONST));
1041 if (strcmp (SIZE_TYPE, "unsigned int") == 0)
1043 intmax_type_node = integer_type_node;
1044 uintmax_type_node = unsigned_type_node;
1045 signed_size_type_node = integer_type_node;
1047 else if (strcmp (SIZE_TYPE, "long unsigned int") == 0)
1049 intmax_type_node = long_integer_type_node;
1050 uintmax_type_node = long_unsigned_type_node;
1051 signed_size_type_node = long_integer_type_node;
1053 else if (strcmp (SIZE_TYPE, "long long unsigned int") == 0)
1055 intmax_type_node = long_long_integer_type_node;
1056 uintmax_type_node = long_long_unsigned_type_node;
1057 signed_size_type_node = long_long_integer_type_node;
1062 wint_type_node = unsigned_type_node;
1063 pid_type_node = integer_type_node;
1067 /* Perform LTO-specific initialization. */
1072 /* We need to generate LTO if running in WPA mode. */
1073 flag_generate_lto = flag_wpa;
1075 /* Initialize libcpp line maps for gcc_assert to work. */
1076 linemap_add (line_table, LC_RENAME, 0, NULL, 0);
1077 linemap_add (line_table, LC_RENAME, 0, NULL, 0);
1079 /* Create the basic integer types. */
1080 build_common_tree_nodes (flag_signed_char);
1082 /* Share char_type_node with whatever would be the default for the target.
1083 char_type_node will be used for internal types such as
1084 va_list_type_node but will not be present in the lto stream. */
1085 /* ??? This breaks the more common case of consistent but non-standard
1086 setting of flag_signed_char, so share according to flag_signed_char.
1089 = flag_signed_char ? signed_char_type_node : unsigned_char_type_node;
1091 /* Tell the middle end what type to use for the size of objects. */
1092 if (strcmp (SIZE_TYPE, "unsigned int") == 0)
1094 set_sizetype (unsigned_type_node);
1095 size_type_node = unsigned_type_node;
1097 else if (strcmp (SIZE_TYPE, "long unsigned int") == 0)
1099 set_sizetype (long_unsigned_type_node);
1100 size_type_node = long_unsigned_type_node;
1102 else if (strcmp (SIZE_TYPE, "long long unsigned int") == 0)
1104 set_sizetype (long_long_unsigned_type_node);
1105 size_type_node = long_long_unsigned_type_node;
1110 /* The global tree for the main identifier is filled in by
1111 language-specific front-end initialization that is not run in the
1112 LTO back-end. It appears that all languages that perform such
1113 initialization currently do so in the same way, so we do it here. */
1114 if (main_identifier_node == NULL_TREE)
1115 main_identifier_node = get_identifier ("main");
1117 /* In the C++ front-end, fileptr_type_node is defined as a variant
1118 copy of of ptr_type_node, rather than ptr_node itself. The
1119 distinction should only be relevant to the front-end, so we
1120 always use the C definition here in lto1. */
1121 gcc_assert (fileptr_type_node == ptr_type_node);
1123 ptrdiff_type_node = integer_type_node;
1125 /* Create other basic types. */
1126 build_common_tree_nodes_2 (/*short_double=*/false);
1127 lto_build_c_type_nodes ();
1128 gcc_assert (va_list_type_node);
1130 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
1132 tree x = build_pointer_type (TREE_TYPE (va_list_type_node));
1133 lto_define_builtins (x, x);
1137 lto_define_builtins (va_list_type_node,
1138 build_reference_type (va_list_type_node));
1141 targetm.init_builtins ();
1142 build_common_builtin_nodes ();
1144 /* Initialize LTO-specific data structures. */
1145 lto_global_var_decls = VEC_alloc (tree, gc, 256);
1151 /* Initialize tree structures required by the LTO front end. */
1153 static void lto_init_ts (void)
1155 tree_contains_struct[NAMESPACE_DECL][TS_DECL_MINIMAL] = 1;
1158 #undef LANG_HOOKS_NAME
1159 #define LANG_HOOKS_NAME "GNU GIMPLE"
1160 #undef LANG_HOOKS_OPTION_LANG_MASK
1161 #define LANG_HOOKS_OPTION_LANG_MASK lto_option_lang_mask
1162 #undef LANG_HOOKS_COMPLAIN_WRONG_LANG_P
1163 #define LANG_HOOKS_COMPLAIN_WRONG_LANG_P lto_complain_wrong_lang_p
1164 #undef LANG_HOOKS_INIT_OPTIONS_STRUCT
1165 #define LANG_HOOKS_INIT_OPTIONS_STRUCT lto_init_options_struct
1166 #undef LANG_HOOKS_HANDLE_OPTION
1167 #define LANG_HOOKS_HANDLE_OPTION lto_handle_option
1168 #undef LANG_HOOKS_POST_OPTIONS
1169 #define LANG_HOOKS_POST_OPTIONS lto_post_options
1170 #undef LANG_HOOKS_GET_ALIAS_SET
1171 #define LANG_HOOKS_GET_ALIAS_SET gimple_get_alias_set
1172 #undef LANG_HOOKS_TYPE_FOR_MODE
1173 #define LANG_HOOKS_TYPE_FOR_MODE lto_type_for_mode
1174 #undef LANG_HOOKS_TYPE_FOR_SIZE
1175 #define LANG_HOOKS_TYPE_FOR_SIZE lto_type_for_size
1176 #undef LANG_HOOKS_SET_DECL_ASSEMBLER_NAME
1177 #define LANG_HOOKS_SET_DECL_ASSEMBLER_NAME lto_set_decl_assembler_name
1178 #undef LANG_HOOKS_GLOBAL_BINDINGS_P
1179 #define LANG_HOOKS_GLOBAL_BINDINGS_P lto_global_bindings_p
1180 #undef LANG_HOOKS_PUSHDECL
1181 #define LANG_HOOKS_PUSHDECL lto_pushdecl
1182 #undef LANG_HOOKS_GETDECLS
1183 #define LANG_HOOKS_GETDECLS lto_getdecls
1184 #undef LANG_HOOKS_WRITE_GLOBALS
1185 #define LANG_HOOKS_WRITE_GLOBALS lto_write_globals
1186 #undef LANG_HOOKS_REGISTER_BUILTIN_TYPE
1187 #define LANG_HOOKS_REGISTER_BUILTIN_TYPE lto_register_builtin_type
1188 #undef LANG_HOOKS_BUILTIN_FUNCTION
1189 #define LANG_HOOKS_BUILTIN_FUNCTION lto_builtin_function
1190 #undef LANG_HOOKS_INIT
1191 #define LANG_HOOKS_INIT lto_init
1192 #undef LANG_HOOKS_PARSE_FILE
1193 #define LANG_HOOKS_PARSE_FILE lto_main
1194 #undef LANG_HOOKS_CALLGRAPH_EXPAND_FUNCTION
1195 #define LANG_HOOKS_CALLGRAPH_EXPAND_FUNCTION tree_rest_of_compilation
1196 #undef LANG_HOOKS_REDUCE_BIT_FIELD_OPERATIONS
1197 #define LANG_HOOKS_REDUCE_BIT_FIELD_OPERATIONS true
1198 #undef LANG_HOOKS_TYPES_COMPATIBLE_P
1199 #define LANG_HOOKS_TYPES_COMPATIBLE_P NULL
1200 #undef LANG_HOOKS_EH_PERSONALITY
1201 #define LANG_HOOKS_EH_PERSONALITY lto_eh_personality
1203 /* Attribute hooks. */
1204 #undef LANG_HOOKS_COMMON_ATTRIBUTE_TABLE
1205 #define LANG_HOOKS_COMMON_ATTRIBUTE_TABLE lto_attribute_table
1206 #undef LANG_HOOKS_FORMAT_ATTRIBUTE_TABLE
1207 #define LANG_HOOKS_FORMAT_ATTRIBUTE_TABLE lto_format_attribute_table
1209 #undef LANG_HOOKS_BEGIN_SECTION
1210 #define LANG_HOOKS_BEGIN_SECTION lto_obj_begin_section
1211 #undef LANG_HOOKS_APPEND_DATA
1212 #define LANG_HOOKS_APPEND_DATA lto_obj_append_data
1213 #undef LANG_HOOKS_END_SECTION
1214 #define LANG_HOOKS_END_SECTION lto_obj_end_section
1216 #undef LANG_HOOKS_INIT_TS
1217 #define LANG_HOOKS_INIT_TS lto_init_ts
1219 struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER;
1221 /* Language hooks that are not part of lang_hooks. */
1224 convert (tree type ATTRIBUTE_UNUSED, tree expr ATTRIBUTE_UNUSED)
1229 /* Tree walking support. */
1231 static enum lto_tree_node_structure_enum
1232 lto_tree_node_structure (union lang_tree_node *t ATTRIBUTE_UNUSED)
1234 return TS_LTO_GENERIC;
1238 #include "gtype-lto.h"
1239 #include "gt-lto-lto-lang.h"