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   built_in_decls[(int) fncode] = decl;
 503   if (implicit_p)
 504     implicit_built_in_decls[(int) fncode] = decl;
 505 }
 506
 507
 508 /* Initialize the attribute table for all the supported builtins.  */
 509
 510 static void
 511 lto_init_attributes (void)
 512 {
 513   /* Fill in the built_in_attributes array.  */
 514 #define DEF_ATTR_NULL_TREE(ENUM)                                \
 515   built_in_attributes[(int) ENUM] = NULL_TREE;
 516 #define DEF_ATTR_INT(ENUM, VALUE)                               \
 517   built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
 518 #define DEF_ATTR_IDENT(ENUM, STRING)                            \
 519   built_in_attributes[(int) ENUM] = get_identifier (STRING);
 520 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
 521   built_in_attributes[(int) ENUM]                       \
 522     = tree_cons (built_in_attributes[(int) PURPOSE],    \
 523                  built_in_attributes[(int) VALUE],      \
 524                  built_in_attributes[(int) CHAIN]);
 525 #include "builtin-attrs.def"
 526 #undef DEF_ATTR_NULL_TREE
 527 #undef DEF_ATTR_INT
 528 #undef DEF_ATTR_IDENT
 529 #undef DEF_ATTR_TREE_LIST
 530 }
 531
 532 /* Create builtin types and functions.  VA_LIST_REF_TYPE_NODE and
 533    VA_LIST_ARG_TYPE_NODE are used in builtin-types.def.  */
 534
 535 static void
 536 lto_define_builtins (tree va_list_ref_type_node ATTRIBUTE_UNUSED,
 537                      tree va_list_arg_type_node ATTRIBUTE_UNUSED)
 538 {
 539 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
 540   builtin_types[ENUM] = VALUE;
 541 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
 542   def_fn_type (ENUM, RETURN, 0, 0);
 543 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
 544   def_fn_type (ENUM, RETURN, 0, 1, ARG1);
 545 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
 546   def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
 547 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
 548   def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
 549 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
 550   def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
 551 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
 552   def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
 553 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
 554                             ARG6)                                       \
 555   def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
 556 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
 557                             ARG6, ARG7)                                 \
 558   def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
 559 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
 560   def_fn_type (ENUM, RETURN, 1, 0);
 561 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
 562   def_fn_type (ENUM, RETURN, 1, 1, ARG1);
 563 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
 564   def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
 565 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
 566   def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
 567 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
 568   def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
 569 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
 570   def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
 571 #define DEF_POINTER_TYPE(ENUM, TYPE) \
 572   builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
 573
 574 #include "builtin-types.def"
 575
 576 #undef DEF_PRIMITIVE_TYPE
 577 #undef DEF_FUNCTION_TYPE_1
 578 #undef DEF_FUNCTION_TYPE_2
 579 #undef DEF_FUNCTION_TYPE_3
 580 #undef DEF_FUNCTION_TYPE_4
 581 #undef DEF_FUNCTION_TYPE_5
 582 #undef DEF_FUNCTION_TYPE_6
 583 #undef DEF_FUNCTION_TYPE_VAR_0
 584 #undef DEF_FUNCTION_TYPE_VAR_1
 585 #undef DEF_FUNCTION_TYPE_VAR_2
 586 #undef DEF_FUNCTION_TYPE_VAR_3
 587 #undef DEF_FUNCTION_TYPE_VAR_4
 588 #undef DEF_FUNCTION_TYPE_VAR_5
 589 #undef DEF_POINTER_TYPE
 590   builtin_types[(int) BT_LAST] = NULL_TREE;
 591
 592   lto_init_attributes ();
 593
 594 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P,\
 595                     NONANSI_P, ATTRS, IMPLICIT, COND)                   \
 596     if (NAME && COND)                                                   \
 597       def_builtin_1 (ENUM, NAME, CLASS, builtin_types[(int) TYPE],      \
 598                      builtin_types[(int) LIBTYPE], BOTH_P, FALLBACK_P,  \
 599                      NONANSI_P, built_in_attributes[(int) ATTRS], IMPLICIT);
 600 #include "builtins.def"
 601 #undef DEF_BUILTIN
 602 }
 603
 604 static GTY(()) tree registered_builtin_types;
 605
 606 /* Language hooks.  */
 607
 608 static unsigned int
 609 lto_option_lang_mask (void)
 610 {
 611   return CL_LTO;
 612 }
 613
 614 static bool
 615 lto_complain_wrong_lang_p (const struct cl_option *option ATTRIBUTE_UNUSED)
 616 {
 617   /* The LTO front end inherits all the options from the first front
 618      end that was used.  However, not all the original front end
 619      options make sense in LTO.
 620
 621      A real solution would be to filter this in collect2, but collect2
 622      does not have access to all the option attributes to know what to
 623      filter.  So, in lto1 we silently accept inherited flags and do
 624      nothing about it.  */
 625   return false;
 626 }
 627
 628 static void
 629 lto_init_options_struct (struct gcc_options *opts)
 630 {
 631   /* By default, C99-like requirements for complex multiply and divide.
 632      ???  Until the complex method is encoded in the IL this is the only
 633      safe choice.  This will pessimize Fortran code with LTO unless
 634      people specify a complex method manually or use -ffast-math.  */
 635   opts->x_flag_complex_method = 2;
 636 }
 637
 638 /* Handle command-line option SCODE.  If the option takes an argument, it is
 639    stored in ARG, which is otherwise NULL.  VALUE holds either a numerical
 640    argument or a binary value indicating whether the positive or negative form
 641    of the option was supplied.  */
 642
 643 const char *resolution_file_name;
 644 static bool
 645 lto_handle_option (size_t scode, const char *arg,
 646                    int value ATTRIBUTE_UNUSED, int kind ATTRIBUTE_UNUSED,
 647                    location_t loc ATTRIBUTE_UNUSED,
 648                    const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED)
 649 {
 650   enum opt_code code = (enum opt_code) scode;
 651   bool result = true;
 652
 653   switch (code)
 654     {
 655     case OPT_fresolution_:
 656       resolution_file_name = arg;
 657       break;
 658
 659     case OPT_Wabi:
 660       warn_psabi = value;
 661       break;
 662
 663     default:
 664       break;
 665     }
 666
 667   return result;
 668 }
 669
 670 /* Perform post-option processing.  Does additional initialization based on
 671    command-line options.  PFILENAME is the main input filename.  Returns false
 672    to enable subsequent back-end initialization.  */
 673
 674 static bool
 675 lto_post_options (const char **pfilename ATTRIBUTE_UNUSED)
 676 {
 677   /* -fltrans and -fwpa are mutually exclusive.  Check for that here.  */
 678   if (flag_wpa && flag_ltrans)
 679     error ("-fwpa and -fltrans are mutually exclusive");
 680
 681   if (flag_ltrans)
 682     {
 683       flag_generate_lto = 0;
 684
 685       /* During LTRANS, we are not looking at the whole program, only
 686          a subset of the whole callgraph.  */
 687       flag_whole_program = 0;
 688     }
 689
 690   if (flag_wpa)
 691     flag_generate_lto = 1;
 692
 693   /* Excess precision other than "fast" requires front-end
 694      support.  */
 695   flag_excess_precision_cmdline = EXCESS_PRECISION_FAST;
 696
 697   lto_read_all_file_options ();
 698
 699   /* Initialize the compiler back end.  */
 700   return false;
 701 }
 702
 703 /* Return an integer type with PRECISION bits of precision,
 704    that is unsigned if UNSIGNEDP is nonzero, otherwise signed.  */
 705
 706 static tree
 707 lto_type_for_size (unsigned precision, int unsignedp)
 708 {
 709   if (precision == TYPE_PRECISION (integer_type_node))
 710     return unsignedp ? unsigned_type_node : integer_type_node;
 711
 712   if (precision == TYPE_PRECISION (signed_char_type_node))
 713     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
 714
 715   if (precision == TYPE_PRECISION (short_integer_type_node))
 716     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
 717
 718   if (precision == TYPE_PRECISION (long_integer_type_node))
 719     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
 720
 721   if (precision == TYPE_PRECISION (long_long_integer_type_node))
 722     return unsignedp
 723            ? long_long_unsigned_type_node
 724            : long_long_integer_type_node;
 725
 726   if (precision <= TYPE_PRECISION (intQI_type_node))
 727     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
 728
 729   if (precision <= TYPE_PRECISION (intHI_type_node))
 730     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
 731
 732   if (precision <= TYPE_PRECISION (intSI_type_node))
 733     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
 734
 735   if (precision <= TYPE_PRECISION (intDI_type_node))
 736     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
 737
 738   if (precision <= TYPE_PRECISION (intTI_type_node))
 739     return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
 740
 741   return NULL_TREE;
 742 }
 743
 744
 745 /* Return a data type that has machine mode MODE.
 746    If the mode is an integer,
 747    then UNSIGNEDP selects between signed and unsigned types.
 748    If the mode is a fixed-point mode,
 749    then UNSIGNEDP selects between saturating and nonsaturating types.  */
 750
 751 static tree
 752 lto_type_for_mode (enum machine_mode mode, int unsigned_p)
 753 {
 754   tree t;
 755
 756   if (mode == TYPE_MODE (integer_type_node))
 757     return unsigned_p ? unsigned_type_node : integer_type_node;
 758
 759   if (mode == TYPE_MODE (signed_char_type_node))
 760     return unsigned_p ? unsigned_char_type_node : signed_char_type_node;
 761
 762   if (mode == TYPE_MODE (short_integer_type_node))
 763     return unsigned_p ? short_unsigned_type_node : short_integer_type_node;
 764
 765   if (mode == TYPE_MODE (long_integer_type_node))
 766     return unsigned_p ? long_unsigned_type_node : long_integer_type_node;
 767
 768   if (mode == TYPE_MODE (long_long_integer_type_node))
 769     return unsigned_p ? long_long_unsigned_type_node : long_long_integer_type_node;
 770
 771   if (mode == QImode)
 772     return unsigned_p ? unsigned_intQI_type_node : intQI_type_node;
 773
 774   if (mode == HImode)
 775     return unsigned_p ? unsigned_intHI_type_node : intHI_type_node;
 776
 777   if (mode == SImode)
 778     return unsigned_p ? unsigned_intSI_type_node : intSI_type_node;
 779
 780   if (mode == DImode)
 781     return unsigned_p ? unsigned_intDI_type_node : intDI_type_node;
 782
 783 #if HOST_BITS_PER_WIDE_INT >= 64
 784   if (mode == TYPE_MODE (intTI_type_node))
 785     return unsigned_p ? unsigned_intTI_type_node : intTI_type_node;
 786 #endif
 787
 788   if (mode == TYPE_MODE (float_type_node))
 789     return float_type_node;
 790
 791   if (mode == TYPE_MODE (double_type_node))
 792     return double_type_node;
 793
 794   if (mode == TYPE_MODE (long_double_type_node))
 795     return long_double_type_node;
 796
 797   if (mode == TYPE_MODE (void_type_node))
 798     return void_type_node;
 799
 800   if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
 801     return (unsigned_p
 802             ? make_unsigned_type (GET_MODE_PRECISION (mode))
 803             : make_signed_type (GET_MODE_PRECISION (mode)));
 804
 805   if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
 806     return (unsigned_p
 807             ? make_unsigned_type (GET_MODE_PRECISION (mode))
 808             : make_signed_type (GET_MODE_PRECISION (mode)));
 809
 810   if (COMPLEX_MODE_P (mode))
 811     {
 812       enum machine_mode inner_mode;
 813       tree inner_type;
 814
 815       if (mode == TYPE_MODE (complex_float_type_node))
 816         return complex_float_type_node;
 817       if (mode == TYPE_MODE (complex_double_type_node))
 818         return complex_double_type_node;
 819       if (mode == TYPE_MODE (complex_long_double_type_node))
 820         return complex_long_double_type_node;
 821
 822       if (mode == TYPE_MODE (complex_integer_type_node) && !unsigned_p)
 823         return complex_integer_type_node;
 824
 825       inner_mode = GET_MODE_INNER (mode);
 826       inner_type = lto_type_for_mode (inner_mode, unsigned_p);
 827       if (inner_type != NULL_TREE)
 828         return build_complex_type (inner_type);
 829     }
 830   else if (VECTOR_MODE_P (mode))
 831     {
 832       enum machine_mode inner_mode = GET_MODE_INNER (mode);
 833       tree inner_type = lto_type_for_mode (inner_mode, unsigned_p);
 834       if (inner_type != NULL_TREE)
 835         return build_vector_type_for_mode (inner_type, mode);
 836     }
 837
 838   if (mode == TYPE_MODE (dfloat32_type_node))
 839     return dfloat32_type_node;
 840   if (mode == TYPE_MODE (dfloat64_type_node))
 841     return dfloat64_type_node;
 842   if (mode == TYPE_MODE (dfloat128_type_node))
 843     return dfloat128_type_node;
 844
 845   if (ALL_SCALAR_FIXED_POINT_MODE_P (mode))
 846     {
 847       if (mode == TYPE_MODE (short_fract_type_node))
 848         return unsigned_p ? sat_short_fract_type_node : short_fract_type_node;
 849       if (mode == TYPE_MODE (fract_type_node))
 850         return unsigned_p ? sat_fract_type_node : fract_type_node;
 851       if (mode == TYPE_MODE (long_fract_type_node))
 852         return unsigned_p ? sat_long_fract_type_node : long_fract_type_node;
 853       if (mode == TYPE_MODE (long_long_fract_type_node))
 854         return unsigned_p ? sat_long_long_fract_type_node
 855                          : long_long_fract_type_node;
 856
 857       if (mode == TYPE_MODE (unsigned_short_fract_type_node))
 858         return unsigned_p ? sat_unsigned_short_fract_type_node
 859                          : unsigned_short_fract_type_node;
 860       if (mode == TYPE_MODE (unsigned_fract_type_node))
 861         return unsigned_p ? sat_unsigned_fract_type_node
 862                          : unsigned_fract_type_node;
 863       if (mode == TYPE_MODE (unsigned_long_fract_type_node))
 864         return unsigned_p ? sat_unsigned_long_fract_type_node
 865                          : unsigned_long_fract_type_node;
 866       if (mode == TYPE_MODE (unsigned_long_long_fract_type_node))
 867         return unsigned_p ? sat_unsigned_long_long_fract_type_node
 868                          : unsigned_long_long_fract_type_node;
 869
 870       if (mode == TYPE_MODE (short_accum_type_node))
 871         return unsigned_p ? sat_short_accum_type_node : short_accum_type_node;
 872       if (mode == TYPE_MODE (accum_type_node))
 873         return unsigned_p ? sat_accum_type_node : accum_type_node;
 874       if (mode == TYPE_MODE (long_accum_type_node))
 875         return unsigned_p ? sat_long_accum_type_node : long_accum_type_node;
 876       if (mode == TYPE_MODE (long_long_accum_type_node))
 877         return unsigned_p ? sat_long_long_accum_type_node
 878                          : long_long_accum_type_node;
 879
 880       if (mode == TYPE_MODE (unsigned_short_accum_type_node))
 881         return unsigned_p ? sat_unsigned_short_accum_type_node
 882                          : unsigned_short_accum_type_node;
 883       if (mode == TYPE_MODE (unsigned_accum_type_node))
 884         return unsigned_p ? sat_unsigned_accum_type_node
 885                          : unsigned_accum_type_node;
 886       if (mode == TYPE_MODE (unsigned_long_accum_type_node))
 887         return unsigned_p ? sat_unsigned_long_accum_type_node
 888                          : unsigned_long_accum_type_node;
 889       if (mode == TYPE_MODE (unsigned_long_long_accum_type_node))
 890         return unsigned_p ? sat_unsigned_long_long_accum_type_node
 891                          : unsigned_long_long_accum_type_node;
 892
 893       if (mode == QQmode)
 894         return unsigned_p ? sat_qq_type_node : qq_type_node;
 895       if (mode == HQmode)
 896         return unsigned_p ? sat_hq_type_node : hq_type_node;
 897       if (mode == SQmode)
 898         return unsigned_p ? sat_sq_type_node : sq_type_node;
 899       if (mode == DQmode)
 900         return unsigned_p ? sat_dq_type_node : dq_type_node;
 901       if (mode == TQmode)
 902         return unsigned_p ? sat_tq_type_node : tq_type_node;
 903
 904       if (mode == UQQmode)
 905         return unsigned_p ? sat_uqq_type_node : uqq_type_node;
 906       if (mode == UHQmode)
 907         return unsigned_p ? sat_uhq_type_node : uhq_type_node;
 908       if (mode == USQmode)
 909         return unsigned_p ? sat_usq_type_node : usq_type_node;
 910       if (mode == UDQmode)
 911         return unsigned_p ? sat_udq_type_node : udq_type_node;
 912       if (mode == UTQmode)
 913         return unsigned_p ? sat_utq_type_node : utq_type_node;
 914
 915       if (mode == HAmode)
 916         return unsigned_p ? sat_ha_type_node : ha_type_node;
 917       if (mode == SAmode)
 918         return unsigned_p ? sat_sa_type_node : sa_type_node;
 919       if (mode == DAmode)
 920         return unsigned_p ? sat_da_type_node : da_type_node;
 921       if (mode == TAmode)
 922         return unsigned_p ? sat_ta_type_node : ta_type_node;
 923
 924       if (mode == UHAmode)
 925         return unsigned_p ? sat_uha_type_node : uha_type_node;
 926       if (mode == USAmode)
 927         return unsigned_p ? sat_usa_type_node : usa_type_node;
 928       if (mode == UDAmode)
 929         return unsigned_p ? sat_uda_type_node : uda_type_node;
 930       if (mode == UTAmode)
 931         return unsigned_p ? sat_uta_type_node : uta_type_node;
 932     }
 933
 934   for (t = registered_builtin_types; t; t = TREE_CHAIN (t))
 935     if (TYPE_MODE (TREE_VALUE (t)) == mode)
 936       return TREE_VALUE (t);
 937
 938   return NULL_TREE;
 939 }
 940
 941 /* Return true if we are in the global binding level.  */
 942
 943 static bool
 944 lto_global_bindings_p (void)
 945 {
 946   return cfun == NULL;
 947 }
 948
 949 static void
 950 lto_set_decl_assembler_name (tree decl)
 951 {
 952   /* This is almost the same as lhd_set_decl_assembler_name, except that
 953      we need to uniquify file-scope names, even if they are not
 954      TREE_PUBLIC, to avoid conflicts between individual files.  */
 955   tree id;
 956
 957   if (TREE_PUBLIC (decl))
 958     id = targetm.mangle_decl_assembler_name (decl, DECL_NAME (decl));
 959   else
 960     {
 961       const char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
 962       char *label;
 963
 964       ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
 965       id = get_identifier (label);
 966     }
 967
 968   SET_DECL_ASSEMBLER_NAME (decl, id);
 969 }
 970
 971 static tree
 972 lto_pushdecl (tree t ATTRIBUTE_UNUSED)
 973 {
 974   /* Do nothing, since we get all information from DWARF and LTO
 975      sections.  */
 976   return NULL_TREE;
 977 }
 978
 979 static tree
 980 lto_getdecls (void)
 981 {
 982   /* We have our own write_globals langhook, hence the getdecls
 983      langhook shouldn't be used, except by dbxout.c, so we can't
 984      just abort here.  */
 985   return NULL_TREE;
 986 }
 987
 988 static void
 989 lto_write_globals (void)
 990 {
 991   tree *vec = VEC_address (tree, lto_global_var_decls);
 992   int len = VEC_length (tree, lto_global_var_decls);
 993   wrapup_global_declarations (vec, len);
 994   emit_debug_global_declarations (vec, len);
 995   VEC_free (tree, gc, lto_global_var_decls);
 996 }
 997
 998 static tree
 999 lto_builtin_function (tree decl)
