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