contrib/gcc-4.7/gcc/lto/lto-lang.c

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