PR middle-end/50199
[official-gcc.git] / gcc / lto / lto-lang.c
blobfccb8c61f8f30a02347dcced088e7db46e864bfd
1 /* Language-dependent hooks for LTO.
2 Copyright (C) 2009-2017 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
10 version.
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
21 #include "config.h"
22 #include "system.h"
23 #include "coretypes.h"
24 #include "target.h"
25 #include "function.h"
26 #include "basic-block.h"
27 #include "tree.h"
28 #include "gimple.h"
29 #include "stringpool.h"
30 #include "diagnostic-core.h"
31 #include "stor-layout.h"
32 #include "langhooks.h"
33 #include "langhooks-def.h"
34 #include "debug.h"
35 #include "lto-tree.h"
36 #include "lto.h"
37 #include "cilk.h"
39 static tree lto_type_for_size (unsigned, int);
41 static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
42 static tree handle_leaf_attribute (tree *, tree, tree, int, bool *);
43 static tree handle_const_attribute (tree *, tree, tree, int, bool *);
44 static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);
45 static tree handle_pure_attribute (tree *, tree, tree, int, bool *);
46 static tree handle_novops_attribute (tree *, tree, tree, int, bool *);
47 static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
48 static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
49 static tree handle_sentinel_attribute (tree *, tree, tree, int, bool *);
50 static tree handle_type_generic_attribute (tree *, tree, tree, int, bool *);
51 static tree handle_transaction_pure_attribute (tree *, tree, tree, int, bool *);
52 static tree handle_returns_twice_attribute (tree *, tree, tree, int, bool *);
53 static tree ignore_attribute (tree *, tree, tree, int, bool *);
55 static tree handle_format_attribute (tree *, tree, tree, int, bool *);
56 static tree handle_fnspec_attribute (tree *, tree, tree, int, bool *);
57 static tree handle_format_arg_attribute (tree *, tree, tree, int, bool *);
59 /* Table of machine-independent attributes supported in GIMPLE. */
60 const struct attribute_spec lto_attribute_table[] =
62 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler,
63 do_diagnostic } */
64 { "noreturn", 0, 0, true, false, false,
65 handle_noreturn_attribute, false },
66 { "leaf", 0, 0, true, false, false,
67 handle_leaf_attribute, false },
68 /* The same comments as for noreturn attributes apply to const ones. */
69 { "const", 0, 0, true, false, false,
70 handle_const_attribute, false },
71 { "malloc", 0, 0, true, false, false,
72 handle_malloc_attribute, false },
73 { "pure", 0, 0, true, false, false,
74 handle_pure_attribute, false },
75 { "no vops", 0, 0, true, false, false,
76 handle_novops_attribute, false },
77 { "nonnull", 0, -1, false, true, true,
78 handle_nonnull_attribute, false },
79 { "nothrow", 0, 0, true, false, false,
80 handle_nothrow_attribute, false },
81 { "returns_twice", 0, 0, true, false, false,
82 handle_returns_twice_attribute, false },
83 { "sentinel", 0, 1, false, true, true,
84 handle_sentinel_attribute, false },
85 { "type generic", 0, 0, false, true, true,
86 handle_type_generic_attribute, false },
87 { "fn spec", 1, 1, false, true, true,
88 handle_fnspec_attribute, false },
89 { "transaction_pure", 0, 0, false, true, true,
90 handle_transaction_pure_attribute, false },
91 /* For internal use only. The leading '*' both prevents its usage in
92 source code and signals that it may be overridden by machine tables. */
93 { "*tm regparm", 0, 0, false, true, true,
94 ignore_attribute, false },
95 { NULL, 0, 0, false, false, false, NULL, false }
98 /* Give the specifications for the format attributes, used by C and all
99 descendants. */
101 const struct attribute_spec lto_format_attribute_table[] =
103 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler,
104 affects_type_identity } */
105 { "format", 3, 3, false, true, true,
106 handle_format_attribute, false },
107 { "format_arg", 1, 1, false, true, true,
108 handle_format_arg_attribute, false },
109 { NULL, 0, 0, false, false, false, NULL, false }
112 enum built_in_attribute
114 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
115 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
116 #define DEF_ATTR_STRING(ENUM, VALUE) ENUM,
117 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
118 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
119 #include "builtin-attrs.def"
120 #undef DEF_ATTR_NULL_TREE
121 #undef DEF_ATTR_INT
122 #undef DEF_ATTR_STRING
123 #undef DEF_ATTR_IDENT
124 #undef DEF_ATTR_TREE_LIST
125 ATTR_LAST
128 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
130 /* Builtin types. */
132 enum lto_builtin_type
134 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
135 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
136 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
137 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
138 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
139 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
140 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
141 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
142 ARG6) NAME,
143 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
144 ARG6, ARG7) NAME,
145 #define DEF_FUNCTION_TYPE_8(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
146 ARG6, ARG7, ARG8) NAME,
147 #define DEF_FUNCTION_TYPE_9(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
148 ARG6, ARG7, ARG8, ARG9) NAME,
149 #define DEF_FUNCTION_TYPE_10(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
150 ARG6, ARG7, ARG8, ARG9, ARG10) NAME,
151 #define DEF_FUNCTION_TYPE_11(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
152 ARG6, ARG7, ARG8, ARG9, ARG10, ARG11) NAME,
153 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
154 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
155 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
156 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
157 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
158 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
159 NAME,
160 #define DEF_FUNCTION_TYPE_VAR_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
161 ARG6) NAME,
162 #define DEF_FUNCTION_TYPE_VAR_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
163 ARG6, ARG7) NAME,
164 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
165 #include "builtin-types.def"
166 #undef DEF_PRIMITIVE_TYPE
167 #undef DEF_FUNCTION_TYPE_0
168 #undef DEF_FUNCTION_TYPE_1
169 #undef DEF_FUNCTION_TYPE_2
170 #undef DEF_FUNCTION_TYPE_3
171 #undef DEF_FUNCTION_TYPE_4
172 #undef DEF_FUNCTION_TYPE_5
173 #undef DEF_FUNCTION_TYPE_6
174 #undef DEF_FUNCTION_TYPE_7
175 #undef DEF_FUNCTION_TYPE_8
176 #undef DEF_FUNCTION_TYPE_9
177 #undef DEF_FUNCTION_TYPE_10
178 #undef DEF_FUNCTION_TYPE_11
179 #undef DEF_FUNCTION_TYPE_VAR_0
180 #undef DEF_FUNCTION_TYPE_VAR_1
181 #undef DEF_FUNCTION_TYPE_VAR_2
182 #undef DEF_FUNCTION_TYPE_VAR_3
183 #undef DEF_FUNCTION_TYPE_VAR_4
184 #undef DEF_FUNCTION_TYPE_VAR_5
185 #undef DEF_FUNCTION_TYPE_VAR_6
186 #undef DEF_FUNCTION_TYPE_VAR_7
187 #undef DEF_POINTER_TYPE
188 BT_LAST
191 typedef enum lto_builtin_type builtin_type;
193 static GTY(()) tree builtin_types[(int) BT_LAST + 1];
195 static GTY(()) tree string_type_node;
196 static GTY(()) tree const_string_type_node;
197 static GTY(()) tree wint_type_node;
198 static GTY(()) tree intmax_type_node;
199 static GTY(()) tree uintmax_type_node;
200 static GTY(()) tree signed_size_type_node;
202 /* Flags needed to process builtins.def. */
203 int flag_isoc94;
204 int flag_isoc99;
205 int flag_isoc11;
207 /* Attribute handlers. */
209 /* Handle a "noreturn" attribute; arguments as in
210 struct attribute_spec.handler. */
212 static tree
213 handle_noreturn_attribute (tree *node, tree ARG_UNUSED (name),
214 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
215 bool * ARG_UNUSED (no_add_attrs))
217 tree type = TREE_TYPE (*node);
219 if (TREE_CODE (*node) == FUNCTION_DECL)
220 TREE_THIS_VOLATILE (*node) = 1;
221 else if (TREE_CODE (type) == POINTER_TYPE
222 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
223 TREE_TYPE (*node)
224 = build_pointer_type
225 (build_type_variant (TREE_TYPE (type),
226 TYPE_READONLY (TREE_TYPE (type)), 1));
227 else
228 gcc_unreachable ();
230 return NULL_TREE;
233 /* Handle a "leaf" attribute; arguments as in
234 struct attribute_spec.handler. */
236 static tree
237 handle_leaf_attribute (tree *node, tree name,
238 tree ARG_UNUSED (args),
239 int ARG_UNUSED (flags), bool *no_add_attrs)
241 if (TREE_CODE (*node) != FUNCTION_DECL)
243 warning (OPT_Wattributes, "%qE attribute ignored", name);
244 *no_add_attrs = true;
246 if (!TREE_PUBLIC (*node))
248 warning (OPT_Wattributes, "%qE attribute has no effect on unit local functions", name);
249 *no_add_attrs = true;
252 return NULL_TREE;
255 /* Handle a "const" attribute; arguments as in
256 struct attribute_spec.handler. */
258 static tree
259 handle_const_attribute (tree *node, tree ARG_UNUSED (name),
260 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
261 bool * ARG_UNUSED (no_add_attrs))
263 tree type = TREE_TYPE (*node);
265 /* See FIXME comment on noreturn in c_common_attribute_table. */
266 if (TREE_CODE (*node) == FUNCTION_DECL)
267 TREE_READONLY (*node) = 1;
268 else if (TREE_CODE (type) == POINTER_TYPE
269 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
270 TREE_TYPE (*node)
271 = build_pointer_type
272 (build_type_variant (TREE_TYPE (type), 1,
273 TREE_THIS_VOLATILE (TREE_TYPE (type))));
274 else
275 gcc_unreachable ();
277 return NULL_TREE;
281 /* Handle a "malloc" attribute; arguments as in
282 struct attribute_spec.handler. */
284 static tree
285 handle_malloc_attribute (tree *node, tree ARG_UNUSED (name),
286 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
287 bool * ARG_UNUSED (no_add_attrs))
289 if (TREE_CODE (*node) == FUNCTION_DECL
290 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node))))
291 DECL_IS_MALLOC (*node) = 1;
292 else
293 gcc_unreachable ();
295 return NULL_TREE;
299 /* Handle a "pure" attribute; arguments as in
300 struct attribute_spec.handler. */
302 static tree
303 handle_pure_attribute (tree *node, tree ARG_UNUSED (name),
304 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
305 bool * ARG_UNUSED (no_add_attrs))
307 if (TREE_CODE (*node) == FUNCTION_DECL)
308 DECL_PURE_P (*node) = 1;
309 else
310 gcc_unreachable ();
312 return NULL_TREE;
316 /* Handle a "no vops" attribute; arguments as in
317 struct attribute_spec.handler. */
319 static tree
320 handle_novops_attribute (tree *node, tree ARG_UNUSED (name),
321 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
322 bool *ARG_UNUSED (no_add_attrs))
324 gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
325 DECL_IS_NOVOPS (*node) = 1;
326 return NULL_TREE;
330 /* Helper for nonnull attribute handling; fetch the operand number
331 from the attribute argument list. */
333 static bool
334 get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
336 /* Verify the arg number is a constant. */
337 if (!tree_fits_uhwi_p (arg_num_expr))
338 return false;
340 *valp = TREE_INT_CST_LOW (arg_num_expr);
341 return true;
344 /* Handle the "nonnull" attribute. */
346 static tree
347 handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
348 tree args, int ARG_UNUSED (flags),
349 bool * ARG_UNUSED (no_add_attrs))
351 tree type = *node;
353 /* If no arguments are specified, all pointer arguments should be
354 non-null. Verify a full prototype is given so that the arguments
355 will have the correct types when we actually check them later.
356 Avoid diagnosing type-generic built-ins since those have no
357 prototype. */
358 if (!args)
360 gcc_assert (prototype_p (type)
361 || !TYPE_ATTRIBUTES (type)
362 || lookup_attribute ("type generic", TYPE_ATTRIBUTES (type)));
364 return NULL_TREE;
367 /* Argument list specified. Verify that each argument number references
368 a pointer argument. */
369 for (; args; args = TREE_CHAIN (args))
371 tree argument;
372 unsigned HOST_WIDE_INT arg_num = 0, ck_num;
374 if (!get_nonnull_operand (TREE_VALUE (args), &arg_num))
375 gcc_unreachable ();
377 argument = TYPE_ARG_TYPES (type);
378 if (argument)
380 for (ck_num = 1; ; ck_num++)
382 if (!argument || ck_num == arg_num)
383 break;
384 argument = TREE_CHAIN (argument);
387 gcc_assert (argument
388 && TREE_CODE (TREE_VALUE (argument)) == POINTER_TYPE);
392 return NULL_TREE;
396 /* Handle a "nothrow" attribute; arguments as in
397 struct attribute_spec.handler. */
399 static tree
400 handle_nothrow_attribute (tree *node, tree ARG_UNUSED (name),
401 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
402 bool * ARG_UNUSED (no_add_attrs))
404 if (TREE_CODE (*node) == FUNCTION_DECL)
405 TREE_NOTHROW (*node) = 1;
406 else
407 gcc_unreachable ();
409 return NULL_TREE;
413 /* Handle a "sentinel" attribute. */
415 static tree
416 handle_sentinel_attribute (tree *node, tree ARG_UNUSED (name), tree args,
417 int ARG_UNUSED (flags),
418 bool * ARG_UNUSED (no_add_attrs))
420 gcc_assert (stdarg_p (*node));
422 if (args)
424 tree position = TREE_VALUE (args);
425 gcc_assert (TREE_CODE (position) == INTEGER_CST);
426 if (tree_int_cst_lt (position, integer_zero_node))
427 gcc_unreachable ();
430 return NULL_TREE;
433 /* Handle a "type_generic" attribute. */
435 static tree
436 handle_type_generic_attribute (tree *node, tree ARG_UNUSED (name),
437 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
438 bool * ARG_UNUSED (no_add_attrs))
440 /* Ensure we have a function type. */
441 gcc_assert (TREE_CODE (*node) == FUNCTION_TYPE);
443 /* Ensure we have a variadic function. */
444 gcc_assert (!prototype_p (*node) || stdarg_p (*node));
446 return NULL_TREE;
449 /* Handle a "transaction_pure" attribute. */
451 static tree
452 handle_transaction_pure_attribute (tree *node, tree ARG_UNUSED (name),
453 tree ARG_UNUSED (args),
454 int ARG_UNUSED (flags),
455 bool * ARG_UNUSED (no_add_attrs))
457 /* Ensure we have a function type. */
458 gcc_assert (TREE_CODE (*node) == FUNCTION_TYPE);
460 return NULL_TREE;
463 /* Handle a "returns_twice" attribute. */
465 static tree
466 handle_returns_twice_attribute (tree *node, tree ARG_UNUSED (name),
467 tree ARG_UNUSED (args),
468 int ARG_UNUSED (flags),
469 bool * ARG_UNUSED (no_add_attrs))
471 gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
473 DECL_IS_RETURNS_TWICE (*node) = 1;
475 return NULL_TREE;
478 /* Ignore the given attribute. Used when this attribute may be usefully
479 overridden by the target, but is not used generically. */
481 static tree
482 ignore_attribute (tree * ARG_UNUSED (node), tree ARG_UNUSED (name),
483 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
484 bool *no_add_attrs)
486 *no_add_attrs = true;
487 return NULL_TREE;
490 /* Handle a "format" attribute; arguments as in
491 struct attribute_spec.handler. */
493 static tree
494 handle_format_attribute (tree * ARG_UNUSED (node), tree ARG_UNUSED (name),
495 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
496 bool *no_add_attrs)
498 *no_add_attrs = true;
499 return NULL_TREE;
503 /* Handle a "format_arg" attribute; arguments as in
504 struct attribute_spec.handler. */
506 tree
507 handle_format_arg_attribute (tree * ARG_UNUSED (node), tree ARG_UNUSED (name),
508 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
509 bool *no_add_attrs)
511 *no_add_attrs = true;
512 return NULL_TREE;
516 /* Handle a "fn spec" attribute; arguments as in
517 struct attribute_spec.handler. */
519 static tree
520 handle_fnspec_attribute (tree *node ATTRIBUTE_UNUSED, tree ARG_UNUSED (name),
521 tree args, int ARG_UNUSED (flags),
522 bool *no_add_attrs ATTRIBUTE_UNUSED)
524 gcc_assert (args
525 && TREE_CODE (TREE_VALUE (args)) == STRING_CST
526 && !TREE_CHAIN (args));
527 return NULL_TREE;
530 /* Cribbed from c-common.c. */
532 static void
533 def_fn_type (builtin_type def, builtin_type ret, bool var, int n, ...)
535 tree t;
536 tree *args = XALLOCAVEC (tree, n);
537 va_list list;
538 int i;
539 bool err = false;
541 va_start (list, n);
542 for (i = 0; i < n; ++i)
544 builtin_type a = (builtin_type) va_arg (list, int);
545 t = builtin_types[a];
546 if (t == error_mark_node)
547 err = true;
548 args[i] = t;
550 va_end (list);
552 t = builtin_types[ret];
553 if (err)
554 t = error_mark_node;
555 if (t == error_mark_node)
557 else if (var)
558 t = build_varargs_function_type_array (t, n, args);
559 else
560 t = build_function_type_array (t, n, args);
562 builtin_types[def] = t;
565 /* Used to help initialize the builtin-types.def table. When a type of
566 the correct size doesn't exist, use error_mark_node instead of NULL.
567 The later results in segfaults even when a decl using the type doesn't
568 get invoked. */
570 static tree
571 builtin_type_for_size (int size, bool unsignedp)
573 tree type = lto_type_for_size (size, unsignedp);
574 return type ? type : error_mark_node;
577 /* Support for DEF_BUILTIN. */
579 static void
580 def_builtin_1 (enum built_in_function fncode, const char *name,
581 enum built_in_class fnclass, tree fntype, tree libtype,
582 bool both_p, bool fallback_p, bool nonansi_p,
583 tree fnattrs, bool implicit_p)
585 tree decl;
586 const char *libname;
588 if (fntype == error_mark_node)
589 return;
591 libname = name + strlen ("__builtin_");
592 decl = add_builtin_function (name, fntype, fncode, fnclass,
593 (fallback_p ? libname : NULL),
594 fnattrs);
596 if (both_p
597 && !flag_no_builtin
598 && !(nonansi_p && flag_no_nonansi_builtin))
599 add_builtin_function (libname, libtype, fncode, fnclass,
600 NULL, fnattrs);
602 set_builtin_decl (fncode, decl, implicit_p);
606 /* Initialize the attribute table for all the supported builtins. */
608 static void
609 lto_init_attributes (void)
611 /* Fill in the built_in_attributes array. */
612 #define DEF_ATTR_NULL_TREE(ENUM) \
613 built_in_attributes[(int) ENUM] = NULL_TREE;
614 #define DEF_ATTR_INT(ENUM, VALUE) \
615 built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
616 #define DEF_ATTR_STRING(ENUM, VALUE) \
617 built_in_attributes[(int) ENUM] = build_string (strlen (VALUE), VALUE);
618 #define DEF_ATTR_IDENT(ENUM, STRING) \
619 built_in_attributes[(int) ENUM] = get_identifier (STRING);
620 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
621 built_in_attributes[(int) ENUM] \
622 = tree_cons (built_in_attributes[(int) PURPOSE], \
623 built_in_attributes[(int) VALUE], \
624 built_in_attributes[(int) CHAIN]);
625 #include "builtin-attrs.def"
626 #undef DEF_ATTR_NULL_TREE
627 #undef DEF_ATTR_INT
628 #undef DEF_ATTR_STRING
629 #undef DEF_ATTR_IDENT
630 #undef DEF_ATTR_TREE_LIST
633 /* Create builtin types and functions. VA_LIST_REF_TYPE_NODE and
634 VA_LIST_ARG_TYPE_NODE are used in builtin-types.def. */
636 static void
637 lto_define_builtins (tree va_list_ref_type_node ATTRIBUTE_UNUSED,
638 tree va_list_arg_type_node ATTRIBUTE_UNUSED)
640 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
641 builtin_types[ENUM] = VALUE;
642 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
643 def_fn_type (ENUM, RETURN, 0, 0);
644 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
645 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
646 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
647 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
648 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
649 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
650 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
651 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
652 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
653 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
654 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
655 ARG6) \
656 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
657 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
658 ARG6, ARG7) \
659 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
660 #define DEF_FUNCTION_TYPE_8(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
661 ARG6, ARG7, ARG8) \
662 def_fn_type (ENUM, RETURN, 0, 8, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, \
663 ARG7, ARG8);
664 #define DEF_FUNCTION_TYPE_9(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
665 ARG6, ARG7, ARG8, ARG9) \
666 def_fn_type (ENUM, RETURN, 0, 9, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, \
667 ARG7, ARG8, ARG9);
668 #define DEF_FUNCTION_TYPE_10(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
669 ARG6, ARG7, ARG8, ARG9, ARG10) \
670 def_fn_type (ENUM, RETURN, 0, 10, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, \
671 ARG7, ARG8, ARG9, ARG10);
672 #define DEF_FUNCTION_TYPE_11(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
673 ARG6, ARG7, ARG8, ARG9, ARG10, ARG11) \
674 def_fn_type (ENUM, RETURN, 0, 11, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, \
675 ARG7, ARG8, ARG9, ARG10, ARG11);
676 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
677 def_fn_type (ENUM, RETURN, 1, 0);
678 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
679 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
680 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
681 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
682 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
683 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
684 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
685 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
686 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
687 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
688 #define DEF_FUNCTION_TYPE_VAR_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
689 ARG6) \
690 def_fn_type (ENUM, RETURN, 1, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
691 #define DEF_FUNCTION_TYPE_VAR_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
692 ARG6, ARG7) \
693 def_fn_type (ENUM, RETURN, 1, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
694 #define DEF_POINTER_TYPE(ENUM, TYPE) \
695 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
697 #include "builtin-types.def"
699 #undef DEF_PRIMITIVE_TYPE
700 #undef DEF_FUNCTION_TYPE_0
701 #undef DEF_FUNCTION_TYPE_1
702 #undef DEF_FUNCTION_TYPE_2
703 #undef DEF_FUNCTION_TYPE_3
704 #undef DEF_FUNCTION_TYPE_4
705 #undef DEF_FUNCTION_TYPE_5
706 #undef DEF_FUNCTION_TYPE_6
707 #undef DEF_FUNCTION_TYPE_7
708 #undef DEF_FUNCTION_TYPE_8
709 #undef DEF_FUNCTION_TYPE_9
710 #undef DEF_FUNCTION_TYPE_10
711 #undef DEF_FUNCTION_TYPE_11
712 #undef DEF_FUNCTION_TYPE_VAR_0
713 #undef DEF_FUNCTION_TYPE_VAR_1
714 #undef DEF_FUNCTION_TYPE_VAR_2
715 #undef DEF_FUNCTION_TYPE_VAR_3
716 #undef DEF_FUNCTION_TYPE_VAR_4
717 #undef DEF_FUNCTION_TYPE_VAR_5
718 #undef DEF_FUNCTION_TYPE_VAR_6
719 #undef DEF_FUNCTION_TYPE_VAR_7
720 #undef DEF_POINTER_TYPE
721 builtin_types[(int) BT_LAST] = NULL_TREE;
723 lto_init_attributes ();
725 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P,\
726 NONANSI_P, ATTRS, IMPLICIT, COND) \
727 if (NAME && COND) \
728 def_builtin_1 (ENUM, NAME, CLASS, builtin_types[(int) TYPE], \
729 builtin_types[(int) LIBTYPE], BOTH_P, FALLBACK_P, \
730 NONANSI_P, built_in_attributes[(int) ATTRS], IMPLICIT);
731 #include "builtins.def"
734 static GTY(()) tree registered_builtin_types;
736 /* Language hooks. */
738 static unsigned int
739 lto_option_lang_mask (void)
741 return CL_LTO;
744 static bool
745 lto_complain_wrong_lang_p (const struct cl_option *option ATTRIBUTE_UNUSED)
747 /* The LTO front end inherits all the options from the first front
748 end that was used. However, not all the original front end
749 options make sense in LTO.
751 A real solution would be to filter this in collect2, but collect2
752 does not have access to all the option attributes to know what to
753 filter. So, in lto1 we silently accept inherited flags and do
754 nothing about it. */
755 return false;
758 static void
759 lto_init_options_struct (struct gcc_options *opts)
761 /* By default, C99-like requirements for complex multiply and divide.
762 ??? Until the complex method is encoded in the IL this is the only
763 safe choice. This will pessimize Fortran code with LTO unless
764 people specify a complex method manually or use -ffast-math. */
765 opts->x_flag_complex_method = 2;
768 /* Handle command-line option SCODE. If the option takes an argument, it is
769 stored in ARG, which is otherwise NULL. VALUE holds either a numerical
770 argument or a binary value indicating whether the positive or negative form
771 of the option was supplied. */
773 const char *resolution_file_name;
774 static bool
775 lto_handle_option (size_t scode, const char *arg,
776 int value ATTRIBUTE_UNUSED, int kind ATTRIBUTE_UNUSED,
777 location_t loc ATTRIBUTE_UNUSED,
778 const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED)
780 enum opt_code code = (enum opt_code) scode;
781 bool result = true;
783 switch (code)
785 case OPT_fresolution_:
786 resolution_file_name = arg;
787 break;
789 case OPT_Wabi:
790 warn_psabi = value;
791 break;
793 case OPT_fwpa:
794 flag_wpa = value ? "" : NULL;
795 break;
797 default:
798 break;
801 return result;
804 /* Perform post-option processing. Does additional initialization based on
805 command-line options. PFILENAME is the main input filename. Returns false
806 to enable subsequent back-end initialization. */
808 static bool
809 lto_post_options (const char **pfilename ATTRIBUTE_UNUSED)
811 /* -fltrans and -fwpa are mutually exclusive. Check for that here. */
812 if (flag_wpa && flag_ltrans)
813 error ("-fwpa and -fltrans are mutually exclusive");
815 if (flag_ltrans)
817 flag_generate_lto = 0;
819 /* During LTRANS, we are not looking at the whole program, only
820 a subset of the whole callgraph. */
821 flag_whole_program = 0;
824 if (flag_wpa)
825 flag_generate_lto = 1;
827 /* Initialize the codegen flags according to the output type. */
828 switch (flag_lto_linker_output)
830 case LTO_LINKER_OUTPUT_REL: /* .o: incremental link producing LTO IL */
831 flag_whole_program = 0;
832 flag_incremental_link = 1;
833 break;
835 case LTO_LINKER_OUTPUT_DYN: /* .so: PID library */
836 /* On some targets, like i386 it makes sense to build PIC library wihout
837 -fpic for performance reasons. So no need to adjust flags. */
838 break;
840 case LTO_LINKER_OUTPUT_PIE: /* PIE binary */
841 /* If -fPIC or -fPIE was used at compile time, be sure that
842 flag_pie is 2. */
843 flag_pie = MAX (flag_pie, flag_pic);
844 flag_pic = flag_pie;
845 break;
847 case LTO_LINKER_OUTPUT_EXEC: /* Normal executable */
848 flag_pic = 0;
849 flag_pie = 0;
850 break;
852 case LTO_LINKER_OUTPUT_UNKNOWN:
853 break;
856 /* Excess precision other than "fast" requires front-end
857 support. */
858 flag_excess_precision_cmdline = EXCESS_PRECISION_FAST;
860 /* When partitioning, we can tear appart STRING_CSTs uses from the same
861 TU into multiple partitions. Without constant merging the constants
862 might not be equal at runtime. See PR50199. */
863 if (!flag_merge_constants)
864 flag_merge_constants = 1;
866 /* Initialize the compiler back end. */
867 return false;
870 /* Return an integer type with PRECISION bits of precision,
871 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
873 static tree
874 lto_type_for_size (unsigned precision, int unsignedp)
876 int i;
878 if (precision == TYPE_PRECISION (integer_type_node))
879 return unsignedp ? unsigned_type_node : integer_type_node;
881 if (precision == TYPE_PRECISION (signed_char_type_node))
882 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
884 if (precision == TYPE_PRECISION (short_integer_type_node))
885 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
887 if (precision == TYPE_PRECISION (long_integer_type_node))
888 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
890 if (precision == TYPE_PRECISION (long_long_integer_type_node))
891 return unsignedp
892 ? long_long_unsigned_type_node
893 : long_long_integer_type_node;
895 for (i = 0; i < NUM_INT_N_ENTS; i ++)
896 if (int_n_enabled_p[i]
897 && precision == int_n_data[i].bitsize)
898 return (unsignedp ? int_n_trees[i].unsigned_type
899 : int_n_trees[i].signed_type);
901 if (precision <= TYPE_PRECISION (intQI_type_node))
902 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
904 if (precision <= TYPE_PRECISION (intHI_type_node))
905 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
907 if (precision <= TYPE_PRECISION (intSI_type_node))
908 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
910 if (precision <= TYPE_PRECISION (intDI_type_node))
911 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
913 if (precision <= TYPE_PRECISION (intTI_type_node))
914 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
916 return NULL_TREE;
920 /* Return a data type that has machine mode MODE.
921 If the mode is an integer,
922 then UNSIGNEDP selects between signed and unsigned types.
923 If the mode is a fixed-point mode,
924 then UNSIGNEDP selects between saturating and nonsaturating types. */
926 static tree
927 lto_type_for_mode (machine_mode mode, int unsigned_p)
929 tree t;
930 int i;
932 if (mode == TYPE_MODE (integer_type_node))
933 return unsigned_p ? unsigned_type_node : integer_type_node;
935 if (mode == TYPE_MODE (signed_char_type_node))
936 return unsigned_p ? unsigned_char_type_node : signed_char_type_node;
938 if (mode == TYPE_MODE (short_integer_type_node))
939 return unsigned_p ? short_unsigned_type_node : short_integer_type_node;
941 if (mode == TYPE_MODE (long_integer_type_node))
942 return unsigned_p ? long_unsigned_type_node : long_integer_type_node;
944 if (mode == TYPE_MODE (long_long_integer_type_node))
945 return unsigned_p ? long_long_unsigned_type_node : long_long_integer_type_node;
947 for (i = 0; i < NUM_INT_N_ENTS; i ++)
948 if (int_n_enabled_p[i]
949 && mode == int_n_data[i].m)
950 return (unsigned_p ? int_n_trees[i].unsigned_type
951 : int_n_trees[i].signed_type);
953 if (mode == QImode)
954 return unsigned_p ? unsigned_intQI_type_node : intQI_type_node;
956 if (mode == HImode)
957 return unsigned_p ? unsigned_intHI_type_node : intHI_type_node;
959 if (mode == SImode)
960 return unsigned_p ? unsigned_intSI_type_node : intSI_type_node;
962 if (mode == DImode)
963 return unsigned_p ? unsigned_intDI_type_node : intDI_type_node;
965 #if HOST_BITS_PER_WIDE_INT >= 64
966 if (mode == TYPE_MODE (intTI_type_node))
967 return unsigned_p ? unsigned_intTI_type_node : intTI_type_node;
968 #endif
970 if (mode == TYPE_MODE (float_type_node))
971 return float_type_node;
973 if (mode == TYPE_MODE (double_type_node))
974 return double_type_node;
976 if (mode == TYPE_MODE (long_double_type_node))
977 return long_double_type_node;
979 if (mode == TYPE_MODE (void_type_node))
980 return void_type_node;
982 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
983 return (unsigned_p
984 ? make_unsigned_type (GET_MODE_PRECISION (mode))
985 : make_signed_type (GET_MODE_PRECISION (mode)));
987 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
988 return (unsigned_p
989 ? make_unsigned_type (GET_MODE_PRECISION (mode))
990 : make_signed_type (GET_MODE_PRECISION (mode)));
992 if (COMPLEX_MODE_P (mode))
994 machine_mode inner_mode;
995 tree inner_type;
997 if (mode == TYPE_MODE (complex_float_type_node))
998 return complex_float_type_node;
999 if (mode == TYPE_MODE (complex_double_type_node))
1000 return complex_double_type_node;
1001 if (mode == TYPE_MODE (complex_long_double_type_node))
1002 return complex_long_double_type_node;
1004 if (mode == TYPE_MODE (complex_integer_type_node) && !unsigned_p)
1005 return complex_integer_type_node;
1007 inner_mode = GET_MODE_INNER (mode);
1008 inner_type = lto_type_for_mode (inner_mode, unsigned_p);
1009 if (inner_type != NULL_TREE)
1010 return build_complex_type (inner_type);
1012 else if (VECTOR_MODE_P (mode))
1014 machine_mode inner_mode = GET_MODE_INNER (mode);
1015 tree inner_type = lto_type_for_mode (inner_mode, unsigned_p);
1016 if (inner_type != NULL_TREE)
1017 return build_vector_type_for_mode (inner_type, mode);
1020 if (mode == TYPE_MODE (dfloat32_type_node))
1021 return dfloat32_type_node;
1022 if (mode == TYPE_MODE (dfloat64_type_node))
1023 return dfloat64_type_node;
1024 if (mode == TYPE_MODE (dfloat128_type_node))
1025 return dfloat128_type_node;
1027 if (ALL_SCALAR_FIXED_POINT_MODE_P (mode))
1029 if (mode == TYPE_MODE (short_fract_type_node))
1030 return unsigned_p ? sat_short_fract_type_node : short_fract_type_node;
1031 if (mode == TYPE_MODE (fract_type_node))
1032 return unsigned_p ? sat_fract_type_node : fract_type_node;
1033 if (mode == TYPE_MODE (long_fract_type_node))
1034 return unsigned_p ? sat_long_fract_type_node : long_fract_type_node;
1035 if (mode == TYPE_MODE (long_long_fract_type_node))
1036 return unsigned_p ? sat_long_long_fract_type_node
1037 : long_long_fract_type_node;
1039 if (mode == TYPE_MODE (unsigned_short_fract_type_node))
1040 return unsigned_p ? sat_unsigned_short_fract_type_node
1041 : unsigned_short_fract_type_node;
1042 if (mode == TYPE_MODE (unsigned_fract_type_node))
1043 return unsigned_p ? sat_unsigned_fract_type_node
1044 : unsigned_fract_type_node;
1045 if (mode == TYPE_MODE (unsigned_long_fract_type_node))
1046 return unsigned_p ? sat_unsigned_long_fract_type_node
1047 : unsigned_long_fract_type_node;
1048 if (mode == TYPE_MODE (unsigned_long_long_fract_type_node))
1049 return unsigned_p ? sat_unsigned_long_long_fract_type_node
1050 : unsigned_long_long_fract_type_node;
1052 if (mode == TYPE_MODE (short_accum_type_node))
1053 return unsigned_p ? sat_short_accum_type_node : short_accum_type_node;
1054 if (mode == TYPE_MODE (accum_type_node))
1055 return unsigned_p ? sat_accum_type_node : accum_type_node;
1056 if (mode == TYPE_MODE (long_accum_type_node))
1057 return unsigned_p ? sat_long_accum_type_node : long_accum_type_node;
1058 if (mode == TYPE_MODE (long_long_accum_type_node))
1059 return unsigned_p ? sat_long_long_accum_type_node
1060 : long_long_accum_type_node;
1062 if (mode == TYPE_MODE (unsigned_short_accum_type_node))
1063 return unsigned_p ? sat_unsigned_short_accum_type_node
1064 : unsigned_short_accum_type_node;
1065 if (mode == TYPE_MODE (unsigned_accum_type_node))
1066 return unsigned_p ? sat_unsigned_accum_type_node
1067 : unsigned_accum_type_node;
1068 if (mode == TYPE_MODE (unsigned_long_accum_type_node))
1069 return unsigned_p ? sat_unsigned_long_accum_type_node
1070 : unsigned_long_accum_type_node;
1071 if (mode == TYPE_MODE (unsigned_long_long_accum_type_node))
1072 return unsigned_p ? sat_unsigned_long_long_accum_type_node
1073 : unsigned_long_long_accum_type_node;
1075 if (mode == QQmode)
1076 return unsigned_p ? sat_qq_type_node : qq_type_node;
1077 if (mode == HQmode)
1078 return unsigned_p ? sat_hq_type_node : hq_type_node;
1079 if (mode == SQmode)
1080 return unsigned_p ? sat_sq_type_node : sq_type_node;
1081 if (mode == DQmode)
1082 return unsigned_p ? sat_dq_type_node : dq_type_node;
1083 if (mode == TQmode)
1084 return unsigned_p ? sat_tq_type_node : tq_type_node;
1086 if (mode == UQQmode)
1087 return unsigned_p ? sat_uqq_type_node : uqq_type_node;
1088 if (mode == UHQmode)
1089 return unsigned_p ? sat_uhq_type_node : uhq_type_node;
1090 if (mode == USQmode)
1091 return unsigned_p ? sat_usq_type_node : usq_type_node;
1092 if (mode == UDQmode)
1093 return unsigned_p ? sat_udq_type_node : udq_type_node;
1094 if (mode == UTQmode)
1095 return unsigned_p ? sat_utq_type_node : utq_type_node;
1097 if (mode == HAmode)
1098 return unsigned_p ? sat_ha_type_node : ha_type_node;
1099 if (mode == SAmode)
1100 return unsigned_p ? sat_sa_type_node : sa_type_node;
1101 if (mode == DAmode)
1102 return unsigned_p ? sat_da_type_node : da_type_node;
1103 if (mode == TAmode)
1104 return unsigned_p ? sat_ta_type_node : ta_type_node;
1106 if (mode == UHAmode)
1107 return unsigned_p ? sat_uha_type_node : uha_type_node;
1108 if (mode == USAmode)
1109 return unsigned_p ? sat_usa_type_node : usa_type_node;
1110 if (mode == UDAmode)
1111 return unsigned_p ? sat_uda_type_node : uda_type_node;
1112 if (mode == UTAmode)
1113 return unsigned_p ? sat_uta_type_node : uta_type_node;
1116 for (t = registered_builtin_types; t; t = TREE_CHAIN (t))
1117 if (TYPE_MODE (TREE_VALUE (t)) == mode)
1118 return TREE_VALUE (t);
1120 return NULL_TREE;
1123 /* Return true if we are in the global binding level. */
1125 static bool
1126 lto_global_bindings_p (void)
1128 return cfun == NULL;
1131 static void
1132 lto_set_decl_assembler_name (tree decl)
1134 /* This is almost the same as lhd_set_decl_assembler_name, except that
1135 we need to uniquify file-scope names, even if they are not
1136 TREE_PUBLIC, to avoid conflicts between individual files. */
1137 tree id;
1139 if (TREE_PUBLIC (decl))
1140 id = targetm.mangle_decl_assembler_name (decl, DECL_NAME (decl));
1141 else
1143 const char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
1144 char *label;
1146 ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
1147 id = get_identifier (label);
1150 SET_DECL_ASSEMBLER_NAME (decl, id);
1153 static tree
1154 lto_pushdecl (tree t ATTRIBUTE_UNUSED)
1156 /* Do nothing, since we get all information from DWARF and LTO
1157 sections. */
1158 return NULL_TREE;
1161 static tree
1162 lto_getdecls (void)
1164 /* We have our own write_globals langhook, hence the getdecls
1165 langhook shouldn't be used, except by dbxout.c, so we can't
1166 just abort here. */
1167 return NULL_TREE;
1170 static tree
1171 lto_builtin_function (tree decl)
1173 return decl;
1176 static void
1177 lto_register_builtin_type (tree type, const char *name)
1179 tree decl;
1181 if (!TYPE_NAME (type))
1183 decl = build_decl (UNKNOWN_LOCATION, TYPE_DECL,
1184 get_identifier (name), type);
1185 DECL_ARTIFICIAL (decl) = 1;
1186 TYPE_NAME (type) = decl;
1189 registered_builtin_types = tree_cons (0, type, registered_builtin_types);
1192 /* Build nodes that would have be created by the C front-end; necessary
1193 for including builtin-types.def and ultimately builtins.def. */
1195 static void
1196 lto_build_c_type_nodes (void)
1198 gcc_assert (void_type_node);
1200 void_list_node = build_tree_list (NULL_TREE, void_type_node);
1201 string_type_node = build_pointer_type (char_type_node);
1202 const_string_type_node
1203 = build_pointer_type (build_qualified_type (char_type_node, TYPE_QUAL_CONST));
1205 if (strcmp (SIZE_TYPE, "unsigned int") == 0)
1207 intmax_type_node = integer_type_node;
1208 uintmax_type_node = unsigned_type_node;
1209 signed_size_type_node = integer_type_node;
1211 else if (strcmp (SIZE_TYPE, "long unsigned int") == 0)
1213 intmax_type_node = long_integer_type_node;
1214 uintmax_type_node = long_unsigned_type_node;
1215 signed_size_type_node = long_integer_type_node;
1217 else if (strcmp (SIZE_TYPE, "long long unsigned int") == 0)
1219 intmax_type_node = long_long_integer_type_node;
1220 uintmax_type_node = long_long_unsigned_type_node;
1221 signed_size_type_node = long_long_integer_type_node;
1223 else
1225 int i;
1227 signed_size_type_node = NULL_TREE;
1228 for (i = 0; i < NUM_INT_N_ENTS; i++)
1229 if (int_n_enabled_p[i])
1231 char name[50];
1232 sprintf (name, "__int%d unsigned", int_n_data[i].bitsize);
1234 if (strcmp (name, SIZE_TYPE) == 0)
1236 intmax_type_node = int_n_trees[i].signed_type;
1237 uintmax_type_node = int_n_trees[i].unsigned_type;
1238 signed_size_type_node = int_n_trees[i].signed_type;
1241 if (signed_size_type_node == NULL_TREE)
1242 gcc_unreachable ();
1245 wint_type_node = unsigned_type_node;
1246 pid_type_node = integer_type_node;
1249 /* Perform LTO-specific initialization. */
1251 static bool
1252 lto_init (void)
1254 int i;
1256 /* We need to generate LTO if running in WPA mode. */
1257 flag_generate_lto = (flag_wpa != NULL);
1259 /* Create the basic integer types. */
1260 build_common_tree_nodes (flag_signed_char);
1262 /* The global tree for the main identifier is filled in by
1263 language-specific front-end initialization that is not run in the
1264 LTO back-end. It appears that all languages that perform such
1265 initialization currently do so in the same way, so we do it here. */
1266 if (main_identifier_node == NULL_TREE)
1267 main_identifier_node = get_identifier ("main");
1269 /* In the C++ front-end, fileptr_type_node is defined as a variant
1270 copy of ptr_type_node, rather than ptr_node itself. The
1271 distinction should only be relevant to the front-end, so we
1272 always use the C definition here in lto1. */
1273 gcc_assert (fileptr_type_node == ptr_type_node);
1274 gcc_assert (TYPE_MAIN_VARIANT (fileptr_type_node) == ptr_type_node);
1275 /* Likewise for const struct tm*. */
1276 gcc_assert (const_tm_ptr_type_node == const_ptr_type_node);
1277 gcc_assert (TYPE_MAIN_VARIANT (const_tm_ptr_type_node)
1278 == const_ptr_type_node);
1280 lto_build_c_type_nodes ();
1281 gcc_assert (va_list_type_node);
1283 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
1285 tree x = build_pointer_type (TREE_TYPE (va_list_type_node));
1286 lto_define_builtins (x, x);
1288 else
1290 lto_define_builtins (build_reference_type (va_list_type_node),
1291 va_list_type_node);
1294 if (flag_cilkplus)
1295 cilk_init_builtins ();
1297 targetm.init_builtins ();
1298 build_common_builtin_nodes ();
1300 /* Assign names to the builtin types, otherwise they'll end up
1301 as __unknown__ in debug info.
1302 ??? We simply need to stop pre-seeding the streamer cache.
1303 Below is modeled after from c-common.c:c_common_nodes_and_builtins */
1304 #define NAME_TYPE(t,n) \
1305 if (t) \
1306 TYPE_NAME (t) = build_decl (UNKNOWN_LOCATION, TYPE_DECL, \
1307 get_identifier (n), t)
1308 NAME_TYPE (integer_type_node, "int");
1309 NAME_TYPE (char_type_node, "char");
1310 NAME_TYPE (long_integer_type_node, "long int");
1311 NAME_TYPE (unsigned_type_node, "unsigned int");
1312 NAME_TYPE (long_unsigned_type_node, "long unsigned int");
1313 NAME_TYPE (long_long_integer_type_node, "long long int");
1314 NAME_TYPE (long_long_unsigned_type_node, "long long unsigned int");
1315 NAME_TYPE (short_integer_type_node, "short int");
1316 NAME_TYPE (short_unsigned_type_node, "short unsigned int");
1317 if (signed_char_type_node != char_type_node)
1318 NAME_TYPE (signed_char_type_node, "signed char");
1319 if (unsigned_char_type_node != char_type_node)
1320 NAME_TYPE (unsigned_char_type_node, "unsigned char");
1321 NAME_TYPE (float_type_node, "float");
1322 NAME_TYPE (double_type_node, "double");
1323 NAME_TYPE (long_double_type_node, "long double");
1324 NAME_TYPE (void_type_node, "void");
1325 NAME_TYPE (boolean_type_node, "bool");
1326 NAME_TYPE (complex_float_type_node, "complex float");
1327 NAME_TYPE (complex_double_type_node, "complex double");
1328 NAME_TYPE (complex_long_double_type_node, "complex long double");
1329 for (i = 0; i < NUM_INT_N_ENTS; i++)
1330 if (int_n_enabled_p[i])
1332 char name[50];
1333 sprintf (name, "__int%d", int_n_data[i].bitsize);
1334 NAME_TYPE (int_n_trees[i].signed_type, name);
1336 #undef NAME_TYPE
1338 /* Initialize LTO-specific data structures. */
1339 in_lto_p = true;
1341 return true;
1344 /* Initialize tree structures required by the LTO front end. */
1346 static void lto_init_ts (void)
1348 tree_contains_struct[NAMESPACE_DECL][TS_DECL_MINIMAL] = 1;
1351 #undef LANG_HOOKS_NAME
1352 #define LANG_HOOKS_NAME "GNU GIMPLE"
1353 #undef LANG_HOOKS_OPTION_LANG_MASK
1354 #define LANG_HOOKS_OPTION_LANG_MASK lto_option_lang_mask
1355 #undef LANG_HOOKS_COMPLAIN_WRONG_LANG_P
1356 #define LANG_HOOKS_COMPLAIN_WRONG_LANG_P lto_complain_wrong_lang_p
1357 #undef LANG_HOOKS_INIT_OPTIONS_STRUCT
1358 #define LANG_HOOKS_INIT_OPTIONS_STRUCT lto_init_options_struct
1359 #undef LANG_HOOKS_HANDLE_OPTION
1360 #define LANG_HOOKS_HANDLE_OPTION lto_handle_option
1361 #undef LANG_HOOKS_POST_OPTIONS
1362 #define LANG_HOOKS_POST_OPTIONS lto_post_options
1363 #undef LANG_HOOKS_GET_ALIAS_SET
1364 #define LANG_HOOKS_GET_ALIAS_SET gimple_get_alias_set
1365 #undef LANG_HOOKS_TYPE_FOR_MODE
1366 #define LANG_HOOKS_TYPE_FOR_MODE lto_type_for_mode
1367 #undef LANG_HOOKS_TYPE_FOR_SIZE
1368 #define LANG_HOOKS_TYPE_FOR_SIZE lto_type_for_size
1369 #undef LANG_HOOKS_SET_DECL_ASSEMBLER_NAME
1370 #define LANG_HOOKS_SET_DECL_ASSEMBLER_NAME lto_set_decl_assembler_name
1371 #undef LANG_HOOKS_GLOBAL_BINDINGS_P
1372 #define LANG_HOOKS_GLOBAL_BINDINGS_P lto_global_bindings_p
1373 #undef LANG_HOOKS_PUSHDECL
1374 #define LANG_HOOKS_PUSHDECL lto_pushdecl
1375 #undef LANG_HOOKS_GETDECLS
1376 #define LANG_HOOKS_GETDECLS lto_getdecls
1377 #undef LANG_HOOKS_REGISTER_BUILTIN_TYPE
1378 #define LANG_HOOKS_REGISTER_BUILTIN_TYPE lto_register_builtin_type
1379 #undef LANG_HOOKS_BUILTIN_FUNCTION
1380 #define LANG_HOOKS_BUILTIN_FUNCTION lto_builtin_function
1381 #undef LANG_HOOKS_INIT
1382 #define LANG_HOOKS_INIT lto_init
1383 #undef LANG_HOOKS_PARSE_FILE
1384 #define LANG_HOOKS_PARSE_FILE lto_main
1385 #undef LANG_HOOKS_REDUCE_BIT_FIELD_OPERATIONS
1386 #define LANG_HOOKS_REDUCE_BIT_FIELD_OPERATIONS true
1387 #undef LANG_HOOKS_TYPES_COMPATIBLE_P
1388 #define LANG_HOOKS_TYPES_COMPATIBLE_P NULL
1389 #undef LANG_HOOKS_EH_PERSONALITY
1390 #define LANG_HOOKS_EH_PERSONALITY lto_eh_personality
1392 /* Attribute hooks. */
1393 #undef LANG_HOOKS_COMMON_ATTRIBUTE_TABLE
1394 #define LANG_HOOKS_COMMON_ATTRIBUTE_TABLE lto_attribute_table
1395 #undef LANG_HOOKS_FORMAT_ATTRIBUTE_TABLE
1396 #define LANG_HOOKS_FORMAT_ATTRIBUTE_TABLE lto_format_attribute_table
1398 #undef LANG_HOOKS_BEGIN_SECTION
1399 #define LANG_HOOKS_BEGIN_SECTION lto_obj_begin_section
1400 #undef LANG_HOOKS_APPEND_DATA
1401 #define LANG_HOOKS_APPEND_DATA lto_obj_append_data
1402 #undef LANG_HOOKS_END_SECTION
1403 #define LANG_HOOKS_END_SECTION lto_obj_end_section
1405 #undef LANG_HOOKS_INIT_TS
1406 #define LANG_HOOKS_INIT_TS lto_init_ts
1408 struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER;
1410 /* Language hooks that are not part of lang_hooks. */
1412 tree
1413 convert (tree type ATTRIBUTE_UNUSED, tree expr ATTRIBUTE_UNUSED)
1415 gcc_unreachable ();
1418 /* Tree walking support. */
1420 static enum lto_tree_node_structure_enum
1421 lto_tree_node_structure (union lang_tree_node *t ATTRIBUTE_UNUSED)
1423 return TS_LTO_GENERIC;
1426 #include "gtype-lto.h"
1427 #include "gt-lto-lto-lang.h"