gcc/targhooks.c

   1 /* Default target hook functions.
   2    Copyright (C) 2003, 2004, 2005, 2007 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify it under
   7 the terms of the GNU General Public License as published by the Free
   8 Software Foundation; either version 3, or (at your option) any later
   9 version.
  10
  11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GCC; see the file COPYING3.  If not see
  18 <http://www.gnu.org/licenses/>.  */
  19
  20 /* The migration of target macros to target hooks works as follows:
  21
  22    1. Create a target hook that uses the existing target macros to
  23       implement the same functionality.
  24
  25    2. Convert all the MI files to use the hook instead of the macro.
  26
  27    3. Repeat for a majority of the remaining target macros.  This will
  28       take some time.
  29
  30    4. Tell target maintainers to start migrating.
  31
  32    5. Eventually convert the backends to override the hook instead of
  33       defining the macros.  This will take some time too.
  34
  35    6. TBD when, poison the macros.  Unmigrated targets will break at
  36       this point.
  37
  38    Note that we expect steps 1-3 to be done by the people that
  39    understand what the MI does with each macro, and step 5 to be done
  40    by the target maintainers for their respective targets.
  41
  42    Note that steps 1 and 2 don't have to be done together, but no
  43    target can override the new hook until step 2 is complete for it.
  44
  45    Once the macros are poisoned, we will revert to the old migration
  46    rules - migrate the macro, callers, and targets all at once.  This
  47    comment can thus be removed at that point.  */
  48
  49 #include "config.h"
  50 #include "system.h"
  51 #include "coretypes.h"
  52 #include "tm.h"
  53 #include "machmode.h"
  54 #include "rtl.h"
  55 #include "tree.h"
  56 #include "expr.h"
  57 #include "output.h"
  58 #include "toplev.h"
  59 #include "function.h"
  60 #include "target.h"
  61 #include "tm_p.h"
  62 #include "target-def.h"
  63 #include "ggc.h"
  64 #include "hard-reg-set.h"
  65 #include "reload.h"
  66 #include "optabs.h"
  67 #include "recog.h"
  68
  69
  70 void
  71 default_external_libcall (rtx fun ATTRIBUTE_UNUSED)
  72 {
  73 #ifdef ASM_OUTPUT_EXTERNAL_LIBCALL
  74   ASM_OUTPUT_EXTERNAL_LIBCALL(asm_out_file, fun);
  75 #endif
  76 }
  77
  78 int
  79 default_unspec_may_trap_p (const_rtx x, unsigned flags)
  80 {
  81   int i;
  82
  83   if (GET_CODE (x) == UNSPEC_VOLATILE
  84       /* Any floating arithmetic may trap.  */
  85       || (SCALAR_FLOAT_MODE_P (GET_MODE (x))
  86           && flag_trapping_math))
  87     return 1;
  88
  89   for (i = 0; i < XVECLEN (x, 0); ++i)
  90     {
  91       if (may_trap_p_1 (XVECEXP (x, 0, i), flags))
  92         return 1;
  93     }
  94
  95   return 0;
  96 }
  97
  98 enum machine_mode
  99 default_cc_modes_compatible (enum machine_mode m1, enum machine_mode m2)
 100 {
 101   if (m1 == m2)
 102     return m1;
 103   return VOIDmode;
 104 }
 105
 106 bool
 107 default_return_in_memory (const_tree type,
 108                           const_tree fntype ATTRIBUTE_UNUSED)
 109 {
 110   return (TYPE_MODE (type) == BLKmode);
 111 }
 112
 113 rtx
 114 default_expand_builtin_saveregs (void)
 115 {
 116   error ("__builtin_saveregs not supported by this target");
 117   return const0_rtx;
 118 }
 119
 120 void
 121 default_setup_incoming_varargs (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED,
 122                                 enum machine_mode mode ATTRIBUTE_UNUSED,
 123                                 tree type ATTRIBUTE_UNUSED,
 124                                 int *pretend_arg_size ATTRIBUTE_UNUSED,
 125                                 int second_time ATTRIBUTE_UNUSED)
 126 {
 127 }
 128
 129 /* The default implementation of TARGET_BUILTIN_SETJMP_FRAME_VALUE.  */
 130
 131 rtx
 132 default_builtin_setjmp_frame_value (void)
 133 {
 134   return virtual_stack_vars_rtx;
 135 }
 136
 137 /* Generic hook that takes a CUMULATIVE_ARGS pointer and returns false.  */
 138
 139 bool
 140 hook_bool_CUMULATIVE_ARGS_false (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED)
 141 {
 142   return false;
 143 }
 144
 145 bool
 146 default_pretend_outgoing_varargs_named (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED)
 147 {
 148   return (targetm.calls.setup_incoming_varargs
 149           != default_setup_incoming_varargs);
 150 }
 151
 152 enum machine_mode
 153 default_eh_return_filter_mode (void)
 154 {
 155   return targetm.unwind_word_mode ();
 156 }
 157
 158 enum machine_mode
 159 default_libgcc_cmp_return_mode (void)
 160 {
 161   return word_mode;
 162 }
 163
 164 enum machine_mode
 165 default_libgcc_shift_count_mode (void)
 166 {
 167   return word_mode;
 168 }
 169
 170 enum machine_mode
 171 default_unwind_word_mode (void)
 172 {
 173   return word_mode;
 174 }
 175
 176 /* The default implementation of TARGET_SHIFT_TRUNCATION_MASK.  */
 177
 178 unsigned HOST_WIDE_INT
 179 default_shift_truncation_mask (enum machine_mode mode)
 180 {
 181   return SHIFT_COUNT_TRUNCATED ? GET_MODE_BITSIZE (mode) - 1 : 0;
 182 }
 183
 184 /* The default implementation of TARGET_MIN_DIVISIONS_FOR_RECIP_MUL.  */
 185
 186 unsigned int
 187 default_min_divisions_for_recip_mul (enum machine_mode mode ATTRIBUTE_UNUSED)
 188 {
 189   return have_insn_for (DIV, mode) ? 3 : 2;
 190 }
 191
 192 /* The default implementation of TARGET_MODE_REP_EXTENDED.  */
 193
 194 int
 195 default_mode_rep_extended (enum machine_mode mode ATTRIBUTE_UNUSED,
 196                            enum machine_mode mode_rep ATTRIBUTE_UNUSED)
 197 {
 198   return UNKNOWN;
 199 }
 200
 201 /* Generic hook that takes a CUMULATIVE_ARGS pointer and returns true.  */
 202
 203 bool
 204 hook_bool_CUMULATIVE_ARGS_true (CUMULATIVE_ARGS * a ATTRIBUTE_UNUSED)
 205 {
 206   return true;
 207 }
 208
 209 /* Return machine mode for non-standard suffix
 210    or VOIDmode if non-standard suffixes are unsupported.  */
 211 enum machine_mode
 212 default_mode_for_suffix (char suffix ATTRIBUTE_UNUSED)
 213 {
 214   return VOIDmode;
 215 }
 216
 217 /* The generic C++ ABI specifies this is a 64-bit value.  */
 218 tree
 219 default_cxx_guard_type (void)
 220 {
 221   return long_long_integer_type_node;
 222 }
 223
 224
 225 /* Returns the size of the cookie to use when allocating an array
 226    whose elements have the indicated TYPE.  Assumes that it is already
 227    known that a cookie is needed.  */
 228
 229 tree
 230 default_cxx_get_cookie_size (tree type)
 231 {
 232   tree cookie_size;
 233
 234   /* We need to allocate an additional max (sizeof (size_t), alignof
 235      (true_type)) bytes.  */
 236   tree sizetype_size;
 237   tree type_align;
 238
 239   sizetype_size = size_in_bytes (sizetype);
 240   type_align = size_int (TYPE_ALIGN_UNIT (type));
 241   if (INT_CST_LT_UNSIGNED (type_align, sizetype_size))
 242     cookie_size = sizetype_size;
 243   else
 244     cookie_size = type_align;
 245
 246   return cookie_size;
 247 }
 248
 249 /* Return true if a parameter must be passed by reference.  This version
 250    of the TARGET_PASS_BY_REFERENCE hook uses just MUST_PASS_IN_STACK.  */
 251
 252 bool
 253 hook_pass_by_reference_must_pass_in_stack (CUMULATIVE_ARGS *c ATTRIBUTE_UNUSED,
 254         enum machine_mode mode ATTRIBUTE_UNUSED, const_tree type ATTRIBUTE_UNUSED,
 255         bool named_arg ATTRIBUTE_UNUSED)
 256 {
 257   return targetm.calls.must_pass_in_stack (mode, type);
 258 }
 259
 260 /* Return true if a parameter follows callee copies conventions.  This
 261    version of the hook is true for all named arguments.  */
 262
 263 bool
 264 hook_callee_copies_named (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED,
 265                           enum machine_mode mode ATTRIBUTE_UNUSED,
 266                           const_tree type ATTRIBUTE_UNUSED, bool named)
 267 {
 268   return named;
 269 }
 270
 271 /* Emit any directives required to unwind this instruction.  */
 272
 273 void
 274 default_unwind_emit (FILE * stream ATTRIBUTE_UNUSED,
 275                      rtx insn ATTRIBUTE_UNUSED)
 276 {
 277   /* Should never happen.  */
 278   gcc_unreachable ();
 279 }
 280
 281 /* True if MODE is valid for the target.  By "valid", we mean able to
 282    be manipulated in non-trivial ways.  In particular, this means all
 283    the arithmetic is supported.
 284
 285    By default we guess this means that any C type is supported.  If
 286    we can't map the mode back to a type that would be available in C,
 287    then reject it.  Special case, here, is the double-word arithmetic
 288    supported by optabs.c.  */
 289
 290 bool
 291 default_scalar_mode_supported_p (enum machine_mode mode)
 292 {
 293   int precision = GET_MODE_PRECISION (mode);
 294
 295   switch (GET_MODE_CLASS (mode))
 296     {
 297     case MODE_PARTIAL_INT:
 298     case MODE_INT:
 299       if (precision == CHAR_TYPE_SIZE)
 300         return true;
 301       if (precision == SHORT_TYPE_SIZE)
 302         return true;
 303       if (precision == INT_TYPE_SIZE)
 304         return true;
 305       if (precision == LONG_TYPE_SIZE)
 306         return true;
 307       if (precision == LONG_LONG_TYPE_SIZE)
 308         return true;
 309       if (precision == 2 * BITS_PER_WORD)
 310         return true;
 311       return false;
 312
 313     case MODE_FLOAT:
 314       if (precision == FLOAT_TYPE_SIZE)
 315         return true;
 316       if (precision == DOUBLE_TYPE_SIZE)
 317         return true;
 318       if (precision == LONG_DOUBLE_TYPE_SIZE)
 319         return true;
 320       return false;
 321
 322     case MODE_DECIMAL_FLOAT:
 323     case MODE_FRACT:
 324     case MODE_UFRACT:
 325     case MODE_ACCUM:
 326     case MODE_UACCUM:
 327       return false;
 328
 329     default:
 330       gcc_unreachable ();
 331     }
 332 }
 333
 334 /* True if the target supports decimal floating point.  */
 335
 336 bool
 337 default_decimal_float_supported_p (void)
 338 {
 339   return ENABLE_DECIMAL_FLOAT;
 340 }
 341
 342 /* True if the target supports fixed-point arithmetic.  */
 343
 344 bool
 345 default_fixed_point_supported_p (void)
 346 {
 347   return ENABLE_FIXED_POINT;
 348 }
 349
 350 /* NULL if INSN insn is valid within a low-overhead loop, otherwise returns
 351    an error message.
 352
 353    This function checks whether a given INSN is valid within a low-overhead
 354    loop.  If INSN is invalid it returns the reason for that, otherwise it
 355    returns NULL. A called function may clobber any special registers required
 356    for low-overhead looping. Additionally, some targets (eg, PPC) use the count
 357    register for branch on table instructions. We reject the doloop pattern in
 358    these cases.  */
 359
 360 const char *
 361 default_invalid_within_doloop (const_rtx insn)
 362 {
 363   if (CALL_P (insn))
 364     return "Function call in loop.";
 365
 366   if (JUMP_P (insn)
 367       && (GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC
 368           || GET_CODE (PATTERN (insn)) == ADDR_VEC))
 369     return "Computed branch in the loop.";
 370
 371   return NULL;
 372 }
 373
 374 /* Mapping of builtin functions to vectorized variants.  */
 375
 376 tree
 377 default_builtin_vectorized_function (enum built_in_function fn ATTRIBUTE_UNUSED,
 378                                      tree type_out ATTRIBUTE_UNUSED,
 379                                      tree type_in ATTRIBUTE_UNUSED)
 380 {
 381   return NULL_TREE;
 382 }
 383
 384 /* Vectorized conversion.  */
 385
 386 tree
 387 default_builtin_vectorized_conversion (enum tree_code code ATTRIBUTE_UNUSED,
 388                                        tree type ATTRIBUTE_UNUSED)
 389 {
 390   return NULL_TREE;
 391 }
 392
 393 /* Reciprocal.  */
 394
 395 tree
 396 default_builtin_reciprocal (enum built_in_function fn ATTRIBUTE_UNUSED,
 397                             bool md_fn ATTRIBUTE_UNUSED,
 398                             bool sqrt ATTRIBUTE_UNUSED)
 399 {
 400   return NULL_TREE;
 401 }
 402
 403 bool
 404 hook_bool_CUMULATIVE_ARGS_mode_tree_bool_false (
 405         CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED,
 406         enum machine_mode mode ATTRIBUTE_UNUSED,
 407         const_tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED)
 408 {
 409   return false;
 410 }
 411
 412 bool
 413 hook_bool_CUMULATIVE_ARGS_mode_tree_bool_true (
 414         CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED,
 415         enum machine_mode mode ATTRIBUTE_UNUSED,
 416         const_tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED)
 417 {
 418   return true;
 419 }
 420
 421 int
 422 hook_int_CUMULATIVE_ARGS_mode_tree_bool_0 (
 423         CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED,
 424         enum machine_mode mode ATTRIBUTE_UNUSED,
 425         tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED)
 426 {
 427   return 0;
 428 }
 429
 430 void
 431 hook_void_bitmap (bitmap regs ATTRIBUTE_UNUSED)
 432 {
 433 }
 434
 435 const char *
 436 hook_invalid_arg_for_unprototyped_fn (
 437         const_tree typelist ATTRIBUTE_UNUSED,
 438         const_tree funcdecl ATTRIBUTE_UNUSED,
 439         const_tree val ATTRIBUTE_UNUSED)
 440 {
 441   return NULL;
 442 }
 443
 444 /* Initialize the stack protection decls.  */
 445
 446 /* Stack protection related decls living in libgcc.  */
 447 static GTY(()) tree stack_chk_guard_decl;
 448
 449 tree
 450 default_stack_protect_guard (void)
 451 {
 452   tree t = stack_chk_guard_decl;
 453
 454   if (t == NULL)
 455     {
 456       t = build_decl (VAR_DECL, get_identifier ("__stack_chk_guard"),
 457                       ptr_type_node);
 458       TREE_STATIC (t) = 1;
 459       TREE_PUBLIC (t) = 1;
 460       DECL_EXTERNAL (t) = 1;
 461       TREE_USED (t) = 1;
 462       TREE_THIS_VOLATILE (t) = 1;
 463       DECL_ARTIFICIAL (t) = 1;
 464       DECL_IGNORED_P (t) = 1;
 465
 466       stack_chk_guard_decl = t;
 467     }
 468
 469   return t;
 470 }
 471
 472 static GTY(()) tree stack_chk_fail_decl;
 473
 474 tree
 475 default_external_stack_protect_fail (void)
 476 {
 477   tree t = stack_chk_fail_decl;
 478
 479   if (t == NULL_TREE)
 480     {
 481       t = build_function_type_list (void_type_node, NULL_TREE);
 482       t = build_decl (FUNCTION_DECL, get_identifier ("__stack_chk_fail"), t);
 483       TREE_STATIC (t) = 1;
 484       TREE_PUBLIC (t) = 1;
 485       DECL_EXTERNAL (t) = 1;
 486       TREE_USED (t) = 1;
 487       TREE_THIS_VOLATILE (t) = 1;
 488       TREE_NOTHROW (t) = 1;
 489       DECL_ARTIFICIAL (t) = 1;
 490       DECL_IGNORED_P (t) = 1;
 491       DECL_VISIBILITY (t) = VISIBILITY_DEFAULT;
 492       DECL_VISIBILITY_SPECIFIED (t) = 1;
 493
 494       stack_chk_fail_decl = t;
 495     }
 496
 497   return build_call_expr (t, 0);
 498 }
 499
 500 tree
 501 default_hidden_stack_protect_fail (void)
 502 {
 503 #ifndef HAVE_GAS_HIDDEN
 504   return default_external_stack_protect_fail ();
 505 #else
 506   tree t = stack_chk_fail_decl;
 507
 508   if (!flag_pic)
 509     return default_external_stack_protect_fail ();
 510
 511   if (t == NULL_TREE)
 512     {
 513       t = build_function_type_list (void_type_node, NULL_TREE);
 514       t = build_decl (FUNCTION_DECL,
 515                       get_identifier ("__stack_chk_fail_local"), t);
 516       TREE_STATIC (t) = 1;
 517       TREE_PUBLIC (t) = 1;
 518       DECL_EXTERNAL (t) = 1;
 519       TREE_USED (t) = 1;
 520       TREE_THIS_VOLATILE (t) = 1;
 521       TREE_NOTHROW (t) = 1;
 522       DECL_ARTIFICIAL (t) = 1;
 523       DECL_IGNORED_P (t) = 1;
 524       DECL_VISIBILITY_SPECIFIED (t) = 1;
 525       DECL_VISIBILITY (t) = VISIBILITY_HIDDEN;
 526
 527       stack_chk_fail_decl = t;
 528     }
 529
 530   return build_call_expr (t, 0);
 531 #endif
 532 }
 533
 534 bool
 535 hook_bool_const_rtx_commutative_p (const_rtx x,
 536                                    int outer_code ATTRIBUTE_UNUSED)
 537 {
 538   return COMMUTATIVE_P (x);
 539 }
 540
 541 rtx
 542 default_function_value (const_tree ret_type ATTRIBUTE_UNUSED,
 543                         const_tree fn_decl_or_type,
 544                         bool outgoing ATTRIBUTE_UNUSED)
 545 {
 546   /* The old interface doesn't handle receiving the function type.  */
 547   if (fn_decl_or_type
 548       && !DECL_P (fn_decl_or_type))
 549     fn_decl_or_type = NULL;
 550
 551 #ifdef FUNCTION_OUTGOING_VALUE
 552   if (outgoing)
 553     return FUNCTION_OUTGOING_VALUE (ret_type, fn_decl_or_type);
 554 #endif
 555
 556 #ifdef FUNCTION_VALUE
 557   return FUNCTION_VALUE (ret_type, fn_decl_or_type);
 558 #else
 559   return NULL_RTX;
 560 #endif
 561 }
 562
 563 rtx
 564 default_internal_arg_pointer (void)
 565 {
 566   /* If the reg that the virtual arg pointer will be translated into is
 567      not a fixed reg or is the stack pointer, make a copy of the virtual
 568      arg pointer, and address parms via the copy.  The frame pointer is
 569      considered fixed even though it is not marked as such.  */
 570   if ((ARG_POINTER_REGNUM == STACK_POINTER_REGNUM
 571        || ! (fixed_regs[ARG_POINTER_REGNUM]
 572              || ARG_POINTER_REGNUM == FRAME_POINTER_REGNUM)))
 573     return copy_to_reg (virtual_incoming_args_rtx);
 574   else
 575     return virtual_incoming_args_rtx;
 576 }
 577
 578 #ifdef IRA_COVER_CLASSES
 579 const enum reg_class *
 580 default_ira_cover_classes (void)
 581 {
 582   static enum reg_class classes[] = IRA_COVER_CLASSES;
 583   return classes;
 584 }
 585 #endif
 586
 587 enum reg_class
 588 default_secondary_reload (bool in_p ATTRIBUTE_UNUSED, rtx x ATTRIBUTE_UNUSED,
 589                           enum reg_class reload_class ATTRIBUTE_UNUSED,
 590                           enum machine_mode reload_mode ATTRIBUTE_UNUSED,
 591                           secondary_reload_info *sri)
 592 {
 593   enum reg_class rclass = NO_REGS;
 594
 595   if (sri->prev_sri && sri->prev_sri->t_icode != CODE_FOR_nothing)
 596     {
 597       sri->icode = sri->prev_sri->t_icode;
 598       return NO_REGS;
 599     }
 600 #ifdef SECONDARY_INPUT_RELOAD_CLASS
 601   if (in_p)
 602     rclass = SECONDARY_INPUT_RELOAD_CLASS (reload_class, reload_mode, x);
 603 #endif
 604 #ifdef SECONDARY_OUTPUT_RELOAD_CLASS
 605   if (! in_p)
 606     rclass = SECONDARY_OUTPUT_RELOAD_CLASS (reload_class, reload_mode, x);
 607 #endif
 608   if (rclass != NO_REGS)
 609     {
 610       enum insn_code icode = (in_p ? reload_in_optab[(int) reload_mode]
 611                               : reload_out_optab[(int) reload_mode]);
 612
 613       if (icode != CODE_FOR_nothing
 614           && insn_data[(int) icode].operand[in_p].predicate
 615           && ! insn_data[(int) icode].operand[in_p].predicate (x, reload_mode))
 616         icode = CODE_FOR_nothing;
 617       else if (icode != CODE_FOR_nothing)
 618         {
 619           const char *insn_constraint, *scratch_constraint;
 620           char insn_letter, scratch_letter;
 621           enum reg_class insn_class, scratch_class;
 622
 623           gcc_assert (insn_data[(int) icode].n_operands == 3);
 624           insn_constraint = insn_data[(int) icode].operand[!in_p].constraint;
 625           if (!*insn_constraint)
 626             insn_class = ALL_REGS;
 627           else
 628             {
 629               if (in_p)
 630                 {
 631                   gcc_assert (*insn_constraint == '=');
 632                   insn_constraint++;
 633                 }
 634               insn_letter = *insn_constraint;
 635               insn_class
 636                 = (insn_letter == 'r' ? GENERAL_REGS
 637                    : REG_CLASS_FROM_CONSTRAINT ((unsigned char) insn_letter,
 638                                                 insn_constraint));
 639               gcc_assert (insn_class != NO_REGS);
 640             }
 641
 642           scratch_constraint = insn_data[(int) icode].operand[2].constraint;
 643           /* The scratch register's constraint must start with "=&",
 644              except for an input reload, where only "=" is necessary,
 645              and where it might be beneficial to re-use registers from
 646              the input.  */
 647           gcc_assert (scratch_constraint[0] == '='
 648                       && (in_p || scratch_constraint[1] == '&'));
 649           scratch_constraint++;
 650           if (*scratch_constraint == '&')
 651             scratch_constraint++;
 652           scratch_letter = *scratch_constraint;
 653           scratch_class
 654             = (scratch_letter == 'r' ? GENERAL_REGS
 655                : REG_CLASS_FROM_CONSTRAINT ((unsigned char) scratch_letter,
 656                                             scratch_constraint));
 657
 658           if (reg_class_subset_p (reload_class, insn_class))
 659             {
 660               gcc_assert (scratch_class == rclass);
 661               rclass = NO_REGS;
 662             }
 663           else
 664             rclass = insn_class;
 665
 666         }
 667       if (rclass == NO_REGS)
 668         sri->icode = icode;
 669       else
 670         sri->t_icode = icode;
 671     }
 672   return rclass;
 673 }
 674
 675 bool
 676 default_handle_c_option (size_t code ATTRIBUTE_UNUSED,
 677                          const char *arg ATTRIBUTE_UNUSED,
 678                          int value ATTRIBUTE_UNUSED)
 679 {
 680   return false;
 681 }
 682
 683 /* By default, if flag_pic is true, then neither local nor global relocs
 684    should be placed in readonly memory.  */
 685
 686 int
 687 default_reloc_rw_mask (void)
 688 {
 689   return flag_pic ? 3 : 0;
 690 }
 691
 692 /* By default, do no modification. */
 693 tree default_mangle_decl_assembler_name (tree decl ATTRIBUTE_UNUSED,
 694                                          tree id)
 695 {
 696    return id;
 697 }
 698
 699 bool
 700 default_builtin_vector_alignment_reachable (const_tree type, bool is_packed)
 701 {
 702   if (is_packed)
 703     return false;
 704
 705   /* Assuming that types whose size is > pointer-size are not guaranteed to be
 706      naturally aligned.  */
 707   if (tree_int_cst_compare (TYPE_SIZE (type), bitsize_int (POINTER_SIZE)) > 0)
 708     return false;
 709
 710   /* Assuming that types whose size is <= pointer-size
 711      are naturally aligned.  */
 712   return true;
 713 }
 714
 715 bool
 716 default_hard_regno_scratch_ok (unsigned int regno ATTRIBUTE_UNUSED)
 717 {
 718   return true;
 719 }
 720
 721 bool
 722 default_target_option_valid_attribute_p (tree ARG_UNUSED (fndecl),
 723                                          tree ARG_UNUSED (name),
 724                                          tree ARG_UNUSED (args),
 725                                          int ARG_UNUSED (flags))
 726 {
 727   warning (OPT_Wattributes,
 728            "target attribute is not supported on this machine");
 729
 730   return false;
 731 }
 732
 733 bool
 734 default_target_option_pragma_parse (tree ARG_UNUSED (args),
 735                                     tree ARG_UNUSED (pop_target))
 736 {
 737   warning (OPT_Wpragmas,
 738            "#pragma GCC target is not supported for this machine");
 739
 740   return false;
 741 }
 742
 743 bool
 744 default_target_option_can_inline_p (tree caller, tree callee)
 745 {
 746   bool ret = false;
 747   tree callee_opts = DECL_FUNCTION_SPECIFIC_TARGET (callee);
 748   tree caller_opts = DECL_FUNCTION_SPECIFIC_TARGET (caller);
 749
 750   /* If callee has no option attributes, then it is ok to inline */
 751   if (!callee_opts)
 752     ret = true;
 753
 754   /* If caller has no option attributes, but callee does then it is not ok to
 755      inline */
 756   else if (!caller_opts)
 757     ret = false;
 758
 759   /* If both caller and callee have attributes, assume that if the pointer is
 760      different, the the two functions have different target options since
 761      build_target_option_node uses a hash table for the options.  */
 762   else
 763     ret = (callee_opts == caller_opts);
 764
 765   return ret;
 766 }
 767
 768 #include "gt-targhooks.h"