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 enum reg_class
 579 default_secondary_reload (bool in_p ATTRIBUTE_UNUSED, rtx x ATTRIBUTE_UNUSED,
 580                           enum reg_class reload_class ATTRIBUTE_UNUSED,
 581                           enum machine_mode reload_mode ATTRIBUTE_UNUSED,
 582                           secondary_reload_info *sri)
 583 {
 584   enum reg_class rclass = NO_REGS;
 585
 586   if (sri->prev_sri && sri->prev_sri->t_icode != CODE_FOR_nothing)
 587     {
 588       sri->icode = sri->prev_sri->t_icode;
 589       return NO_REGS;
 590     }
 591 #ifdef SECONDARY_INPUT_RELOAD_CLASS
 592   if (in_p)
 593     rclass = SECONDARY_INPUT_RELOAD_CLASS (reload_class, reload_mode, x);
 594 #endif
 595 #ifdef SECONDARY_OUTPUT_RELOAD_CLASS
 596   if (! in_p)
 597     rclass = SECONDARY_OUTPUT_RELOAD_CLASS (reload_class, reload_mode, x);
 598 #endif
 599   if (rclass != NO_REGS)
 600     {
 601       enum insn_code icode = (in_p ? reload_in_optab[(int) reload_mode]
 602                               : reload_out_optab[(int) reload_mode]);
 603
 604       if (icode != CODE_FOR_nothing
 605           && insn_data[(int) icode].operand[in_p].predicate
 606           && ! insn_data[(int) icode].operand[in_p].predicate (x, reload_mode))
 607         icode = CODE_FOR_nothing;
 608       else if (icode != CODE_FOR_nothing)
 609         {
 610           const char *insn_constraint, *scratch_constraint;
 611           char insn_letter, scratch_letter;
 612           enum reg_class insn_class, scratch_class;
 613
 614           gcc_assert (insn_data[(int) icode].n_operands == 3);
 615           insn_constraint = insn_data[(int) icode].operand[!in_p].constraint;
 616           if (!*insn_constraint)
 617             insn_class = ALL_REGS;
 618           else
 619             {
 620               if (in_p)
 621                 {
 622                   gcc_assert (*insn_constraint == '=');
 623                   insn_constraint++;
 624                 }
 625               insn_letter = *insn_constraint;
 626               insn_class
 627                 = (insn_letter == 'r' ? GENERAL_REGS
 628                    : REG_CLASS_FROM_CONSTRAINT ((unsigned char) insn_letter,
 629                                                 insn_constraint));
 630               gcc_assert (insn_class != NO_REGS);
 631             }
 632
 633           scratch_constraint = insn_data[(int) icode].operand[2].constraint;
 634           /* The scratch register's constraint must start with "=&",
 635              except for an input reload, where only "=" is necessary,
 636              and where it might be beneficial to re-use registers from
 637              the input.  */
 638           gcc_assert (scratch_constraint[0] == '='
 639                       && (in_p || scratch_constraint[1] == '&'));
 640           scratch_constraint++;
 641           if (*scratch_constraint == '&')
 642             scratch_constraint++;
 643           scratch_letter = *scratch_constraint;
 644           scratch_class
 645             = (scratch_letter == 'r' ? GENERAL_REGS
 646                : REG_CLASS_FROM_CONSTRAINT ((unsigned char) scratch_letter,
 647                                             scratch_constraint));
 648
 649           if (reg_class_subset_p (reload_class, insn_class))
 650             {
 651               gcc_assert (scratch_class == rclass);
 652               rclass = NO_REGS;
 653             }
 654           else
 655             rclass = insn_class;
 656
 657         }
 658       if (rclass == NO_REGS)
 659         sri->icode = icode;
 660       else
 661         sri->t_icode = icode;
 662     }
 663   return rclass;
 664 }
 665
 666 bool
 667 default_handle_c_option (size_t code ATTRIBUTE_UNUSED,
 668                          const char *arg ATTRIBUTE_UNUSED,
 669                          int value ATTRIBUTE_UNUSED)
 670 {
 671   return false;
 672 }
 673
 674 /* By default, if flag_pic is true, then neither local nor global relocs
 675    should be placed in readonly memory.  */
 676
 677 int
 678 default_reloc_rw_mask (void)
 679 {
 680   return flag_pic ? 3 : 0;
 681 }
 682
 683 /* By default, do no modification. */
 684 tree default_mangle_decl_assembler_name (tree decl ATTRIBUTE_UNUSED,
 685                                          tree id)
 686 {
 687    return id;
 688 }
 689
 690 bool
 691 default_builtin_vector_alignment_reachable (const_tree type, bool is_packed)
 692 {
 693   if (is_packed)
 694     return false;
 695
 696   /* Assuming that types whose size is > pointer-size are not guaranteed to be
 697      naturally aligned.  */
 698   if (tree_int_cst_compare (TYPE_SIZE (type), bitsize_int (POINTER_SIZE)) > 0)
 699     return false;
 700
 701   /* Assuming that types whose size is <= pointer-size
 702      are naturally aligned.  */
 703   return true;
 704 }
 705
 706 bool
 707 default_hard_regno_scratch_ok (unsigned int regno ATTRIBUTE_UNUSED)
 708 {
 709   return true;
 710 }
 711
 712 bool
 713 default_target_option_valid_attribute_p (tree ARG_UNUSED (fndecl),
 714                                          tree ARG_UNUSED (name),
 715                                          tree ARG_UNUSED (args),
 716                                          int ARG_UNUSED (flags))
 717 {
 718   return false;
 719 }
 720
 721 bool
 722 default_target_option_can_inline_p (tree caller, tree callee)
 723 {
 724   bool ret = false;
 725   tree callee_opts = DECL_FUNCTION_SPECIFIC_TARGET (callee);
 726   tree caller_opts = DECL_FUNCTION_SPECIFIC_TARGET (caller);
 727
 728   /* If callee has no option attributes, then it is ok to inline */
 729   if (!callee_opts)
 730     ret = true;
 731
 732   /* If caller has no option attributes, but callee does then it is not ok to
 733      inline */
 734   else if (!caller_opts)
 735     ret = false;
 736
 737   /* If both caller and callee have attributes, assume that if the pointer is
 738      different, the the two functions have different target options since
 739      build_target_option_node uses a hash table for the options.  */
 740   else
 741     ret = (callee_opts == caller_opts);
 742
 743   return ret;
 744 }
 745
 746 #include "gt-targhooks.h"