1 /* Language-dependent hooks for LTO.
2 Copyright 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
3 Contributed by CodeSourcery, Inc.
4
5 This file is part of GCC.
6
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.
11
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.
16
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/>. */
20
21 #include "config.h"
22 #include "system.h"
23 #include "coretypes.h"
24 #include "flags.h"
25 #include "tm.h"
26 #include "tree.h"
27 #include "target.h"
28 #include "langhooks.h"
29 #include "langhooks-def.h"
30 #include "debug.h"
31 #include "lto-tree.h"
32 #include "lto.h"
33 #include "tree-inline.h"
34 #include "gimple.h"
35 #include "diagnostic-core.h"
36 #include "toplev.h"
37 #include "lto-streamer.h"
38
39 static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
40 static tree handle_leaf_attribute (tree *, tree, tree, int, bool *);
41 static tree handle_const_attribute (tree *, tree, tree, int, bool *);
42 static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);
43 static tree handle_pure_attribute (tree *, tree, tree, int, bool *);
44 static tree handle_novops_attribute (tree *, tree, tree, int, bool *);
45 static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
46 static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
47 static tree handle_sentinel_attribute (tree *, tree, tree, int, bool *);
48 static tree handle_type_generic_attribute (tree *, tree, tree, int, bool *);
49 static tree handle_transaction_pure_attribute (tree *, tree, tree, int, bool *);
50 static tree handle_returns_twice_attribute (tree *, tree, tree, int, bool *);
51 static tree ignore_attribute (tree *, tree, tree, int, bool *);
52
53 static tree handle_format_attribute (tree *, tree, tree, int, bool *);
54 static tree handle_format_arg_attribute (tree *, tree, tree, int, bool *);
55
56 /* Table of machine-independent attributes supported in GIMPLE. */
57 const struct attribute_spec lto_attribute_table[] =
58 {
59 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler,
60 do_diagnostic } */
61 { "noreturn", 0, 0, true, false, false,
62 handle_noreturn_attribute, false },
63 { "leaf", 0, 0, true, false, false,
64 handle_leaf_attribute, false },
65 /* The same comments as for noreturn attributes apply to const ones. */
66 { "const", 0, 0, true, false, false,
67 handle_const_attribute, false },
68 { "malloc", 0, 0, true, false, false,
69 handle_malloc_attribute, false },
70 { "pure", 0, 0, true, false, false,
71 handle_pure_attribute, false },
72 { "no vops", 0, 0, true, false, false,
73 handle_novops_attribute, false },
74 { "nonnull", 0, -1, false, true, true,
75 handle_nonnull_attribute, false },
76 { "nothrow", 0, 0, true, false, false,
77 handle_nothrow_attribute, false },
78 { "returns_twice", 0, 0, true, false, false,
79 handle_returns_twice_attribute, false },
80 { "sentinel", 0, 1, false, true, true,
81 handle_sentinel_attribute, false },
82 { "type generic", 0, 0, false, true, true,
83 handle_type_generic_attribute, false },
84 { "transaction_pure", 0, 0, false, true, true,
85 handle_transaction_pure_attribute, false },
86 /* For internal use only. The leading '*' both prevents its usage in
87 source code and signals that it may be overridden by machine tables. */
88 { "*tm regparm", 0, 0, false, true, true,
89 ignore_attribute, false },
90 { NULL, 0, 0, false, false, false, NULL, false }
91 };
92
93 /* Give the specifications for the format attributes, used by C and all
94 descendants. */
95
96 const struct attribute_spec lto_format_attribute_table[] =
97 {
98 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler,
99 affects_type_identity } */
100 { "format", 3, 3, false, true, true,
101 handle_format_attribute, false },
102 { "format_arg", 1, 1, false, true, true,
103 handle_format_arg_attribute, false },
104 { NULL, 0, 0, false, false, false, NULL, false }
105 };
106
107 enum built_in_attribute
108 {
109 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
110 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
111 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
112 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
113 #include "builtin-attrs.def"
114 #undef DEF_ATTR_NULL_TREE
115 #undef DEF_ATTR_INT
116 #undef DEF_ATTR_IDENT
117 #undef DEF_ATTR_TREE_LIST
118 ATTR_LAST
119 };
120
121 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
122
123 /* Builtin types. */
124
125 enum lto_builtin_type
126 {
127 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
128 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
129 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
130 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
131 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
132 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
133 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
134 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME,
135 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME,
136 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
137 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
138 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
139 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
140 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
141 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
142 NAME,
143 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
144 #include "builtin-types.def"
145 #undef DEF_PRIMITIVE_TYPE
146 #undef DEF_FUNCTION_TYPE_0
147 #undef DEF_FUNCTION_TYPE_1
148 #undef DEF_FUNCTION_TYPE_2
149 #undef DEF_FUNCTION_TYPE_3
150 #undef DEF_FUNCTION_TYPE_4
151 #undef DEF_FUNCTION_TYPE_5
152 #undef DEF_FUNCTION_TYPE_6
153 #undef DEF_FUNCTION_TYPE_7
154 #undef DEF_FUNCTION_TYPE_VAR_0
155 #undef DEF_FUNCTION_TYPE_VAR_1
156 #undef DEF_FUNCTION_TYPE_VAR_2
157 #undef DEF_FUNCTION_TYPE_VAR_3
158 #undef DEF_FUNCTION_TYPE_VAR_4
159 #undef DEF_FUNCTION_TYPE_VAR_5
160 #undef DEF_POINTER_TYPE
161 BT_LAST
162 };
163
164 typedef enum lto_builtin_type builtin_type;
165
166 static GTY(()) tree builtin_types[(int) BT_LAST + 1];
167
168 static GTY(()) tree string_type_node;
169 static GTY(()) tree const_string_type_node;
170 static GTY(()) tree wint_type_node;
171 static GTY(()) tree intmax_type_node;
172 static GTY(()) tree uintmax_type_node;
173 static GTY(()) tree signed_size_type_node;
174
175 /* Flags needed to process builtins.def. */
176 int flag_isoc94;
177 int flag_isoc99;
178
179 /* Attribute handlers. */
180
181 /* Handle a "noreturn" attribute; arguments as in
182 struct attribute_spec.handler. */
183
184 static tree
handle_noreturn_attribute(tree * node,tree ARG_UNUSED (name),tree ARG_UNUSED (args),int ARG_UNUSED (flags),bool * ARG_UNUSED (no_add_attrs))185 handle_noreturn_attribute (tree *node, tree ARG_UNUSED (name),
186 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
187 bool * ARG_UNUSED (no_add_attrs))
188 {
189 tree type = TREE_TYPE (*node);
190
191 if (TREE_CODE (*node) == FUNCTION_DECL)
192 TREE_THIS_VOLATILE (*node) = 1;
193 else if (TREE_CODE (type) == POINTER_TYPE
194 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
195 TREE_TYPE (*node)
196 = build_pointer_type
197 (build_type_variant (TREE_TYPE (type),
198 TYPE_READONLY (TREE_TYPE (type)), 1));
199 else
200 gcc_unreachable ();
201
202 return NULL_TREE;
203 }
204
205 /* Handle a "leaf" attribute; arguments as in
206 struct attribute_spec.handler. */
207
208 static tree
handle_leaf_attribute(tree * node,tree name,tree ARG_UNUSED (args),int ARG_UNUSED (flags),bool * no_add_attrs)209 handle_leaf_attribute (tree *node, tree name,
210 tree ARG_UNUSED (args),
211 int ARG_UNUSED (flags), bool *no_add_attrs)
212 {
213 if (TREE_CODE (*node) != FUNCTION_DECL)
214 {
215 warning (OPT_Wattributes, "%qE attribute ignored", name);
216 *no_add_attrs = true;
217 }
218 if (!TREE_PUBLIC (*node))
219 {
220 warning (OPT_Wattributes, "%qE attribute has no effect on unit local functions", name);
221 *no_add_attrs = true;
222 }
223
224 return NULL_TREE;
225 }
226
227 /* Handle a "const" attribute; arguments as in
228 struct attribute_spec.handler. */
229
230 static tree
handle_const_attribute(tree * node,tree ARG_UNUSED (name),tree ARG_UNUSED (args),int ARG_UNUSED (flags),bool * ARG_UNUSED (no_add_attrs))231 handle_const_attribute (tree *node, tree ARG_UNUSED (name),
232 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
233 bool * ARG_UNUSED (no_add_attrs))
234 {
235 tree type = TREE_TYPE (*node);
236
237 /* See FIXME comment on noreturn in c_common_attribute_table. */
238 if (TREE_CODE (*node) == FUNCTION_DECL)
239 TREE_READONLY (*node) = 1;
240 else if (TREE_CODE (type) == POINTER_TYPE
241 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
242 TREE_TYPE (*node)
243 = build_pointer_type
244 (build_type_variant (TREE_TYPE (type), 1,
245 TREE_THIS_VOLATILE (TREE_TYPE (type))));
246 else
247 gcc_unreachable ();
248
249 return NULL_TREE;
250 }
251
252
253 /* Handle a "malloc" attribute; arguments as in
254 struct attribute_spec.handler. */
255
256 static tree
handle_malloc_attribute(tree * node,tree ARG_UNUSED (name),tree ARG_UNUSED (args),int ARG_UNUSED (flags),bool * ARG_UNUSED (no_add_attrs))257 handle_malloc_attribute (tree *node, tree ARG_UNUSED (name),
258 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
259 bool * ARG_UNUSED (no_add_attrs))
260 {
261 if (TREE_CODE (*node) == FUNCTION_DECL
262 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node))))
263 DECL_IS_MALLOC (*node) = 1;
264 else
265 gcc_unreachable ();
266
267 return NULL_TREE;
268 }
269
270
271 /* Handle a "pure" attribute; arguments as in
272 struct attribute_spec.handler. */
273
274 static tree
handle_pure_attribute(tree * node,tree ARG_UNUSED (name),tree ARG_UNUSED (args),int ARG_UNUSED (flags),bool * ARG_UNUSED (no_add_attrs))275 handle_pure_attribute (tree *node, tree ARG_UNUSED (name),
276 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
277 bool * ARG_UNUSED (no_add_attrs))
278 {
279 if (TREE_CODE (*node) == FUNCTION_DECL)
280 DECL_PURE_P (*node) = 1;
281 else
282 gcc_unreachable ();
283
284 return NULL_TREE;
285 }
286
287
288 /* Handle a "no vops" attribute; arguments as in
289 struct attribute_spec.handler. */
290
291 static tree
handle_novops_attribute(tree * node,tree ARG_UNUSED (name),tree ARG_UNUSED (args),int ARG_UNUSED (flags),bool * ARG_UNUSED (no_add_attrs))292 handle_novops_attribute (tree *node, tree ARG_UNUSED (name),
293 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
294 bool *ARG_UNUSED (no_add_attrs))
295 {
296 gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
297 DECL_IS_NOVOPS (*node) = 1;
298 return NULL_TREE;
299 }
300
301
302 /* Helper for nonnull attribute handling; fetch the operand number
303 from the attribute argument list. */
304
305 static bool
get_nonnull_operand(tree arg_num_expr,unsigned HOST_WIDE_INT * valp)306 get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
307 {
308 /* Verify the arg number is a constant. */
309 if (TREE_CODE (arg_num_expr) != INTEGER_CST
310 || TREE_INT_CST_HIGH (arg_num_expr) != 0)
311 return false;
312
313 *valp = TREE_INT_CST_LOW (arg_num_expr);
314 return true;
315 }
316
317 /* Handle the "nonnull" attribute. */
318
319 static tree
handle_nonnull_attribute(tree * node,tree ARG_UNUSED (name),tree args,int ARG_UNUSED (flags),bool * ARG_UNUSED (no_add_attrs))320 handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
321 tree args, int ARG_UNUSED (flags),
322 bool * ARG_UNUSED (no_add_attrs))
323 {
324 tree type = *node;
325
326 /* If no arguments are specified, all pointer arguments should be
327 non-null. Verify a full prototype is given so that the arguments
328 will have the correct types when we actually check them later. */
329 if (!args)
330 {
331 gcc_assert (prototype_p (type));
332 return NULL_TREE;
333 }
334
335 /* Argument list specified. Verify that each argument number references
336 a pointer argument. */
337 for (; args; args = TREE_CHAIN (args))
338 {
339 tree argument;
340 unsigned HOST_WIDE_INT arg_num = 0, ck_num;
341
342 if (!get_nonnull_operand (TREE_VALUE (args), &arg_num))
343 gcc_unreachable ();
344
345 argument = TYPE_ARG_TYPES (type);
346 if (argument)
347 {
348 for (ck_num = 1; ; ck_num++)
349 {
350 if (!argument || ck_num == arg_num)
351 break;
352 argument = TREE_CHAIN (argument);
353 }
354
355 gcc_assert (argument
356 && TREE_CODE (TREE_VALUE (argument)) == POINTER_TYPE);
357 }
358 }
359
360 return NULL_TREE;
361 }
362
363
364 /* Handle a "nothrow" attribute; arguments as in
365 struct attribute_spec.handler. */
366
367 static tree
handle_nothrow_attribute(tree * node,tree ARG_UNUSED (name),tree ARG_UNUSED (args),int ARG_UNUSED (flags),bool * ARG_UNUSED (no_add_attrs))368 handle_nothrow_attribute (tree *node, tree ARG_UNUSED (name),
369 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
370 bool * ARG_UNUSED (no_add_attrs))
371 {
372 if (TREE_CODE (*node) == FUNCTION_DECL)
373 TREE_NOTHROW (*node) = 1;
374 else
375 gcc_unreachable ();
376
377 return NULL_TREE;
378 }
379
380
381 /* Handle a "sentinel" attribute. */
382
383 static tree
handle_sentinel_attribute(tree * node,tree ARG_UNUSED (name),tree args,int ARG_UNUSED (flags),bool * ARG_UNUSED (no_add_attrs))384 handle_sentinel_attribute (tree *node, tree ARG_UNUSED (name), tree args,
385 int ARG_UNUSED (flags),
386 bool * ARG_UNUSED (no_add_attrs))
387 {
388 gcc_assert (stdarg_p (*node));
389
390 if (args)
391 {
392 tree position = TREE_VALUE (args);
393 gcc_assert (TREE_CODE (position) == INTEGER_CST);
394 if (tree_int_cst_lt (position, integer_zero_node))
395 gcc_unreachable ();
396 }
397
398 return NULL_TREE;
399 }
400
401 /* Handle a "type_generic" attribute. */
402
403 static tree
handle_type_generic_attribute(tree * node,tree ARG_UNUSED (name),tree ARG_UNUSED (args),int ARG_UNUSED (flags),bool * ARG_UNUSED (no_add_attrs))404 handle_type_generic_attribute (tree *node, tree ARG_UNUSED (name),
405 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
406 bool * ARG_UNUSED (no_add_attrs))
407 {
408 /* Ensure we have a function type. */
409 gcc_assert (TREE_CODE (*node) == FUNCTION_TYPE);
410
411 /* Ensure we have a variadic function. */
412 gcc_assert (!prototype_p (*node) || stdarg_p (*node));
413
414 return NULL_TREE;
415 }
416
417 /* Handle a "transaction_pure" attribute. */
418
419 static tree
handle_transaction_pure_attribute(tree * node,tree ARG_UNUSED (name),tree ARG_UNUSED (args),int ARG_UNUSED (flags),bool * ARG_UNUSED (no_add_attrs))420 handle_transaction_pure_attribute (tree *node, tree ARG_UNUSED (name),
421 tree ARG_UNUSED (args),
422 int ARG_UNUSED (flags),
423 bool * ARG_UNUSED (no_add_attrs))
424 {
425 /* Ensure we have a function type. */
426 gcc_assert (TREE_CODE (*node) == FUNCTION_TYPE);
427
428 return NULL_TREE;
429 }
430
431 /* Handle a "returns_twice" attribute. */
432
433 static tree
handle_returns_twice_attribute(tree * node,tree ARG_UNUSED (name),tree ARG_UNUSED (args),int ARG_UNUSED (flags),bool * ARG_UNUSED (no_add_attrs))434 handle_returns_twice_attribute (tree *node, tree ARG_UNUSED (name),
435 tree ARG_UNUSED (args),
436 int ARG_UNUSED (flags),
437 bool * ARG_UNUSED (no_add_attrs))
438 {
439 gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
440
441 DECL_IS_RETURNS_TWICE (*node) = 1;
442
443 return NULL_TREE;
444 }
445
446 /* Ignore the given attribute. Used when this attribute may be usefully
447 overridden by the target, but is not used generically. */
448
449 static tree
ignore_attribute(tree * ARG_UNUSED (node),tree ARG_UNUSED (name),tree ARG_UNUSED (args),int ARG_UNUSED (flags),bool * no_add_attrs)450 ignore_attribute (tree * ARG_UNUSED (node), tree ARG_UNUSED (name),
451 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
452 bool *no_add_attrs)
453 {
454 *no_add_attrs = true;
455 return NULL_TREE;
456 }
457
458 /* Handle a "format" attribute; arguments as in
459 struct attribute_spec.handler. */
460
461 static tree
handle_format_attribute(tree * ARG_UNUSED (node),tree ARG_UNUSED (name),tree ARG_UNUSED (args),int ARG_UNUSED (flags),bool * no_add_attrs)462 handle_format_attribute (tree * ARG_UNUSED (node), tree ARG_UNUSED (name),
463 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
464 bool *no_add_attrs)
465 {
466 *no_add_attrs = true;
467 return NULL_TREE;
468 }
469
470
471 /* Handle a "format_arg" attribute; arguments as in
472 struct attribute_spec.handler. */
473
474 tree
handle_format_arg_attribute(tree * ARG_UNUSED (node),tree ARG_UNUSED (name),tree ARG_UNUSED (args),int ARG_UNUSED (flags),bool * no_add_attrs)475 handle_format_arg_attribute (tree * ARG_UNUSED (node), tree ARG_UNUSED (name),
476 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
477 bool *no_add_attrs)
478 {
479 *no_add_attrs = true;
480 return NULL_TREE;
481 }
482
483
484 /* Cribbed from c-common.c. */
485
486 static void
def_fn_type(builtin_type def,builtin_type ret,bool var,int n,...)487 def_fn_type (builtin_type def, builtin_type ret, bool var, int n, ...)
488 {
489 tree t;
490 tree *args = XALLOCAVEC (tree, n);
491 va_list list;
492 int i;
493
494 va_start (list, n);
495 for (i = 0; i < n; ++i)
496 {
497 builtin_type a = (builtin_type) va_arg (list, int);
498 t = builtin_types[a];
499 if (t == error_mark_node)
500 goto egress;
501 args[i] = t;
502 }
503 va_end (list);
504
505 t = builtin_types[ret];
506 if (t == error_mark_node)
507 goto egress;
508 if (var)
509 t = build_varargs_function_type_array (t, n, args);
510 else
511 t = build_function_type_array (t, n, args);
512
513 egress:
514 builtin_types[def] = t;
515 va_end (list);
516 }
517
518 /* Used to help initialize the builtin-types.def table. When a type of
519 the correct size doesn't exist, use error_mark_node instead of NULL.
520 The later results in segfaults even when a decl using the type doesn't
521 get invoked. */
522
523 static tree
builtin_type_for_size(int size,bool unsignedp)524 builtin_type_for_size (int size, bool unsignedp)
525 {
526 tree type = lang_hooks.types.type_for_size (size, unsignedp);
527 return type ? type : error_mark_node;
528 }
529
530 /* Support for DEF_BUILTIN. */
531
532 static void
def_builtin_1(enum built_in_function fncode,const char * name,enum built_in_class fnclass,tree fntype,tree libtype,bool both_p,bool fallback_p,bool nonansi_p,tree fnattrs,bool implicit_p)533 def_builtin_1 (enum built_in_function fncode, const char *name,
534 enum built_in_class fnclass, tree fntype, tree libtype,
535 bool both_p, bool fallback_p, bool nonansi_p,
536 tree fnattrs, bool implicit_p)
537 {
538 tree decl;
539 const char *libname;
540
541 if (fntype == error_mark_node)
542 return;
543
544 libname = name + strlen ("__builtin_");
545 decl = add_builtin_function (name, fntype, fncode, fnclass,
546 (fallback_p ? libname : NULL),
547 fnattrs);
548
549 if (both_p
550 && !flag_no_builtin
551 && !(nonansi_p && flag_no_nonansi_builtin))
552 add_builtin_function (libname, libtype, fncode, fnclass,
553 NULL, fnattrs);
554
555 set_builtin_decl (fncode, decl, implicit_p);
556 }
557
558
559 /* Initialize the attribute table for all the supported builtins. */
560
561 static void
lto_init_attributes(void)562 lto_init_attributes (void)
563 {
564 /* Fill in the built_in_attributes array. */
565 #define DEF_ATTR_NULL_TREE(ENUM) \
566 built_in_attributes[(int) ENUM] = NULL_TREE;
567 #define DEF_ATTR_INT(ENUM, VALUE) \
568 built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
569 #define DEF_ATTR_IDENT(ENUM, STRING) \
570 built_in_attributes[(int) ENUM] = get_identifier (STRING);
571 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
572 built_in_attributes[(int) ENUM] \
573 = tree_cons (built_in_attributes[(int) PURPOSE], \
574 built_in_attributes[(int) VALUE], \
575 built_in_attributes[(int) CHAIN]);
576 #include "builtin-attrs.def"
577 #undef DEF_ATTR_NULL_TREE
578 #undef DEF_ATTR_INT
579 #undef DEF_ATTR_IDENT
580 #undef DEF_ATTR_TREE_LIST
581 }
582
583 /* Create builtin types and functions. VA_LIST_REF_TYPE_NODE and
584 VA_LIST_ARG_TYPE_NODE are used in builtin-types.def. */
585
586 static void
lto_define_builtins(tree va_list_ref_type_node ATTRIBUTE_UNUSED,tree va_list_arg_type_node ATTRIBUTE_UNUSED)587 lto_define_builtins (tree va_list_ref_type_node ATTRIBUTE_UNUSED,
588 tree va_list_arg_type_node ATTRIBUTE_UNUSED)
589 {
590 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
591 builtin_types[ENUM] = VALUE;
592 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
593 def_fn_type (ENUM, RETURN, 0, 0);
594 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
595 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
596 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
597 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
598 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
599 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
600 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
601 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
602 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
603 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
604 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
605 ARG6) \
606 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
607 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
608 ARG6, ARG7) \
609 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
610 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
611 def_fn_type (ENUM, RETURN, 1, 0);
612 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
613 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
614 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
615 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
616 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
617 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
618 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
619 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
620 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
621 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
622 #define DEF_POINTER_TYPE(ENUM, TYPE) \
623 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
624
625 #include "builtin-types.def"
626
627 #undef DEF_PRIMITIVE_TYPE
628 #undef DEF_FUNCTION_TYPE_1
629 #undef DEF_FUNCTION_TYPE_2
630 #undef DEF_FUNCTION_TYPE_3
631 #undef DEF_FUNCTION_TYPE_4
632 #undef DEF_FUNCTION_TYPE_5
633 #undef DEF_FUNCTION_TYPE_6
634 #undef DEF_FUNCTION_TYPE_VAR_0
635 #undef DEF_FUNCTION_TYPE_VAR_1
636 #undef DEF_FUNCTION_TYPE_VAR_2
637 #undef DEF_FUNCTION_TYPE_VAR_3
638 #undef DEF_FUNCTION_TYPE_VAR_4
639 #undef DEF_FUNCTION_TYPE_VAR_5
640 #undef DEF_POINTER_TYPE
641 builtin_types[(int) BT_LAST] = NULL_TREE;
642
643 lto_init_attributes ();
644
645 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P,\
646 NONANSI_P, ATTRS, IMPLICIT, COND) \
647 if (NAME && COND) \
648 def_builtin_1 (ENUM, NAME, CLASS, builtin_types[(int) TYPE], \
649 builtin_types[(int) LIBTYPE], BOTH_P, FALLBACK_P, \
650 NONANSI_P, built_in_attributes[(int) ATTRS], IMPLICIT);
651 #include "builtins.def"
652 #undef DEF_BUILTIN
653 }
654
655 static GTY(()) tree registered_builtin_types;
656
657 /* Language hooks. */
658
659 static unsigned int
lto_option_lang_mask(void)660 lto_option_lang_mask (void)
661 {
662 return CL_LTO;
663 }
664
665 static bool
lto_complain_wrong_lang_p(const struct cl_option * option ATTRIBUTE_UNUSED)666 lto_complain_wrong_lang_p (const struct cl_option *option ATTRIBUTE_UNUSED)
667 {
668 /* The LTO front end inherits all the options from the first front
669 end that was used. However, not all the original front end
670 options make sense in LTO.
671
672 A real solution would be to filter this in collect2, but collect2
673 does not have access to all the option attributes to know what to
674 filter. So, in lto1 we silently accept inherited flags and do
675 nothing about it. */
676 return false;
677 }
678
679 static void
lto_init_options_struct(struct gcc_options * opts)680 lto_init_options_struct (struct gcc_options *opts)
681 {
682 /* By default, C99-like requirements for complex multiply and divide.
683 ??? Until the complex method is encoded in the IL this is the only
684 safe choice. This will pessimize Fortran code with LTO unless
685 people specify a complex method manually or use -ffast-math. */
686 opts->x_flag_complex_method = 2;
687 }
688
689 /* Handle command-line option SCODE. If the option takes an argument, it is
690 stored in ARG, which is otherwise NULL. VALUE holds either a numerical
691 argument or a binary value indicating whether the positive or negative form
692 of the option was supplied. */
693
694 const char *resolution_file_name;
695 static bool
lto_handle_option(size_t scode,const char * arg,int value ATTRIBUTE_UNUSED,int kind ATTRIBUTE_UNUSED,location_t loc ATTRIBUTE_UNUSED,const struct cl_option_handlers * handlers ATTRIBUTE_UNUSED)696 lto_handle_option (size_t scode, const char *arg,
697 int value ATTRIBUTE_UNUSED, int kind ATTRIBUTE_UNUSED,
698 location_t loc ATTRIBUTE_UNUSED,
699 const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED)
700 {
701 enum opt_code code = (enum opt_code) scode;
702 bool result = true;
703
704 switch (code)
705 {
706 case OPT_fresolution_:
707 resolution_file_name = arg;
708 break;
709
710 case OPT_Wabi:
711 warn_psabi = value;
712 break;
713
714 default:
715 break;
716 }
717
718 return result;
719 }
720
721 /* Perform post-option processing. Does additional initialization based on
722 command-line options. PFILENAME is the main input filename. Returns false
723 to enable subsequent back-end initialization. */
724
725 static bool
lto_post_options(const char ** pfilename ATTRIBUTE_UNUSED)726 lto_post_options (const char **pfilename ATTRIBUTE_UNUSED)
727 {
728 /* -fltrans and -fwpa are mutually exclusive. Check for that here. */
729 if (flag_wpa && flag_ltrans)
730 error ("-fwpa and -fltrans are mutually exclusive");
731
732 if (flag_ltrans)
733 {
734 flag_generate_lto = 0;
735
736 /* During LTRANS, we are not looking at the whole program, only
737 a subset of the whole callgraph. */
738 flag_whole_program = 0;
739 }
740
741 if (flag_wpa)
742 flag_generate_lto = 1;
743
744 /* Excess precision other than "fast" requires front-end
745 support. */
746 flag_excess_precision_cmdline = EXCESS_PRECISION_FAST;
747
748 /* Initialize the compiler back end. */
749 return false;
750 }
751
752 /* Return an integer type with PRECISION bits of precision,
753 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
754
755 static tree
lto_type_for_size(unsigned precision,int unsignedp)756 lto_type_for_size (unsigned precision, int unsignedp)
757 {
758 if (precision == TYPE_PRECISION (integer_type_node))
759 return unsignedp ? unsigned_type_node : integer_type_node;
760
761 if (precision == TYPE_PRECISION (signed_char_type_node))
762 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
763
764 if (precision == TYPE_PRECISION (short_integer_type_node))
765 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
766
767 if (precision == TYPE_PRECISION (long_integer_type_node))
768 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
769
770 if (precision == TYPE_PRECISION (long_long_integer_type_node))
771 return unsignedp
772 ? long_long_unsigned_type_node
773 : long_long_integer_type_node;
774
775 if (precision <= TYPE_PRECISION (intQI_type_node))
776 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
777
778 if (precision <= TYPE_PRECISION (intHI_type_node))
779 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
780
781 if (precision <= TYPE_PRECISION (intSI_type_node))
782 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
783
784 if (precision <= TYPE_PRECISION (intDI_type_node))
785 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
786
787 if (precision <= TYPE_PRECISION (intTI_type_node))
788 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
789
790 return NULL_TREE;
791 }
792
793
794 /* Return a data type that has machine mode MODE.
795 If the mode is an integer,
796 then UNSIGNEDP selects between signed and unsigned types.
797 If the mode is a fixed-point mode,
798 then UNSIGNEDP selects between saturating and nonsaturating types. */
799
800 static tree
lto_type_for_mode(enum machine_mode mode,int unsigned_p)801 lto_type_for_mode (enum machine_mode mode, int unsigned_p)
802 {
803 tree t;
804
805 if (mode == TYPE_MODE (integer_type_node))
806 return unsigned_p ? unsigned_type_node : integer_type_node;
807
808 if (mode == TYPE_MODE (signed_char_type_node))
809 return unsigned_p ? unsigned_char_type_node : signed_char_type_node;
810
811 if (mode == TYPE_MODE (short_integer_type_node))
812 return unsigned_p ? short_unsigned_type_node : short_integer_type_node;
813
814 if (mode == TYPE_MODE (long_integer_type_node))
815 return unsigned_p ? long_unsigned_type_node : long_integer_type_node;
816
817 if (mode == TYPE_MODE (long_long_integer_type_node))
818 return unsigned_p ? long_long_unsigned_type_node : long_long_integer_type_node;
819
820 if (mode == QImode)
821 return unsigned_p ? unsigned_intQI_type_node : intQI_type_node;
822
823 if (mode == HImode)
824 return unsigned_p ? unsigned_intHI_type_node : intHI_type_node;
825
826 if (mode == SImode)
827 return unsigned_p ? unsigned_intSI_type_node : intSI_type_node;
828
829 if (mode == DImode)
830 return unsigned_p ? unsigned_intDI_type_node : intDI_type_node;
831
832 #if HOST_BITS_PER_WIDE_INT >= 64
833 if (mode == TYPE_MODE (intTI_type_node))
834 return unsigned_p ? unsigned_intTI_type_node : intTI_type_node;
835 #endif
836
837 if (mode == TYPE_MODE (float_type_node))
838 return float_type_node;
839
840 if (mode == TYPE_MODE (double_type_node))
841 return double_type_node;
842
843 if (mode == TYPE_MODE (long_double_type_node))
844 return long_double_type_node;
845
846 if (mode == TYPE_MODE (void_type_node))
847 return void_type_node;
848
849 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
850 return (unsigned_p
851 ? make_unsigned_type (GET_MODE_PRECISION (mode))
852 : make_signed_type (GET_MODE_PRECISION (mode)));
853
854 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
855 return (unsigned_p
856 ? make_unsigned_type (GET_MODE_PRECISION (mode))
857 : make_signed_type (GET_MODE_PRECISION (mode)));
858
859 if (COMPLEX_MODE_P (mode))
860 {
861 enum machine_mode inner_mode;
862 tree inner_type;
863
864 if (mode == TYPE_MODE (complex_float_type_node))
865 return complex_float_type_node;
866 if (mode == TYPE_MODE (complex_double_type_node))
867 return complex_double_type_node;
868 if (mode == TYPE_MODE (complex_long_double_type_node))
869 return complex_long_double_type_node;
870
871 if (mode == TYPE_MODE (complex_integer_type_node) && !unsigned_p)
872 return complex_integer_type_node;
873
874 inner_mode = GET_MODE_INNER (mode);
875 inner_type = lto_type_for_mode (inner_mode, unsigned_p);
876 if (inner_type != NULL_TREE)
877 return build_complex_type (inner_type);
878 }
879 else if (VECTOR_MODE_P (mode))
880 {
881 enum machine_mode inner_mode = GET_MODE_INNER (mode);
882 tree inner_type = lto_type_for_mode (inner_mode, unsigned_p);
883 if (inner_type != NULL_TREE)
884 return build_vector_type_for_mode (inner_type, mode);
885 }
886
887 if (mode == TYPE_MODE (dfloat32_type_node))
888 return dfloat32_type_node;
889 if (mode == TYPE_MODE (dfloat64_type_node))
890 return dfloat64_type_node;
891 if (mode == TYPE_MODE (dfloat128_type_node))
892 return dfloat128_type_node;
893
894 if (ALL_SCALAR_FIXED_POINT_MODE_P (mode))
895 {
896 if (mode == TYPE_MODE (short_fract_type_node))
897 return unsigned_p ? sat_short_fract_type_node : short_fract_type_node;
898 if (mode == TYPE_MODE (fract_type_node))
899 return unsigned_p ? sat_fract_type_node : fract_type_node;
900 if (mode == TYPE_MODE (long_fract_type_node))
901 return unsigned_p ? sat_long_fract_type_node : long_fract_type_node;
902 if (mode == TYPE_MODE (long_long_fract_type_node))
903 return unsigned_p ? sat_long_long_fract_type_node
904 : long_long_fract_type_node;
905
906 if (mode == TYPE_MODE (unsigned_short_fract_type_node))
907 return unsigned_p ? sat_unsigned_short_fract_type_node
908 : unsigned_short_fract_type_node;
909 if (mode == TYPE_MODE (unsigned_fract_type_node))
910 return unsigned_p ? sat_unsigned_fract_type_node
911 : unsigned_fract_type_node;
912 if (mode == TYPE_MODE (unsigned_long_fract_type_node))
913 return unsigned_p ? sat_unsigned_long_fract_type_node
914 : unsigned_long_fract_type_node;
915 if (mode == TYPE_MODE (unsigned_long_long_fract_type_node))
916 return unsigned_p ? sat_unsigned_long_long_fract_type_node
917 : unsigned_long_long_fract_type_node;
918
919 if (mode == TYPE_MODE (short_accum_type_node))
920 return unsigned_p ? sat_short_accum_type_node : short_accum_type_node;
921 if (mode == TYPE_MODE (accum_type_node))
922 return unsigned_p ? sat_accum_type_node : accum_type_node;
923 if (mode == TYPE_MODE (long_accum_type_node))
924 return unsigned_p ? sat_long_accum_type_node : long_accum_type_node;
925 if (mode == TYPE_MODE (long_long_accum_type_node))
926 return unsigned_p ? sat_long_long_accum_type_node
927 : long_long_accum_type_node;
928
929 if (mode == TYPE_MODE (unsigned_short_accum_type_node))
930 return unsigned_p ? sat_unsigned_short_accum_type_node
931 : unsigned_short_accum_type_node;
932 if (mode == TYPE_MODE (unsigned_accum_type_node))
933 return unsigned_p ? sat_unsigned_accum_type_node
934 : unsigned_accum_type_node;
935 if (mode == TYPE_MODE (unsigned_long_accum_type_node))
936 return unsigned_p ? sat_unsigned_long_accum_type_node
937 : unsigned_long_accum_type_node;
938 if (mode == TYPE_MODE (unsigned_long_long_accum_type_node))
939 return unsigned_p ? sat_unsigned_long_long_accum_type_node
940 : unsigned_long_long_accum_type_node;
941
942 if (mode == QQmode)
943 return unsigned_p ? sat_qq_type_node : qq_type_node;
944 if (mode == HQmode)
945 return unsigned_p ? sat_hq_type_node : hq_type_node;
946 if (mode == SQmode)
947 return unsigned_p ? sat_sq_type_node : sq_type_node;
948 if (mode == DQmode)
949 return unsigned_p ? sat_dq_type_node : dq_type_node;
950 if (mode == TQmode)
951 return unsigned_p ? sat_tq_type_node : tq_type_node;
952
953 if (mode == UQQmode)
954 return unsigned_p ? sat_uqq_type_node : uqq_type_node;
955 if (mode == UHQmode)
956 return unsigned_p ? sat_uhq_type_node : uhq_type_node;
957 if (mode == USQmode)
958 return unsigned_p ? sat_usq_type_node : usq_type_node;
959 if (mode == UDQmode)
960 return unsigned_p ? sat_udq_type_node : udq_type_node;
961 if (mode == UTQmode)
962 return unsigned_p ? sat_utq_type_node : utq_type_node;
963
964 if (mode == HAmode)
965 return unsigned_p ? sat_ha_type_node : ha_type_node;
966 if (mode == SAmode)
967 return unsigned_p ? sat_sa_type_node : sa_type_node;
968 if (mode == DAmode)
969 return unsigned_p ? sat_da_type_node : da_type_node;
970 if (mode == TAmode)
971 return unsigned_p ? sat_ta_type_node : ta_type_node;
972
973 if (mode == UHAmode)
974 return unsigned_p ? sat_uha_type_node : uha_type_node;
975 if (mode == USAmode)
976 return unsigned_p ? sat_usa_type_node : usa_type_node;
977 if (mode == UDAmode)
978 return unsigned_p ? sat_uda_type_node : uda_type_node;
979 if (mode == UTAmode)
980 return unsigned_p ? sat_uta_type_node : uta_type_node;
981 }
982
983 for (t = registered_builtin_types; t; t = TREE_CHAIN (t))
984 if (TYPE_MODE (TREE_VALUE (t)) == mode)
985 return TREE_VALUE (t);
986
987 return NULL_TREE;
988 }
989
990 /* Return true if we are in the global binding level. */
991
992 static bool
lto_global_bindings_p(void)993 lto_global_bindings_p (void)
994 {
995 return cfun == NULL;
996 }
997
998 static void
lto_set_decl_assembler_name(tree decl)999 lto_set_decl_assembler_name (tree decl)
1000 {
1001 /* This is almost the same as lhd_set_decl_assembler_name, except that
1002 we need to uniquify file-scope names, even if they are not
1003 TREE_PUBLIC, to avoid conflicts between individual files. */
1004 tree id;
1005
1006 if (TREE_PUBLIC (decl))
1007 id = targetm.mangle_decl_assembler_name (decl, DECL_NAME (decl));
1008 else
1009 {
1010 const char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
1011 char *label;
1012
1013 ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
1014 id = get_identifier (label);
1015 }
1016
1017 SET_DECL_ASSEMBLER_NAME (decl, id);
1018 }
1019
1020 static tree
lto_pushdecl(tree t ATTRIBUTE_UNUSED)1021 lto_pushdecl (tree t ATTRIBUTE_UNUSED)
1022 {
1023 /* Do nothing, since we get all information from DWARF and LTO
1024 sections. */
1025 return NULL_TREE;
1026 }
1027
1028 static tree
lto_getdecls(void)1029 lto_getdecls (void)
1030 {
1031 /* We have our own write_globals langhook, hence the getdecls
1032 langhook shouldn't be used, except by dbxout.c, so we can't
1033 just abort here. */
1034 return NULL_TREE;
1035 }
1036
1037 static void
lto_write_globals(void)1038 lto_write_globals (void)
1039 {
1040 tree *vec = VEC_address (tree, lto_global_var_decls);
1041 int len = VEC_length (tree, lto_global_var_decls);
1042 wrapup_global_declarations (vec, len);
1043 emit_debug_global_declarations (vec, len);
1044 VEC_free (tree, gc, lto_global_var_decls);
1045 }
1046
1047 static tree
lto_builtin_function(tree decl)1048 lto_builtin_function (tree decl)
1049 {
1050 return decl;
1051 }
1052
1053 static void
lto_register_builtin_type(tree type,const char * name)1054 lto_register_builtin_type (tree type, const char *name)
1055 {
1056 tree decl;
1057
1058 decl = build_decl (UNKNOWN_LOCATION, TYPE_DECL, get_identifier (name), type);
1059 DECL_ARTIFICIAL (decl) = 1;
1060 if (!TYPE_NAME (type))
1061 TYPE_NAME (type) = decl;
1062
1063 registered_builtin_types = tree_cons (0, type, registered_builtin_types);
1064 }
1065
1066 /* Build nodes that would have be created by the C front-end; necessary
1067 for including builtin-types.def and ultimately builtins.def. */
1068
1069 static void
lto_build_c_type_nodes(void)1070 lto_build_c_type_nodes (void)
1071 {
1072 gcc_assert (void_type_node);
1073
1074 void_list_node = build_tree_list (NULL_TREE, void_type_node);
1075 string_type_node = build_pointer_type (char_type_node);
1076 const_string_type_node
1077 = build_pointer_type (build_qualified_type (char_type_node, TYPE_QUAL_CONST));
1078
1079 if (strcmp (SIZE_TYPE, "unsigned int") == 0)
1080 {
1081 intmax_type_node = integer_type_node;
1082 uintmax_type_node = unsigned_type_node;
1083 signed_size_type_node = integer_type_node;
1084 }
1085 else if (strcmp (SIZE_TYPE, "long unsigned int") == 0)
1086 {
1087 intmax_type_node = long_integer_type_node;
1088 uintmax_type_node = long_unsigned_type_node;
1089 signed_size_type_node = long_integer_type_node;
1090 }
1091 else if (strcmp (SIZE_TYPE, "long long unsigned int") == 0)
1092 {
1093 intmax_type_node = long_long_integer_type_node;
1094 uintmax_type_node = long_long_unsigned_type_node;
1095 signed_size_type_node = long_long_integer_type_node;
1096 }
1097 else
1098 gcc_unreachable ();
1099
1100 wint_type_node = unsigned_type_node;
1101 pid_type_node = integer_type_node;
1102 }
1103
1104 /* Re-compute TYPE_CANONICAL for NODE and related types. */
1105
1106 static void
lto_register_canonical_types(tree node)1107 lto_register_canonical_types (tree node)
1108 {
1109 if (!node
1110 || !TYPE_P (node))
1111 return;
1112
1113 TYPE_CANONICAL (node) = NULL_TREE;
1114 TYPE_CANONICAL (node) = gimple_register_canonical_type (node);
1115
1116 if (POINTER_TYPE_P (node)
1117 || TREE_CODE (node) == COMPLEX_TYPE
1118 || TREE_CODE (node) == ARRAY_TYPE)
1119 lto_register_canonical_types (TREE_TYPE (node));
1120 }
1121
1122 /* Perform LTO-specific initialization. */
1123
1124 static bool
lto_init(void)1125 lto_init (void)
1126 {
1127 unsigned i;
1128
1129 /* We need to generate LTO if running in WPA mode. */
1130 flag_generate_lto = flag_wpa;
1131
1132 /* Initialize libcpp line maps for gcc_assert to work. */
1133 linemap_add (line_table, LC_ENTER, 0, NULL, 0);
1134
1135 /* Create the basic integer types. */
1136 build_common_tree_nodes (flag_signed_char, /*short_double=*/false);
1137
1138 /* The global tree for the main identifier is filled in by
1139 language-specific front-end initialization that is not run in the
1140 LTO back-end. It appears that all languages that perform such
1141 initialization currently do so in the same way, so we do it here. */
1142 if (main_identifier_node == NULL_TREE)
1143 main_identifier_node = get_identifier ("main");
1144
1145 /* In the C++ front-end, fileptr_type_node is defined as a variant
1146 copy of of ptr_type_node, rather than ptr_node itself. The
1147 distinction should only be relevant to the front-end, so we
1148 always use the C definition here in lto1. */
1149 gcc_assert (fileptr_type_node == ptr_type_node);
1150 gcc_assert (TYPE_MAIN_VARIANT (fileptr_type_node) == ptr_type_node);
1151
1152 ptrdiff_type_node = integer_type_node;
1153
1154 lto_build_c_type_nodes ();
1155 gcc_assert (va_list_type_node);
1156
1157 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
1158 {
1159 tree x = build_pointer_type (TREE_TYPE (va_list_type_node));
1160 lto_define_builtins (x, x);
1161 }
1162 else
1163 {
1164 lto_define_builtins (va_list_type_node,
1165 build_reference_type (va_list_type_node));
1166 }
1167
1168 targetm.init_builtins ();
1169 build_common_builtin_nodes ();
1170
1171 /* Assign names to the builtin types, otherwise they'll end up
1172 as __unknown__ in debug info.
1173 ??? We simply need to stop pre-seeding the streamer cache.
1174 Below is modeled after from c-common.c:c_common_nodes_and_builtins */
1175 #define NAME_TYPE(t,n) \
1176 if (t) \
1177 TYPE_NAME (t) = build_decl (UNKNOWN_LOCATION, TYPE_DECL, \
1178 get_identifier (n), t)
1179 NAME_TYPE (integer_type_node, "int");
1180 NAME_TYPE (char_type_node, "char");
1181 NAME_TYPE (long_integer_type_node, "long int");
1182 NAME_TYPE (unsigned_type_node, "unsigned int");
1183 NAME_TYPE (long_unsigned_type_node, "long unsigned int");
1184 NAME_TYPE (long_long_integer_type_node, "long long int");
1185 NAME_TYPE (long_long_unsigned_type_node, "long long unsigned int");
1186 NAME_TYPE (short_integer_type_node, "short int");
1187 NAME_TYPE (short_unsigned_type_node, "short unsigned int");
1188 if (signed_char_type_node != char_type_node)
1189 NAME_TYPE (signed_char_type_node, "signed char");
1190 if (unsigned_char_type_node != char_type_node)
1191 NAME_TYPE (unsigned_char_type_node, "unsigned char");
1192 NAME_TYPE (float_type_node, "float");
1193 NAME_TYPE (double_type_node, "double");
1194 NAME_TYPE (long_double_type_node, "long double");
1195 NAME_TYPE (void_type_node, "void");
1196 NAME_TYPE (boolean_type_node, "bool");
1197 #undef NAME_TYPE
1198
1199 /* Register the common node types with the canonical type machinery so
1200 we properly share alias-sets across languages and TUs. Do not
1201 expose the common nodes as type merge target - those that should be
1202 are already exposed so by pre-loading the LTO streamer caches. */
1203 for (i = 0; i < itk_none; ++i)
1204 lto_register_canonical_types (integer_types[i]);
1205 /* The sizetypes are not used to access data so we do not need to
1206 do anything about them. */
1207 for (i = 0; i < TI_MAX; ++i)
1208 lto_register_canonical_types (global_trees[i]);
1209
1210 /* Initialize LTO-specific data structures. */
1211 lto_global_var_decls = VEC_alloc (tree, gc, 256);
1212 in_lto_p = true;
1213
1214 return true;
1215 }
1216
1217 /* Initialize tree structures required by the LTO front end. */
1218
lto_init_ts(void)1219 static void lto_init_ts (void)
1220 {
1221 tree_contains_struct[NAMESPACE_DECL][TS_DECL_MINIMAL] = 1;
1222 }
1223
1224 #undef LANG_HOOKS_NAME
1225 #define LANG_HOOKS_NAME "GNU GIMPLE"
1226 #undef LANG_HOOKS_OPTION_LANG_MASK
1227 #define LANG_HOOKS_OPTION_LANG_MASK lto_option_lang_mask
1228 #undef LANG_HOOKS_COMPLAIN_WRONG_LANG_P
1229 #define LANG_HOOKS_COMPLAIN_WRONG_LANG_P lto_complain_wrong_lang_p
1230 #undef LANG_HOOKS_INIT_OPTIONS_STRUCT
1231 #define LANG_HOOKS_INIT_OPTIONS_STRUCT lto_init_options_struct
1232 #undef LANG_HOOKS_HANDLE_OPTION
1233 #define LANG_HOOKS_HANDLE_OPTION lto_handle_option
1234 #undef LANG_HOOKS_POST_OPTIONS
1235 #define LANG_HOOKS_POST_OPTIONS lto_post_options
1236 #undef LANG_HOOKS_GET_ALIAS_SET
1237 #define LANG_HOOKS_GET_ALIAS_SET gimple_get_alias_set
1238 #undef LANG_HOOKS_TYPE_FOR_MODE
1239 #define LANG_HOOKS_TYPE_FOR_MODE lto_type_for_mode
1240 #undef LANG_HOOKS_TYPE_FOR_SIZE
1241 #define LANG_HOOKS_TYPE_FOR_SIZE lto_type_for_size
1242 #undef LANG_HOOKS_SET_DECL_ASSEMBLER_NAME
1243 #define LANG_HOOKS_SET_DECL_ASSEMBLER_NAME lto_set_decl_assembler_name
1244 #undef LANG_HOOKS_GLOBAL_BINDINGS_P
1245 #define LANG_HOOKS_GLOBAL_BINDINGS_P lto_global_bindings_p
1246 #undef LANG_HOOKS_PUSHDECL
1247 #define LANG_HOOKS_PUSHDECL lto_pushdecl
1248 #undef LANG_HOOKS_GETDECLS
1249 #define LANG_HOOKS_GETDECLS lto_getdecls
1250 #undef LANG_HOOKS_WRITE_GLOBALS
1251 #define LANG_HOOKS_WRITE_GLOBALS lto_write_globals
1252 #undef LANG_HOOKS_REGISTER_BUILTIN_TYPE
1253 #define LANG_HOOKS_REGISTER_BUILTIN_TYPE lto_register_builtin_type
1254 #undef LANG_HOOKS_BUILTIN_FUNCTION
1255 #define LANG_HOOKS_BUILTIN_FUNCTION lto_builtin_function
1256 #undef LANG_HOOKS_INIT
1257 #define LANG_HOOKS_INIT lto_init
1258 #undef LANG_HOOKS_PARSE_FILE
1259 #define LANG_HOOKS_PARSE_FILE lto_main
1260 #undef LANG_HOOKS_CALLGRAPH_EXPAND_FUNCTION
1261 #define LANG_HOOKS_CALLGRAPH_EXPAND_FUNCTION tree_rest_of_compilation
1262 #undef LANG_HOOKS_REDUCE_BIT_FIELD_OPERATIONS
1263 #define LANG_HOOKS_REDUCE_BIT_FIELD_OPERATIONS true
1264 #undef LANG_HOOKS_TYPES_COMPATIBLE_P
1265 #define LANG_HOOKS_TYPES_COMPATIBLE_P NULL
1266 #undef LANG_HOOKS_EH_PERSONALITY
1267 #define LANG_HOOKS_EH_PERSONALITY lto_eh_personality
1268
1269 /* Attribute hooks. */
1270 #undef LANG_HOOKS_COMMON_ATTRIBUTE_TABLE
1271 #define LANG_HOOKS_COMMON_ATTRIBUTE_TABLE lto_attribute_table
1272 #undef LANG_HOOKS_FORMAT_ATTRIBUTE_TABLE
1273 #define LANG_HOOKS_FORMAT_ATTRIBUTE_TABLE lto_format_attribute_table
1274
1275 #undef LANG_HOOKS_BEGIN_SECTION
1276 #define LANG_HOOKS_BEGIN_SECTION lto_obj_begin_section
1277 #undef LANG_HOOKS_APPEND_DATA
1278 #define LANG_HOOKS_APPEND_DATA lto_obj_append_data
1279 #undef LANG_HOOKS_END_SECTION
1280 #define LANG_HOOKS_END_SECTION lto_obj_end_section
1281
1282 #undef LANG_HOOKS_INIT_TS
1283 #define LANG_HOOKS_INIT_TS lto_init_ts
1284
1285 struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER;
1286
1287 /* Language hooks that are not part of lang_hooks. */
1288
1289 tree
convert(tree type ATTRIBUTE_UNUSED,tree expr ATTRIBUTE_UNUSED)1290 convert (tree type ATTRIBUTE_UNUSED, tree expr ATTRIBUTE_UNUSED)
1291 {
1292 gcc_unreachable ();
1293 }
1294
1295 /* Tree walking support. */
1296
1297 static enum lto_tree_node_structure_enum
lto_tree_node_structure(union lang_tree_node * t ATTRIBUTE_UNUSED)1298 lto_tree_node_structure (union lang_tree_node *t ATTRIBUTE_UNUSED)
1299 {
1300 return TS_LTO_GENERIC;
1301 }
1302
1303 #include "ggc.h"
1304 #include "gtype-lto.h"
1305 #include "gt-lto-lto-lang.h"
1306