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,
 620                    int value ATTRIBUTE_UNUSED, int kind ATTRIBUTE_UNUSED)
 621 {
 622   enum opt_code code = (enum opt_code) scode;
 623   int result = 1;
 624
 625   switch (code)
 626     {
 627     case OPT_fresolution_:
 628       resolution_file_name = arg;
 629       result = 1;
 630       break;
 631
 632     case OPT_Wabi:
 633       warn_psabi = value;
 634       break;
 635
 636     case OPT_fsigned_char:
 637       flag_signed_char = value;
 638       break;
 639
 640     case OPT_funsigned_char:
 641       flag_signed_char = !value;
 642       break;
 643
 644     default:
 645       break;
 646     }
 647
 648   return result;
 649 }
 650
 651 /* Perform post-option processing.  Does additional initialization based on
 652    command-line options.  PFILENAME is the main input filename.  Returns false
 653    to enable subsequent back-end initialization.  */
 654
 655 static bool
 656 lto_post_options (const char **pfilename ATTRIBUTE_UNUSED)
 657 {
 658   /* -fltrans and -fwpa are mutually exclusive.  Check for that here.  */
 659   if (flag_wpa && flag_ltrans)
 660     error ("-fwpa and -fltrans are mutually exclusive");
 661
 662   if (flag_ltrans)
 663     {
 664       flag_generate_lto = 0;
 665
 666       /* During LTRANS, we are not looking at the whole program, only
 667          a subset of the whole callgraph.  */
 668       flag_whole_program = 0;
 669     }
 670
 671   if (flag_wpa)
 672     flag_generate_lto = 1;
 673
 674   /* Excess precision other than "fast" requires front-end
 675      support.  */
 676   flag_excess_precision_cmdline = EXCESS_PRECISION_FAST;
 677
 678   lto_read_all_file_options ();
 679
 680   /* Initialize the compiler back end.  */
 681   return false;
 682 }
 683
 684 /* Return an integer type with PRECISION bits of precision,
 685    that is unsigned if UNSIGNEDP is nonzero, otherwise signed.  */
 686
 687 static tree
 688 lto_type_for_size (unsigned precision, int unsignedp)
 689 {
 690   if (precision == TYPE_PRECISION (integer_type_node))
 691     return unsignedp ? unsigned_type_node : integer_type_node;
 692
 693   if (precision == TYPE_PRECISION (signed_char_type_node))
 694     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
 695
 696   if (precision == TYPE_PRECISION (short_integer_type_node))
 697     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
 698
 699   if (precision == TYPE_PRECISION (long_integer_type_node))
 700     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
 701
 702   if (precision == TYPE_PRECISION (long_long_integer_type_node))
 703     return unsignedp
 704            ? long_long_unsigned_type_node
 705            : long_long_integer_type_node;
 706
 707   if (precision <= TYPE_PRECISION (intQI_type_node))
 708     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
 709
 710   if (precision <= TYPE_PRECISION (intHI_type_node))
 711     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
 712
 713   if (precision <= TYPE_PRECISION (intSI_type_node))
 714     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
 715
 716   if (precision <= TYPE_PRECISION (intDI_type_node))
 717     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
 718
 719   if (precision <= TYPE_PRECISION (intTI_type_node))
 720     return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
 721
 722   return NULL_TREE;
 723 }
 724
 725
 726 /* Return a data type that has machine mode MODE.
 727    If the mode is an integer,
 728    then UNSIGNEDP selects between signed and unsigned types.
 729    If the mode is a fixed-point mode,
 730    then UNSIGNEDP selects between saturating and nonsaturating types.  */
 731
 732 static tree
 733 lto_type_for_mode (enum machine_mode mode, int unsigned_p)
 734 {
 735   tree t;
 736
 737   if (mode == TYPE_MODE (integer_type_node))
 738     return unsigned_p ? unsigned_type_node : integer_type_node;
 739
 740   if (mode == TYPE_MODE (signed_char_type_node))
 741     return unsigned_p ? unsigned_char_type_node : signed_char_type_node;
 742
 743   if (mode == TYPE_MODE (short_integer_type_node))
 744     return unsigned_p ? short_unsigned_type_node : short_integer_type_node;
 745
 746   if (mode == TYPE_MODE (long_integer_type_node))
 747     return unsigned_p ? long_unsigned_type_node : long_integer_type_node;
 748
 749   if (mode == TYPE_MODE (long_long_integer_type_node))
 750     return unsigned_p ? long_long_unsigned_type_node : long_long_integer_type_node;
 751
 752   if (mode == QImode)
 753     return unsigned_p ? unsigned_intQI_type_node : intQI_type_node;
 754
 755   if (mode == HImode)
 756     return unsigned_p ? unsigned_intHI_type_node : intHI_type_node;
 757
 758   if (mode == SImode)
 759     return unsigned_p ? unsigned_intSI_type_node : intSI_type_node;
 760
 761   if (mode == DImode)
 762     return unsigned_p ? unsigned_intDI_type_node : intDI_type_node;
 763
 764 #if HOST_BITS_PER_WIDE_INT >= 64
 765   if (mode == TYPE_MODE (intTI_type_node))
 766     return unsigned_p ? unsigned_intTI_type_node : intTI_type_node;
 767 #endif
 768
 769   if (mode == TYPE_MODE (float_type_node))
 770     return float_type_node;
 771
 772   if (mode == TYPE_MODE (double_type_node))
 773     return double_type_node;
 774
 775   if (mode == TYPE_MODE (long_double_type_node))
 776     return long_double_type_node;
 777
 778   if (mode == TYPE_MODE (void_type_node))
 779     return void_type_node;
 780
 781   if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
 782     return (unsigned_p
 783             ? make_unsigned_type (GET_MODE_PRECISION (mode))
 784             : make_signed_type (GET_MODE_PRECISION (mode)));
 785
 786   if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
 787     return (unsigned_p
 788             ? make_unsigned_type (GET_MODE_PRECISION (mode))
 789             : make_signed_type (GET_MODE_PRECISION (mode)));
 790
 791   if (COMPLEX_MODE_P (mode))
 792     {
 793       enum machine_mode inner_mode;
 794       tree inner_type;
 795
 796       if (mode == TYPE_MODE (complex_float_type_node))
 797         return complex_float_type_node;
 798       if (mode == TYPE_MODE (complex_double_type_node))
 799         return complex_double_type_node;
 800       if (mode == TYPE_MODE (complex_long_double_type_node))
 801         return complex_long_double_type_node;
 802
 803       if (mode == TYPE_MODE (complex_integer_type_node) && !unsigned_p)
 804         return complex_integer_type_node;
 805
 806       inner_mode = GET_MODE_INNER (mode);
 807       inner_type = lto_type_for_mode (inner_mode, unsigned_p);
 808       if (inner_type != NULL_TREE)
 809         return build_complex_type (inner_type);
 810     }
 811   else if (VECTOR_MODE_P (mode))
 812     {
 813       enum machine_mode inner_mode = GET_MODE_INNER (mode);
 814       tree inner_type = lto_type_for_mode (inner_mode, unsigned_p);
 815       if (inner_type != NULL_TREE)
 816         return build_vector_type_for_mode (inner_type, mode);
 817     }
 818
 819   if (mode == TYPE_MODE (dfloat32_type_node))
 820     return dfloat32_type_node;
 821   if (mode == TYPE_MODE (dfloat64_type_node))
 822     return dfloat64_type_node;
 823   if (mode == TYPE_MODE (dfloat128_type_node))
 824     return dfloat128_type_node;
 825
 826   if (ALL_SCALAR_FIXED_POINT_MODE_P (mode))
 827     {
 828       if (mode == TYPE_MODE (short_fract_type_node))
 829         return unsigned_p ? sat_short_fract_type_node : short_fract_type_node;
 830       if (mode == TYPE_MODE (fract_type_node))
 831         return unsigned_p ? sat_fract_type_node : fract_type_node;
 832       if (mode == TYPE_MODE (long_fract_type_node))
 833         return unsigned_p ? sat_long_fract_type_node : long_fract_type_node;
 834       if (mode == TYPE_MODE (long_long_fract_type_node))
 835         return unsigned_p ? sat_long_long_fract_type_node
 836                          : long_long_fract_type_node;
 837
 838       if (mode == TYPE_MODE (unsigned_short_fract_type_node))
 839         return unsigned_p ? sat_unsigned_short_fract_type_node
 840                          : unsigned_short_fract_type_node;
 841       if (mode == TYPE_MODE (unsigned_fract_type_node))
 842         return unsigned_p ? sat_unsigned_fract_type_node
 843                          : unsigned_fract_type_node;
 844       if (mode == TYPE_MODE (unsigned_long_fract_type_node))
 845         return unsigned_p ? sat_unsigned_long_fract_type_node
 846                          : unsigned_long_fract_type_node;
 847       if (mode == TYPE_MODE (unsigned_long_long_fract_type_node))
 848         return unsigned_p ? sat_unsigned_long_long_fract_type_node
 849                          : unsigned_long_long_fract_type_node;
 850
 851       if (mode == TYPE_MODE (short_accum_type_node))
 852         return unsigned_p ? sat_short_accum_type_node : short_accum_type_node;
 853       if (mode == TYPE_MODE (accum_type_node))
 854         return unsigned_p ? sat_accum_type_node : accum_type_node;
 855       if (mode == TYPE_MODE (long_accum_type_node))
 856         return unsigned_p ? sat_long_accum_type_node : long_accum_type_node;
 857       if (mode == TYPE_MODE (long_long_accum_type_node))
 858         return unsigned_p ? sat_long_long_accum_type_node
 859                          : long_long_accum_type_node;
 860
 861       if (mode == TYPE_MODE (unsigned_short_accum_type_node))
 862         return unsigned_p ? sat_unsigned_short_accum_type_node
 863                          : unsigned_short_accum_type_node;
 864       if (mode == TYPE_MODE (unsigned_accum_type_node))
 865         return unsigned_p ? sat_unsigned_accum_type_node
 866                          : unsigned_accum_type_node;
 867       if (mode == TYPE_MODE (unsigned_long_accum_type_node))
 868         return unsigned_p ? sat_unsigned_long_accum_type_node
 869                          : unsigned_long_accum_type_node;
 870       if (mode == TYPE_MODE (unsigned_long_long_accum_type_node))
 871         return unsigned_p ? sat_unsigned_long_long_accum_type_node
 872                          : unsigned_long_long_accum_type_node;
 873
 874       if (mode == QQmode)
 875         return unsigned_p ? sat_qq_type_node : qq_type_node;
 876       if (mode == HQmode)
 877         return unsigned_p ? sat_hq_type_node : hq_type_node;
 878       if (mode == SQmode)
 879         return unsigned_p ? sat_sq_type_node : sq_type_node;
 880       if (mode == DQmode)
 881         return unsigned_p ? sat_dq_type_node : dq_type_node;
 882       if (mode == TQmode)
 883         return unsigned_p ? sat_tq_type_node : tq_type_node;
 884
 885       if (mode == UQQmode)
 886         return unsigned_p ? sat_uqq_type_node : uqq_type_node;
 887       if (mode == UHQmode)
 888         return unsigned_p ? sat_uhq_type_node : uhq_type_node;
 889       if (mode == USQmode)
 890         return unsigned_p ? sat_usq_type_node : usq_type_node;
 891       if (mode == UDQmode)
 892         return unsigned_p ? sat_udq_type_node : udq_type_node;
 893       if (mode == UTQmode)
 894         return unsigned_p ? sat_utq_type_node : utq_type_node;
 895
 896       if (mode == HAmode)
 897         return unsigned_p ? sat_ha_type_node : ha_type_node;
 898       if (mode == SAmode)
 899         return unsigned_p ? sat_sa_type_node : sa_type_node;
 900       if (mode == DAmode)
 901         return unsigned_p ? sat_da_type_node : da_type_node;
 902       if (mode == TAmode)
 903         return unsigned_p ? sat_ta_type_node : ta_type_node;
 904
 905       if (mode == UHAmode)
 906         return unsigned_p ? sat_uha_type_node : uha_type_node;
 907       if (mode == USAmode)
 908         return unsigned_p ? sat_usa_type_node : usa_type_node;
 909       if (mode == UDAmode)
 910         return unsigned_p ? sat_uda_type_node : uda_type_node;
 911       if (mode == UTAmode)
 912         return unsigned_p ? sat_uta_type_node : uta_type_node;
 913     }
 914
 915   for (t = registered_builtin_types; t; t = TREE_CHAIN (t))
 916     if (TYPE_MODE (TREE_VALUE (t)) == mode)
 917       return TREE_VALUE (t);
 918
 919   return NULL_TREE;
 920 }
 921
 922 static int
 923 lto_global_bindings_p (void)
 924 {
 925   return cfun == NULL;
 926 }
 927
 928 static void
 929 lto_set_decl_assembler_name (tree decl)
 930 {
 931   /* This is almost the same as lhd_set_decl_assembler_name, except that
 932      we need to uniquify file-scope names, even if they are not
 933      TREE_PUBLIC, to avoid conflicts between individual files.  */
 934   tree id;
 935
 936   if (TREE_PUBLIC (decl))
 937     id = targetm.mangle_decl_assembler_name (decl, DECL_NAME (decl));
 938   else
 939     {
 940       const char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
 941       char *label;
 942
 943       ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
 944       id = get_identifier (label);
 945     }
 946
 947   SET_DECL_ASSEMBLER_NAME (decl, id);
 948 }
 949
 950 static tree
 951 lto_pushdecl (tree t ATTRIBUTE_UNUSED)
 952 {
 953   /* Do nothing, since we get all information from DWARF and LTO
 954      sections.  */
 955   return NULL_TREE;
 956 }
 957
 958 static tree
 959 lto_getdecls (void)
 960 {
 961   return registered_builtin_fndecls;
 962 }
 963
 964 static void
 965 lto_write_globals (void)
 966 {
 967   tree *vec = VEC_address (tree, lto_global_var_decls);
 968   int len = VEC_length (tree, lto_global_var_decls);
 969   wrapup_global_declarations (vec, len);
 970   emit_debug_global_declarations (vec, len);
 971   VEC_free (tree, gc, lto_global_var_decls);
 972 }
 973
 974 static tree
 975 lto_builtin_function (tree decl)
 976 {
 977   /* Record it.  */
 978   TREE_CHAIN (decl) = registered_builtin_fndecls;
 979   registered_builtin_fndecls = decl;
 980
 981   return decl;
 982 }
 983
 984 static void
 985 lto_register_builtin_type (tree type, const char *name)
 986 {
 987   tree decl;
 988
 989   decl = build_decl (UNKNOWN_LOCATION, TYPE_DECL, get_identifier (name), type);
 990   DECL_ARTIFICIAL (decl) = 1;
 991   if (!TYPE_NAME (type))
 992     TYPE_NAME (type) = decl;
 993
 994   registered_builtin_types = tree_cons (0, type, registered_builtin_types);
 995 }
 996
 997 /* Build nodes that would have be created by the C front-end; necessary
 998    for including builtin-types.def and ultimately builtins.def.  */
 999