1000 {
1001   return decl;
1002 }
1003
1004 static void
1005 lto_register_builtin_type (tree type, const char *name)
1006 {
1007   tree decl;
1008
1009   decl = build_decl (UNKNOWN_LOCATION, TYPE_DECL, get_identifier (name), type);
1010   DECL_ARTIFICIAL (decl) = 1;
1011   if (!TYPE_NAME (type))
1012     TYPE_NAME (type) = decl;
1013
1014   registered_builtin_types = tree_cons (0, type, registered_builtin_types);
1015 }
1016
1017 /* Build nodes that would have be created by the C front-end; necessary
1018    for including builtin-types.def and ultimately builtins.def.  */
1019
1020 static void
1021 lto_build_c_type_nodes (void)
1022 {
1023   gcc_assert (void_type_node);
1024
1025   void_list_node = build_tree_list (NULL_TREE, void_type_node);
1026   string_type_node = build_pointer_type (char_type_node);
1027   const_string_type_node
1028     = build_pointer_type (build_qualified_type (char_type_node, TYPE_QUAL_CONST));
1029
1030   if (strcmp (SIZE_TYPE, "unsigned int") == 0)
1031     {
1032       intmax_type_node = integer_type_node;
1033       uintmax_type_node = unsigned_type_node;
1034       signed_size_type_node = integer_type_node;
1035     }
1036   else if (strcmp (SIZE_TYPE, "long unsigned int") == 0)
1037     {
1038       intmax_type_node = long_integer_type_node;
1039       uintmax_type_node = long_unsigned_type_node;
1040       signed_size_type_node = long_integer_type_node;
1041     }
1042   else if (strcmp (SIZE_TYPE, "long long unsigned int") == 0)
1043     {
1044       intmax_type_node = long_long_integer_type_node;
1045       uintmax_type_node = long_long_unsigned_type_node;
1046       signed_size_type_node = long_long_integer_type_node;
1047     }
1048   else
1049     gcc_unreachable ();
1050
1051   wint_type_node = unsigned_type_node;
1052   pid_type_node = integer_type_node;
1053 }
1054
1055 /* Re-compute TYPE_CANONICAL for NODE and related types.  */
1056
1057 static void
1058 lto_register_canonical_types (tree node)
1059 {
1060   if (!node
1061       || !TYPE_P (node))
1062     return;
1063
1064   TYPE_CANONICAL (node) = NULL_TREE;
1065   TYPE_CANONICAL (node) = gimple_register_canonical_type (node);
1066
1067   if (POINTER_TYPE_P (node)
1068       || TREE_CODE (node) == COMPLEX_TYPE
1069       || TREE_CODE (node) == ARRAY_TYPE)
1070     lto_register_canonical_types (TREE_TYPE (node));
1071 }
1072
1073 /* Perform LTO-specific initialization.  */
1074
1075 static bool
1076 lto_init (void)
1077 {
1078   unsigned i;
1079
1080   /* We need to generate LTO if running in WPA mode.  */
1081   flag_generate_lto = flag_wpa;
1082
1083   /* Initialize libcpp line maps for gcc_assert to work.  */
1084   linemap_add (line_table, LC_ENTER, 0, NULL, 0);
1085
1086   /* Create the basic integer types.  */
1087   build_common_tree_nodes (flag_signed_char, /*short_double=*/false);
1088
1089   /* The global tree for the main identifier is filled in by
1090      language-specific front-end initialization that is not run in the
1091      LTO back-end.  It appears that all languages that perform such
1092      initialization currently do so in the same way, so we do it here.  */
1093   if (main_identifier_node == NULL_TREE)
1094     main_identifier_node = get_identifier ("main");
1095
1096   /* In the C++ front-end, fileptr_type_node is defined as a variant
1097      copy of of ptr_type_node, rather than ptr_node itself.  The
1098      distinction should only be relevant to the front-end, so we
1099      always use the C definition here in lto1.  */
1100   gcc_assert (fileptr_type_node == ptr_type_node);
1101   gcc_assert (TYPE_MAIN_VARIANT (fileptr_type_node) == ptr_type_node);
1102
1103   ptrdiff_type_node = integer_type_node;
1104
1105   lto_build_c_type_nodes ();
1106   gcc_assert (va_list_type_node);
1107
1108   if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
1109     {
1110       tree x = build_pointer_type (TREE_TYPE (va_list_type_node));
1111       lto_define_builtins (x, x);
1112     }
1113   else
1114     {
1115       lto_define_builtins (va_list_type_node,
1116                            build_reference_type (va_list_type_node));
1117     }
1118
1119   targetm.init_builtins ();
1120   build_common_builtin_nodes ();
1121
1122   /* Assign names to the builtin types, otherwise they'll end up
1123      as __unknown__ in debug info.
1124      ???  We simply need to stop pre-seeding the streamer cache.
1125      Below is modeled after from c-common.c:c_common_nodes_and_builtins  */
1126 #define NAME_TYPE(t,n) \
1127   if (t) \
1128     TYPE_NAME (t) = build_decl (UNKNOWN_LOCATION, TYPE_DECL, \
1129                                 get_identifier (n), t)
1130   NAME_TYPE (integer_type_node, "int");
1131   NAME_TYPE (char_type_node, "char");
1132   NAME_TYPE (long_integer_type_node, "long int");
1133   NAME_TYPE (unsigned_type_node, "unsigned int");
1134   NAME_TYPE (long_unsigned_type_node, "long unsigned int");
1135   NAME_TYPE (long_long_integer_type_node, "long long int");
1136   NAME_TYPE (long_long_unsigned_type_node, "long long unsigned int");
1137   NAME_TYPE (short_integer_type_node, "short int");
1138   NAME_TYPE (short_unsigned_type_node, "short unsigned int");
1139   if (signed_char_type_node != char_type_node)
1140     NAME_TYPE (signed_char_type_node, "signed char");
1141   if (unsigned_char_type_node != char_type_node)
1142     NAME_TYPE (unsigned_char_type_node, "unsigned char");
1143   NAME_TYPE (float_type_node, "float");
1144   NAME_TYPE (double_type_node, "double");
1145   NAME_TYPE (long_double_type_node, "long double");
1146   NAME_TYPE (void_type_node, "void");
1147   NAME_TYPE (boolean_type_node, "bool");
1148 #undef NAME_TYPE
1149
1150   /* Register the common node types with the canonical type machinery so
1151      we properly share alias-sets across languages and TUs.  Do not
1152      expose the common nodes as type merge target - those that should be
1153      are already exposed so by pre-loading the LTO streamer caches.  */
1154   for (i = 0; i < itk_none; ++i)
1155     lto_register_canonical_types (integer_types[i]);
1156   /* The sizetypes are not used to access data so we do not need to
1157      do anything about them.  */
1158   for (i = 0; i < TI_MAX; ++i)
1159     lto_register_canonical_types (global_trees[i]);
1160
1161   /* Initialize LTO-specific data structures.  */
1162   lto_global_var_decls = VEC_alloc (tree, gc, 256);
1163   in_lto_p = true;
1164
1165   return true;
1166 }
1167
1168 /* Initialize tree structures required by the LTO front end.  */
1169
1170 static void lto_init_ts (void)
1171 {
1172   tree_contains_struct[NAMESPACE_DECL][TS_DECL_MINIMAL] = 1;
1173 }
1174
1175 #undef LANG_HOOKS_NAME
1176 #define LANG_HOOKS_NAME "GNU GIMPLE"
1177 #undef LANG_HOOKS_OPTION_LANG_MASK
1178 #define LANG_HOOKS_OPTION_LANG_MASK lto_option_lang_mask
1179 #undef LANG_HOOKS_COMPLAIN_WRONG_LANG_P
1180 #define LANG_HOOKS_COMPLAIN_WRONG_LANG_P lto_complain_wrong_lang_p
1181 #undef LANG_HOOKS_INIT_OPTIONS_STRUCT
1182 #define LANG_HOOKS_INIT_OPTIONS_STRUCT lto_init_options_struct
1183 #undef LANG_HOOKS_HANDLE_OPTION
1184 #define LANG_HOOKS_HANDLE_OPTION lto_handle_option
1185 #undef LANG_HOOKS_POST_OPTIONS
1186 #define LANG_HOOKS_POST_OPTIONS lto_post_options
1187 #undef LANG_HOOKS_GET_ALIAS_SET
1188 #define LANG_HOOKS_GET_ALIAS_SET gimple_get_alias_set
1189 #undef LANG_HOOKS_TYPE_FOR_MODE
1190 #define LANG_HOOKS_TYPE_FOR_MODE lto_type_for_mode
1191 #undef LANG_HOOKS_TYPE_FOR_SIZE
1192 #define LANG_HOOKS_TYPE_FOR_SIZE lto_type_for_size
1193 #undef LANG_HOOKS_SET_DECL_ASSEMBLER_NAME
1194 #define LANG_HOOKS_SET_DECL_ASSEMBLER_NAME lto_set_decl_assembler_name
1195 #undef LANG_HOOKS_GLOBAL_BINDINGS_P
1196 #define LANG_HOOKS_GLOBAL_BINDINGS_P lto_global_bindings_p
1197 #undef LANG_HOOKS_PUSHDECL
1198 #define LANG_HOOKS_PUSHDECL lto_pushdecl
1199 #undef LANG_HOOKS_GETDECLS
1200 #define LANG_HOOKS_GETDECLS lto_getdecls
1201 #undef LANG_HOOKS_WRITE_GLOBALS
1202 #define LANG_HOOKS_WRITE_GLOBALS lto_write_globals
1203 #undef LANG_HOOKS_REGISTER_BUILTIN_TYPE
1204 #define LANG_HOOKS_REGISTER_BUILTIN_TYPE lto_register_builtin_type
1205 #undef LANG_HOOKS_BUILTIN_FUNCTION
1206 #define LANG_HOOKS_BUILTIN_FUNCTION lto_builtin_function
1207 #undef LANG_HOOKS_INIT
1208 #define LANG_HOOKS_INIT lto_init
1209 #undef LANG_HOOKS_PARSE_FILE
1210 #define LANG_HOOKS_PARSE_FILE lto_main
1211 #undef LANG_HOOKS_CALLGRAPH_EXPAND_FUNCTION
1212 #define LANG_HOOKS_CALLGRAPH_EXPAND_FUNCTION tree_rest_of_compilation
1213 #undef LANG_HOOKS_REDUCE_BIT_FIELD_OPERATIONS
1214 #define LANG_HOOKS_REDUCE_BIT_FIELD_OPERATIONS true
1215 #undef LANG_HOOKS_TYPES_COMPATIBLE_P
1216 #define LANG_HOOKS_TYPES_COMPATIBLE_P NULL
1217 #undef LANG_HOOKS_EH_PERSONALITY
1218 #define LANG_HOOKS_EH_PERSONALITY lto_eh_personality
1219
1220 /* Attribute hooks.  */
1221 #undef LANG_HOOKS_COMMON_ATTRIBUTE_TABLE
1222 #define LANG_HOOKS_COMMON_ATTRIBUTE_TABLE lto_attribute_table
1223 #undef LANG_HOOKS_FORMAT_ATTRIBUTE_TABLE
1224 #define LANG_HOOKS_FORMAT_ATTRIBUTE_TABLE lto_format_attribute_table
1225
1226 #undef LANG_HOOKS_BEGIN_SECTION
1227 #define LANG_HOOKS_BEGIN_SECTION lto_obj_begin_section
1228 #undef LANG_HOOKS_APPEND_DATA
1229 #define LANG_HOOKS_APPEND_DATA lto_obj_append_data
1230 #undef LANG_HOOKS_END_SECTION
1231 #define LANG_HOOKS_END_SECTION lto_obj_end_section
1232
1233 #undef LANG_HOOKS_INIT_TS
1234 #define LANG_HOOKS_INIT_TS lto_init_ts
1235
1236 struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER;
1237
1238 /* Language hooks that are not part of lang_hooks.  */
1239
1240 tree
1241 convert (tree type ATTRIBUTE_UNUSED, tree expr ATTRIBUTE_UNUSED)
1242 {
1243   gcc_unreachable ();
1244 }
1245
1246 /* Tree walking support.  */
1247
1248 static enum lto_tree_node_structure_enum
1249 lto_tree_node_structure (union lang_tree_node *t ATTRIBUTE_UNUSED)
1250 {
1251   return TS_LTO_GENERIC;
1252 }
1253
1254 #include "ggc.h"
1255 #include "gtype-lto.h"
1256 #include "gt-lto-lto-lang.h"