1/* Default target hook functions. 2 Copyright (C) 2003, 2004, 2005, 2007, 2008, 2009, 2010 3 Free Software Foundation, Inc. 4 5This file is part of GCC. 6 7GCC is free software; you can redistribute it and/or modify it under 8the terms of the GNU General Public License as published by the Free 9Software Foundation; either version 3, or (at your option) any later 10version. 11 12GCC is distributed in the hope that it will be useful, but WITHOUT ANY 13WARRANTY; without even the implied warranty of MERCHANTABILITY or 14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 15for more details. 16 17You should have received a copy of the GNU General Public License 18along with GCC; see the file COPYING3. If not see 19<http://www.gnu.org/licenses/>. */ 20 21/* The migration of target macros to target hooks works as follows: 22 23 1. Create a target hook that uses the existing target macros to 24 implement the same functionality. 25 26 2. Convert all the MI files to use the hook instead of the macro. 27 28 3. Repeat for a majority of the remaining target macros. This will 29 take some time. 30 31 4. Tell target maintainers to start migrating. 32 33 5. Eventually convert the backends to override the hook instead of 34 defining the macros. This will take some time too. 35 36 6. TBD when, poison the macros. Unmigrated targets will break at 37 this point. 38 39 Note that we expect steps 1-3 to be done by the people that 40 understand what the MI does with each macro, and step 5 to be done 41 by the target maintainers for their respective targets. 42 43 Note that steps 1 and 2 don't have to be done together, but no 44 target can override the new hook until step 2 is complete for it. 45 46 Once the macros are poisoned, we will revert to the old migration 47 rules - migrate the macro, callers, and targets all at once. This 48 comment can thus be removed at that point. */ 49 50#include "config.h" 51#include "system.h" 52#include "coretypes.h" 53#include "tm.h" 54#include "machmode.h" 55#include "rtl.h" 56#include "tree.h" 57#include "expr.h" 58#include "output.h" 59#include "toplev.h" 60#include "function.h" 61#include "target.h" 62#include "tm_p.h" 63#include "target-def.h" 64#include "ggc.h" 65#include "hard-reg-set.h" 66#include "reload.h" 67#include "optabs.h" 68#include "recog.h" 69 70 71bool 72default_legitimate_address_p (enum machine_mode mode ATTRIBUTE_UNUSED, 73 rtx addr ATTRIBUTE_UNUSED, 74 bool strict ATTRIBUTE_UNUSED) 75{ 76#ifdef GO_IF_LEGITIMATE_ADDRESS 77 /* Defer to the old implementation using a goto. */ 78 if (strict) 79 return strict_memory_address_p (mode, addr); 80 else 81 return memory_address_p (mode, addr); 82#else 83 gcc_unreachable (); 84#endif 85} 86 87void 88default_external_libcall (rtx fun ATTRIBUTE_UNUSED) 89{ 90#ifdef ASM_OUTPUT_EXTERNAL_LIBCALL 91 ASM_OUTPUT_EXTERNAL_LIBCALL(asm_out_file, fun); 92#endif 93} 94 95int 96default_unspec_may_trap_p (const_rtx x, unsigned flags) 97{ 98 int i; 99 100 if (GET_CODE (x) == UNSPEC_VOLATILE 101 /* Any floating arithmetic may trap. */ 102 || (SCALAR_FLOAT_MODE_P (GET_MODE (x)) 103 && flag_trapping_math)) 104 return 1; 105 106 for (i = 0; i < XVECLEN (x, 0); ++i) 107 { 108 if (may_trap_p_1 (XVECEXP (x, 0, i), flags)) 109 return 1; 110 } 111 112 return 0; 113} 114 115enum machine_mode 116default_promote_function_mode (const_tree type ATTRIBUTE_UNUSED, 117 enum machine_mode mode, 118 int *punsignedp ATTRIBUTE_UNUSED, 119 const_tree funtype ATTRIBUTE_UNUSED, 120 int for_return ATTRIBUTE_UNUSED) 121{ 122 if (for_return == 2) 123 return promote_mode (type, mode, punsignedp); 124 return mode; 125} 126 127enum machine_mode 128default_promote_function_mode_always_promote (const_tree type, 129 enum machine_mode mode, 130 int *punsignedp, 131 const_tree funtype ATTRIBUTE_UNUSED, 132 int for_return ATTRIBUTE_UNUSED) 133{ 134 return promote_mode (type, mode, punsignedp); 135} 136 137 138enum machine_mode 139default_cc_modes_compatible (enum machine_mode m1, enum machine_mode m2) 140{ 141 if (m1 == m2) 142 return m1; 143 return VOIDmode; 144} 145 146bool 147default_return_in_memory (const_tree type, 148 const_tree fntype ATTRIBUTE_UNUSED) 149{ 150 return (TYPE_MODE (type) == BLKmode); 151} 152 153rtx 154default_legitimize_address (rtx x, rtx orig_x ATTRIBUTE_UNUSED, 155 enum machine_mode mode ATTRIBUTE_UNUSED) 156{ 157 return x; 158} 159 160rtx 161default_expand_builtin_saveregs (void) 162{ 163 error ("__builtin_saveregs not supported by this target"); 164 return const0_rtx; 165} 166 167void 168default_setup_incoming_varargs (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED, 169 enum machine_mode mode ATTRIBUTE_UNUSED, 170 tree type ATTRIBUTE_UNUSED, 171 int *pretend_arg_size ATTRIBUTE_UNUSED, 172 int second_time ATTRIBUTE_UNUSED) 173{ 174} 175 176/* The default implementation of TARGET_BUILTIN_SETJMP_FRAME_VALUE. */ 177 178rtx 179default_builtin_setjmp_frame_value (void) 180{ 181 return virtual_stack_vars_rtx; 182} 183 184/* Generic hook that takes a CUMULATIVE_ARGS pointer and returns false. */ 185 186bool 187hook_bool_CUMULATIVE_ARGS_false (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED) 188{ 189 return false; 190} 191 192bool 193default_pretend_outgoing_varargs_named (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED) 194{ 195 return (targetm.calls.setup_incoming_varargs 196 != default_setup_incoming_varargs); 197} 198 199enum machine_mode 200default_eh_return_filter_mode (void) 201{ 202 return targetm.unwind_word_mode (); 203} 204 205enum machine_mode 206default_libgcc_cmp_return_mode (void) 207{ 208 return word_mode; 209} 210 211enum machine_mode 212default_libgcc_shift_count_mode (void) 213{ 214 return word_mode; 215} 216 217enum machine_mode 218default_unwind_word_mode (void) 219{ 220 return word_mode; 221} 222 223/* The default implementation of TARGET_SHIFT_TRUNCATION_MASK. */ 224 225unsigned HOST_WIDE_INT 226default_shift_truncation_mask (enum machine_mode mode) 227{ 228 return SHIFT_COUNT_TRUNCATED ? GET_MODE_BITSIZE (mode) - 1 : 0; 229} 230 231/* The default implementation of TARGET_MIN_DIVISIONS_FOR_RECIP_MUL. */ 232 233unsigned int 234default_min_divisions_for_recip_mul (enum machine_mode mode ATTRIBUTE_UNUSED) 235{ 236 return have_insn_for (DIV, mode) ? 3 : 2; 237} 238 239/* The default implementation of TARGET_MODE_REP_EXTENDED. */ 240 241int 242default_mode_rep_extended (enum machine_mode mode ATTRIBUTE_UNUSED, 243 enum machine_mode mode_rep ATTRIBUTE_UNUSED) 244{ 245 return UNKNOWN; 246} 247 248/* Generic hook that takes a CUMULATIVE_ARGS pointer and returns true. */ 249 250bool 251hook_bool_CUMULATIVE_ARGS_true (CUMULATIVE_ARGS * a ATTRIBUTE_UNUSED) 252{ 253 return true; 254} 255 256/* Return machine mode for non-standard suffix 257 or VOIDmode if non-standard suffixes are unsupported. */ 258enum machine_mode 259default_mode_for_suffix (char suffix ATTRIBUTE_UNUSED) 260{ 261 return VOIDmode; 262} 263 264/* The generic C++ ABI specifies this is a 64-bit value. */ 265tree 266default_cxx_guard_type (void) 267{ 268 return long_long_integer_type_node; 269} 270 271 272/* Returns the size of the cookie to use when allocating an array 273 whose elements have the indicated TYPE. Assumes that it is already 274 known that a cookie is needed. */ 275 276tree 277default_cxx_get_cookie_size (tree type) 278{ 279 tree cookie_size; 280 281 /* We need to allocate an additional max (sizeof (size_t), alignof 282 (true_type)) bytes. */ 283 tree sizetype_size; 284 tree type_align; 285 286 sizetype_size = size_in_bytes (sizetype); 287 type_align = size_int (TYPE_ALIGN_UNIT (type)); 288 if (INT_CST_LT_UNSIGNED (type_align, sizetype_size)) 289 cookie_size = sizetype_size; 290 else 291 cookie_size = type_align; 292 293 return cookie_size; 294} 295 296/* Return true if a parameter must be passed by reference. This version 297 of the TARGET_PASS_BY_REFERENCE hook uses just MUST_PASS_IN_STACK. */ 298 299bool 300hook_pass_by_reference_must_pass_in_stack (CUMULATIVE_ARGS *c ATTRIBUTE_UNUSED, 301 enum machine_mode mode ATTRIBUTE_UNUSED, const_tree type ATTRIBUTE_UNUSED, 302 bool named_arg ATTRIBUTE_UNUSED) 303{ 304 return targetm.calls.must_pass_in_stack (mode, type); 305} 306 307/* Return true if a parameter follows callee copies conventions. This 308 version of the hook is true for all named arguments. */ 309 310bool 311hook_callee_copies_named (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED, 312 enum machine_mode mode ATTRIBUTE_UNUSED, 313 const_tree type ATTRIBUTE_UNUSED, bool named) 314{ 315 return named; 316} 317 318/* Emit any directives required to unwind this instruction. */ 319 320void 321default_unwind_emit (FILE * stream ATTRIBUTE_UNUSED, 322 rtx insn ATTRIBUTE_UNUSED) 323{ 324 /* Should never happen. */ 325 gcc_unreachable (); 326} 327 328/* True if MODE is valid for the target. By "valid", we mean able to 329 be manipulated in non-trivial ways. In particular, this means all 330 the arithmetic is supported. 331 332 By default we guess this means that any C type is supported. If 333 we can't map the mode back to a type that would be available in C, 334 then reject it. Special case, here, is the double-word arithmetic 335 supported by optabs.c. */ 336 337bool 338default_scalar_mode_supported_p (enum machine_mode mode) 339{ 340 int precision = GET_MODE_PRECISION (mode); 341 342 switch (GET_MODE_CLASS (mode)) 343 { 344 case MODE_PARTIAL_INT: 345 case MODE_INT: 346 if (precision == CHAR_TYPE_SIZE) 347 return true; 348 if (precision == SHORT_TYPE_SIZE) 349 return true; 350 if (precision == INT_TYPE_SIZE) 351 return true; 352 if (precision == LONG_TYPE_SIZE) 353 return true; 354 if (precision == LONG_LONG_TYPE_SIZE) 355 return true; 356 if (precision == 2 * BITS_PER_WORD) 357 return true; 358 return false; 359 360 case MODE_FLOAT: 361 if (precision == FLOAT_TYPE_SIZE) 362 return true; 363 if (precision == DOUBLE_TYPE_SIZE) 364 return true; 365 if (precision == LONG_DOUBLE_TYPE_SIZE) 366 return true; 367 return false; 368 369 case MODE_DECIMAL_FLOAT: 370 case MODE_FRACT: 371 case MODE_UFRACT: 372 case MODE_ACCUM: 373 case MODE_UACCUM: 374 return false; 375 376 default: 377 gcc_unreachable (); 378 } 379} 380 381/* True if the target supports decimal floating point. */ 382 383bool 384default_decimal_float_supported_p (void) 385{ 386 return ENABLE_DECIMAL_FLOAT; 387} 388 389/* True if the target supports fixed-point arithmetic. */ 390 391bool 392default_fixed_point_supported_p (void) 393{ 394 return ENABLE_FIXED_POINT; 395} 396 397/* NULL if INSN insn is valid within a low-overhead loop, otherwise returns 398 an error message. 399 400 This function checks whether a given INSN is valid within a low-overhead 401 loop. If INSN is invalid it returns the reason for that, otherwise it 402 returns NULL. A called function may clobber any special registers required 403 for low-overhead looping. Additionally, some targets (eg, PPC) use the count 404 register for branch on table instructions. We reject the doloop pattern in 405 these cases. */ 406 407const char * 408default_invalid_within_doloop (const_rtx insn) 409{ 410 if (CALL_P (insn)) 411 return "Function call in loop."; 412 413 if (JUMP_TABLE_DATA_P (insn)) 414 return "Computed branch in the loop."; 415 416 return NULL; 417} 418 419/* Mapping of builtin functions to vectorized variants. */ 420 421tree 422default_builtin_vectorized_function (tree fndecl ATTRIBUTE_UNUSED, 423 tree type_out ATTRIBUTE_UNUSED, 424 tree type_in ATTRIBUTE_UNUSED) 425{ 426 return NULL_TREE; 427} 428 429/* Vectorized conversion. */ 430 431tree 432default_builtin_vectorized_conversion (unsigned int code ATTRIBUTE_UNUSED, 433 tree type ATTRIBUTE_UNUSED) 434{ 435 return NULL_TREE; 436} 437 438/* Reciprocal. */ 439 440tree 441default_builtin_reciprocal (unsigned int fn ATTRIBUTE_UNUSED, 442 bool md_fn ATTRIBUTE_UNUSED, 443 bool sqrt ATTRIBUTE_UNUSED) 444{ 445 return NULL_TREE; 446} 447 448bool 449hook_bool_CUMULATIVE_ARGS_mode_tree_bool_false ( 450 CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED, 451 enum machine_mode mode ATTRIBUTE_UNUSED, 452 const_tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED) 453{ 454 return false; 455} 456 457bool 458hook_bool_CUMULATIVE_ARGS_mode_tree_bool_true ( 459 CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED, 460 enum machine_mode mode ATTRIBUTE_UNUSED, 461 const_tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED) 462{ 463 return true; 464} 465 466int 467hook_int_CUMULATIVE_ARGS_mode_tree_bool_0 ( 468 CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED, 469 enum machine_mode mode ATTRIBUTE_UNUSED, 470 tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED) 471{ 472 return 0; 473} 474 475void 476hook_void_bitmap (bitmap regs ATTRIBUTE_UNUSED) 477{ 478} 479 480const char * 481hook_invalid_arg_for_unprototyped_fn ( 482 const_tree typelist ATTRIBUTE_UNUSED, 483 const_tree funcdecl ATTRIBUTE_UNUSED, 484 const_tree val ATTRIBUTE_UNUSED) 485{ 486 return NULL; 487} 488 489/* Initialize the stack protection decls. */ 490 491/* Stack protection related decls living in libgcc. */ 492static GTY(()) tree stack_chk_guard_decl; 493 494tree 495default_stack_protect_guard (void) 496{ 497 tree t = stack_chk_guard_decl; 498 499 if (t == NULL) 500 { 501 t = build_decl (UNKNOWN_LOCATION, 502 VAR_DECL, get_identifier ("__stack_chk_guard"), 503 ptr_type_node); 504 TREE_STATIC (t) = 1; 505 TREE_PUBLIC (t) = 1; 506 DECL_EXTERNAL (t) = 1; 507 TREE_USED (t) = 1; 508 TREE_THIS_VOLATILE (t) = 1; 509 DECL_ARTIFICIAL (t) = 1; 510 DECL_IGNORED_P (t) = 1; 511 512 stack_chk_guard_decl = t; 513 } 514 515 return t; 516} 517 518static GTY(()) tree stack_chk_fail_decl; 519 520tree 521default_external_stack_protect_fail (void) 522{ 523 tree t = stack_chk_fail_decl; 524 525 if (t == NULL_TREE) 526 { 527 t = build_function_type_list (void_type_node, NULL_TREE); 528 t = build_decl (UNKNOWN_LOCATION, 529 FUNCTION_DECL, get_identifier ("__stack_chk_fail"), t); 530 TREE_STATIC (t) = 1; 531 TREE_PUBLIC (t) = 1; 532 DECL_EXTERNAL (t) = 1; 533 TREE_USED (t) = 1; 534 TREE_THIS_VOLATILE (t) = 1; 535 TREE_NOTHROW (t) = 1; 536 DECL_ARTIFICIAL (t) = 1; 537 DECL_IGNORED_P (t) = 1; 538 DECL_VISIBILITY (t) = VISIBILITY_DEFAULT; 539 DECL_VISIBILITY_SPECIFIED (t) = 1; 540 541 stack_chk_fail_decl = t; 542 } 543 544 return build_call_expr (t, 0); 545} 546 547tree 548default_hidden_stack_protect_fail (void) 549{ 550#ifndef HAVE_GAS_HIDDEN 551 return default_external_stack_protect_fail (); 552#else 553 tree t = stack_chk_fail_decl; 554 555 if (!flag_pic) 556 return default_external_stack_protect_fail (); 557 558 if (t == NULL_TREE) 559 { 560 t = build_function_type_list (void_type_node, NULL_TREE); 561 t = build_decl (UNKNOWN_LOCATION, FUNCTION_DECL, 562 get_identifier ("__stack_chk_fail_local"), t); 563 TREE_STATIC (t) = 1; 564 TREE_PUBLIC (t) = 1; 565 DECL_EXTERNAL (t) = 1; 566 TREE_USED (t) = 1; 567 TREE_THIS_VOLATILE (t) = 1; 568 TREE_NOTHROW (t) = 1; 569 DECL_ARTIFICIAL (t) = 1; 570 DECL_IGNORED_P (t) = 1; 571 DECL_VISIBILITY_SPECIFIED (t) = 1; 572#if 1 573 /* 574 * This is a hack: 575 * It appears that our gas does not generate @PLT for hidden 576 * symbols. It could be that we need a newer version, or that 577 * this local function is handled differently on linux. 578 */ 579 DECL_VISIBILITY (t) = VISIBILITY_DEFAULT; 580#else 581 DECL_VISIBILITY (t) = VISIBILITY_HIDDEN; 582#endif 583 584 stack_chk_fail_decl = t; 585 } 586 587 return build_call_expr (t, 0); 588#endif 589} 590 591bool 592hook_bool_const_rtx_commutative_p (const_rtx x, 593 int outer_code ATTRIBUTE_UNUSED) 594{ 595 return COMMUTATIVE_P (x); 596} 597 598rtx 599default_function_value (const_tree ret_type ATTRIBUTE_UNUSED, 600 const_tree fn_decl_or_type, 601 bool outgoing ATTRIBUTE_UNUSED) 602{ 603 /* The old interface doesn't handle receiving the function type. */ 604 if (fn_decl_or_type 605 && !DECL_P (fn_decl_or_type)) 606 fn_decl_or_type = NULL; 607 608#ifdef FUNCTION_OUTGOING_VALUE 609 if (outgoing) 610 return FUNCTION_OUTGOING_VALUE (ret_type, fn_decl_or_type); 611#endif 612 613#ifdef FUNCTION_VALUE 614 return FUNCTION_VALUE (ret_type, fn_decl_or_type); 615#else 616 gcc_unreachable (); 617#endif 618} 619 620rtx 621default_libcall_value (enum machine_mode mode ATTRIBUTE_UNUSED, 622 const_rtx fun ATTRIBUTE_UNUSED) 623{ 624#ifdef LIBCALL_VALUE 625 return LIBCALL_VALUE (mode); 626#else 627 gcc_unreachable (); 628#endif 629} 630 631rtx 632default_internal_arg_pointer (void) 633{ 634 /* If the reg that the virtual arg pointer will be translated into is 635 not a fixed reg or is the stack pointer, make a copy of the virtual 636 arg pointer, and address parms via the copy. The frame pointer is 637 considered fixed even though it is not marked as such. */ 638 if ((ARG_POINTER_REGNUM == STACK_POINTER_REGNUM 639 || ! (fixed_regs[ARG_POINTER_REGNUM] 640 || ARG_POINTER_REGNUM == FRAME_POINTER_REGNUM))) 641 return copy_to_reg (virtual_incoming_args_rtx); 642 else 643 return virtual_incoming_args_rtx; 644} 645 646rtx 647default_static_chain (const_tree fndecl, bool incoming_p) 648{ 649 if (!DECL_STATIC_CHAIN (fndecl)) 650 return NULL; 651 652 if (incoming_p) 653 { 654#ifdef STATIC_CHAIN_INCOMING_REGNUM 655 return gen_rtx_REG (Pmode, STATIC_CHAIN_INCOMING_REGNUM); 656#endif 657 } 658 659#ifdef STATIC_CHAIN_REGNUM 660 return gen_rtx_REG (Pmode, STATIC_CHAIN_REGNUM); 661#endif 662 663 { 664 static bool issued_error; 665 if (!issued_error) 666 { 667 issued_error = true; 668 sorry ("nested functions not supported on this target"); 669 } 670 671 /* It really doesn't matter what we return here, so long at it 672 doesn't cause the rest of the compiler to crash. */ 673 return gen_rtx_MEM (Pmode, stack_pointer_rtx); 674 } 675} 676 677void 678default_trampoline_init (rtx ARG_UNUSED (m_tramp), tree ARG_UNUSED (t_func), 679 rtx ARG_UNUSED (r_chain)) 680{ 681 sorry ("nested function trampolines not supported on this target"); 682} 683 684enum reg_class 685default_branch_target_register_class (void) 686{ 687 return NO_REGS; 688} 689 690#ifdef IRA_COVER_CLASSES 691const enum reg_class * 692default_ira_cover_classes (void) 693{ 694 static enum reg_class classes[] = IRA_COVER_CLASSES; 695 return classes; 696} 697#endif 698 699enum reg_class 700default_secondary_reload (bool in_p ATTRIBUTE_UNUSED, rtx x ATTRIBUTE_UNUSED, 701 enum reg_class reload_class ATTRIBUTE_UNUSED, 702 enum machine_mode reload_mode ATTRIBUTE_UNUSED, 703 secondary_reload_info *sri) 704{ 705 enum reg_class rclass = NO_REGS; 706 707 if (sri->prev_sri && sri->prev_sri->t_icode != CODE_FOR_nothing) 708 { 709 sri->icode = sri->prev_sri->t_icode; 710 return NO_REGS; 711 } 712#ifdef SECONDARY_INPUT_RELOAD_CLASS 713 if (in_p) 714 rclass = SECONDARY_INPUT_RELOAD_CLASS (reload_class, reload_mode, x); 715#endif 716#ifdef SECONDARY_OUTPUT_RELOAD_CLASS 717 if (! in_p) 718 rclass = SECONDARY_OUTPUT_RELOAD_CLASS (reload_class, reload_mode, x); 719#endif 720 if (rclass != NO_REGS) 721 { 722 enum insn_code icode = (in_p ? reload_in_optab[(int) reload_mode] 723 : reload_out_optab[(int) reload_mode]); 724 725 if (icode != CODE_FOR_nothing 726 && insn_data[(int) icode].operand[in_p].predicate 727 && ! insn_data[(int) icode].operand[in_p].predicate (x, reload_mode)) 728 icode = CODE_FOR_nothing; 729 else if (icode != CODE_FOR_nothing) 730 { 731 const char *insn_constraint, *scratch_constraint; 732 char insn_letter, scratch_letter; 733 enum reg_class insn_class, scratch_class; 734 735 gcc_assert (insn_data[(int) icode].n_operands == 3); 736 insn_constraint = insn_data[(int) icode].operand[!in_p].constraint; 737 if (!*insn_constraint) 738 insn_class = ALL_REGS; 739 else 740 { 741 if (in_p) 742 { 743 gcc_assert (*insn_constraint == '='); 744 insn_constraint++; 745 } 746 insn_letter = *insn_constraint; 747 insn_class 748 = (insn_letter == 'r' ? GENERAL_REGS 749 : REG_CLASS_FROM_CONSTRAINT ((unsigned char) insn_letter, 750 insn_constraint)); 751 gcc_assert (insn_class != NO_REGS); 752 } 753 754 scratch_constraint = insn_data[(int) icode].operand[2].constraint; 755 /* The scratch register's constraint must start with "=&", 756 except for an input reload, where only "=" is necessary, 757 and where it might be beneficial to re-use registers from 758 the input. */ 759 gcc_assert (scratch_constraint[0] == '=' 760 && (in_p || scratch_constraint[1] == '&')); 761 scratch_constraint++; 762 if (*scratch_constraint == '&') 763 scratch_constraint++; 764 scratch_letter = *scratch_constraint; 765 scratch_class 766 = (scratch_letter == 'r' ? GENERAL_REGS 767 : REG_CLASS_FROM_CONSTRAINT ((unsigned char) scratch_letter, 768 scratch_constraint)); 769 770 if (reg_class_subset_p (reload_class, insn_class)) 771 { 772 gcc_assert (scratch_class == rclass); 773 rclass = NO_REGS; 774 } 775 else 776 rclass = insn_class; 777 778 } 779 if (rclass == NO_REGS) 780 sri->icode = icode; 781 else 782 sri->t_icode = icode; 783 } 784 return rclass; 785} 786 787bool 788default_handle_c_option (size_t code ATTRIBUTE_UNUSED, 789 const char *arg ATTRIBUTE_UNUSED, 790 int value ATTRIBUTE_UNUSED) 791{ 792 return false; 793} 794 795/* By default, if flag_pic is true, then neither local nor global relocs 796 should be placed in readonly memory. */ 797 798int 799default_reloc_rw_mask (void) 800{ 801 return flag_pic ? 3 : 0; 802} 803 804/* By default, do no modification. */ 805tree default_mangle_decl_assembler_name (tree decl ATTRIBUTE_UNUSED, 806 tree id) 807{ 808 return id; 809} 810 811bool 812default_builtin_vector_alignment_reachable (const_tree type, bool is_packed) 813{ 814 if (is_packed) 815 return false; 816 817 /* Assuming that types whose size is > pointer-size are not guaranteed to be 818 naturally aligned. */ 819 if (tree_int_cst_compare (TYPE_SIZE (type), bitsize_int (POINTER_SIZE)) > 0) 820 return false; 821 822 /* Assuming that types whose size is <= pointer-size 823 are naturally aligned. */ 824 return true; 825} 826 827/* By default, assume that a target supports any factor of misalignment 828 memory access if it supports movmisalign patten. 829 is_packed is true if the memory access is defined in a packed struct. */ 830bool 831default_builtin_support_vector_misalignment (enum machine_mode mode, 832 const_tree type 833 ATTRIBUTE_UNUSED, 834 int misalignment 835 ATTRIBUTE_UNUSED, 836 bool is_packed 837 ATTRIBUTE_UNUSED) 838{ 839 if (optab_handler (movmisalign_optab, mode)->insn_code != CODE_FOR_nothing) 840 return true; 841 return false; 842} 843 844/* Determine whether or not a pointer mode is valid. Assume defaults 845 of ptr_mode or Pmode - can be overridden. */ 846bool 847default_valid_pointer_mode (enum machine_mode mode) 848{ 849 return (mode == ptr_mode || mode == Pmode); 850} 851 852/* Return the mode for a pointer to a given ADDRSPACE, defaulting to ptr_mode 853 for the generic address space only. */ 854 855enum machine_mode 856default_addr_space_pointer_mode (addr_space_t addrspace ATTRIBUTE_UNUSED) 857{ 858 gcc_assert (ADDR_SPACE_GENERIC_P (addrspace)); 859 return ptr_mode; 860} 861 862/* Return the mode for an address in a given ADDRSPACE, defaulting to Pmode 863 for the generic address space only. */ 864 865enum machine_mode 866default_addr_space_address_mode (addr_space_t addrspace ATTRIBUTE_UNUSED) 867{ 868 gcc_assert (ADDR_SPACE_GENERIC_P (addrspace)); 869 return Pmode; 870} 871 872/* Named address space version of valid_pointer_mode. */ 873 874bool 875default_addr_space_valid_pointer_mode (enum machine_mode mode, addr_space_t as) 876{ 877 if (!ADDR_SPACE_GENERIC_P (as)) 878 return (mode == targetm.addr_space.pointer_mode (as) 879 || mode == targetm.addr_space.address_mode (as)); 880 881 return targetm.valid_pointer_mode (mode); 882} 883 884/* Some places still assume that all pointer or address modes are the 885 standard Pmode and ptr_mode. These optimizations become invalid if 886 the target actually supports multiple different modes. For now, 887 we disable such optimizations on such targets, using this function. */ 888 889bool 890target_default_pointer_address_modes_p (void) 891{ 892 if (targetm.addr_space.address_mode != default_addr_space_address_mode) 893 return false; 894 if (targetm.addr_space.pointer_mode != default_addr_space_pointer_mode) 895 return false; 896 897 return true; 898} 899 900/* Named address space version of legitimate_address_p. */ 901 902bool 903default_addr_space_legitimate_address_p (enum machine_mode mode, rtx mem, 904 bool strict, addr_space_t as) 905{ 906 if (!ADDR_SPACE_GENERIC_P (as)) 907 gcc_unreachable (); 908 909 return targetm.legitimate_address_p (mode, mem, strict); 910} 911 912/* Named address space version of LEGITIMIZE_ADDRESS. */ 913 914rtx 915default_addr_space_legitimize_address (rtx x, rtx oldx, 916 enum machine_mode mode, addr_space_t as) 917{ 918 if (!ADDR_SPACE_GENERIC_P (as)) 919 return x; 920 921 return targetm.legitimize_address (x, oldx, mode); 922} 923 924/* The default hook for determining if one named address space is a subset of 925 another and to return which address space to use as the common address 926 space. */ 927 928bool 929default_addr_space_subset_p (addr_space_t subset, addr_space_t superset) 930{ 931 return (subset == superset); 932} 933 934/* The default hook for TARGET_ADDR_SPACE_CONVERT. This hook should never be 935 called for targets with only a generic address space. */ 936 937rtx 938default_addr_space_convert (rtx op ATTRIBUTE_UNUSED, 939 tree from_type ATTRIBUTE_UNUSED, 940 tree to_type ATTRIBUTE_UNUSED) 941{ 942 gcc_unreachable (); 943} 944 945bool 946default_hard_regno_scratch_ok (unsigned int regno ATTRIBUTE_UNUSED) 947{ 948 return true; 949} 950 951bool 952default_target_option_valid_attribute_p (tree ARG_UNUSED (fndecl), 953 tree ARG_UNUSED (name), 954 tree ARG_UNUSED (args), 955 int ARG_UNUSED (flags)) 956{ 957 warning (OPT_Wattributes, 958 "target attribute is not supported on this machine"); 959 960 return false; 961} 962 963bool 964default_target_option_pragma_parse (tree ARG_UNUSED (args), 965 tree ARG_UNUSED (pop_target)) 966{ 967 warning (OPT_Wpragmas, 968 "#pragma GCC target is not supported for this machine"); 969 970 return false; 971} 972 973bool 974default_target_can_inline_p (tree caller, tree callee) 975{ 976 bool ret = false; 977 tree callee_opts = DECL_FUNCTION_SPECIFIC_TARGET (callee); 978 tree caller_opts = DECL_FUNCTION_SPECIFIC_TARGET (caller); 979 980 /* If callee has no option attributes, then it is ok to inline */ 981 if (!callee_opts) 982 ret = true; 983 984 /* If caller has no option attributes, but callee does then it is not ok to 985 inline */ 986 else if (!caller_opts) 987 ret = false; 988 989 /* If both caller and callee have attributes, assume that if the pointer is 990 different, the the two functions have different target options since 991 build_target_option_node uses a hash table for the options. */ 992 else 993 ret = (callee_opts == caller_opts); 994 995 return ret; 996} 997 998#ifndef HAVE_casesi 999# define HAVE_casesi 0 1000#endif 1001 1002/* If the machine does not have a case insn that compares the bounds, 1003 this means extra overhead for dispatch tables, which raises the 1004 threshold for using them. */ 1005 1006unsigned int default_case_values_threshold (void) 1007{ 1008 return (HAVE_casesi ? 4 : 5); 1009} 1010 1011bool 1012default_have_conditional_execution (void) 1013{ 1014#ifdef HAVE_conditional_execution 1015 return HAVE_conditional_execution; 1016#else 1017 return false; 1018#endif 1019} 1020 1021#include "gt-targhooks.h" 1022