1000 static void
1001 lto_build_c_type_nodes (void)
1002 {
1003   gcc_assert (void_type_node);
1004
1005   void_list_node = build_tree_list (NULL_TREE, void_type_node);
1006   string_type_node = build_pointer_type (char_type_node);
1007   const_string_type_node
1008     = build_pointer_type (build_qualified_type (char_type_node, TYPE_QUAL_CONST));
1009
1010   if (strcmp (SIZE_TYPE, "unsigned int") == 0)
1011     {
1012       intmax_type_node = integer_type_node;
1013       uintmax_type_node = unsigned_type_node;
1014       signed_size_type_node = integer_type_node;
1015     }
1016   else if (strcmp (SIZE_TYPE, "long unsigned int") == 0)
1017     {
1018       intmax_type_node = long_integer_type_node;
1019       uintmax_type_node = long_unsigned_type_node;
1020       signed_size_type_node = long_integer_type_node;
1021     }
1022   else if (strcmp (SIZE_TYPE, "long long unsigned int") == 0)
1023     {
1024       intmax_type_node = long_long_integer_type_node;
1025       uintmax_type_node = long_long_unsigned_type_node;
1026       signed_size_type_node = long_long_integer_type_node;
1027     }
1028   else
1029     gcc_unreachable ();
1030
1031   wint_type_node = unsigned_type_node;
1032   pid_type_node = integer_type_node;
1033 }
1034
1035
1036 /* Perform LTO-specific initialization.  */
1037
1038 static bool
1039 lto_init (void)
1040 {
1041   /* We need to generate LTO if running in WPA mode.  */
1042   flag_generate_lto = flag_wpa;
1043
1044   /* Initialize libcpp line maps for gcc_assert to work.  */
1045   linemap_add (line_table, LC_RENAME, 0, NULL, 0);
1046   linemap_add (line_table, LC_RENAME, 0, NULL, 0);
1047
1048   /* Create the basic integer types.  */
1049   build_common_tree_nodes (flag_signed_char);
1050
1051   /* Share char_type_node with whatever would be the default for the target.
1052      char_type_node will be used for internal types such as
1053      va_list_type_node but will not be present in the lto stream.  */
1054   /* ???  This breaks the more common case of consistent but non-standard
1055      setting of flag_signed_char, so share according to flag_signed_char.
1056      See PR42528.  */
1057   char_type_node
1058     = flag_signed_char ? signed_char_type_node : unsigned_char_type_node;
1059
1060   /* Tell the middle end what type to use for the size of objects.  */
1061   if (strcmp (SIZE_TYPE, "unsigned int") == 0)
1062     {
1063       set_sizetype (unsigned_type_node);
1064       size_type_node = unsigned_type_node;
1065     }
1066   else if (strcmp (SIZE_TYPE, "long unsigned int") == 0)
1067     {
1068       set_sizetype (long_unsigned_type_node);
1069       size_type_node = long_unsigned_type_node;
1070     }
1071   else if (strcmp (SIZE_TYPE, "long long unsigned int") == 0)
1072     {
1073       set_sizetype (long_long_unsigned_type_node);
1074       size_type_node = long_long_unsigned_type_node;
1075     }
1076   else
1077     gcc_unreachable ();
1078
1079   /* The global tree for the main identifier is filled in by
1080      language-specific front-end initialization that is not run in the
1081      LTO back-end.  It appears that all languages that perform such
1082      initialization currently do so in the same way, so we do it here.  */
1083   if (main_identifier_node == NULL_TREE)
1084     main_identifier_node = get_identifier ("main");
1085
1086   /* In the C++ front-end, fileptr_type_node is defined as a variant
1087      copy of of ptr_type_node, rather than ptr_node itself.  The
1088      distinction should only be relevant to the front-end, so we
1089      always use the C definition here in lto1.  */
1090   gcc_assert (fileptr_type_node == ptr_type_node);
1091
1092   ptrdiff_type_node = integer_type_node;
1093
1094   /* Create other basic types.  */
1095   build_common_tree_nodes_2 (/*short_double=*/false);
1096   lto_build_c_type_nodes ();
1097   gcc_assert (va_list_type_node);
1098
1099   if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
1100     {
1101       tree x = build_pointer_type (TREE_TYPE (va_list_type_node));
1102       lto_define_builtins (x, x);
1103     }
1104   else
1105     {
1106       lto_define_builtins (va_list_type_node,
1107                            build_reference_type (va_list_type_node));
1108     }
1109
1110   targetm.init_builtins ();
1111   build_common_builtin_nodes ();
1112
1113   /* Initialize LTO-specific data structures.  */
1114   lto_global_var_decls = VEC_alloc (tree, gc, 256);
1115   in_lto_p = true;
1116
1117   return true;
1118 }
1119
1120 /* Initialize tree structures required by the LTO front end.  */
1121
1122 static void lto_init_ts (void)
1123 {
1124   tree_contains_struct[NAMESPACE_DECL][TS_DECL_MINIMAL] = 1;
1125 }
1126
1127 #undef LANG_HOOKS_NAME
1128 #define LANG_HOOKS_NAME "GNU GIMPLE"
1129 #undef LANG_HOOKS_INIT_OPTIONS
1130 #define LANG_HOOKS_INIT_OPTIONS lto_init_options
1131 #undef LANG_HOOKS_HANDLE_OPTION
1132 #define LANG_HOOKS_HANDLE_OPTION lto_handle_option
1133 #undef LANG_HOOKS_POST_OPTIONS
1134 #define LANG_HOOKS_POST_OPTIONS lto_post_options
1135 #undef LANG_HOOKS_GET_ALIAS_SET
1136 #define LANG_HOOKS_GET_ALIAS_SET gimple_get_alias_set
1137 #undef LANG_HOOKS_TYPE_FOR_MODE
1138 #define LANG_HOOKS_TYPE_FOR_MODE lto_type_for_mode
1139 #undef LANG_HOOKS_TYPE_FOR_SIZE
1140 #define LANG_HOOKS_TYPE_FOR_SIZE lto_type_for_size
1141 #undef LANG_HOOKS_SET_DECL_ASSEMBLER_NAME
1142 #define LANG_HOOKS_SET_DECL_ASSEMBLER_NAME lto_set_decl_assembler_name
1143 #undef LANG_HOOKS_GLOBAL_BINDINGS_P
1144 #define LANG_HOOKS_GLOBAL_BINDINGS_P lto_global_bindings_p
1145 #undef LANG_HOOKS_PUSHDECL
1146 #define LANG_HOOKS_PUSHDECL lto_pushdecl
1147 #undef LANG_HOOKS_GETDECLS
1148 #define LANG_HOOKS_GETDECLS lto_getdecls
1149 #undef LANG_HOOKS_WRITE_GLOBALS
1150 #define LANG_HOOKS_WRITE_GLOBALS lto_write_globals
1151 #undef LANG_HOOKS_REGISTER_BUILTIN_TYPE
1152 #define LANG_HOOKS_REGISTER_BUILTIN_TYPE lto_register_builtin_type
1153 #undef LANG_HOOKS_BUILTIN_FUNCTION
1154 #define LANG_HOOKS_BUILTIN_FUNCTION lto_builtin_function
1155 #undef LANG_HOOKS_INIT
1156 #define LANG_HOOKS_INIT lto_init
1157 #undef LANG_HOOKS_PARSE_FILE
1158 #define LANG_HOOKS_PARSE_FILE lto_main
1159 #undef LANG_HOOKS_CALLGRAPH_EXPAND_FUNCTION
1160 #define LANG_HOOKS_CALLGRAPH_EXPAND_FUNCTION tree_rest_of_compilation
1161 #undef LANG_HOOKS_REDUCE_BIT_FIELD_OPERATIONS
1162 #define LANG_HOOKS_REDUCE_BIT_FIELD_OPERATIONS true
1163 #undef LANG_HOOKS_TYPES_COMPATIBLE_P
1164 #define LANG_HOOKS_TYPES_COMPATIBLE_P NULL
1165
1166 /* Attribute hooks.  */
1167 #undef LANG_HOOKS_COMMON_ATTRIBUTE_TABLE
1168 #define LANG_HOOKS_COMMON_ATTRIBUTE_TABLE lto_attribute_table
1169 #undef LANG_HOOKS_FORMAT_ATTRIBUTE_TABLE
1170 #define LANG_HOOKS_FORMAT_ATTRIBUTE_TABLE lto_format_attribute_table
1171
1172 #undef LANG_HOOKS_BEGIN_SECTION
1173 #define LANG_HOOKS_BEGIN_SECTION lto_obj_begin_section
1174 #undef LANG_HOOKS_APPEND_DATA
1175 #define LANG_HOOKS_APPEND_DATA lto_obj_append_data
1176 #undef LANG_HOOKS_END_SECTION
1177 #define LANG_HOOKS_END_SECTION lto_obj_end_section
1178
1179 #undef LANG_HOOKS_INIT_TS
1180 #define LANG_HOOKS_INIT_TS lto_init_ts
1181
1182 struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER;
1183
1184 /* Language hooks that are not part of lang_hooks.  */
1185
1186 tree
1187 convert (tree type ATTRIBUTE_UNUSED, tree expr ATTRIBUTE_UNUSED)
1188 {
1189   gcc_unreachable ();
1190 }
1191
1192 /* Tree walking support.  */
1193
1194 static enum lto_tree_node_structure_enum
1195 lto_tree_node_structure (union lang_tree_node *t ATTRIBUTE_UNUSED)
1196 {
1197   return TS_LTO_GENERIC;
1198 }
1199
1200 #include "ggc.h"
1201 #include "gtype-lto.h"
1202 #include "gt-lto-lto-lang.h"