gcc/lto/lto-lang.c

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