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