gcc/lto/lto-lang.c

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