1 /* Language-dependent hooks for LTO.
2 Copyright (C) 2009-2019 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"
26 #include "basic-block.h"
29 #include "stringpool.h"
30 #include "diagnostic-core.h"
31 #include "stor-layout.h"
32 #include "langhooks.h"
33 #include "langhooks-def.h"
37 #include "lto-common.h"
38 #include "stringpool.h"
41 /* LTO specific dumps. */
42 int lto_link_dump_id
, decl_merge_dump_id
, partition_dump_id
;
44 static tree
handle_noreturn_attribute (tree
*, tree
, tree
, int, bool *);
45 static tree
handle_leaf_attribute (tree
*, tree
, tree
, int, bool *);
46 static tree
handle_const_attribute (tree
*, tree
, tree
, int, bool *);
47 static tree
handle_malloc_attribute (tree
*, tree
, tree
, int, bool *);
48 static tree
handle_pure_attribute (tree
*, tree
, tree
, int, bool *);
49 static tree
handle_novops_attribute (tree
*, tree
, tree
, int, bool *);
50 static tree
handle_nonnull_attribute (tree
*, tree
, tree
, int, bool *);
51 static tree
handle_nothrow_attribute (tree
*, tree
, tree
, int, bool *);
52 static tree
handle_sentinel_attribute (tree
*, tree
, tree
, int, bool *);
53 static tree
handle_type_generic_attribute (tree
*, tree
, tree
, int, bool *);
54 static tree
handle_transaction_pure_attribute (tree
*, tree
, tree
, int, bool *);
55 static tree
handle_returns_twice_attribute (tree
*, tree
, tree
, int, bool *);
56 static tree
handle_patchable_function_entry_attribute (tree
*, tree
, tree
,
58 static tree
ignore_attribute (tree
*, tree
, tree
, int, bool *);
60 static tree
handle_format_attribute (tree
*, tree
, tree
, int, bool *);
61 static tree
handle_fnspec_attribute (tree
*, tree
, tree
, int, bool *);
62 static tree
handle_format_arg_attribute (tree
*, tree
, tree
, int, bool *);
64 /* Helper to define attribute exclusions. */
65 #define ATTR_EXCL(name, function, type, variable) \
66 { name, function, type, variable }
68 /* Define attributes that are mutually exclusive with one another. */
69 static const struct attribute_spec::exclusions attr_noreturn_exclusions
[] =
71 ATTR_EXCL ("noreturn", true, true, true),
72 ATTR_EXCL ("alloc_align", true, true, true),
73 ATTR_EXCL ("alloc_size", true, true, true),
74 ATTR_EXCL ("const", true, true, true),
75 ATTR_EXCL ("malloc", true, true, true),
76 ATTR_EXCL ("pure", true, true, true),
77 ATTR_EXCL ("returns_twice", true, true, true),
78 ATTR_EXCL ("warn_unused_result", true, true, true),
79 ATTR_EXCL (NULL
, false, false, false),
82 static const struct attribute_spec::exclusions attr_returns_twice_exclusions
[] =
84 ATTR_EXCL ("noreturn", true, true, true),
85 ATTR_EXCL (NULL
, false, false, false),
88 static const struct attribute_spec::exclusions attr_const_pure_exclusions
[] =
90 ATTR_EXCL ("const", true, true, true),
91 ATTR_EXCL ("noreturn", true, true, true),
92 ATTR_EXCL ("pure", true, true, true),
93 ATTR_EXCL (NULL
, false, false, false)
96 /* Table of machine-independent attributes supported in GIMPLE. */
97 const struct attribute_spec lto_attribute_table
[] =
99 /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
100 affects_type_identity, handler, exclude } */
101 { "noreturn", 0, 0, true, false, false, false,
102 handle_noreturn_attribute
,
103 attr_noreturn_exclusions
},
104 { "leaf", 0, 0, true, false, false, false,
105 handle_leaf_attribute
, NULL
},
106 /* The same comments as for noreturn attributes apply to const ones. */
107 { "const", 0, 0, true, false, false, false,
108 handle_const_attribute
,
109 attr_const_pure_exclusions
},
110 { "malloc", 0, 0, true, false, false, false,
111 handle_malloc_attribute
, NULL
},
112 { "pure", 0, 0, true, false, false, false,
113 handle_pure_attribute
,
114 attr_const_pure_exclusions
},
115 { "no vops", 0, 0, true, false, false, false,
116 handle_novops_attribute
, NULL
},
117 { "nonnull", 0, -1, false, true, true, false,
118 handle_nonnull_attribute
, NULL
},
119 { "nothrow", 0, 0, true, false, false, false,
120 handle_nothrow_attribute
, NULL
},
121 { "patchable_function_entry", 1, 2, true, false, false, false,
122 handle_patchable_function_entry_attribute
,
124 { "returns_twice", 0, 0, true, false, false, false,
125 handle_returns_twice_attribute
,
126 attr_returns_twice_exclusions
},
127 { "sentinel", 0, 1, false, true, true, false,
128 handle_sentinel_attribute
, NULL
},
129 { "type generic", 0, 0, false, true, true, false,
130 handle_type_generic_attribute
, NULL
},
131 { "fn spec", 1, 1, false, true, true, false,
132 handle_fnspec_attribute
, NULL
},
133 { "transaction_pure", 0, 0, false, true, true, false,
134 handle_transaction_pure_attribute
, NULL
},
135 /* For internal use only. The leading '*' both prevents its usage in
136 source code and signals that it may be overridden by machine tables. */
137 { "*tm regparm", 0, 0, false, true, true, false,
138 ignore_attribute
, NULL
},
139 { NULL
, 0, 0, false, false, false, false, NULL
, NULL
}
142 /* Give the specifications for the format attributes, used by C and all
145 const struct attribute_spec lto_format_attribute_table
[] =
147 /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
148 affects_type_identity, handler, exclude } */
149 { "format", 3, 3, false, true, true, false,
150 handle_format_attribute
, NULL
},
151 { "format_arg", 1, 1, false, true, true, false,
152 handle_format_arg_attribute
, NULL
},
153 { NULL
, 0, 0, false, false, false, false, NULL
, NULL
}
156 enum built_in_attribute
158 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
159 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
160 #define DEF_ATTR_STRING(ENUM, VALUE) ENUM,
161 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
162 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
163 #include "builtin-attrs.def"
164 #undef DEF_ATTR_NULL_TREE
166 #undef DEF_ATTR_STRING
167 #undef DEF_ATTR_IDENT
168 #undef DEF_ATTR_TREE_LIST
172 static GTY(()) tree built_in_attributes
[(int) ATTR_LAST
];
176 enum lto_builtin_type
178 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
179 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
180 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
181 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
182 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
183 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
184 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
185 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
187 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
189 #define DEF_FUNCTION_TYPE_8(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
190 ARG6, ARG7, ARG8) NAME,
191 #define DEF_FUNCTION_TYPE_9(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
192 ARG6, ARG7, ARG8, ARG9) NAME,
193 #define DEF_FUNCTION_TYPE_10(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
194 ARG6, ARG7, ARG8, ARG9, ARG10) NAME,
195 #define DEF_FUNCTION_TYPE_11(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
196 ARG6, ARG7, ARG8, ARG9, ARG10, ARG11) NAME,
197 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
198 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
199 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
200 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
201 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
202 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
204 #define DEF_FUNCTION_TYPE_VAR_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
206 #define DEF_FUNCTION_TYPE_VAR_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
208 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
209 #include "builtin-types.def"
210 #undef DEF_PRIMITIVE_TYPE
211 #undef DEF_FUNCTION_TYPE_0
212 #undef DEF_FUNCTION_TYPE_1
213 #undef DEF_FUNCTION_TYPE_2
214 #undef DEF_FUNCTION_TYPE_3
215 #undef DEF_FUNCTION_TYPE_4
216 #undef DEF_FUNCTION_TYPE_5
217 #undef DEF_FUNCTION_TYPE_6
218 #undef DEF_FUNCTION_TYPE_7
219 #undef DEF_FUNCTION_TYPE_8
220 #undef DEF_FUNCTION_TYPE_9
221 #undef DEF_FUNCTION_TYPE_10
222 #undef DEF_FUNCTION_TYPE_11
223 #undef DEF_FUNCTION_TYPE_VAR_0
224 #undef DEF_FUNCTION_TYPE_VAR_1
225 #undef DEF_FUNCTION_TYPE_VAR_2
226 #undef DEF_FUNCTION_TYPE_VAR_3
227 #undef DEF_FUNCTION_TYPE_VAR_4
228 #undef DEF_FUNCTION_TYPE_VAR_5
229 #undef DEF_FUNCTION_TYPE_VAR_6
230 #undef DEF_FUNCTION_TYPE_VAR_7
231 #undef DEF_POINTER_TYPE
235 typedef enum lto_builtin_type builtin_type
;
237 static GTY(()) tree builtin_types
[(int) BT_LAST
+ 1];
239 static GTY(()) tree string_type_node
;
240 static GTY(()) tree const_string_type_node
;
241 static GTY(()) tree wint_type_node
;
242 static GTY(()) tree intmax_type_node
;
243 static GTY(()) tree uintmax_type_node
;
244 static GTY(()) tree signed_size_type_node
;
246 /* Flags needed to process builtins.def. */
252 /* Attribute handlers. */
254 /* Handle a "noreturn" attribute; arguments as in
255 struct attribute_spec.handler. */
258 handle_noreturn_attribute (tree
*node
, tree
ARG_UNUSED (name
),
259 tree
ARG_UNUSED (args
), int ARG_UNUSED (flags
),
260 bool * ARG_UNUSED (no_add_attrs
))
262 tree type
= TREE_TYPE (*node
);
264 if (TREE_CODE (*node
) == FUNCTION_DECL
)
265 TREE_THIS_VOLATILE (*node
) = 1;
266 else if (TREE_CODE (type
) == POINTER_TYPE
267 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
270 (build_type_variant (TREE_TYPE (type
),
271 TYPE_READONLY (TREE_TYPE (type
)), 1));
278 /* Handle a "leaf" attribute; arguments as in
279 struct attribute_spec.handler. */
282 handle_leaf_attribute (tree
*node
, tree name
,
283 tree
ARG_UNUSED (args
),
284 int ARG_UNUSED (flags
), bool *no_add_attrs
)
286 if (TREE_CODE (*node
) != FUNCTION_DECL
)
288 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
289 *no_add_attrs
= true;
291 if (!TREE_PUBLIC (*node
))
293 warning (OPT_Wattributes
, "%qE attribute has no effect on unit local functions", name
);
294 *no_add_attrs
= true;
300 /* Handle a "const" attribute; arguments as in
301 struct attribute_spec.handler. */
304 handle_const_attribute (tree
*node
, tree
ARG_UNUSED (name
),
305 tree
ARG_UNUSED (args
), int ARG_UNUSED (flags
),
306 bool * ARG_UNUSED (no_add_attrs
))
308 if (TREE_CODE (*node
) != FUNCTION_DECL
309 || !fndecl_built_in_p (*node
))
310 inform (UNKNOWN_LOCATION
, "%s:%s: %E: %E", __FILE__
, __func__
, *node
, name
);
312 tree type
= TREE_TYPE (*node
);
314 /* See FIXME comment on noreturn in c_common_attribute_table. */
315 if (TREE_CODE (*node
) == FUNCTION_DECL
)
316 TREE_READONLY (*node
) = 1;
317 else if (TREE_CODE (type
) == POINTER_TYPE
318 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
321 (build_type_variant (TREE_TYPE (type
), 1,
322 TREE_THIS_VOLATILE (TREE_TYPE (type
))));
330 /* Handle a "malloc" attribute; arguments as in
331 struct attribute_spec.handler. */
334 handle_malloc_attribute (tree
*node
, tree
ARG_UNUSED (name
),
335 tree
ARG_UNUSED (args
), int ARG_UNUSED (flags
),
336 bool * ARG_UNUSED (no_add_attrs
))
338 if (TREE_CODE (*node
) == FUNCTION_DECL
339 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node
))))
340 DECL_IS_MALLOC (*node
) = 1;
348 /* Handle a "pure" attribute; arguments as in
349 struct attribute_spec.handler. */
352 handle_pure_attribute (tree
*node
, tree
ARG_UNUSED (name
),
353 tree
ARG_UNUSED (args
), int ARG_UNUSED (flags
),
354 bool * ARG_UNUSED (no_add_attrs
))
356 if (TREE_CODE (*node
) == FUNCTION_DECL
)
357 DECL_PURE_P (*node
) = 1;
365 /* Handle a "no vops" attribute; arguments as in
366 struct attribute_spec.handler. */
369 handle_novops_attribute (tree
*node
, tree
ARG_UNUSED (name
),
370 tree
ARG_UNUSED (args
), int ARG_UNUSED (flags
),
371 bool *ARG_UNUSED (no_add_attrs
))
373 gcc_assert (TREE_CODE (*node
) == FUNCTION_DECL
);
374 DECL_IS_NOVOPS (*node
) = 1;
379 /* Helper for nonnull attribute handling; fetch the operand number
380 from the attribute argument list. */
383 get_nonnull_operand (tree arg_num_expr
, unsigned HOST_WIDE_INT
*valp
)
385 /* Verify the arg number is a constant. */
386 if (!tree_fits_uhwi_p (arg_num_expr
))
389 *valp
= TREE_INT_CST_LOW (arg_num_expr
);
393 /* Handle the "nonnull" attribute. */
396 handle_nonnull_attribute (tree
*node
, tree
ARG_UNUSED (name
),
397 tree args
, int ARG_UNUSED (flags
),
398 bool * ARG_UNUSED (no_add_attrs
))
402 /* If no arguments are specified, all pointer arguments should be
403 non-null. Verify a full prototype is given so that the arguments
404 will have the correct types when we actually check them later.
405 Avoid diagnosing type-generic built-ins since those have no
409 gcc_assert (prototype_p (type
)
410 || !TYPE_ATTRIBUTES (type
)
411 || lookup_attribute ("type generic", TYPE_ATTRIBUTES (type
)));
416 /* Argument list specified. Verify that each argument number references
417 a pointer argument. */
418 for (; args
; args
= TREE_CHAIN (args
))
421 unsigned HOST_WIDE_INT arg_num
= 0, ck_num
;
423 if (!get_nonnull_operand (TREE_VALUE (args
), &arg_num
))
426 argument
= TYPE_ARG_TYPES (type
);
429 for (ck_num
= 1; ; ck_num
++)
431 if (!argument
|| ck_num
== arg_num
)
433 argument
= TREE_CHAIN (argument
);
437 && TREE_CODE (TREE_VALUE (argument
)) == POINTER_TYPE
);
445 /* Handle a "nothrow" attribute; arguments as in
446 struct attribute_spec.handler. */
449 handle_nothrow_attribute (tree
*node
, tree
ARG_UNUSED (name
),
450 tree
ARG_UNUSED (args
), int ARG_UNUSED (flags
),
451 bool * ARG_UNUSED (no_add_attrs
))
453 if (TREE_CODE (*node
) == FUNCTION_DECL
)
454 TREE_NOTHROW (*node
) = 1;
462 /* Handle a "sentinel" attribute. */
465 handle_sentinel_attribute (tree
*node
, tree
ARG_UNUSED (name
), tree args
,
466 int ARG_UNUSED (flags
),
467 bool * ARG_UNUSED (no_add_attrs
))
469 gcc_assert (stdarg_p (*node
));
473 tree position
= TREE_VALUE (args
);
474 gcc_assert (TREE_CODE (position
) == INTEGER_CST
);
475 if (tree_int_cst_lt (position
, integer_zero_node
))
482 /* Handle a "type_generic" attribute. */
485 handle_type_generic_attribute (tree
*node
, tree
ARG_UNUSED (name
),
486 tree
ARG_UNUSED (args
), int ARG_UNUSED (flags
),
487 bool * ARG_UNUSED (no_add_attrs
))
489 /* Ensure we have a function type. */
490 gcc_assert (TREE_CODE (*node
) == FUNCTION_TYPE
);
492 /* Ensure we have a variadic function. */
493 gcc_assert (!prototype_p (*node
) || stdarg_p (*node
));
498 /* Handle a "transaction_pure" attribute. */
501 handle_transaction_pure_attribute (tree
*node
, tree
ARG_UNUSED (name
),
502 tree
ARG_UNUSED (args
),
503 int ARG_UNUSED (flags
),
504 bool * ARG_UNUSED (no_add_attrs
))
506 /* Ensure we have a function type. */
507 gcc_assert (TREE_CODE (*node
) == FUNCTION_TYPE
);
512 /* Handle a "returns_twice" attribute. */
515 handle_returns_twice_attribute (tree
*node
, tree
ARG_UNUSED (name
),
516 tree
ARG_UNUSED (args
),
517 int ARG_UNUSED (flags
),
518 bool * ARG_UNUSED (no_add_attrs
))
520 gcc_assert (TREE_CODE (*node
) == FUNCTION_DECL
);
522 DECL_IS_RETURNS_TWICE (*node
) = 1;
528 handle_patchable_function_entry_attribute (tree
*, tree
, tree
, int, bool *)
530 /* Nothing to be done here. */
534 /* Ignore the given attribute. Used when this attribute may be usefully
535 overridden by the target, but is not used generically. */
538 ignore_attribute (tree
* ARG_UNUSED (node
), tree
ARG_UNUSED (name
),
539 tree
ARG_UNUSED (args
), int ARG_UNUSED (flags
),
542 *no_add_attrs
= true;
546 /* Handle a "format" attribute; arguments as in
547 struct attribute_spec.handler. */
550 handle_format_attribute (tree
* ARG_UNUSED (node
), tree
ARG_UNUSED (name
),
551 tree
ARG_UNUSED (args
), int ARG_UNUSED (flags
),
554 *no_add_attrs
= true;
559 /* Handle a "format_arg" attribute; arguments as in
560 struct attribute_spec.handler. */
563 handle_format_arg_attribute (tree
* ARG_UNUSED (node
), tree
ARG_UNUSED (name
),
564 tree
ARG_UNUSED (args
), int ARG_UNUSED (flags
),
567 *no_add_attrs
= true;
572 /* Handle a "fn spec" attribute; arguments as in
573 struct attribute_spec.handler. */
576 handle_fnspec_attribute (tree
*node ATTRIBUTE_UNUSED
, tree
ARG_UNUSED (name
),
577 tree args
, int ARG_UNUSED (flags
),
578 bool *no_add_attrs ATTRIBUTE_UNUSED
)
581 && TREE_CODE (TREE_VALUE (args
)) == STRING_CST
582 && !TREE_CHAIN (args
));
586 /* Cribbed from c-common.c. */
589 def_fn_type (builtin_type def
, builtin_type ret
, bool var
, int n
, ...)
592 tree
*args
= XALLOCAVEC (tree
, n
);
598 for (i
= 0; i
< n
; ++i
)
600 builtin_type a
= (builtin_type
) va_arg (list
, int);
601 t
= builtin_types
[a
];
602 if (t
== error_mark_node
)
608 t
= builtin_types
[ret
];
611 if (t
== error_mark_node
)
614 t
= build_varargs_function_type_array (t
, n
, args
);
616 t
= build_function_type_array (t
, n
, args
);
618 builtin_types
[def
] = t
;
621 /* Used to help initialize the builtin-types.def table. When a type of
622 the correct size doesn't exist, use error_mark_node instead of NULL.
623 The later results in segfaults even when a decl using the type doesn't
627 builtin_type_for_size (int size
, bool unsignedp
)
629 tree type
= lang_hooks
.types
.type_for_size (size
, unsignedp
);
630 return type
? type
: error_mark_node
;
633 /* Support for DEF_BUILTIN. */
636 def_builtin_1 (enum built_in_function fncode
, const char *name
,
637 enum built_in_class fnclass
, tree fntype
, tree libtype
,
638 bool both_p
, bool fallback_p
, bool nonansi_p
,
639 tree fnattrs
, bool implicit_p
)
644 if (fntype
== error_mark_node
)
647 libname
= name
+ strlen ("__builtin_");
648 decl
= add_builtin_function (name
, fntype
, fncode
, fnclass
,
649 (fallback_p
? libname
: NULL
),
654 && !(nonansi_p
&& flag_no_nonansi_builtin
))
655 add_builtin_function (libname
, libtype
, fncode
, fnclass
,
658 set_builtin_decl (fncode
, decl
, implicit_p
);
662 /* Initialize the attribute table for all the supported builtins. */
665 lto_init_attributes (void)
667 /* Fill in the built_in_attributes array. */
668 #define DEF_ATTR_NULL_TREE(ENUM) \
669 built_in_attributes[(int) ENUM] = NULL_TREE;
670 #define DEF_ATTR_INT(ENUM, VALUE) \
671 built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
672 #define DEF_ATTR_STRING(ENUM, VALUE) \
673 built_in_attributes[(int) ENUM] = build_string (strlen (VALUE), VALUE);
674 #define DEF_ATTR_IDENT(ENUM, STRING) \
675 built_in_attributes[(int) ENUM] = get_identifier (STRING);
676 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
677 built_in_attributes[(int) ENUM] \
678 = tree_cons (built_in_attributes[(int) PURPOSE], \
679 built_in_attributes[(int) VALUE], \
680 built_in_attributes[(int) CHAIN]);
681 #include "builtin-attrs.def"
682 #undef DEF_ATTR_NULL_TREE
684 #undef DEF_ATTR_STRING
685 #undef DEF_ATTR_IDENT
686 #undef DEF_ATTR_TREE_LIST
689 /* Create builtin types and functions. VA_LIST_REF_TYPE_NODE and
690 VA_LIST_ARG_TYPE_NODE are used in builtin-types.def. */
693 lto_define_builtins (tree va_list_ref_type_node ATTRIBUTE_UNUSED
,
694 tree va_list_arg_type_node ATTRIBUTE_UNUSED
)
696 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
697 builtin_types[ENUM] = VALUE;
698 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
699 def_fn_type (ENUM, RETURN, 0, 0);
700 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
701 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
702 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
703 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
704 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
705 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
706 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
707 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
708 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
709 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
710 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
712 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
713 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
715 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
716 #define DEF_FUNCTION_TYPE_8(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
718 def_fn_type (ENUM, RETURN, 0, 8, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, \
720 #define DEF_FUNCTION_TYPE_9(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
721 ARG6, ARG7, ARG8, ARG9) \
722 def_fn_type (ENUM, RETURN, 0, 9, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, \
724 #define DEF_FUNCTION_TYPE_10(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
725 ARG6, ARG7, ARG8, ARG9, ARG10) \
726 def_fn_type (ENUM, RETURN, 0, 10, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, \
727 ARG7, ARG8, ARG9, ARG10);
728 #define DEF_FUNCTION_TYPE_11(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
729 ARG6, ARG7, ARG8, ARG9, ARG10, ARG11) \
730 def_fn_type (ENUM, RETURN, 0, 11, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, \
731 ARG7, ARG8, ARG9, ARG10, ARG11);
732 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
733 def_fn_type (ENUM, RETURN, 1, 0);
734 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
735 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
736 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
737 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
738 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
739 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
740 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
741 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
742 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
743 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
744 #define DEF_FUNCTION_TYPE_VAR_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
746 def_fn_type (ENUM, RETURN, 1, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
747 #define DEF_FUNCTION_TYPE_VAR_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
749 def_fn_type (ENUM, RETURN, 1, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
750 #define DEF_POINTER_TYPE(ENUM, TYPE) \
751 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
753 #include "builtin-types.def"
755 #undef DEF_PRIMITIVE_TYPE
756 #undef DEF_FUNCTION_TYPE_0
757 #undef DEF_FUNCTION_TYPE_1
758 #undef DEF_FUNCTION_TYPE_2
759 #undef DEF_FUNCTION_TYPE_3
760 #undef DEF_FUNCTION_TYPE_4
761 #undef DEF_FUNCTION_TYPE_5
762 #undef DEF_FUNCTION_TYPE_6
763 #undef DEF_FUNCTION_TYPE_7
764 #undef DEF_FUNCTION_TYPE_8
765 #undef DEF_FUNCTION_TYPE_9
766 #undef DEF_FUNCTION_TYPE_10
767 #undef DEF_FUNCTION_TYPE_11
768 #undef DEF_FUNCTION_TYPE_VAR_0
769 #undef DEF_FUNCTION_TYPE_VAR_1
770 #undef DEF_FUNCTION_TYPE_VAR_2
771 #undef DEF_FUNCTION_TYPE_VAR_3
772 #undef DEF_FUNCTION_TYPE_VAR_4
773 #undef DEF_FUNCTION_TYPE_VAR_5
774 #undef DEF_FUNCTION_TYPE_VAR_6
775 #undef DEF_FUNCTION_TYPE_VAR_7
776 #undef DEF_POINTER_TYPE
777 builtin_types
[(int) BT_LAST
] = NULL_TREE
;
779 lto_init_attributes ();
781 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P,\
782 NONANSI_P, ATTRS, IMPLICIT, COND) \
784 def_builtin_1 (ENUM, NAME, CLASS, builtin_types[(int) TYPE], \
785 builtin_types[(int) LIBTYPE], BOTH_P, FALLBACK_P, \
786 NONANSI_P, built_in_attributes[(int) ATTRS], IMPLICIT);
787 #include "builtins.def"
790 static GTY(()) tree registered_builtin_types
;
792 /* Language hooks. */
795 lto_complain_wrong_lang_p (const struct cl_option
*option ATTRIBUTE_UNUSED
)
797 /* The LTO front end inherits all the options from the first front
798 end that was used. However, not all the original front end
799 options make sense in LTO.
801 A real solution would be to filter this in collect2, but collect2
802 does not have access to all the option attributes to know what to
803 filter. So, in lto1 we silently accept inherited flags and do
809 lto_init_options_struct (struct gcc_options
*opts
)
811 /* By default, C99-like requirements for complex multiply and divide.
812 ??? Until the complex method is encoded in the IL this is the only
813 safe choice. This will pessimize Fortran code with LTO unless
814 people specify a complex method manually or use -ffast-math. */
815 opts
->x_flag_complex_method
= 2;
818 /* Handle command-line option SCODE. If the option takes an argument, it is
819 stored in ARG, which is otherwise NULL. VALUE holds either a numerical
820 argument or a binary value indicating whether the positive or negative form
821 of the option was supplied. */
823 const char *resolution_file_name
;
825 lto_handle_option (size_t scode
, const char *arg
,
826 HOST_WIDE_INT value ATTRIBUTE_UNUSED
,
827 int kind ATTRIBUTE_UNUSED
,
828 location_t loc ATTRIBUTE_UNUSED
,
829 const struct cl_option_handlers
*handlers ATTRIBUTE_UNUSED
)
831 enum opt_code code
= (enum opt_code
) scode
;
836 case OPT_fresolution_
:
837 resolution_file_name
= arg
;
845 flag_wpa
= value
? "" : NULL
;
855 /* Perform post-option processing. Does additional initialization based on
856 command-line options. PFILENAME is the main input filename. Returns false
857 to enable subsequent back-end initialization. */
860 lto_post_options (const char **pfilename ATTRIBUTE_UNUSED
)
862 /* -fltrans and -fwpa are mutually exclusive. Check for that here. */
863 if (flag_wpa
&& flag_ltrans
)
864 error ("%<-fwpa%> and %<-fltrans%> are mutually exclusive");
868 flag_generate_lto
= 0;
870 /* During LTRANS, we are not looking at the whole program, only
871 a subset of the whole callgraph. */
872 flag_whole_program
= 0;
876 flag_generate_lto
= 1;
878 /* Initialize the codegen flags according to the output type. */
879 switch (flag_lto_linker_output
)
881 case LTO_LINKER_OUTPUT_REL
: /* .o: incremental link producing LTO IL */
882 /* Configure compiler same way as normal frontend would do with -flto:
883 this way we read the trees (declarations & types), symbol table,
884 optimization summaries and link them. Subsequently we output new LTO
887 flag_incremental_link
= INCREMENTAL_LINK_LTO
;
888 flag_whole_program
= 0;
890 flag_generate_lto
= 1;
891 /* It would be cool to produce .o file directly, but our current
892 simple objects does not contain the lto symbol markers. Go the slow
893 way through the asm file. */
894 lang_hooks
.lto
.begin_section
= lhd_begin_section
;
895 lang_hooks
.lto
.append_data
= lhd_append_data
;
896 lang_hooks
.lto
.end_section
= lhd_end_section
;
898 error ("%<-flinker-output=rel%> and %<-fltrans%> are mutually "
902 case LTO_LINKER_OUTPUT_NOLTOREL
: /* .o: incremental link producing asm */
903 flag_whole_program
= 0;
904 flag_incremental_link
= INCREMENTAL_LINK_NOLTO
;
907 case LTO_LINKER_OUTPUT_DYN
: /* .so: PID library */
908 /* On some targets, like i386 it makes sense to build PIC library wihout
909 -fpic for performance reasons. So no need to adjust flags. */
912 case LTO_LINKER_OUTPUT_PIE
: /* PIE binary */
913 /* If -fPIC or -fPIE was used at compile time, be sure that
915 flag_pie
= MAX (flag_pie
, flag_pic
);
920 case LTO_LINKER_OUTPUT_EXEC
: /* Normal executable */
926 case LTO_LINKER_OUTPUT_UNKNOWN
:
930 /* Excess precision other than "fast" requires front-end
932 if (flag_excess_precision
== EXCESS_PRECISION_DEFAULT
)
933 flag_excess_precision
= EXCESS_PRECISION_FAST
;
935 /* When partitioning, we can tear appart STRING_CSTs uses from the same
936 TU into multiple partitions. Without constant merging the constants
937 might not be equal at runtime. See PR50199. */
938 if (!flag_merge_constants
)
939 flag_merge_constants
= 1;
941 /* Initialize the compiler back end. */
945 /* Return a data type that has machine mode MODE.
946 If the mode is an integer,
947 then UNSIGNEDP selects between signed and unsigned types.
948 If the mode is a fixed-point mode,
949 then UNSIGNEDP selects between saturating and nonsaturating types. */
952 lto_type_for_mode (machine_mode mode
, int unsigned_p
)
957 if (mode
== TYPE_MODE (integer_type_node
))
958 return unsigned_p
? unsigned_type_node
: integer_type_node
;
960 if (mode
== TYPE_MODE (signed_char_type_node
))
961 return unsigned_p
? unsigned_char_type_node
: signed_char_type_node
;
963 if (mode
== TYPE_MODE (short_integer_type_node
))
964 return unsigned_p
? short_unsigned_type_node
: short_integer_type_node
;
966 if (mode
== TYPE_MODE (long_integer_type_node
))
967 return unsigned_p
? long_unsigned_type_node
: long_integer_type_node
;
969 if (mode
== TYPE_MODE (long_long_integer_type_node
))
970 return unsigned_p
? long_long_unsigned_type_node
: long_long_integer_type_node
;
972 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
973 if (int_n_enabled_p
[i
]
974 && mode
== int_n_data
[i
].m
)
975 return (unsigned_p
? int_n_trees
[i
].unsigned_type
976 : int_n_trees
[i
].signed_type
);
979 return unsigned_p
? unsigned_intQI_type_node
: intQI_type_node
;
982 return unsigned_p
? unsigned_intHI_type_node
: intHI_type_node
;
985 return unsigned_p
? unsigned_intSI_type_node
: intSI_type_node
;
988 return unsigned_p
? unsigned_intDI_type_node
: intDI_type_node
;
990 #if HOST_BITS_PER_WIDE_INT >= 64
991 if (mode
== TYPE_MODE (intTI_type_node
))
992 return unsigned_p
? unsigned_intTI_type_node
: intTI_type_node
;
995 if (mode
== TYPE_MODE (float_type_node
))
996 return float_type_node
;
998 if (mode
== TYPE_MODE (double_type_node
))
999 return double_type_node
;
1001 if (mode
== TYPE_MODE (long_double_type_node
))
1002 return long_double_type_node
;
1004 if (mode
== TYPE_MODE (void_type_node
))
1005 return void_type_node
;
1007 if (mode
== TYPE_MODE (build_pointer_type (char_type_node
))
1008 || mode
== TYPE_MODE (build_pointer_type (integer_type_node
)))
1010 unsigned int precision
1011 = GET_MODE_PRECISION (as_a
<scalar_int_mode
> (mode
));
1013 ? make_unsigned_type (precision
)
1014 : make_signed_type (precision
));
1017 if (COMPLEX_MODE_P (mode
))
1019 machine_mode inner_mode
;
1022 if (mode
== TYPE_MODE (complex_float_type_node
))
1023 return complex_float_type_node
;
1024 if (mode
== TYPE_MODE (complex_double_type_node
))
1025 return complex_double_type_node
;
1026 if (mode
== TYPE_MODE (complex_long_double_type_node
))
1027 return complex_long_double_type_node
;
1029 if (mode
== TYPE_MODE (complex_integer_type_node
) && !unsigned_p
)
1030 return complex_integer_type_node
;
1032 inner_mode
= GET_MODE_INNER (mode
);
1033 inner_type
= lto_type_for_mode (inner_mode
, unsigned_p
);
1034 if (inner_type
!= NULL_TREE
)
1035 return build_complex_type (inner_type
);
1037 else if (GET_MODE_CLASS (mode
) == MODE_VECTOR_BOOL
1038 && valid_vector_subparts_p (GET_MODE_NUNITS (mode
)))
1040 unsigned int elem_bits
= vector_element_size (GET_MODE_BITSIZE (mode
),
1041 GET_MODE_NUNITS (mode
));
1042 tree bool_type
= build_nonstandard_boolean_type (elem_bits
);
1043 return build_vector_type_for_mode (bool_type
, mode
);
1045 else if (VECTOR_MODE_P (mode
)
1046 && valid_vector_subparts_p (GET_MODE_NUNITS (mode
)))
1048 machine_mode inner_mode
= GET_MODE_INNER (mode
);
1049 tree inner_type
= lto_type_for_mode (inner_mode
, unsigned_p
);
1050 if (inner_type
!= NULL_TREE
)
1051 return build_vector_type_for_mode (inner_type
, mode
);
1054 if (mode
== TYPE_MODE (dfloat32_type_node
))
1055 return dfloat32_type_node
;
1056 if (mode
== TYPE_MODE (dfloat64_type_node
))
1057 return dfloat64_type_node
;
1058 if (mode
== TYPE_MODE (dfloat128_type_node
))
1059 return dfloat128_type_node
;
1061 if (ALL_SCALAR_FIXED_POINT_MODE_P (mode
))
1063 if (mode
== TYPE_MODE (short_fract_type_node
))
1064 return unsigned_p
? sat_short_fract_type_node
: short_fract_type_node
;
1065 if (mode
== TYPE_MODE (fract_type_node
))
1066 return unsigned_p
? sat_fract_type_node
: fract_type_node
;
1067 if (mode
== TYPE_MODE (long_fract_type_node
))
1068 return unsigned_p
? sat_long_fract_type_node
: long_fract_type_node
;
1069 if (mode
== TYPE_MODE (long_long_fract_type_node
))
1070 return unsigned_p
? sat_long_long_fract_type_node
1071 : long_long_fract_type_node
;
1073 if (mode
== TYPE_MODE (unsigned_short_fract_type_node
))
1074 return unsigned_p
? sat_unsigned_short_fract_type_node
1075 : unsigned_short_fract_type_node
;
1076 if (mode
== TYPE_MODE (unsigned_fract_type_node
))
1077 return unsigned_p
? sat_unsigned_fract_type_node
1078 : unsigned_fract_type_node
;
1079 if (mode
== TYPE_MODE (unsigned_long_fract_type_node
))
1080 return unsigned_p
? sat_unsigned_long_fract_type_node
1081 : unsigned_long_fract_type_node
;
1082 if (mode
== TYPE_MODE (unsigned_long_long_fract_type_node
))
1083 return unsigned_p
? sat_unsigned_long_long_fract_type_node
1084 : unsigned_long_long_fract_type_node
;
1086 if (mode
== TYPE_MODE (short_accum_type_node
))
1087 return unsigned_p
? sat_short_accum_type_node
: short_accum_type_node
;
1088 if (mode
== TYPE_MODE (accum_type_node
))
1089 return unsigned_p
? sat_accum_type_node
: accum_type_node
;
1090 if (mode
== TYPE_MODE (long_accum_type_node
))
1091 return unsigned_p
? sat_long_accum_type_node
: long_accum_type_node
;
1092 if (mode
== TYPE_MODE (long_long_accum_type_node
))
1093 return unsigned_p
? sat_long_long_accum_type_node
1094 : long_long_accum_type_node
;
1096 if (mode
== TYPE_MODE (unsigned_short_accum_type_node
))
1097 return unsigned_p
? sat_unsigned_short_accum_type_node
1098 : unsigned_short_accum_type_node
;
1099 if (mode
== TYPE_MODE (unsigned_accum_type_node
))
1100 return unsigned_p
? sat_unsigned_accum_type_node
1101 : unsigned_accum_type_node
;
1102 if (mode
== TYPE_MODE (unsigned_long_accum_type_node
))
1103 return unsigned_p
? sat_unsigned_long_accum_type_node
1104 : unsigned_long_accum_type_node
;
1105 if (mode
== TYPE_MODE (unsigned_long_long_accum_type_node
))
1106 return unsigned_p
? sat_unsigned_long_long_accum_type_node
1107 : unsigned_long_long_accum_type_node
;
1110 return unsigned_p
? sat_qq_type_node
: qq_type_node
;
1112 return unsigned_p
? sat_hq_type_node
: hq_type_node
;
1114 return unsigned_p
? sat_sq_type_node
: sq_type_node
;
1116 return unsigned_p
? sat_dq_type_node
: dq_type_node
;
1118 return unsigned_p
? sat_tq_type_node
: tq_type_node
;
1120 if (mode
== UQQmode
)
1121 return unsigned_p
? sat_uqq_type_node
: uqq_type_node
;
1122 if (mode
== UHQmode
)
1123 return unsigned_p
? sat_uhq_type_node
: uhq_type_node
;
1124 if (mode
== USQmode
)
1125 return unsigned_p
? sat_usq_type_node
: usq_type_node
;
1126 if (mode
== UDQmode
)
1127 return unsigned_p
? sat_udq_type_node
: udq_type_node
;
1128 if (mode
== UTQmode
)
1129 return unsigned_p
? sat_utq_type_node
: utq_type_node
;
1132 return unsigned_p
? sat_ha_type_node
: ha_type_node
;
1134 return unsigned_p
? sat_sa_type_node
: sa_type_node
;
1136 return unsigned_p
? sat_da_type_node
: da_type_node
;
1138 return unsigned_p
? sat_ta_type_node
: ta_type_node
;
1140 if (mode
== UHAmode
)
1141 return unsigned_p
? sat_uha_type_node
: uha_type_node
;
1142 if (mode
== USAmode
)
1143 return unsigned_p
? sat_usa_type_node
: usa_type_node
;
1144 if (mode
== UDAmode
)
1145 return unsigned_p
? sat_uda_type_node
: uda_type_node
;
1146 if (mode
== UTAmode
)
1147 return unsigned_p
? sat_uta_type_node
: uta_type_node
;
1150 for (t
= registered_builtin_types
; t
; t
= TREE_CHAIN (t
))
1151 if (TYPE_MODE (TREE_VALUE (t
)) == mode
)
1152 return TREE_VALUE (t
);
1157 /* Return true if we are in the global binding level. */
1160 lto_global_bindings_p (void)
1162 return cfun
== NULL
;
1166 lto_set_decl_assembler_name (tree decl
)
1168 /* This is almost the same as lhd_set_decl_assembler_name, except that
1169 we need to uniquify file-scope names, even if they are not
1170 TREE_PUBLIC, to avoid conflicts between individual files. */
1173 if (TREE_PUBLIC (decl
))
1174 id
= targetm
.mangle_decl_assembler_name (decl
, DECL_NAME (decl
));
1177 const char *name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
1180 ASM_FORMAT_PRIVATE_NAME (label
, name
, DECL_UID (decl
));
1181 id
= get_identifier (label
);
1184 SET_DECL_ASSEMBLER_NAME (decl
, id
);
1188 lto_pushdecl (tree t ATTRIBUTE_UNUSED
)
1190 /* Do nothing, since we get all information from DWARF and LTO
1198 /* We have our own write_globals langhook, hence the getdecls
1199 langhook shouldn't be used, except by dbxout.c, so we can't
1205 lto_builtin_function (tree decl
)
1211 lto_register_builtin_type (tree type
, const char *name
)
1215 if (!TYPE_NAME (type
))
1217 decl
= build_decl (UNKNOWN_LOCATION
, TYPE_DECL
,
1218 get_identifier (name
), type
);
1219 DECL_ARTIFICIAL (decl
) = 1;
1220 TYPE_NAME (type
) = decl
;
1223 registered_builtin_types
= tree_cons (0, type
, registered_builtin_types
);
1226 /* Build nodes that would have be created by the C front-end; necessary
1227 for including builtin-types.def and ultimately builtins.def. */
1230 lto_build_c_type_nodes (void)
1232 gcc_assert (void_type_node
);
1234 void_list_node
= build_tree_list (NULL_TREE
, void_type_node
);
1235 string_type_node
= build_pointer_type (char_type_node
);
1236 const_string_type_node
1237 = build_pointer_type (build_qualified_type (char_type_node
, TYPE_QUAL_CONST
));
1239 if (strcmp (SIZE_TYPE
, "unsigned int") == 0)
1241 intmax_type_node
= integer_type_node
;
1242 uintmax_type_node
= unsigned_type_node
;
1243 signed_size_type_node
= integer_type_node
;
1245 else if (strcmp (SIZE_TYPE
, "long unsigned int") == 0)
1247 intmax_type_node
= long_integer_type_node
;
1248 uintmax_type_node
= long_unsigned_type_node
;
1249 signed_size_type_node
= long_integer_type_node
;
1251 else if (strcmp (SIZE_TYPE
, "long long unsigned int") == 0)
1253 intmax_type_node
= long_long_integer_type_node
;
1254 uintmax_type_node
= long_long_unsigned_type_node
;
1255 signed_size_type_node
= long_long_integer_type_node
;
1261 signed_size_type_node
= NULL_TREE
;
1262 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
1263 if (int_n_enabled_p
[i
])
1265 char name
[50], altname
[50];
1266 sprintf (name
, "__int%d unsigned", int_n_data
[i
].bitsize
);
1267 sprintf (altname
, "__int%d__ unsigned", int_n_data
[i
].bitsize
);
1269 if (strcmp (name
, SIZE_TYPE
) == 0
1270 || strcmp (altname
, SIZE_TYPE
) == 0)
1272 intmax_type_node
= int_n_trees
[i
].signed_type
;
1273 uintmax_type_node
= int_n_trees
[i
].unsigned_type
;
1274 signed_size_type_node
= int_n_trees
[i
].signed_type
;
1277 if (signed_size_type_node
== NULL_TREE
)
1281 wint_type_node
= unsigned_type_node
;
1282 pid_type_node
= integer_type_node
;
1285 /* Perform LTO-specific initialization. */
1292 /* Initialize LTO-specific data structures. */
1295 /* We need to generate LTO if running in WPA mode. */
1296 flag_generate_lto
= (flag_incremental_link
== INCREMENTAL_LINK_LTO
1297 || flag_wpa
!= NULL
);
1299 /* Create the basic integer types. */
1300 build_common_tree_nodes (flag_signed_char
);
1302 /* The global tree for the main identifier is filled in by
1303 language-specific front-end initialization that is not run in the
1304 LTO back-end. It appears that all languages that perform such
1305 initialization currently do so in the same way, so we do it here. */
1306 if (main_identifier_node
== NULL_TREE
)
1307 main_identifier_node
= get_identifier ("main");
1309 /* In the C++ front-end, fileptr_type_node is defined as a variant
1310 copy of ptr_type_node, rather than ptr_node itself. The
1311 distinction should only be relevant to the front-end, so we
1312 always use the C definition here in lto1.
1313 Likewise for const struct tm*. */
1314 for (unsigned i
= 0;
1315 i
< sizeof (builtin_structptr_types
) / sizeof (builtin_structptr_type
);
1318 gcc_assert (builtin_structptr_types
[i
].node
1319 == builtin_structptr_types
[i
].base
);
1320 gcc_assert (TYPE_MAIN_VARIANT (builtin_structptr_types
[i
].node
)
1321 == builtin_structptr_types
[i
].base
);
1324 lto_build_c_type_nodes ();
1325 gcc_assert (va_list_type_node
);
1327 if (TREE_CODE (va_list_type_node
) == ARRAY_TYPE
)
1329 tree x
= build_pointer_type (TREE_TYPE (va_list_type_node
));
1330 lto_define_builtins (x
, x
);
1334 lto_define_builtins (build_reference_type (va_list_type_node
),
1338 targetm
.init_builtins ();
1339 build_common_builtin_nodes ();
1341 /* Assign names to the builtin types, otherwise they'll end up
1342 as __unknown__ in debug info.
1343 ??? We simply need to stop pre-seeding the streamer cache.
1344 Below is modeled after from c-common.c:c_common_nodes_and_builtins */
1345 #define NAME_TYPE(t,n) \
1347 TYPE_NAME (t) = build_decl (UNKNOWN_LOCATION, TYPE_DECL, \
1348 get_identifier (n), t)
1349 NAME_TYPE (integer_type_node
, "int");
1350 NAME_TYPE (char_type_node
, "char");
1351 NAME_TYPE (long_integer_type_node
, "long int");
1352 NAME_TYPE (unsigned_type_node
, "unsigned int");
1353 NAME_TYPE (long_unsigned_type_node
, "long unsigned int");
1354 NAME_TYPE (long_long_integer_type_node
, "long long int");
1355 NAME_TYPE (long_long_unsigned_type_node
, "long long unsigned int");
1356 NAME_TYPE (short_integer_type_node
, "short int");
1357 NAME_TYPE (short_unsigned_type_node
, "short unsigned int");
1358 if (signed_char_type_node
!= char_type_node
)
1359 NAME_TYPE (signed_char_type_node
, "signed char");
1360 if (unsigned_char_type_node
!= char_type_node
)
1361 NAME_TYPE (unsigned_char_type_node
, "unsigned char");
1362 NAME_TYPE (float_type_node
, "float");
1363 NAME_TYPE (double_type_node
, "double");
1364 NAME_TYPE (long_double_type_node
, "long double");
1365 NAME_TYPE (void_type_node
, "void");
1366 NAME_TYPE (boolean_type_node
, "bool");
1367 NAME_TYPE (complex_float_type_node
, "complex float");
1368 NAME_TYPE (complex_double_type_node
, "complex double");
1369 NAME_TYPE (complex_long_double_type_node
, "complex long double");
1370 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
1371 if (int_n_enabled_p
[i
])
1374 sprintf (name
, "__int%d", int_n_data
[i
].bitsize
);
1375 NAME_TYPE (int_n_trees
[i
].signed_type
, name
);
1382 /* Register c++-specific dumps. */
1385 lto_register_dumps (gcc::dump_manager
*dumps
)
1387 lto_link_dump_id
= dumps
->dump_register
1388 (".lto-link", "ipa-lto-link", "ipa-lto-link",
1389 DK_ipa
, OPTGROUP_NONE
, false);
1390 decl_merge_dump_id
= dumps
->dump_register
1391 (".lto-decl-merge", "ipa-lto-decl-merge", "ipa-lto-decl-merge",
1392 DK_ipa
, OPTGROUP_NONE
, false);
1393 partition_dump_id
= dumps
->dump_register
1394 (".lto-partition", "ipa-lto-partition", "ipa-lto-partition",
1395 DK_ipa
, OPTGROUP_NONE
, false);
1399 /* Initialize tree structures required by the LTO front end. */
1401 static void lto_init_ts (void)
1403 tree_contains_struct
[NAMESPACE_DECL
][TS_DECL_MINIMAL
] = 1;
1406 #undef LANG_HOOKS_NAME
1407 #define LANG_HOOKS_NAME "GNU GIMPLE"
1408 #undef LANG_HOOKS_OPTION_LANG_MASK
1409 #define LANG_HOOKS_OPTION_LANG_MASK lto_option_lang_mask
1410 #undef LANG_HOOKS_COMPLAIN_WRONG_LANG_P
1411 #define LANG_HOOKS_COMPLAIN_WRONG_LANG_P lto_complain_wrong_lang_p
1412 #undef LANG_HOOKS_INIT_OPTIONS_STRUCT
1413 #define LANG_HOOKS_INIT_OPTIONS_STRUCT lto_init_options_struct
1414 #undef LANG_HOOKS_REGISTER_DUMPS
1415 #define LANG_HOOKS_REGISTER_DUMPS lto_register_dumps
1416 #undef LANG_HOOKS_HANDLE_OPTION
1417 #define LANG_HOOKS_HANDLE_OPTION lto_handle_option
1418 #undef LANG_HOOKS_POST_OPTIONS
1419 #define LANG_HOOKS_POST_OPTIONS lto_post_options
1420 #undef LANG_HOOKS_GET_ALIAS_SET
1421 #define LANG_HOOKS_GET_ALIAS_SET gimple_get_alias_set
1422 #undef LANG_HOOKS_TYPE_FOR_MODE
1423 #define LANG_HOOKS_TYPE_FOR_MODE lto_type_for_mode
1424 #undef LANG_HOOKS_SET_DECL_ASSEMBLER_NAME
1425 #define LANG_HOOKS_SET_DECL_ASSEMBLER_NAME lto_set_decl_assembler_name
1426 #undef LANG_HOOKS_GLOBAL_BINDINGS_P
1427 #define LANG_HOOKS_GLOBAL_BINDINGS_P lto_global_bindings_p
1428 #undef LANG_HOOKS_PUSHDECL
1429 #define LANG_HOOKS_PUSHDECL lto_pushdecl
1430 #undef LANG_HOOKS_GETDECLS
1431 #define LANG_HOOKS_GETDECLS lto_getdecls
1432 #undef LANG_HOOKS_REGISTER_BUILTIN_TYPE
1433 #define LANG_HOOKS_REGISTER_BUILTIN_TYPE lto_register_builtin_type
1434 #undef LANG_HOOKS_BUILTIN_FUNCTION
1435 #define LANG_HOOKS_BUILTIN_FUNCTION lto_builtin_function
1436 #undef LANG_HOOKS_INIT
1437 #define LANG_HOOKS_INIT lto_init
1438 #undef LANG_HOOKS_PARSE_FILE
1439 #define LANG_HOOKS_PARSE_FILE lto_main
1440 #undef LANG_HOOKS_REDUCE_BIT_FIELD_OPERATIONS
1441 #define LANG_HOOKS_REDUCE_BIT_FIELD_OPERATIONS true
1442 #undef LANG_HOOKS_TYPES_COMPATIBLE_P
1443 #define LANG_HOOKS_TYPES_COMPATIBLE_P NULL
1444 #undef LANG_HOOKS_EH_PERSONALITY
1445 #define LANG_HOOKS_EH_PERSONALITY lto_eh_personality
1447 /* Attribute hooks. */
1448 #undef LANG_HOOKS_COMMON_ATTRIBUTE_TABLE
1449 #define LANG_HOOKS_COMMON_ATTRIBUTE_TABLE lto_attribute_table
1450 #undef LANG_HOOKS_FORMAT_ATTRIBUTE_TABLE
1451 #define LANG_HOOKS_FORMAT_ATTRIBUTE_TABLE lto_format_attribute_table
1453 #undef LANG_HOOKS_BEGIN_SECTION
1454 #define LANG_HOOKS_BEGIN_SECTION lto_obj_begin_section
1455 #undef LANG_HOOKS_APPEND_DATA
1456 #define LANG_HOOKS_APPEND_DATA lto_obj_append_data
1457 #undef LANG_HOOKS_END_SECTION
1458 #define LANG_HOOKS_END_SECTION lto_obj_end_section
1460 #undef LANG_HOOKS_INIT_TS
1461 #define LANG_HOOKS_INIT_TS lto_init_ts
1463 struct lang_hooks lang_hooks
= LANG_HOOKS_INITIALIZER
;
1465 /* Language hooks that are not part of lang_hooks. */
1468 convert (tree type ATTRIBUTE_UNUSED
, tree expr ATTRIBUTE_UNUSED
)
1473 /* Tree walking support. */
1475 static enum lto_tree_node_structure_enum
1476 lto_tree_node_structure (union lang_tree_node
*t ATTRIBUTE_UNUSED
)
1478 return TS_LTO_GENERIC
;
1481 #include "gtype-lto.h"
1482 #include "gt-lto-lto-lang.h"