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