gcc/lto/lto-lang.c

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