1 /* Language-dependent hooks for LTO.
2 Copyright (C) 2009-2018 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 "stringpool.h"
40 static tree
handle_noreturn_attribute (tree
*, tree
, tree
, int, bool *);
41 static tree
handle_leaf_attribute (tree
*, tree
, tree
, int, bool *);
42 static tree
handle_const_attribute (tree
*, tree
, tree
, int, bool *);
43 static tree
handle_malloc_attribute (tree
*, tree
, tree
, int, bool *);
44 static tree
handle_pure_attribute (tree
*, tree
, tree
, int, bool *);
45 static tree
handle_novops_attribute (tree
*, tree
, tree
, int, bool *);
46 static tree
handle_nonnull_attribute (tree
*, tree
, tree
, int, bool *);
47 static tree
handle_nothrow_attribute (tree
*, tree
, tree
, int, bool *);
48 static tree
handle_sentinel_attribute (tree
*, tree
, tree
, int, bool *);
49 static tree
handle_type_generic_attribute (tree
*, tree
, tree
, int, bool *);
50 static tree
handle_transaction_pure_attribute (tree
*, tree
, tree
, int, bool *);
51 static tree
handle_returns_twice_attribute (tree
*, tree
, tree
, int, bool *);
52 static tree
handle_patchable_function_entry_attribute (tree
*, tree
, tree
,
54 static tree
ignore_attribute (tree
*, tree
, tree
, int, bool *);
56 static tree
handle_format_attribute (tree
*, tree
, tree
, int, bool *);
57 static tree
handle_fnspec_attribute (tree
*, tree
, tree
, int, bool *);
58 static tree
handle_format_arg_attribute (tree
*, tree
, tree
, int, bool *);
60 /* Helper to define attribute exclusions. */
61 #define ATTR_EXCL(name, function, type, variable) \
62 { name, function, type, variable }
64 /* Define attributes that are mutually exclusive with one another. */
65 static const struct attribute_spec::exclusions attr_noreturn_exclusions
[] =
67 ATTR_EXCL ("noreturn", true, true, true),
68 ATTR_EXCL ("alloc_align", true, true, true),
69 ATTR_EXCL ("alloc_size", true, true, true),
70 ATTR_EXCL ("const", true, true, true),
71 ATTR_EXCL ("malloc", true, true, true),
72 ATTR_EXCL ("pure", true, true, true),
73 ATTR_EXCL ("returns_twice", true, true, true),
74 ATTR_EXCL ("warn_unused_result", true, true, true),
75 ATTR_EXCL (NULL
, false, false, false),
78 static const struct attribute_spec::exclusions attr_returns_twice_exclusions
[] =
80 ATTR_EXCL ("noreturn", true, true, true),
81 ATTR_EXCL (NULL
, false, false, false),
84 static const struct attribute_spec::exclusions attr_const_pure_exclusions
[] =
86 ATTR_EXCL ("const", true, true, true),
87 ATTR_EXCL ("noreturn", true, true, true),
88 ATTR_EXCL ("pure", true, true, true),
89 ATTR_EXCL (NULL
, false, false, false)
92 /* Table of machine-independent attributes supported in GIMPLE. */
93 const struct attribute_spec lto_attribute_table
[] =
95 /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
96 affects_type_identity, handler, exclude } */
97 { "noreturn", 0, 0, true, false, false, false,
98 handle_noreturn_attribute
,
99 attr_noreturn_exclusions
},
100 { "leaf", 0, 0, true, false, false, false,
101 handle_leaf_attribute
, NULL
},
102 /* The same comments as for noreturn attributes apply to const ones. */
103 { "const", 0, 0, true, false, false, false,
104 handle_const_attribute
,
105 attr_const_pure_exclusions
},
106 { "malloc", 0, 0, true, false, false, false,
107 handle_malloc_attribute
, NULL
},
108 { "pure", 0, 0, true, false, false, false,
109 handle_pure_attribute
,
110 attr_const_pure_exclusions
},
111 { "no vops", 0, 0, true, false, false, false,
112 handle_novops_attribute
, NULL
},
113 { "nonnull", 0, -1, false, true, true, false,
114 handle_nonnull_attribute
, NULL
},
115 { "nothrow", 0, 0, true, false, false, false,
116 handle_nothrow_attribute
, NULL
},
117 { "patchable_function_entry", 1, 2, true, false, false, false,
118 handle_patchable_function_entry_attribute
,
120 { "returns_twice", 0, 0, true, false, false, false,
121 handle_returns_twice_attribute
,
122 attr_returns_twice_exclusions
},
123 { "sentinel", 0, 1, false, true, true, false,
124 handle_sentinel_attribute
, NULL
},
125 { "type generic", 0, 0, false, true, true, false,
126 handle_type_generic_attribute
, NULL
},
127 { "fn spec", 1, 1, false, true, true, false,
128 handle_fnspec_attribute
, NULL
},
129 { "transaction_pure", 0, 0, false, true, true, false,
130 handle_transaction_pure_attribute
, NULL
},
131 /* For internal use only. The leading '*' both prevents its usage in
132 source code and signals that it may be overridden by machine tables. */
133 { "*tm regparm", 0, 0, false, true, true, false,
134 ignore_attribute
, NULL
},
135 { NULL
, 0, 0, false, false, false, false, NULL
, NULL
}
138 /* Give the specifications for the format attributes, used by C and all
141 const struct attribute_spec lto_format_attribute_table
[] =
143 /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
144 affects_type_identity, handler, exclude } */
145 { "format", 3, 3, false, true, true, false,
146 handle_format_attribute
, NULL
},
147 { "format_arg", 1, 1, false, true, true, false,
148 handle_format_arg_attribute
, NULL
},
149 { NULL
, 0, 0, false, false, false, false, NULL
, NULL
}
152 enum built_in_attribute
154 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
155 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
156 #define DEF_ATTR_STRING(ENUM, VALUE) ENUM,
157 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
158 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
159 #include "builtin-attrs.def"
160 #undef DEF_ATTR_NULL_TREE
162 #undef DEF_ATTR_STRING
163 #undef DEF_ATTR_IDENT
164 #undef DEF_ATTR_TREE_LIST
168 static GTY(()) tree built_in_attributes
[(int) ATTR_LAST
];
172 enum lto_builtin_type
174 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
175 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
176 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
177 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
178 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
179 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
180 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
181 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
183 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
185 #define DEF_FUNCTION_TYPE_8(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
186 ARG6, ARG7, ARG8) NAME,
187 #define DEF_FUNCTION_TYPE_9(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
188 ARG6, ARG7, ARG8, ARG9) NAME,
189 #define DEF_FUNCTION_TYPE_10(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
190 ARG6, ARG7, ARG8, ARG9, ARG10) NAME,
191 #define DEF_FUNCTION_TYPE_11(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
192 ARG6, ARG7, ARG8, ARG9, ARG10, ARG11) NAME,
193 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
194 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
195 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
196 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
197 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
198 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
200 #define DEF_FUNCTION_TYPE_VAR_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
202 #define DEF_FUNCTION_TYPE_VAR_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
204 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
205 #include "builtin-types.def"
206 #undef DEF_PRIMITIVE_TYPE
207 #undef DEF_FUNCTION_TYPE_0
208 #undef DEF_FUNCTION_TYPE_1
209 #undef DEF_FUNCTION_TYPE_2
210 #undef DEF_FUNCTION_TYPE_3
211 #undef DEF_FUNCTION_TYPE_4
212 #undef DEF_FUNCTION_TYPE_5
213 #undef DEF_FUNCTION_TYPE_6
214 #undef DEF_FUNCTION_TYPE_7
215 #undef DEF_FUNCTION_TYPE_8
216 #undef DEF_FUNCTION_TYPE_9
217 #undef DEF_FUNCTION_TYPE_10
218 #undef DEF_FUNCTION_TYPE_11
219 #undef DEF_FUNCTION_TYPE_VAR_0
220 #undef DEF_FUNCTION_TYPE_VAR_1
221 #undef DEF_FUNCTION_TYPE_VAR_2
222 #undef DEF_FUNCTION_TYPE_VAR_3
223 #undef DEF_FUNCTION_TYPE_VAR_4
224 #undef DEF_FUNCTION_TYPE_VAR_5
225 #undef DEF_FUNCTION_TYPE_VAR_6
226 #undef DEF_FUNCTION_TYPE_VAR_7
227 #undef DEF_POINTER_TYPE
231 typedef enum lto_builtin_type builtin_type
;
233 static GTY(()) tree builtin_types
[(int) BT_LAST
+ 1];
235 static GTY(()) tree string_type_node
;
236 static GTY(()) tree const_string_type_node
;
237 static GTY(()) tree wint_type_node
;
238 static GTY(()) tree intmax_type_node
;
239 static GTY(()) tree uintmax_type_node
;
240 static GTY(()) tree signed_size_type_node
;
242 /* Flags needed to process builtins.def. */
247 /* Attribute handlers. */
249 /* Handle a "noreturn" attribute; arguments as in
250 struct attribute_spec.handler. */
253 handle_noreturn_attribute (tree
*node
, tree
ARG_UNUSED (name
),
254 tree
ARG_UNUSED (args
), int ARG_UNUSED (flags
),
255 bool * ARG_UNUSED (no_add_attrs
))
257 tree type
= TREE_TYPE (*node
);
259 if (TREE_CODE (*node
) == FUNCTION_DECL
)
260 TREE_THIS_VOLATILE (*node
) = 1;
261 else if (TREE_CODE (type
) == POINTER_TYPE
262 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
265 (build_type_variant (TREE_TYPE (type
),
266 TYPE_READONLY (TREE_TYPE (type
)), 1));
273 /* Handle a "leaf" attribute; arguments as in
274 struct attribute_spec.handler. */
277 handle_leaf_attribute (tree
*node
, tree name
,
278 tree
ARG_UNUSED (args
),
279 int ARG_UNUSED (flags
), bool *no_add_attrs
)
281 if (TREE_CODE (*node
) != FUNCTION_DECL
)
283 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
284 *no_add_attrs
= true;
286 if (!TREE_PUBLIC (*node
))
288 warning (OPT_Wattributes
, "%qE attribute has no effect on unit local functions", name
);
289 *no_add_attrs
= true;
295 /* Handle a "const" attribute; arguments as in
296 struct attribute_spec.handler. */
299 handle_const_attribute (tree
*node
, tree
ARG_UNUSED (name
),
300 tree
ARG_UNUSED (args
), int ARG_UNUSED (flags
),
301 bool * ARG_UNUSED (no_add_attrs
))
303 if (TREE_CODE (*node
) != FUNCTION_DECL
304 || !DECL_BUILT_IN (*node
))
305 inform (UNKNOWN_LOCATION
, "%s:%s: %E: %E", __FILE__
, __func__
, *node
, name
);
307 tree type
= TREE_TYPE (*node
);
309 /* See FIXME comment on noreturn in c_common_attribute_table. */
310 if (TREE_CODE (*node
) == FUNCTION_DECL
)
311 TREE_READONLY (*node
) = 1;
312 else if (TREE_CODE (type
) == POINTER_TYPE
313 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
316 (build_type_variant (TREE_TYPE (type
), 1,
317 TREE_THIS_VOLATILE (TREE_TYPE (type
))));
325 /* Handle a "malloc" attribute; arguments as in
326 struct attribute_spec.handler. */
329 handle_malloc_attribute (tree
*node
, tree
ARG_UNUSED (name
),
330 tree
ARG_UNUSED (args
), int ARG_UNUSED (flags
),
331 bool * ARG_UNUSED (no_add_attrs
))
333 if (TREE_CODE (*node
) == FUNCTION_DECL
334 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node
))))
335 DECL_IS_MALLOC (*node
) = 1;
343 /* Handle a "pure" attribute; arguments as in
344 struct attribute_spec.handler. */
347 handle_pure_attribute (tree
*node
, tree
ARG_UNUSED (name
),
348 tree
ARG_UNUSED (args
), int ARG_UNUSED (flags
),
349 bool * ARG_UNUSED (no_add_attrs
))
351 if (TREE_CODE (*node
) == FUNCTION_DECL
)
352 DECL_PURE_P (*node
) = 1;
360 /* Handle a "no vops" attribute; arguments as in
361 struct attribute_spec.handler. */
364 handle_novops_attribute (tree
*node
, tree
ARG_UNUSED (name
),
365 tree
ARG_UNUSED (args
), int ARG_UNUSED (flags
),
366 bool *ARG_UNUSED (no_add_attrs
))
368 gcc_assert (TREE_CODE (*node
) == FUNCTION_DECL
);
369 DECL_IS_NOVOPS (*node
) = 1;
374 /* Helper for nonnull attribute handling; fetch the operand number
375 from the attribute argument list. */
378 get_nonnull_operand (tree arg_num_expr
, unsigned HOST_WIDE_INT
*valp
)
380 /* Verify the arg number is a constant. */
381 if (!tree_fits_uhwi_p (arg_num_expr
))
384 *valp
= TREE_INT_CST_LOW (arg_num_expr
);
388 /* Handle the "nonnull" attribute. */
391 handle_nonnull_attribute (tree
*node
, tree
ARG_UNUSED (name
),
392 tree args
, int ARG_UNUSED (flags
),
393 bool * ARG_UNUSED (no_add_attrs
))
397 /* If no arguments are specified, all pointer arguments should be
398 non-null. Verify a full prototype is given so that the arguments
399 will have the correct types when we actually check them later.
400 Avoid diagnosing type-generic built-ins since those have no
404 gcc_assert (prototype_p (type
)
405 || !TYPE_ATTRIBUTES (type
)
406 || lookup_attribute ("type generic", TYPE_ATTRIBUTES (type
)));
411 /* Argument list specified. Verify that each argument number references
412 a pointer argument. */
413 for (; args
; args
= TREE_CHAIN (args
))
416 unsigned HOST_WIDE_INT arg_num
= 0, ck_num
;
418 if (!get_nonnull_operand (TREE_VALUE (args
), &arg_num
))
421 argument
= TYPE_ARG_TYPES (type
);
424 for (ck_num
= 1; ; ck_num
++)
426 if (!argument
|| ck_num
== arg_num
)
428 argument
= TREE_CHAIN (argument
);
432 && TREE_CODE (TREE_VALUE (argument
)) == POINTER_TYPE
);
440 /* Handle a "nothrow" attribute; arguments as in
441 struct attribute_spec.handler. */
444 handle_nothrow_attribute (tree
*node
, tree
ARG_UNUSED (name
),
445 tree
ARG_UNUSED (args
), int ARG_UNUSED (flags
),
446 bool * ARG_UNUSED (no_add_attrs
))
448 if (TREE_CODE (*node
) == FUNCTION_DECL
)
449 TREE_NOTHROW (*node
) = 1;
457 /* Handle a "sentinel" attribute. */
460 handle_sentinel_attribute (tree
*node
, tree
ARG_UNUSED (name
), tree args
,
461 int ARG_UNUSED (flags
),
462 bool * ARG_UNUSED (no_add_attrs
))
464 gcc_assert (stdarg_p (*node
));
468 tree position
= TREE_VALUE (args
);
469 gcc_assert (TREE_CODE (position
) == INTEGER_CST
);
470 if (tree_int_cst_lt (position
, integer_zero_node
))
477 /* Handle a "type_generic" attribute. */
480 handle_type_generic_attribute (tree
*node
, tree
ARG_UNUSED (name
),
481 tree
ARG_UNUSED (args
), int ARG_UNUSED (flags
),
482 bool * ARG_UNUSED (no_add_attrs
))
484 /* Ensure we have a function type. */
485 gcc_assert (TREE_CODE (*node
) == FUNCTION_TYPE
);
487 /* Ensure we have a variadic function. */
488 gcc_assert (!prototype_p (*node
) || stdarg_p (*node
));
493 /* Handle a "transaction_pure" attribute. */
496 handle_transaction_pure_attribute (tree
*node
, tree
ARG_UNUSED (name
),
497 tree
ARG_UNUSED (args
),
498 int ARG_UNUSED (flags
),
499 bool * ARG_UNUSED (no_add_attrs
))
501 /* Ensure we have a function type. */
502 gcc_assert (TREE_CODE (*node
) == FUNCTION_TYPE
);
507 /* Handle a "returns_twice" attribute. */
510 handle_returns_twice_attribute (tree
*node
, tree
ARG_UNUSED (name
),
511 tree
ARG_UNUSED (args
),
512 int ARG_UNUSED (flags
),
513 bool * ARG_UNUSED (no_add_attrs
))
515 gcc_assert (TREE_CODE (*node
) == FUNCTION_DECL
);
517 DECL_IS_RETURNS_TWICE (*node
) = 1;
523 handle_patchable_function_entry_attribute (tree
*, tree
, tree
, int, bool *)
525 /* Nothing to be done here. */
529 /* Ignore the given attribute. Used when this attribute may be usefully
530 overridden by the target, but is not used generically. */
533 ignore_attribute (tree
* ARG_UNUSED (node
), tree
ARG_UNUSED (name
),
534 tree
ARG_UNUSED (args
), int ARG_UNUSED (flags
),
537 *no_add_attrs
= true;
541 /* Handle a "format" attribute; arguments as in
542 struct attribute_spec.handler. */
545 handle_format_attribute (tree
* ARG_UNUSED (node
), tree
ARG_UNUSED (name
),
546 tree
ARG_UNUSED (args
), int ARG_UNUSED (flags
),
549 *no_add_attrs
= true;
554 /* Handle a "format_arg" attribute; arguments as in
555 struct attribute_spec.handler. */
558 handle_format_arg_attribute (tree
* ARG_UNUSED (node
), tree
ARG_UNUSED (name
),
559 tree
ARG_UNUSED (args
), int ARG_UNUSED (flags
),
562 *no_add_attrs
= true;
567 /* Handle a "fn spec" attribute; arguments as in
568 struct attribute_spec.handler. */
571 handle_fnspec_attribute (tree
*node ATTRIBUTE_UNUSED
, tree
ARG_UNUSED (name
),
572 tree args
, int ARG_UNUSED (flags
),
573 bool *no_add_attrs ATTRIBUTE_UNUSED
)
576 && TREE_CODE (TREE_VALUE (args
)) == STRING_CST
577 && !TREE_CHAIN (args
));
581 /* Cribbed from c-common.c. */
584 def_fn_type (builtin_type def
, builtin_type ret
, bool var
, int n
, ...)
587 tree
*args
= XALLOCAVEC (tree
, n
);
593 for (i
= 0; i
< n
; ++i
)
595 builtin_type a
= (builtin_type
) va_arg (list
, int);
596 t
= builtin_types
[a
];
597 if (t
== error_mark_node
)
603 t
= builtin_types
[ret
];
606 if (t
== error_mark_node
)
609 t
= build_varargs_function_type_array (t
, n
, args
);
611 t
= build_function_type_array (t
, n
, args
);
613 builtin_types
[def
] = t
;
616 /* Used to help initialize the builtin-types.def table. When a type of
617 the correct size doesn't exist, use error_mark_node instead of NULL.
618 The later results in segfaults even when a decl using the type doesn't
622 builtin_type_for_size (int size
, bool unsignedp
)
624 tree type
= lang_hooks
.types
.type_for_size (size
, unsignedp
);
625 return type
? type
: error_mark_node
;
628 /* Support for DEF_BUILTIN. */
631 def_builtin_1 (enum built_in_function fncode
, const char *name
,
632 enum built_in_class fnclass
, tree fntype
, tree libtype
,
633 bool both_p
, bool fallback_p
, bool nonansi_p
,
634 tree fnattrs
, bool implicit_p
)
639 if (fntype
== error_mark_node
)
642 libname
= name
+ strlen ("__builtin_");
643 decl
= add_builtin_function (name
, fntype
, fncode
, fnclass
,
644 (fallback_p
? libname
: NULL
),
649 && !(nonansi_p
&& flag_no_nonansi_builtin
))
650 add_builtin_function (libname
, libtype
, fncode
, fnclass
,
653 set_builtin_decl (fncode
, decl
, implicit_p
);
657 /* Initialize the attribute table for all the supported builtins. */
660 lto_init_attributes (void)
662 /* Fill in the built_in_attributes array. */
663 #define DEF_ATTR_NULL_TREE(ENUM) \
664 built_in_attributes[(int) ENUM] = NULL_TREE;
665 #define DEF_ATTR_INT(ENUM, VALUE) \
666 built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
667 #define DEF_ATTR_STRING(ENUM, VALUE) \
668 built_in_attributes[(int) ENUM] = build_string (strlen (VALUE), VALUE);
669 #define DEF_ATTR_IDENT(ENUM, STRING) \
670 built_in_attributes[(int) ENUM] = get_identifier (STRING);
671 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
672 built_in_attributes[(int) ENUM] \
673 = tree_cons (built_in_attributes[(int) PURPOSE], \
674 built_in_attributes[(int) VALUE], \
675 built_in_attributes[(int) CHAIN]);
676 #include "builtin-attrs.def"
677 #undef DEF_ATTR_NULL_TREE
679 #undef DEF_ATTR_STRING
680 #undef DEF_ATTR_IDENT
681 #undef DEF_ATTR_TREE_LIST
684 /* Create builtin types and functions. VA_LIST_REF_TYPE_NODE and
685 VA_LIST_ARG_TYPE_NODE are used in builtin-types.def. */
688 lto_define_builtins (tree va_list_ref_type_node ATTRIBUTE_UNUSED
,
689 tree va_list_arg_type_node ATTRIBUTE_UNUSED
)
691 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
692 builtin_types[ENUM] = VALUE;
693 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
694 def_fn_type (ENUM, RETURN, 0, 0);
695 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
696 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
697 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
698 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
699 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
700 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
701 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
702 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
703 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
704 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
705 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
707 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
708 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
710 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
711 #define DEF_FUNCTION_TYPE_8(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
713 def_fn_type (ENUM, RETURN, 0, 8, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, \
715 #define DEF_FUNCTION_TYPE_9(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
716 ARG6, ARG7, ARG8, ARG9) \
717 def_fn_type (ENUM, RETURN, 0, 9, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, \
719 #define DEF_FUNCTION_TYPE_10(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
720 ARG6, ARG7, ARG8, ARG9, ARG10) \
721 def_fn_type (ENUM, RETURN, 0, 10, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, \
722 ARG7, ARG8, ARG9, ARG10);
723 #define DEF_FUNCTION_TYPE_11(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
724 ARG6, ARG7, ARG8, ARG9, ARG10, ARG11) \
725 def_fn_type (ENUM, RETURN, 0, 11, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, \
726 ARG7, ARG8, ARG9, ARG10, ARG11);
727 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
728 def_fn_type (ENUM, RETURN, 1, 0);
729 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
730 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
731 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
732 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
733 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
734 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
735 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
736 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
737 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
738 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
739 #define DEF_FUNCTION_TYPE_VAR_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
741 def_fn_type (ENUM, RETURN, 1, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
742 #define DEF_FUNCTION_TYPE_VAR_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
744 def_fn_type (ENUM, RETURN, 1, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
745 #define DEF_POINTER_TYPE(ENUM, TYPE) \
746 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
748 #include "builtin-types.def"
750 #undef DEF_PRIMITIVE_TYPE
751 #undef DEF_FUNCTION_TYPE_0
752 #undef DEF_FUNCTION_TYPE_1
753 #undef DEF_FUNCTION_TYPE_2
754 #undef DEF_FUNCTION_TYPE_3
755 #undef DEF_FUNCTION_TYPE_4
756 #undef DEF_FUNCTION_TYPE_5
757 #undef DEF_FUNCTION_TYPE_6
758 #undef DEF_FUNCTION_TYPE_7
759 #undef DEF_FUNCTION_TYPE_8
760 #undef DEF_FUNCTION_TYPE_9
761 #undef DEF_FUNCTION_TYPE_10
762 #undef DEF_FUNCTION_TYPE_11
763 #undef DEF_FUNCTION_TYPE_VAR_0
764 #undef DEF_FUNCTION_TYPE_VAR_1
765 #undef DEF_FUNCTION_TYPE_VAR_2
766 #undef DEF_FUNCTION_TYPE_VAR_3
767 #undef DEF_FUNCTION_TYPE_VAR_4
768 #undef DEF_FUNCTION_TYPE_VAR_5
769 #undef DEF_FUNCTION_TYPE_VAR_6
770 #undef DEF_FUNCTION_TYPE_VAR_7
771 #undef DEF_POINTER_TYPE
772 builtin_types
[(int) BT_LAST
] = NULL_TREE
;
774 lto_init_attributes ();
776 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P,\
777 NONANSI_P, ATTRS, IMPLICIT, COND) \
779 def_builtin_1 (ENUM, NAME, CLASS, builtin_types[(int) TYPE], \
780 builtin_types[(int) LIBTYPE], BOTH_P, FALLBACK_P, \
781 NONANSI_P, built_in_attributes[(int) ATTRS], IMPLICIT);
782 #include "builtins.def"
785 static GTY(()) tree registered_builtin_types
;
787 /* Language hooks. */
790 lto_option_lang_mask (void)
796 lto_complain_wrong_lang_p (const struct cl_option
*option ATTRIBUTE_UNUSED
)
798 /* The LTO front end inherits all the options from the first front
799 end that was used. However, not all the original front end
800 options make sense in LTO.
802 A real solution would be to filter this in collect2, but collect2
803 does not have access to all the option attributes to know what to
804 filter. So, in lto1 we silently accept inherited flags and do
810 lto_init_options_struct (struct gcc_options
*opts
)
812 /* By default, C99-like requirements for complex multiply and divide.
813 ??? Until the complex method is encoded in the IL this is the only
814 safe choice. This will pessimize Fortran code with LTO unless
815 people specify a complex method manually or use -ffast-math. */
816 opts
->x_flag_complex_method
= 2;
819 /* Handle command-line option SCODE. If the option takes an argument, it is
820 stored in ARG, which is otherwise NULL. VALUE holds either a numerical
821 argument or a binary value indicating whether the positive or negative form
822 of the option was supplied. */
824 const char *resolution_file_name
;
826 lto_handle_option (size_t scode
, const char *arg
,
827 int value ATTRIBUTE_UNUSED
, 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 exclussive");
901 case LTO_LINKER_OUTPUT_NOLTOREL
: /* .o: incremental link producing asm */
902 flag_whole_program
= 0;
903 flag_incremental_link
= INCREMENTAL_LINK_NOLTO
;
906 case LTO_LINKER_OUTPUT_DYN
: /* .so: PID library */
907 /* On some targets, like i386 it makes sense to build PIC library wihout
908 -fpic for performance reasons. So no need to adjust flags. */
911 case LTO_LINKER_OUTPUT_PIE
: /* PIE binary */
912 /* If -fPIC or -fPIE was used at compile time, be sure that
914 flag_pie
= MAX (flag_pie
, flag_pic
);
919 case LTO_LINKER_OUTPUT_EXEC
: /* Normal executable */
925 case LTO_LINKER_OUTPUT_UNKNOWN
:
929 /* Excess precision other than "fast" requires front-end
931 flag_excess_precision_cmdline
= EXCESS_PRECISION_FAST
;
933 /* When partitioning, we can tear appart STRING_CSTs uses from the same
934 TU into multiple partitions. Without constant merging the constants
935 might not be equal at runtime. See PR50199. */
936 if (!flag_merge_constants
)
937 flag_merge_constants
= 1;
939 /* Initialize the compiler back end. */
943 /* Return a data type that has machine mode MODE.
944 If the mode is an integer,
945 then UNSIGNEDP selects between signed and unsigned types.
946 If the mode is a fixed-point mode,
947 then UNSIGNEDP selects between saturating and nonsaturating types. */
950 lto_type_for_mode (machine_mode mode
, int unsigned_p
)
955 if (mode
== TYPE_MODE (integer_type_node
))
956 return unsigned_p
? unsigned_type_node
: integer_type_node
;
958 if (mode
== TYPE_MODE (signed_char_type_node
))
959 return unsigned_p
? unsigned_char_type_node
: signed_char_type_node
;
961 if (mode
== TYPE_MODE (short_integer_type_node
))
962 return unsigned_p
? short_unsigned_type_node
: short_integer_type_node
;
964 if (mode
== TYPE_MODE (long_integer_type_node
))
965 return unsigned_p
? long_unsigned_type_node
: long_integer_type_node
;
967 if (mode
== TYPE_MODE (long_long_integer_type_node
))
968 return unsigned_p
? long_long_unsigned_type_node
: long_long_integer_type_node
;
970 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
971 if (int_n_enabled_p
[i
]
972 && mode
== int_n_data
[i
].m
)
973 return (unsigned_p
? int_n_trees
[i
].unsigned_type
974 : int_n_trees
[i
].signed_type
);
977 return unsigned_p
? unsigned_intQI_type_node
: intQI_type_node
;
980 return unsigned_p
? unsigned_intHI_type_node
: intHI_type_node
;
983 return unsigned_p
? unsigned_intSI_type_node
: intSI_type_node
;
986 return unsigned_p
? unsigned_intDI_type_node
: intDI_type_node
;
988 #if HOST_BITS_PER_WIDE_INT >= 64
989 if (mode
== TYPE_MODE (intTI_type_node
))
990 return unsigned_p
? unsigned_intTI_type_node
: intTI_type_node
;
993 if (mode
== TYPE_MODE (float_type_node
))
994 return float_type_node
;
996 if (mode
== TYPE_MODE (double_type_node
))
997 return double_type_node
;
999 if (mode
== TYPE_MODE (long_double_type_node
))
1000 return long_double_type_node
;
1002 if (mode
== TYPE_MODE (void_type_node
))
1003 return void_type_node
;
1005 if (mode
== TYPE_MODE (build_pointer_type (char_type_node
))
1006 || mode
== TYPE_MODE (build_pointer_type (integer_type_node
)))
1008 unsigned int precision
1009 = GET_MODE_PRECISION (as_a
<scalar_int_mode
> (mode
));
1011 ? make_unsigned_type (precision
)
1012 : make_signed_type (precision
));
1015 if (COMPLEX_MODE_P (mode
))
1017 machine_mode inner_mode
;
1020 if (mode
== TYPE_MODE (complex_float_type_node
))
1021 return complex_float_type_node
;
1022 if (mode
== TYPE_MODE (complex_double_type_node
))
1023 return complex_double_type_node
;
1024 if (mode
== TYPE_MODE (complex_long_double_type_node
))
1025 return complex_long_double_type_node
;
1027 if (mode
== TYPE_MODE (complex_integer_type_node
) && !unsigned_p
)
1028 return complex_integer_type_node
;
1030 inner_mode
= GET_MODE_INNER (mode
);
1031 inner_type
= lto_type_for_mode (inner_mode
, unsigned_p
);
1032 if (inner_type
!= NULL_TREE
)
1033 return build_complex_type (inner_type
);
1035 else if (GET_MODE_CLASS (mode
) == MODE_VECTOR_BOOL
1036 && valid_vector_subparts_p (GET_MODE_NUNITS (mode
)))
1038 unsigned int elem_bits
= vector_element_size (GET_MODE_BITSIZE (mode
),
1039 GET_MODE_NUNITS (mode
));
1040 tree bool_type
= build_nonstandard_boolean_type (elem_bits
);
1041 return build_vector_type_for_mode (bool_type
, mode
);
1043 else if (VECTOR_MODE_P (mode
)
1044 && valid_vector_subparts_p (GET_MODE_NUNITS (mode
)))
1046 machine_mode inner_mode
= GET_MODE_INNER (mode
);
1047 tree inner_type
= lto_type_for_mode (inner_mode
, unsigned_p
);
1048 if (inner_type
!= NULL_TREE
)
1049 return build_vector_type_for_mode (inner_type
, mode
);
1052 if (mode
== TYPE_MODE (dfloat32_type_node
))
1053 return dfloat32_type_node
;
1054 if (mode
== TYPE_MODE (dfloat64_type_node
))
1055 return dfloat64_type_node
;
1056 if (mode
== TYPE_MODE (dfloat128_type_node
))
1057 return dfloat128_type_node
;
1059 if (ALL_SCALAR_FIXED_POINT_MODE_P (mode
))
1061 if (mode
== TYPE_MODE (short_fract_type_node
))
1062 return unsigned_p
? sat_short_fract_type_node
: short_fract_type_node
;
1063 if (mode
== TYPE_MODE (fract_type_node
))
1064 return unsigned_p
? sat_fract_type_node
: fract_type_node
;
1065 if (mode
== TYPE_MODE (long_fract_type_node
))
1066 return unsigned_p
? sat_long_fract_type_node
: long_fract_type_node
;
1067 if (mode
== TYPE_MODE (long_long_fract_type_node
))
1068 return unsigned_p
? sat_long_long_fract_type_node
1069 : long_long_fract_type_node
;
1071 if (mode
== TYPE_MODE (unsigned_short_fract_type_node
))
1072 return unsigned_p
? sat_unsigned_short_fract_type_node
1073 : unsigned_short_fract_type_node
;
1074 if (mode
== TYPE_MODE (unsigned_fract_type_node
))
1075 return unsigned_p
? sat_unsigned_fract_type_node
1076 : unsigned_fract_type_node
;
1077 if (mode
== TYPE_MODE (unsigned_long_fract_type_node
))
1078 return unsigned_p
? sat_unsigned_long_fract_type_node
1079 : unsigned_long_fract_type_node
;
1080 if (mode
== TYPE_MODE (unsigned_long_long_fract_type_node
))
1081 return unsigned_p
? sat_unsigned_long_long_fract_type_node
1082 : unsigned_long_long_fract_type_node
;
1084 if (mode
== TYPE_MODE (short_accum_type_node
))
1085 return unsigned_p
? sat_short_accum_type_node
: short_accum_type_node
;
1086 if (mode
== TYPE_MODE (accum_type_node
))
1087 return unsigned_p
? sat_accum_type_node
: accum_type_node
;
1088 if (mode
== TYPE_MODE (long_accum_type_node
))
1089 return unsigned_p
? sat_long_accum_type_node
: long_accum_type_node
;
1090 if (mode
== TYPE_MODE (long_long_accum_type_node
))
1091 return unsigned_p
? sat_long_long_accum_type_node
1092 : long_long_accum_type_node
;
1094 if (mode
== TYPE_MODE (unsigned_short_accum_type_node
))
1095 return unsigned_p
? sat_unsigned_short_accum_type_node
1096 : unsigned_short_accum_type_node
;
1097 if (mode
== TYPE_MODE (unsigned_accum_type_node
))
1098 return unsigned_p
? sat_unsigned_accum_type_node
1099 : unsigned_accum_type_node
;
1100 if (mode
== TYPE_MODE (unsigned_long_accum_type_node
))
1101 return unsigned_p
? sat_unsigned_long_accum_type_node
1102 : unsigned_long_accum_type_node
;
1103 if (mode
== TYPE_MODE (unsigned_long_long_accum_type_node
))
1104 return unsigned_p
? sat_unsigned_long_long_accum_type_node
1105 : unsigned_long_long_accum_type_node
;
1108 return unsigned_p
? sat_qq_type_node
: qq_type_node
;
1110 return unsigned_p
? sat_hq_type_node
: hq_type_node
;
1112 return unsigned_p
? sat_sq_type_node
: sq_type_node
;
1114 return unsigned_p
? sat_dq_type_node
: dq_type_node
;
1116 return unsigned_p
? sat_tq_type_node
: tq_type_node
;
1118 if (mode
== UQQmode
)
1119 return unsigned_p
? sat_uqq_type_node
: uqq_type_node
;
1120 if (mode
== UHQmode
)
1121 return unsigned_p
? sat_uhq_type_node
: uhq_type_node
;
1122 if (mode
== USQmode
)
1123 return unsigned_p
? sat_usq_type_node
: usq_type_node
;
1124 if (mode
== UDQmode
)
1125 return unsigned_p
? sat_udq_type_node
: udq_type_node
;
1126 if (mode
== UTQmode
)
1127 return unsigned_p
? sat_utq_type_node
: utq_type_node
;
1130 return unsigned_p
? sat_ha_type_node
: ha_type_node
;
1132 return unsigned_p
? sat_sa_type_node
: sa_type_node
;
1134 return unsigned_p
? sat_da_type_node
: da_type_node
;
1136 return unsigned_p
? sat_ta_type_node
: ta_type_node
;
1138 if (mode
== UHAmode
)
1139 return unsigned_p
? sat_uha_type_node
: uha_type_node
;
1140 if (mode
== USAmode
)
1141 return unsigned_p
? sat_usa_type_node
: usa_type_node
;
1142 if (mode
== UDAmode
)
1143 return unsigned_p
? sat_uda_type_node
: uda_type_node
;
1144 if (mode
== UTAmode
)
1145 return unsigned_p
? sat_uta_type_node
: uta_type_node
;
1148 for (t
= registered_builtin_types
; t
; t
= TREE_CHAIN (t
))
1149 if (TYPE_MODE (TREE_VALUE (t
)) == mode
)
1150 return TREE_VALUE (t
);
1155 /* Return true if we are in the global binding level. */
1158 lto_global_bindings_p (void)
1160 return cfun
== NULL
;
1164 lto_set_decl_assembler_name (tree decl
)
1166 /* This is almost the same as lhd_set_decl_assembler_name, except that
1167 we need to uniquify file-scope names, even if they are not
1168 TREE_PUBLIC, to avoid conflicts between individual files. */
1171 if (TREE_PUBLIC (decl
))
1172 id
= targetm
.mangle_decl_assembler_name (decl
, DECL_NAME (decl
));
1175 const char *name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
1178 ASM_FORMAT_PRIVATE_NAME (label
, name
, DECL_UID (decl
));
1179 id
= get_identifier (label
);
1182 SET_DECL_ASSEMBLER_NAME (decl
, id
);
1186 lto_pushdecl (tree t ATTRIBUTE_UNUSED
)
1188 /* Do nothing, since we get all information from DWARF and LTO
1196 /* We have our own write_globals langhook, hence the getdecls
1197 langhook shouldn't be used, except by dbxout.c, so we can't
1203 lto_builtin_function (tree decl
)
1209 lto_register_builtin_type (tree type
, const char *name
)
1213 if (!TYPE_NAME (type
))
1215 decl
= build_decl (UNKNOWN_LOCATION
, TYPE_DECL
,
1216 get_identifier (name
), type
);
1217 DECL_ARTIFICIAL (decl
) = 1;
1218 TYPE_NAME (type
) = decl
;
1221 registered_builtin_types
= tree_cons (0, type
, registered_builtin_types
);
1224 /* Build nodes that would have be created by the C front-end; necessary
1225 for including builtin-types.def and ultimately builtins.def. */
1228 lto_build_c_type_nodes (void)
1230 gcc_assert (void_type_node
);
1232 void_list_node
= build_tree_list (NULL_TREE
, void_type_node
);
1233 string_type_node
= build_pointer_type (char_type_node
);
1234 const_string_type_node
1235 = build_pointer_type (build_qualified_type (char_type_node
, TYPE_QUAL_CONST
));
1237 if (strcmp (SIZE_TYPE
, "unsigned int") == 0)
1239 intmax_type_node
= integer_type_node
;
1240 uintmax_type_node
= unsigned_type_node
;
1241 signed_size_type_node
= integer_type_node
;
1243 else if (strcmp (SIZE_TYPE
, "long unsigned int") == 0)
1245 intmax_type_node
= long_integer_type_node
;
1246 uintmax_type_node
= long_unsigned_type_node
;
1247 signed_size_type_node
= long_integer_type_node
;
1249 else if (strcmp (SIZE_TYPE
, "long long unsigned int") == 0)
1251 intmax_type_node
= long_long_integer_type_node
;
1252 uintmax_type_node
= long_long_unsigned_type_node
;
1253 signed_size_type_node
= long_long_integer_type_node
;
1259 signed_size_type_node
= NULL_TREE
;
1260 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
1261 if (int_n_enabled_p
[i
])
1264 sprintf (name
, "__int%d unsigned", int_n_data
[i
].bitsize
);
1266 if (strcmp (name
, SIZE_TYPE
) == 0)
1268 intmax_type_node
= int_n_trees
[i
].signed_type
;
1269 uintmax_type_node
= int_n_trees
[i
].unsigned_type
;
1270 signed_size_type_node
= int_n_trees
[i
].signed_type
;
1273 if (signed_size_type_node
== NULL_TREE
)
1277 wint_type_node
= unsigned_type_node
;
1278 pid_type_node
= integer_type_node
;
1281 /* Perform LTO-specific initialization. */
1288 /* Initialize LTO-specific data structures. */
1291 /* We need to generate LTO if running in WPA mode. */
1292 flag_generate_lto
= (flag_incremental_link
== INCREMENTAL_LINK_LTO
1293 || flag_wpa
!= NULL
);
1295 /* Create the basic integer types. */
1296 build_common_tree_nodes (flag_signed_char
);
1298 /* The global tree for the main identifier is filled in by
1299 language-specific front-end initialization that is not run in the
1300 LTO back-end. It appears that all languages that perform such
1301 initialization currently do so in the same way, so we do it here. */
1302 if (main_identifier_node
== NULL_TREE
)
1303 main_identifier_node
= get_identifier ("main");
1305 /* In the C++ front-end, fileptr_type_node is defined as a variant
1306 copy of ptr_type_node, rather than ptr_node itself. The
1307 distinction should only be relevant to the front-end, so we
1308 always use the C definition here in lto1.
1309 Likewise for const struct tm*. */
1310 for (unsigned i
= 0;
1311 i
< sizeof (builtin_structptr_types
) / sizeof (builtin_structptr_type
);
1314 gcc_assert (builtin_structptr_types
[i
].node
1315 == builtin_structptr_types
[i
].base
);
1316 gcc_assert (TYPE_MAIN_VARIANT (builtin_structptr_types
[i
].node
)
1317 == builtin_structptr_types
[i
].base
);
1320 lto_build_c_type_nodes ();
1321 gcc_assert (va_list_type_node
);
1323 if (TREE_CODE (va_list_type_node
) == ARRAY_TYPE
)
1325 tree x
= build_pointer_type (TREE_TYPE (va_list_type_node
));
1326 lto_define_builtins (x
, x
);
1330 lto_define_builtins (build_reference_type (va_list_type_node
),
1334 targetm
.init_builtins ();
1335 build_common_builtin_nodes ();
1337 /* Assign names to the builtin types, otherwise they'll end up
1338 as __unknown__ in debug info.
1339 ??? We simply need to stop pre-seeding the streamer cache.
1340 Below is modeled after from c-common.c:c_common_nodes_and_builtins */
1341 #define NAME_TYPE(t,n) \
1343 TYPE_NAME (t) = build_decl (UNKNOWN_LOCATION, TYPE_DECL, \
1344 get_identifier (n), t)
1345 NAME_TYPE (integer_type_node
, "int");
1346 NAME_TYPE (char_type_node
, "char");
1347 NAME_TYPE (long_integer_type_node
, "long int");
1348 NAME_TYPE (unsigned_type_node
, "unsigned int");
1349 NAME_TYPE (long_unsigned_type_node
, "long unsigned int");
1350 NAME_TYPE (long_long_integer_type_node
, "long long int");
1351 NAME_TYPE (long_long_unsigned_type_node
, "long long unsigned int");
1352 NAME_TYPE (short_integer_type_node
, "short int");
1353 NAME_TYPE (short_unsigned_type_node
, "short unsigned int");
1354 if (signed_char_type_node
!= char_type_node
)
1355 NAME_TYPE (signed_char_type_node
, "signed char");
1356 if (unsigned_char_type_node
!= char_type_node
)
1357 NAME_TYPE (unsigned_char_type_node
, "unsigned char");
1358 NAME_TYPE (float_type_node
, "float");
1359 NAME_TYPE (double_type_node
, "double");
1360 NAME_TYPE (long_double_type_node
, "long double");
1361 NAME_TYPE (void_type_node
, "void");
1362 NAME_TYPE (boolean_type_node
, "bool");
1363 NAME_TYPE (complex_float_type_node
, "complex float");
1364 NAME_TYPE (complex_double_type_node
, "complex double");
1365 NAME_TYPE (complex_long_double_type_node
, "complex long double");
1366 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
1367 if (int_n_enabled_p
[i
])
1370 sprintf (name
, "__int%d", int_n_data
[i
].bitsize
);
1371 NAME_TYPE (int_n_trees
[i
].signed_type
, name
);
1378 /* Initialize tree structures required by the LTO front end. */
1380 static void lto_init_ts (void)
1382 tree_contains_struct
[NAMESPACE_DECL
][TS_DECL_MINIMAL
] = 1;
1385 #undef LANG_HOOKS_NAME
1386 #define LANG_HOOKS_NAME "GNU GIMPLE"
1387 #undef LANG_HOOKS_OPTION_LANG_MASK
1388 #define LANG_HOOKS_OPTION_LANG_MASK lto_option_lang_mask
1389 #undef LANG_HOOKS_COMPLAIN_WRONG_LANG_P
1390 #define LANG_HOOKS_COMPLAIN_WRONG_LANG_P lto_complain_wrong_lang_p
1391 #undef LANG_HOOKS_INIT_OPTIONS_STRUCT
1392 #define LANG_HOOKS_INIT_OPTIONS_STRUCT lto_init_options_struct
1393 #undef LANG_HOOKS_HANDLE_OPTION
1394 #define LANG_HOOKS_HANDLE_OPTION lto_handle_option
1395 #undef LANG_HOOKS_POST_OPTIONS
1396 #define LANG_HOOKS_POST_OPTIONS lto_post_options
1397 #undef LANG_HOOKS_GET_ALIAS_SET
1398 #define LANG_HOOKS_GET_ALIAS_SET gimple_get_alias_set
1399 #undef LANG_HOOKS_TYPE_FOR_MODE
1400 #define LANG_HOOKS_TYPE_FOR_MODE lto_type_for_mode
1401 #undef LANG_HOOKS_SET_DECL_ASSEMBLER_NAME
1402 #define LANG_HOOKS_SET_DECL_ASSEMBLER_NAME lto_set_decl_assembler_name
1403 #undef LANG_HOOKS_GLOBAL_BINDINGS_P
1404 #define LANG_HOOKS_GLOBAL_BINDINGS_P lto_global_bindings_p
1405 #undef LANG_HOOKS_PUSHDECL
1406 #define LANG_HOOKS_PUSHDECL lto_pushdecl
1407 #undef LANG_HOOKS_GETDECLS
1408 #define LANG_HOOKS_GETDECLS lto_getdecls
1409 #undef LANG_HOOKS_REGISTER_BUILTIN_TYPE
1410 #define LANG_HOOKS_REGISTER_BUILTIN_TYPE lto_register_builtin_type
1411 #undef LANG_HOOKS_BUILTIN_FUNCTION
1412 #define LANG_HOOKS_BUILTIN_FUNCTION lto_builtin_function
1413 #undef LANG_HOOKS_INIT
1414 #define LANG_HOOKS_INIT lto_init
1415 #undef LANG_HOOKS_PARSE_FILE
1416 #define LANG_HOOKS_PARSE_FILE lto_main
1417 #undef LANG_HOOKS_REDUCE_BIT_FIELD_OPERATIONS
1418 #define LANG_HOOKS_REDUCE_BIT_FIELD_OPERATIONS true
1419 #undef LANG_HOOKS_TYPES_COMPATIBLE_P
1420 #define LANG_HOOKS_TYPES_COMPATIBLE_P NULL
1421 #undef LANG_HOOKS_EH_PERSONALITY
1422 #define LANG_HOOKS_EH_PERSONALITY lto_eh_personality
1424 /* Attribute hooks. */
1425 #undef LANG_HOOKS_COMMON_ATTRIBUTE_TABLE
1426 #define LANG_HOOKS_COMMON_ATTRIBUTE_TABLE lto_attribute_table
1427 #undef LANG_HOOKS_FORMAT_ATTRIBUTE_TABLE
1428 #define LANG_HOOKS_FORMAT_ATTRIBUTE_TABLE lto_format_attribute_table
1430 #undef LANG_HOOKS_BEGIN_SECTION
1431 #define LANG_HOOKS_BEGIN_SECTION lto_obj_begin_section
1432 #undef LANG_HOOKS_APPEND_DATA
1433 #define LANG_HOOKS_APPEND_DATA lto_obj_append_data
1434 #undef LANG_HOOKS_END_SECTION
1435 #define LANG_HOOKS_END_SECTION lto_obj_end_section
1437 #undef LANG_HOOKS_INIT_TS
1438 #define LANG_HOOKS_INIT_TS lto_init_ts
1440 struct lang_hooks lang_hooks
= LANG_HOOKS_INITIALIZER
;
1442 /* Language hooks that are not part of lang_hooks. */
1445 convert (tree type ATTRIBUTE_UNUSED
, tree expr ATTRIBUTE_UNUSED
)
1450 /* Tree walking support. */
1452 static enum lto_tree_node_structure_enum
1453 lto_tree_node_structure (union lang_tree_node
*t ATTRIBUTE_UNUSED
)
1455 return TS_LTO_GENERIC
;
1458 #include "gtype-lto.h"
1459 #include "gt-lto-lto-lang.h"