1 /* Language-dependent hooks for LTO.
2 Copyright 2009 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"
29 #include "langhooks.h"
30 #include "langhooks-def.h"
34 #include "tree-inline.h"
38 static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
39 static tree handle_const_attribute (tree *, tree, tree, int, bool *);
40 static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);
41 static tree handle_pure_attribute (tree *, tree, tree, int, bool *);
42 static tree handle_novops_attribute (tree *, tree, tree, int, bool *);
43 static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
44 static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
45 static tree handle_sentinel_attribute (tree *, tree, tree, int, bool *);
46 static tree handle_type_generic_attribute (tree *, tree, tree, int, bool *);
47 static tree handle_format_attribute (tree *, tree, tree, int, bool *);
48 static tree handle_format_arg_attribute (tree *, tree, tree, int, bool *);
50 /* Table of machine-independent attributes supported in GIMPLE. */
51 const struct attribute_spec lto_attribute_table[] =
53 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
54 { "noreturn", 0, 0, true, false, false,
55 handle_noreturn_attribute },
56 /* The same comments as for noreturn attributes apply to const ones. */
57 { "const", 0, 0, true, false, false,
58 handle_const_attribute },
59 { "malloc", 0, 0, true, false, false,
60 handle_malloc_attribute },
61 { "pure", 0, 0, true, false, false,
62 handle_pure_attribute },
63 { "no vops", 0, 0, true, false, false,
64 handle_novops_attribute },
65 { "nonnull", 0, -1, false, true, true,
66 handle_nonnull_attribute },
67 { "nothrow", 0, 0, true, false, false,
68 handle_nothrow_attribute },
69 { "sentinel", 0, 1, false, true, true,
70 handle_sentinel_attribute },
71 { "type generic", 0, 0, false, true, true,
72 handle_type_generic_attribute },
73 { NULL, 0, 0, false, false, false, NULL }
76 /* Give the specifications for the format attributes, used by C and all
79 const struct attribute_spec lto_format_attribute_table[] =
81 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
82 { "format", 3, 3, false, true, true,
83 handle_format_attribute },
84 { "format_arg", 1, 1, false, true, true,
85 handle_format_arg_attribute },
86 { NULL, 0, 0, false, false, false, NULL }
89 enum built_in_attribute
91 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
92 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
93 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
94 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
95 #include "builtin-attrs.def"
96 #undef DEF_ATTR_NULL_TREE
99 #undef DEF_ATTR_TREE_LIST
103 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
107 enum lto_builtin_type
109 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
110 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
111 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
112 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
113 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
114 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
115 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
116 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME,
117 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME,
118 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
119 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
120 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
121 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
122 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
123 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
125 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
126 #include "builtin-types.def"
127 #undef DEF_PRIMITIVE_TYPE
128 #undef DEF_FUNCTION_TYPE_0
129 #undef DEF_FUNCTION_TYPE_1
130 #undef DEF_FUNCTION_TYPE_2
131 #undef DEF_FUNCTION_TYPE_3
132 #undef DEF_FUNCTION_TYPE_4
133 #undef DEF_FUNCTION_TYPE_5
134 #undef DEF_FUNCTION_TYPE_6
135 #undef DEF_FUNCTION_TYPE_7
136 #undef DEF_FUNCTION_TYPE_VAR_0
137 #undef DEF_FUNCTION_TYPE_VAR_1
138 #undef DEF_FUNCTION_TYPE_VAR_2
139 #undef DEF_FUNCTION_TYPE_VAR_3
140 #undef DEF_FUNCTION_TYPE_VAR_4
141 #undef DEF_FUNCTION_TYPE_VAR_5
142 #undef DEF_POINTER_TYPE
146 typedef enum lto_builtin_type builtin_type;
148 static GTY(()) tree builtin_types[(int) BT_LAST + 1];
150 static GTY(()) tree string_type_node;
151 static GTY(()) tree const_string_type_node;
152 static GTY(()) tree wint_type_node;
153 static GTY(()) tree intmax_type_node;
154 static GTY(()) tree uintmax_type_node;
155 static GTY(()) tree signed_size_type_node;
157 /* Flags needed to process builtins.def. */
159 int flag_no_nonansi_builtin;
163 /* Attribute handlers. */
165 /* Handle a "noreturn" attribute; arguments as in
166 struct attribute_spec.handler. */
169 handle_noreturn_attribute (tree *node, tree ARG_UNUSED (name),
170 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
171 bool * ARG_UNUSED (no_add_attrs))
173 tree type = TREE_TYPE (*node);
175 if (TREE_CODE (*node) == FUNCTION_DECL)
176 TREE_THIS_VOLATILE (*node) = 1;
177 else if (TREE_CODE (type) == POINTER_TYPE
178 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
181 (build_type_variant (TREE_TYPE (type),
182 TYPE_READONLY (TREE_TYPE (type)), 1));
190 /* Handle a "const" attribute; arguments as in
191 struct attribute_spec.handler. */
194 handle_const_attribute (tree *node, tree ARG_UNUSED (name),
195 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
196 bool * ARG_UNUSED (no_add_attrs))
198 tree type = TREE_TYPE (*node);
200 /* See FIXME comment on noreturn in c_common_attribute_table. */
201 if (TREE_CODE (*node) == FUNCTION_DECL)
202 TREE_READONLY (*node) = 1;
203 else if (TREE_CODE (type) == POINTER_TYPE
204 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
207 (build_type_variant (TREE_TYPE (type), 1,
208 TREE_THIS_VOLATILE (TREE_TYPE (type))));
216 /* Handle a "malloc" attribute; arguments as in
217 struct attribute_spec.handler. */
220 handle_malloc_attribute (tree *node, tree ARG_UNUSED (name),
221 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
222 bool * ARG_UNUSED (no_add_attrs))
224 if (TREE_CODE (*node) == FUNCTION_DECL
225 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node))))
226 DECL_IS_MALLOC (*node) = 1;
234 /* Handle a "pure" attribute; arguments as in
235 struct attribute_spec.handler. */
238 handle_pure_attribute (tree *node, tree ARG_UNUSED (name),
239 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
240 bool * ARG_UNUSED (no_add_attrs))
242 if (TREE_CODE (*node) == FUNCTION_DECL)
243 DECL_PURE_P (*node) = 1;
251 /* Handle a "no vops" attribute; arguments as in
252 struct attribute_spec.handler. */
255 handle_novops_attribute (tree *node, tree ARG_UNUSED (name),
256 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
257 bool *ARG_UNUSED (no_add_attrs))
259 gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
260 DECL_IS_NOVOPS (*node) = 1;
265 /* Helper for nonnull attribute handling; fetch the operand number
266 from the attribute argument list. */
269 get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
271 /* Verify the arg number is a constant. */
272 if (TREE_CODE (arg_num_expr) != INTEGER_CST
273 || TREE_INT_CST_HIGH (arg_num_expr) != 0)
276 *valp = TREE_INT_CST_LOW (arg_num_expr);
280 /* Handle the "nonnull" attribute. */
283 handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
284 tree args, int ARG_UNUSED (flags),
285 bool * ARG_UNUSED (no_add_attrs))
289 /* If no arguments are specified, all pointer arguments should be
290 non-null. Verify a full prototype is given so that the arguments
291 will have the correct types when we actually check them later. */
294 gcc_assert (TYPE_ARG_TYPES (type));
298 /* Argument list specified. Verify that each argument number references
299 a pointer argument. */
300 for (; args; args = TREE_CHAIN (args))
303 unsigned HOST_WIDE_INT arg_num = 0, ck_num;
305 if (!get_nonnull_operand (TREE_VALUE (args), &arg_num))
308 argument = TYPE_ARG_TYPES (type);
311 for (ck_num = 1; ; ck_num++)
313 if (!argument || ck_num == arg_num)
315 argument = TREE_CHAIN (argument);
319 && TREE_CODE (TREE_VALUE (argument)) == POINTER_TYPE);
327 /* Handle a "nothrow" attribute; arguments as in
328 struct attribute_spec.handler. */
331 handle_nothrow_attribute (tree *node, tree ARG_UNUSED (name),
332 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
333 bool * ARG_UNUSED (no_add_attrs))
335 if (TREE_CODE (*node) == FUNCTION_DECL)
336 TREE_NOTHROW (*node) = 1;
344 /* Handle a "sentinel" attribute. */
347 handle_sentinel_attribute (tree *node, tree ARG_UNUSED (name), tree args,
348 int ARG_UNUSED (flags),
349 bool * ARG_UNUSED (no_add_attrs))
351 tree params = TYPE_ARG_TYPES (*node);
354 while (TREE_CHAIN (params))
355 params = TREE_CHAIN (params);
357 gcc_assert (!VOID_TYPE_P (TREE_VALUE (params)));
361 tree position = TREE_VALUE (args);
362 gcc_assert (TREE_CODE (position) == INTEGER_CST);
363 if (tree_int_cst_lt (position, integer_zero_node))
370 /* Handle a "type_generic" attribute. */
373 handle_type_generic_attribute (tree *node, tree ARG_UNUSED (name),
374 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
375 bool * ARG_UNUSED (no_add_attrs))
379 /* Ensure we have a function type. */
380 gcc_assert (TREE_CODE (*node) == FUNCTION_TYPE);
382 params = TYPE_ARG_TYPES (*node);
383 while (params && ! VOID_TYPE_P (TREE_VALUE (params)))
384 params = TREE_CHAIN (params);
386 /* Ensure we have a variadic function. */
387 gcc_assert (!params);
392 /* Handle a "format" attribute; arguments as in
393 struct attribute_spec.handler. */
396 handle_format_attribute (tree * ARG_UNUSED (node), tree ARG_UNUSED (name),
397 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
400 *no_add_attrs = true;
405 /* Handle a "format_arg" attribute; arguments as in
406 struct attribute_spec.handler. */
409 handle_format_arg_attribute (tree * ARG_UNUSED (node), tree ARG_UNUSED (name),
410 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
413 *no_add_attrs = true;
418 /* Cribbed from c-common.c. */
421 def_fn_type (builtin_type def, builtin_type ret, bool var, int n, ...)
428 for (i = 0; i < n; ++i)
430 builtin_type a = (builtin_type) va_arg (list, int);
431 t = builtin_types[a];
432 if (t == error_mark_node)
434 args = tree_cons (NULL_TREE, t, args);
438 args = nreverse (args);
440 args = chainon (args, void_list_node);
442 t = builtin_types[ret];
443 if (t == error_mark_node)
445 t = build_function_type (t, args);
448 builtin_types[def] = t;
451 /* Used to help initialize the builtin-types.def table. When a type of
452 the correct size doesn't exist, use error_mark_node instead of NULL.
453 The later results in segfaults even when a decl using the type doesn't
457 builtin_type_for_size (int size, bool unsignedp)
459 tree type = lang_hooks.types.type_for_size (size, unsignedp);
460 return type ? type : error_mark_node;
463 /* Support for DEF_BUILTIN. */
466 def_builtin_1 (enum built_in_function fncode, const char *name,
467 enum built_in_class fnclass, tree fntype, tree libtype,
468 bool both_p, bool fallback_p, bool nonansi_p,
469 tree fnattrs, bool implicit_p)
474 if (fntype == error_mark_node)
477 libname = name + strlen ("__builtin_");
478 decl = add_builtin_function (name, fntype, fncode, fnclass,
479 (fallback_p ? libname : NULL),
484 && !(nonansi_p && flag_no_nonansi_builtin))
485 add_builtin_function (libname, libtype, fncode, fnclass,
488 built_in_decls[(int) fncode] = decl;
490 implicit_built_in_decls[(int) fncode] = decl;
494 /* Initialize the attribute table for all the supported builtins. */
497 lto_init_attributes (void)
499 /* Fill in the built_in_attributes array. */
500 #define DEF_ATTR_NULL_TREE(ENUM) \
501 built_in_attributes[(int) ENUM] = NULL_TREE;
502 #define DEF_ATTR_INT(ENUM, VALUE) \
503 built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
504 #define DEF_ATTR_IDENT(ENUM, STRING) \
505 built_in_attributes[(int) ENUM] = get_identifier (STRING);
506 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
507 built_in_attributes[(int) ENUM] \
508 = tree_cons (built_in_attributes[(int) PURPOSE], \
509 built_in_attributes[(int) VALUE], \
510 built_in_attributes[(int) CHAIN]);
511 #include "builtin-attrs.def"
512 #undef DEF_ATTR_NULL_TREE
514 #undef DEF_ATTR_IDENT
515 #undef DEF_ATTR_TREE_LIST
518 /* Create builtin types and functions. VA_LIST_REF_TYPE_NODE and
519 VA_LIST_ARG_TYPE_NODE are used in builtin-types.def. */
522 lto_define_builtins (tree va_list_ref_type_node ATTRIBUTE_UNUSED,
523 tree va_list_arg_type_node ATTRIBUTE_UNUSED)
525 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
526 builtin_types[ENUM] = VALUE;
527 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
528 def_fn_type (ENUM, RETURN, 0, 0);
529 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
530 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
531 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
532 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
533 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
534 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
535 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
536 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
537 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
538 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
539 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
541 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
542 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
544 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
545 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
546 def_fn_type (ENUM, RETURN, 1, 0);
547 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
548 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
549 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
550 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
551 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
552 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
553 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
554 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
555 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
556 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
557 #define DEF_POINTER_TYPE(ENUM, TYPE) \
558 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
560 #include "builtin-types.def"
562 #undef DEF_PRIMITIVE_TYPE
563 #undef DEF_FUNCTION_TYPE_1
564 #undef DEF_FUNCTION_TYPE_2
565 #undef DEF_FUNCTION_TYPE_3
566 #undef DEF_FUNCTION_TYPE_4
567 #undef DEF_FUNCTION_TYPE_5
568 #undef DEF_FUNCTION_TYPE_6
569 #undef DEF_FUNCTION_TYPE_VAR_0
570 #undef DEF_FUNCTION_TYPE_VAR_1
571 #undef DEF_FUNCTION_TYPE_VAR_2
572 #undef DEF_FUNCTION_TYPE_VAR_3
573 #undef DEF_FUNCTION_TYPE_VAR_4
574 #undef DEF_FUNCTION_TYPE_VAR_5
575 #undef DEF_POINTER_TYPE
576 builtin_types[(int) BT_LAST] = NULL_TREE;
578 lto_init_attributes ();
580 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P,\
581 NONANSI_P, ATTRS, IMPLICIT, COND) \
583 def_builtin_1 (ENUM, NAME, CLASS, builtin_types[(int) TYPE], \
584 builtin_types[(int) LIBTYPE], BOTH_P, FALLBACK_P, \
585 NONANSI_P, built_in_attributes[(int) ATTRS], IMPLICIT);
586 #include "builtins.def"
590 static GTY(()) tree registered_builtin_types;
592 /* A chain of builtin functions that we need to recognize. We will
593 assume that all other function names we see will be defined by the
595 static GTY(()) tree registered_builtin_fndecls;
597 /* Language hooks. */
600 lto_init_options (unsigned int argc ATTRIBUTE_UNUSED,
601 const char **argv ATTRIBUTE_UNUSED)
603 /* By default, C99-like requirements for complex multiply and divide.
604 ??? Until the complex method is encoded in the IL this is the only
605 safe choice. This will pessimize Fortran code with LTO unless
606 people specify a complex method manually or use -ffast-math. */
607 flag_complex_method = 2;
612 /* Handle command-line option SCODE. If the option takes an argument, it is
613 stored in ARG, which is otherwise NULL. VALUE holds either a numerical
614 argument or a binary value indicating whether the positive or negative form
615 of the option was supplied. */
617 const char *resolution_file_name;
619 lto_handle_option (size_t scode, const char *arg,
620 int value ATTRIBUTE_UNUSED, int kind ATTRIBUTE_UNUSED)
622 enum opt_code code = (enum opt_code) scode;
627 case OPT_fresolution_:
628 resolution_file_name = arg;
636 case OPT_fsigned_char:
637 flag_signed_char = value;
640 case OPT_funsigned_char:
641 flag_signed_char = !value;
651 /* Perform post-option processing. Does additional initialization based on
652 command-line options. PFILENAME is the main input filename. Returns false
653 to enable subsequent back-end initialization. */
656 lto_post_options (const char **pfilename ATTRIBUTE_UNUSED)
658 /* -fltrans and -fwpa are mutually exclusive. Check for that here. */
659 if (flag_wpa && flag_ltrans)
660 error ("-fwpa and -fltrans are mutually exclusive");
664 flag_generate_lto = 0;
666 /* During LTRANS, we are not looking at the whole program, only
667 a subset of the whole callgraph. */
668 flag_whole_program = 0;
672 flag_generate_lto = 1;
674 /* Excess precision other than "fast" requires front-end
676 flag_excess_precision_cmdline = EXCESS_PRECISION_FAST;
678 lto_read_all_file_options ();
680 /* Initialize the compiler back end. */
684 /* Return an integer type with PRECISION bits of precision,
685 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
688 lto_type_for_size (unsigned precision, int unsignedp)
690 if (precision == TYPE_PRECISION (integer_type_node))
691 return unsignedp ? unsigned_type_node : integer_type_node;
693 if (precision == TYPE_PRECISION (signed_char_type_node))
694 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
696 if (precision == TYPE_PRECISION (short_integer_type_node))
697 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
699 if (precision == TYPE_PRECISION (long_integer_type_node))
700 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
702 if (precision == TYPE_PRECISION (long_long_integer_type_node))
704 ? long_long_unsigned_type_node
705 : long_long_integer_type_node;
707 if (precision <= TYPE_PRECISION (intQI_type_node))
708 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
710 if (precision <= TYPE_PRECISION (intHI_type_node))
711 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
713 if (precision <= TYPE_PRECISION (intSI_type_node))
714 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
716 if (precision <= TYPE_PRECISION (intDI_type_node))
717 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
719 if (precision <= TYPE_PRECISION (intTI_type_node))
720 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
726 /* Return a data type that has machine mode MODE.
727 If the mode is an integer,
728 then UNSIGNEDP selects between signed and unsigned types.
729 If the mode is a fixed-point mode,
730 then UNSIGNEDP selects between saturating and nonsaturating types. */
733 lto_type_for_mode (enum machine_mode mode, int unsigned_p)
737 if (mode == TYPE_MODE (integer_type_node))
738 return unsigned_p ? unsigned_type_node : integer_type_node;
740 if (mode == TYPE_MODE (signed_char_type_node))
741 return unsigned_p ? unsigned_char_type_node : signed_char_type_node;
743 if (mode == TYPE_MODE (short_integer_type_node))
744 return unsigned_p ? short_unsigned_type_node : short_integer_type_node;
746 if (mode == TYPE_MODE (long_integer_type_node))
747 return unsigned_p ? long_unsigned_type_node : long_integer_type_node;
749 if (mode == TYPE_MODE (long_long_integer_type_node))
750 return unsigned_p ? long_long_unsigned_type_node : long_long_integer_type_node;
753 return unsigned_p ? unsigned_intQI_type_node : intQI_type_node;
756 return unsigned_p ? unsigned_intHI_type_node : intHI_type_node;
759 return unsigned_p ? unsigned_intSI_type_node : intSI_type_node;
762 return unsigned_p ? unsigned_intDI_type_node : intDI_type_node;
764 #if HOST_BITS_PER_WIDE_INT >= 64
765 if (mode == TYPE_MODE (intTI_type_node))
766 return unsigned_p ? unsigned_intTI_type_node : intTI_type_node;
769 if (mode == TYPE_MODE (float_type_node))
770 return float_type_node;
772 if (mode == TYPE_MODE (double_type_node))
773 return double_type_node;
775 if (mode == TYPE_MODE (long_double_type_node))
776 return long_double_type_node;
778 if (mode == TYPE_MODE (void_type_node))
779 return void_type_node;
781 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
783 ? make_unsigned_type (GET_MODE_PRECISION (mode))
784 : make_signed_type (GET_MODE_PRECISION (mode)));
786 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
788 ? make_unsigned_type (GET_MODE_PRECISION (mode))
789 : make_signed_type (GET_MODE_PRECISION (mode)));
791 if (COMPLEX_MODE_P (mode))
793 enum machine_mode inner_mode;
796 if (mode == TYPE_MODE (complex_float_type_node))
797 return complex_float_type_node;
798 if (mode == TYPE_MODE (complex_double_type_node))
799 return complex_double_type_node;
800 if (mode == TYPE_MODE (complex_long_double_type_node))
801 return complex_long_double_type_node;
803 if (mode == TYPE_MODE (complex_integer_type_node) && !unsigned_p)
804 return complex_integer_type_node;
806 inner_mode = GET_MODE_INNER (mode);
807 inner_type = lto_type_for_mode (inner_mode, unsigned_p);
808 if (inner_type != NULL_TREE)
809 return build_complex_type (inner_type);
811 else if (VECTOR_MODE_P (mode))
813 enum machine_mode inner_mode = GET_MODE_INNER (mode);
814 tree inner_type = lto_type_for_mode (inner_mode, unsigned_p);
815 if (inner_type != NULL_TREE)
816 return build_vector_type_for_mode (inner_type, mode);
819 if (mode == TYPE_MODE (dfloat32_type_node))
820 return dfloat32_type_node;
821 if (mode == TYPE_MODE (dfloat64_type_node))
822 return dfloat64_type_node;
823 if (mode == TYPE_MODE (dfloat128_type_node))
824 return dfloat128_type_node;
826 if (ALL_SCALAR_FIXED_POINT_MODE_P (mode))
828 if (mode == TYPE_MODE (short_fract_type_node))
829 return unsigned_p ? sat_short_fract_type_node : short_fract_type_node;
830 if (mode == TYPE_MODE (fract_type_node))
831 return unsigned_p ? sat_fract_type_node : fract_type_node;
832 if (mode == TYPE_MODE (long_fract_type_node))
833 return unsigned_p ? sat_long_fract_type_node : long_fract_type_node;
834 if (mode == TYPE_MODE (long_long_fract_type_node))
835 return unsigned_p ? sat_long_long_fract_type_node
836 : long_long_fract_type_node;
838 if (mode == TYPE_MODE (unsigned_short_fract_type_node))
839 return unsigned_p ? sat_unsigned_short_fract_type_node
840 : unsigned_short_fract_type_node;
841 if (mode == TYPE_MODE (unsigned_fract_type_node))
842 return unsigned_p ? sat_unsigned_fract_type_node
843 : unsigned_fract_type_node;
844 if (mode == TYPE_MODE (unsigned_long_fract_type_node))
845 return unsigned_p ? sat_unsigned_long_fract_type_node
846 : unsigned_long_fract_type_node;
847 if (mode == TYPE_MODE (unsigned_long_long_fract_type_node))
848 return unsigned_p ? sat_unsigned_long_long_fract_type_node
849 : unsigned_long_long_fract_type_node;
851 if (mode == TYPE_MODE (short_accum_type_node))
852 return unsigned_p ? sat_short_accum_type_node : short_accum_type_node;
853 if (mode == TYPE_MODE (accum_type_node))
854 return unsigned_p ? sat_accum_type_node : accum_type_node;
855 if (mode == TYPE_MODE (long_accum_type_node))
856 return unsigned_p ? sat_long_accum_type_node : long_accum_type_node;
857 if (mode == TYPE_MODE (long_long_accum_type_node))
858 return unsigned_p ? sat_long_long_accum_type_node
859 : long_long_accum_type_node;
861 if (mode == TYPE_MODE (unsigned_short_accum_type_node))
862 return unsigned_p ? sat_unsigned_short_accum_type_node
863 : unsigned_short_accum_type_node;
864 if (mode == TYPE_MODE (unsigned_accum_type_node))
865 return unsigned_p ? sat_unsigned_accum_type_node
866 : unsigned_accum_type_node;
867 if (mode == TYPE_MODE (unsigned_long_accum_type_node))
868 return unsigned_p ? sat_unsigned_long_accum_type_node
869 : unsigned_long_accum_type_node;
870 if (mode == TYPE_MODE (unsigned_long_long_accum_type_node))
871 return unsigned_p ? sat_unsigned_long_long_accum_type_node
872 : unsigned_long_long_accum_type_node;
875 return unsigned_p ? sat_qq_type_node : qq_type_node;
877 return unsigned_p ? sat_hq_type_node : hq_type_node;
879 return unsigned_p ? sat_sq_type_node : sq_type_node;
881 return unsigned_p ? sat_dq_type_node : dq_type_node;
883 return unsigned_p ? sat_tq_type_node : tq_type_node;
886 return unsigned_p ? sat_uqq_type_node : uqq_type_node;
888 return unsigned_p ? sat_uhq_type_node : uhq_type_node;
890 return unsigned_p ? sat_usq_type_node : usq_type_node;
892 return unsigned_p ? sat_udq_type_node : udq_type_node;
894 return unsigned_p ? sat_utq_type_node : utq_type_node;
897 return unsigned_p ? sat_ha_type_node : ha_type_node;
899 return unsigned_p ? sat_sa_type_node : sa_type_node;
901 return unsigned_p ? sat_da_type_node : da_type_node;
903 return unsigned_p ? sat_ta_type_node : ta_type_node;
906 return unsigned_p ? sat_uha_type_node : uha_type_node;
908 return unsigned_p ? sat_usa_type_node : usa_type_node;
910 return unsigned_p ? sat_uda_type_node : uda_type_node;
912 return unsigned_p ? sat_uta_type_node : uta_type_node;
915 for (t = registered_builtin_types; t; t = TREE_CHAIN (t))
916 if (TYPE_MODE (TREE_VALUE (t)) == mode)
917 return TREE_VALUE (t);
923 lto_global_bindings_p (void)
929 lto_set_decl_assembler_name (tree decl)
931 /* This is almost the same as lhd_set_decl_assembler_name, except that
932 we need to uniquify file-scope names, even if they are not
933 TREE_PUBLIC, to avoid conflicts between individual files. */
936 if (TREE_PUBLIC (decl))
937 id = targetm.mangle_decl_assembler_name (decl, DECL_NAME (decl));
940 const char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
943 ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
944 id = get_identifier (label);
947 SET_DECL_ASSEMBLER_NAME (decl, id);
951 lto_pushdecl (tree t ATTRIBUTE_UNUSED)
953 /* Do nothing, since we get all information from DWARF and LTO
961 return registered_builtin_fndecls;
965 lto_write_globals (void)
967 tree *vec = VEC_address (tree, lto_global_var_decls);
968 int len = VEC_length (tree, lto_global_var_decls);
969 wrapup_global_declarations (vec, len);
970 emit_debug_global_declarations (vec, len);
971 VEC_free (tree, gc, lto_global_var_decls);
975 lto_builtin_function (tree decl)
978 TREE_CHAIN (decl) = registered_builtin_fndecls;
979 registered_builtin_fndecls = decl;
985 lto_register_builtin_type (tree type, const char *name)
989 decl = build_decl (UNKNOWN_LOCATION, TYPE_DECL, get_identifier (name), type);
990 DECL_ARTIFICIAL (decl) = 1;
991 if (!TYPE_NAME (type))
992 TYPE_NAME (type) = decl;
994 registered_builtin_types = tree_cons (0, type, registered_builtin_types);
997 /* Build nodes that would have be created by the C front-end; necessary
998 for including builtin-types.def and ultimately builtins.def. */
1001 lto_build_c_type_nodes (void)
1003 gcc_assert (void_type_node);
1005 void_list_node = build_tree_list (NULL_TREE, void_type_node);
1006 string_type_node = build_pointer_type (char_type_node);
1007 const_string_type_node
1008 = build_pointer_type (build_qualified_type (char_type_node, TYPE_QUAL_CONST));
1010 if (strcmp (SIZE_TYPE, "unsigned int") == 0)
1012 intmax_type_node = integer_type_node;
1013 uintmax_type_node = unsigned_type_node;
1014 signed_size_type_node = integer_type_node;
1016 else if (strcmp (SIZE_TYPE, "long unsigned int") == 0)
1018 intmax_type_node = long_integer_type_node;
1019 uintmax_type_node = long_unsigned_type_node;
1020 signed_size_type_node = long_integer_type_node;
1022 else if (strcmp (SIZE_TYPE, "long long unsigned int") == 0)
1024 intmax_type_node = long_long_integer_type_node;
1025 uintmax_type_node = long_long_unsigned_type_node;
1026 signed_size_type_node = long_long_integer_type_node;
1031 wint_type_node = unsigned_type_node;
1032 pid_type_node = integer_type_node;
1036 /* Perform LTO-specific initialization. */
1041 /* We need to generate LTO if running in WPA mode. */
1042 flag_generate_lto = flag_wpa;
1044 /* Initialize libcpp line maps for gcc_assert to work. */
1045 linemap_add (line_table, LC_RENAME, 0, NULL, 0);
1046 linemap_add (line_table, LC_RENAME, 0, NULL, 0);
1048 /* Create the basic integer types. */
1049 build_common_tree_nodes (flag_signed_char);
1051 /* Share char_type_node with whatever would be the default for the target.
1052 char_type_node will be used for internal types such as
1053 va_list_type_node but will not be present in the lto stream. */
1054 /* ??? This breaks the more common case of consistent but non-standard
1055 setting of flag_signed_char, so share according to flag_signed_char.
1058 = flag_signed_char ? signed_char_type_node : unsigned_char_type_node;
1060 /* Tell the middle end what type to use for the size of objects. */
1061 if (strcmp (SIZE_TYPE, "unsigned int") == 0)
1063 set_sizetype (unsigned_type_node);
1064 size_type_node = unsigned_type_node;
1066 else if (strcmp (SIZE_TYPE, "long unsigned int") == 0)
1068 set_sizetype (long_unsigned_type_node);
1069 size_type_node = long_unsigned_type_node;
1071 else if (strcmp (SIZE_TYPE, "long long unsigned int") == 0)
1073 set_sizetype (long_long_unsigned_type_node);
1074 size_type_node = long_long_unsigned_type_node;
1079 /* The global tree for the main identifier is filled in by
1080 language-specific front-end initialization that is not run in the
1081 LTO back-end. It appears that all languages that perform such
1082 initialization currently do so in the same way, so we do it here. */
1083 if (main_identifier_node == NULL_TREE)
1084 main_identifier_node = get_identifier ("main");
1086 /* In the C++ front-end, fileptr_type_node is defined as a variant
1087 copy of of ptr_type_node, rather than ptr_node itself. The
1088 distinction should only be relevant to the front-end, so we
1089 always use the C definition here in lto1. */
1090 gcc_assert (fileptr_type_node == ptr_type_node);
1092 ptrdiff_type_node = integer_type_node;
1094 /* Create other basic types. */
1095 build_common_tree_nodes_2 (/*short_double=*/false);
1096 lto_build_c_type_nodes ();
1097 gcc_assert (va_list_type_node);
1099 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
1101 tree x = build_pointer_type (TREE_TYPE (va_list_type_node));
1102 lto_define_builtins (x, x);
1106 lto_define_builtins (va_list_type_node,
1107 build_reference_type (va_list_type_node));
1110 targetm.init_builtins ();
1111 build_common_builtin_nodes ();
1113 /* Initialize LTO-specific data structures. */
1114 lto_global_var_decls = VEC_alloc (tree, gc, 256);
1120 /* Initialize tree structures required by the LTO front end. */
1122 static void lto_init_ts (void)
1124 tree_contains_struct[NAMESPACE_DECL][TS_DECL_MINIMAL] = 1;
1127 #undef LANG_HOOKS_NAME
1128 #define LANG_HOOKS_NAME "GNU GIMPLE"
1129 #undef LANG_HOOKS_INIT_OPTIONS
1130 #define LANG_HOOKS_INIT_OPTIONS lto_init_options
1131 #undef LANG_HOOKS_HANDLE_OPTION
1132 #define LANG_HOOKS_HANDLE_OPTION lto_handle_option
1133 #undef LANG_HOOKS_POST_OPTIONS
1134 #define LANG_HOOKS_POST_OPTIONS lto_post_options
1135 #undef LANG_HOOKS_GET_ALIAS_SET
1136 #define LANG_HOOKS_GET_ALIAS_SET gimple_get_alias_set
1137 #undef LANG_HOOKS_TYPE_FOR_MODE
1138 #define LANG_HOOKS_TYPE_FOR_MODE lto_type_for_mode
1139 #undef LANG_HOOKS_TYPE_FOR_SIZE
1140 #define LANG_HOOKS_TYPE_FOR_SIZE lto_type_for_size
1141 #undef LANG_HOOKS_SET_DECL_ASSEMBLER_NAME
1142 #define LANG_HOOKS_SET_DECL_ASSEMBLER_NAME lto_set_decl_assembler_name
1143 #undef LANG_HOOKS_GLOBAL_BINDINGS_P
1144 #define LANG_HOOKS_GLOBAL_BINDINGS_P lto_global_bindings_p
1145 #undef LANG_HOOKS_PUSHDECL
1146 #define LANG_HOOKS_PUSHDECL lto_pushdecl
1147 #undef LANG_HOOKS_GETDECLS
1148 #define LANG_HOOKS_GETDECLS lto_getdecls
1149 #undef LANG_HOOKS_WRITE_GLOBALS
1150 #define LANG_HOOKS_WRITE_GLOBALS lto_write_globals
1151 #undef LANG_HOOKS_REGISTER_BUILTIN_TYPE
1152 #define LANG_HOOKS_REGISTER_BUILTIN_TYPE lto_register_builtin_type
1153 #undef LANG_HOOKS_BUILTIN_FUNCTION
1154 #define LANG_HOOKS_BUILTIN_FUNCTION lto_builtin_function
1155 #undef LANG_HOOKS_INIT
1156 #define LANG_HOOKS_INIT lto_init
1157 #undef LANG_HOOKS_PARSE_FILE
1158 #define LANG_HOOKS_PARSE_FILE lto_main
1159 #undef LANG_HOOKS_CALLGRAPH_EXPAND_FUNCTION
1160 #define LANG_HOOKS_CALLGRAPH_EXPAND_FUNCTION tree_rest_of_compilation
1161 #undef LANG_HOOKS_REDUCE_BIT_FIELD_OPERATIONS
1162 #define LANG_HOOKS_REDUCE_BIT_FIELD_OPERATIONS true
1163 #undef LANG_HOOKS_TYPES_COMPATIBLE_P
1164 #define LANG_HOOKS_TYPES_COMPATIBLE_P NULL
1166 /* Attribute hooks. */
1167 #undef LANG_HOOKS_COMMON_ATTRIBUTE_TABLE
1168 #define LANG_HOOKS_COMMON_ATTRIBUTE_TABLE lto_attribute_table
1169 #undef LANG_HOOKS_FORMAT_ATTRIBUTE_TABLE
1170 #define LANG_HOOKS_FORMAT_ATTRIBUTE_TABLE lto_format_attribute_table
1172 #undef LANG_HOOKS_BEGIN_SECTION
1173 #define LANG_HOOKS_BEGIN_SECTION lto_obj_begin_section
1174 #undef LANG_HOOKS_APPEND_DATA
1175 #define LANG_HOOKS_APPEND_DATA lto_obj_append_data
1176 #undef LANG_HOOKS_END_SECTION
1177 #define LANG_HOOKS_END_SECTION lto_obj_end_section
1179 #undef LANG_HOOKS_INIT_TS
1180 #define LANG_HOOKS_INIT_TS lto_init_ts
1182 struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER;
1184 /* Language hooks that are not part of lang_hooks. */
1187 convert (tree type ATTRIBUTE_UNUSED, tree expr ATTRIBUTE_UNUSED)
1192 /* Tree walking support. */
1194 static enum lto_tree_node_structure_enum
1195 lto_tree_node_structure (union lang_tree_node *t ATTRIBUTE_UNUSED)
1197 return TS_LTO_GENERIC;
1201 #include "gtype-lto.h"
1202 #include "gt-lto-lto-lang.h"