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 #ifndef RETURN_IN_MEMORY
 111   return (TYPE_MODE (type) == BLKmode);
 112 #else
 113   return RETURN_IN_MEMORY (type);
 114 #endif
 115 }
 116
 117 rtx
 118 default_expand_builtin_saveregs (void)
 119 {
 120   error ("__builtin_saveregs not supported by this target");
 121   return const0_rtx;
 122 }
 123
 124 void
 125 default_setup_incoming_varargs (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED,
 126                                 enum machine_mode mode ATTRIBUTE_UNUSED,
 127                                 tree type ATTRIBUTE_UNUSED,
 128                                 int *pretend_arg_size ATTRIBUTE_UNUSED,
 129                                 int second_time ATTRIBUTE_UNUSED)
 130 {
 131 }
 132
 133 /* The default implementation of TARGET_BUILTIN_SETJMP_FRAME_VALUE.  */
 134
 135 rtx
 136 default_builtin_setjmp_frame_value (void)
 137 {
 138   return virtual_stack_vars_rtx;
 139 }
 140
 141 /* Generic hook that takes a CUMULATIVE_ARGS pointer and returns false.  */
 142
 143 bool
 144 hook_bool_CUMULATIVE_ARGS_false (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED)
 145 {
 146   return false;
 147 }
 148
 149 bool
 150 default_pretend_outgoing_varargs_named (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED)
 151 {
 152   return (targetm.calls.setup_incoming_varargs
 153           != default_setup_incoming_varargs);
 154 }
 155
 156 enum machine_mode
 157 default_eh_return_filter_mode (void)
 158 {
 159   return word_mode;
 160 }
 161
 162 enum machine_mode
 163 default_libgcc_cmp_return_mode (void)
 164 {
 165   return word_mode;
 166 }
 167
 168 enum machine_mode
 169 default_libgcc_shift_count_mode (void)
 170 {
 171   return word_mode;
 172 }
 173
 174 /* The default implementation of TARGET_SHIFT_TRUNCATION_MASK.  */
 175
 176 unsigned HOST_WIDE_INT
 177 default_shift_truncation_mask (enum machine_mode mode)
 178 {
 179   return SHIFT_COUNT_TRUNCATED ? GET_MODE_BITSIZE (mode) - 1 : 0;
 180 }
 181
 182 /* The default implementation of TARGET_MIN_DIVISIONS_FOR_RECIP_MUL.  */
 183
 184 unsigned int
 185 default_min_divisions_for_recip_mul (enum machine_mode mode ATTRIBUTE_UNUSED)
 186 {
 187   return have_insn_for (DIV, mode) ? 3 : 2;
 188 }
 189
 190 /* The default implementation of TARGET_MODE_REP_EXTENDED.  */
 191
 192 int
 193 default_mode_rep_extended (enum machine_mode mode ATTRIBUTE_UNUSED,
 194                            enum machine_mode mode_rep ATTRIBUTE_UNUSED)
 195 {
 196   return UNKNOWN;
 197 }
 198
 199 /* Generic hook that takes a CUMULATIVE_ARGS pointer and returns true.  */
 200
 201 bool
 202 hook_bool_CUMULATIVE_ARGS_true (CUMULATIVE_ARGS * a ATTRIBUTE_UNUSED)
 203 {
 204   return true;
 205 }
 206
 207 /* Return machine mode for non-standard suffix
 208    or VOIDmode if non-standard suffixes are unsupported.  */
 209 enum machine_mode
 210 default_mode_for_suffix (char suffix ATTRIBUTE_UNUSED)
 211 {
 212   return VOIDmode;
 213 }
 214
 215 /* The generic C++ ABI specifies this is a 64-bit value.  */
 216 tree
 217 default_cxx_guard_type (void)
 218 {
 219   return long_long_integer_type_node;
 220 }
 221
 222
 223 /* Returns the size of the cookie to use when allocating an array
 224    whose elements have the indicated TYPE.  Assumes that it is already
 225    known that a cookie is needed.  */
 226
 227 tree
 228 default_cxx_get_cookie_size (tree type)
 229 {
 230   tree cookie_size;
 231
 232   /* We need to allocate an additional max (sizeof (size_t), alignof
 233      (true_type)) bytes.  */
 234   tree sizetype_size;
 235   tree type_align;
 236
 237   sizetype_size = size_in_bytes (sizetype);
 238   type_align = size_int (TYPE_ALIGN_UNIT (type));
 239   if (INT_CST_LT_UNSIGNED (type_align, sizetype_size))
 240     cookie_size = sizetype_size;
 241   else
 242     cookie_size = type_align;
 243
 244   return cookie_size;
 245 }
 246
 247 /* Return true if a parameter must be passed by reference.  This version
 248    of the TARGET_PASS_BY_REFERENCE hook uses just MUST_PASS_IN_STACK.  */
 249
 250 bool
 251 hook_pass_by_reference_must_pass_in_stack (CUMULATIVE_ARGS *c ATTRIBUTE_UNUSED,
 252         enum machine_mode mode ATTRIBUTE_UNUSED, const_tree type ATTRIBUTE_UNUSED,
 253         bool named_arg ATTRIBUTE_UNUSED)
 254 {
 255   return targetm.calls.must_pass_in_stack (mode, type);
 256 }
 257
 258 /* Return true if a parameter follows callee copies conventions.  This
 259    version of the hook is true for all named arguments.  */
 260
 261 bool
 262 hook_callee_copies_named (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED,
 263                           enum machine_mode mode ATTRIBUTE_UNUSED,
 264                           const_tree type ATTRIBUTE_UNUSED, bool named)
 265 {
 266   return named;
 267 }
 268
 269 /* Emit any directives required to unwind this instruction.  */
 270
 271 void
 272 default_unwind_emit (FILE * stream ATTRIBUTE_UNUSED,
 273                      rtx insn ATTRIBUTE_UNUSED)
 274 {
 275   /* Should never happen.  */
 276   gcc_unreachable ();
 277 }
 278
 279 /* True if MODE is valid for the target.  By "valid", we mean able to
 280    be manipulated in non-trivial ways.  In particular, this means all
 281    the arithmetic is supported.
 282
 283    By default we guess this means that any C type is supported.  If
 284    we can't map the mode back to a type that would be available in C,
 285    then reject it.  Special case, here, is the double-word arithmetic
 286    supported by optabs.c.  */
 287
 288 bool
 289 default_scalar_mode_supported_p (enum machine_mode mode)
 290 {
 291   int precision = GET_MODE_PRECISION (mode);
 292
 293   switch (GET_MODE_CLASS (mode))
 294     {
 295     case MODE_PARTIAL_INT:
 296     case MODE_INT:
 297       if (precision == CHAR_TYPE_SIZE)
 298         return true;
 299       if (precision == SHORT_TYPE_SIZE)
 300         return true;
 301       if (precision == INT_TYPE_SIZE)
 302         return true;
 303       if (precision == LONG_TYPE_SIZE)
 304         return true;
 305       if (precision == LONG_LONG_TYPE_SIZE)
 306         return true;
 307       if (precision == 2 * BITS_PER_WORD)
 308         return true;
 309       return false;
 310
 311     case MODE_FLOAT:
 312       if (precision == FLOAT_TYPE_SIZE)
 313         return true;
 314       if (precision == DOUBLE_TYPE_SIZE)
 315         return true;
 316       if (precision == LONG_DOUBLE_TYPE_SIZE)
 317         return true;
 318       return false;
 319
 320     case MODE_DECIMAL_FLOAT:
 321     case MODE_FRACT:
 322     case MODE_UFRACT:
 323     case MODE_ACCUM:
 324     case MODE_UACCUM:
 325       return false;
 326
 327     default:
 328       gcc_unreachable ();
 329     }
 330 }
 331
 332 /* True if the target supports decimal floating point.  */
 333
 334 bool
 335 default_decimal_float_supported_p (void)
 336 {
 337   return ENABLE_DECIMAL_FLOAT;
 338 }
 339
 340 /* True if the target supports fixed-point arithmetic.  */
 341
 342 bool
 343 default_fixed_point_supported_p (void)
 344 {
 345   return ENABLE_FIXED_POINT;
 346 }
 347
 348 /* NULL if INSN insn is valid within a low-overhead loop, otherwise returns
 349    an error message.
 350
 351    This function checks whether a given INSN is valid within a low-overhead
 352    loop.  If INSN is invalid it returns the reason for that, otherwise it
 353    returns NULL. A called function may clobber any special registers required
 354    for low-overhead looping. Additionally, some targets (eg, PPC) use the count
 355    register for branch on table instructions. We reject the doloop pattern in
 356    these cases.  */
 357
 358 const char *
 359 default_invalid_within_doloop (const_rtx insn)
 360 {
 361   if (CALL_P (insn))
 362     return "Function call in loop.";
 363
 364   if (JUMP_P (insn)
 365       && (GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC
 366           || GET_CODE (PATTERN (insn)) == ADDR_VEC))
 367     return "Computed branch in the loop.";
 368
 369   return NULL;
 370 }
 371
 372 /* Mapping of builtin functions to vectorized variants.  */
 373
 374 tree
 375 default_builtin_vectorized_function (enum built_in_function fn ATTRIBUTE_UNUSED,
 376                                      tree type_out ATTRIBUTE_UNUSED,
 377                                      tree type_in ATTRIBUTE_UNUSED)
 378 {
 379   return NULL_TREE;
 380 }
 381
 382 /* Vectorized conversion.  */
 383
 384 tree
 385 default_builtin_vectorized_conversion (enum tree_code code ATTRIBUTE_UNUSED,
 386                                        tree type ATTRIBUTE_UNUSED)
 387 {
 388   return NULL_TREE;
 389 }
 390
 391 /* Reciprocal.  */
 392
 393 tree
 394 default_builtin_reciprocal (enum built_in_function fn ATTRIBUTE_UNUSED,
 395                             bool md_fn ATTRIBUTE_UNUSED,
 396                             bool sqrt ATTRIBUTE_UNUSED)
 397 {
 398   return NULL_TREE;
 399 }
 400
 401 bool
 402 hook_bool_CUMULATIVE_ARGS_mode_tree_bool_false (
 403         CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED,
 404         enum machine_mode mode ATTRIBUTE_UNUSED,
 405         const_tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED)
 406 {
 407   return false;
 408 }
 409
 410 bool
 411 hook_bool_CUMULATIVE_ARGS_mode_tree_bool_true (
 412         CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED,
 413         enum machine_mode mode ATTRIBUTE_UNUSED,
 414         const_tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED)
 415 {
 416   return true;
 417 }
 418
 419 int
 420 hook_int_CUMULATIVE_ARGS_mode_tree_bool_0 (
 421         CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED,
 422         enum machine_mode mode ATTRIBUTE_UNUSED,
 423         tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED)
 424 {
 425   return 0;
 426 }
 427
 428 void
 429 hook_void_bitmap (bitmap regs ATTRIBUTE_UNUSED)
 430 {
 431 }
 432
 433 const char *
 434 hook_invalid_arg_for_unprototyped_fn (
 435         const_tree typelist ATTRIBUTE_UNUSED,
 436         const_tree funcdecl ATTRIBUTE_UNUSED,
 437         const_tree val ATTRIBUTE_UNUSED)
 438 {
 439   return NULL;
 440 }
 441
 442 /* Initialize the stack protection decls.  */
 443
 444 /* Stack protection related decls living in libgcc.  */
 445 static GTY(()) tree stack_chk_guard_decl;
 446
 447 tree
 448 default_stack_protect_guard (void)
 449 {
 450   tree t = stack_chk_guard_decl;
 451
 452   if (t == NULL)
 453     {
 454       t = build_decl (VAR_DECL, get_identifier ("__stack_chk_guard"),
 455                       ptr_type_node);
 456       TREE_STATIC (t) = 1;
 457       TREE_PUBLIC (t) = 1;
 458       DECL_EXTERNAL (t) = 1;
 459       TREE_USED (t) = 1;
 460       TREE_THIS_VOLATILE (t) = 1;
 461       DECL_ARTIFICIAL (t) = 1;
 462       DECL_IGNORED_P (t) = 1;
 463
 464       stack_chk_guard_decl = t;
 465     }
 466
 467   return t;
 468 }
 469
 470 static GTY(()) tree stack_chk_fail_decl;
 471
 472 tree
 473 default_external_stack_protect_fail (void)
 474 {
 475   tree t = stack_chk_fail_decl;
 476
 477   if (t == NULL_TREE)
 478     {
 479       t = build_function_type_list (void_type_node, NULL_TREE);
 480       t = build_decl (FUNCTION_DECL, get_identifier ("__stack_chk_fail"), t);
 481       TREE_STATIC (t) = 1;
 482       TREE_PUBLIC (t) = 1;
 483       DECL_EXTERNAL (t) = 1;
 484       TREE_USED (t) = 1;
 485       TREE_THIS_VOLATILE (t) = 1;
 486       TREE_NOTHROW (t) = 1;
 487       DECL_ARTIFICIAL (t) = 1;
 488       DECL_IGNORED_P (t) = 1;
 489       DECL_VISIBILITY (t) = VISIBILITY_DEFAULT;
 490       DECL_VISIBILITY_SPECIFIED (t) = 1;
 491
 492       stack_chk_fail_decl = t;
 493     }
 494
 495   return build_call_expr (t, 0);
 496 }
 497
 498 tree
 499 default_hidden_stack_protect_fail (void)
 500 {
 501 #ifndef HAVE_GAS_HIDDEN
 502   return default_external_stack_protect_fail ();
 503 #else
 504   tree t = stack_chk_fail_decl;
 505
 506   if (!flag_pic)
 507     return default_external_stack_protect_fail ();
 508
 509   if (t == NULL_TREE)
 510     {
 511       t = build_function_type_list (void_type_node, NULL_TREE);
 512       t = build_decl (FUNCTION_DECL,
 513                       get_identifier ("__stack_chk_fail_local"), t);
 514       TREE_STATIC (t) = 1;
 515       TREE_PUBLIC (t) = 1;
 516       DECL_EXTERNAL (t) = 1;
 517       TREE_USED (t) = 1;
 518       TREE_THIS_VOLATILE (t) = 1;
 519       TREE_NOTHROW (t) = 1;
 520       DECL_ARTIFICIAL (t) = 1;
 521       DECL_IGNORED_P (t) = 1;
 522       DECL_VISIBILITY_SPECIFIED (t) = 1;
 523       DECL_VISIBILITY (t) = VISIBILITY_HIDDEN;
 524
 525       stack_chk_fail_decl = t;
 526     }
 527
 528   return build_call_expr (t, 0);
 529 #endif
 530 }
 531
 532 bool
 533 hook_bool_const_rtx_commutative_p (const_rtx x,
 534                                    int outer_code ATTRIBUTE_UNUSED)
 535 {
 536   return COMMUTATIVE_P (x);
 537 }
 538
 539 rtx
 540 default_function_value (const_tree ret_type ATTRIBUTE_UNUSED,
 541                         const_tree fn_decl_or_type,
 542                         bool outgoing ATTRIBUTE_UNUSED)
 543 {
 544   /* The old interface doesn't handle receiving the function type.  */
 545   if (fn_decl_or_type
 546       && !DECL_P (fn_decl_or_type))
 547     fn_decl_or_type = NULL;
 548
 549 #ifdef FUNCTION_OUTGOING_VALUE
 550   if (outgoing)
 551     return FUNCTION_OUTGOING_VALUE (ret_type, fn_decl_or_type);
 552 #endif
 553
 554 #ifdef FUNCTION_VALUE
 555   return FUNCTION_VALUE (ret_type, fn_decl_or_type);
 556 #else
 557   return NULL_RTX;
 558 #endif
 559 }
 560
 561 rtx
 562 default_internal_arg_pointer (void)
 563 {
 564   /* If the reg that the virtual arg pointer will be translated into is
 565      not a fixed reg or is the stack pointer, make a copy of the virtual
 566      arg pointer, and address parms via the copy.  The frame pointer is
 567      considered fixed even though it is not marked as such.  */
 568   if ((ARG_POINTER_REGNUM == STACK_POINTER_REGNUM
 569        || ! (fixed_regs[ARG_POINTER_REGNUM]
 570              || ARG_POINTER_REGNUM == FRAME_POINTER_REGNUM)))
 571     return copy_to_reg (virtual_incoming_args_rtx);
 572   else
 573     return virtual_incoming_args_rtx;
 574 }
 575
 576 enum reg_class
 577 default_secondary_reload (bool in_p ATTRIBUTE_UNUSED, rtx x ATTRIBUTE_UNUSED,
 578                           enum reg_class reload_class ATTRIBUTE_UNUSED,
 579                           enum machine_mode reload_mode ATTRIBUTE_UNUSED,
 580                           secondary_reload_info *sri)
 581 {
 582   enum reg_class class = NO_REGS;
 583
 584   if (sri->prev_sri && sri->prev_sri->t_icode != CODE_FOR_nothing)
 585     {
 586       sri->icode = sri->prev_sri->t_icode;
 587       return NO_REGS;
 588     }
 589 #ifdef SECONDARY_INPUT_RELOAD_CLASS
 590   if (in_p)
 591     class = SECONDARY_INPUT_RELOAD_CLASS (reload_class, reload_mode, x);
 592 #endif
 593 #ifdef SECONDARY_OUTPUT_RELOAD_CLASS
 594   if (! in_p)
 595     class = SECONDARY_OUTPUT_RELOAD_CLASS (reload_class, reload_mode, x);
 596 #endif
 597   if (class != NO_REGS)
 598     {
 599       enum insn_code icode = (in_p ? reload_in_optab[(int) reload_mode]
 600                               : reload_out_optab[(int) reload_mode]);
 601
 602       if (icode != CODE_FOR_nothing
 603           && insn_data[(int) icode].operand[in_p].predicate
 604           && ! insn_data[(int) icode].operand[in_p].predicate (x, reload_mode))
 605         icode = CODE_FOR_nothing;
 606       else if (icode != CODE_FOR_nothing)
 607         {
 608           const char *insn_constraint, *scratch_constraint;
 609           char insn_letter, scratch_letter;
 610           enum reg_class insn_class, scratch_class;
 611
 612           gcc_assert (insn_data[(int) icode].n_operands == 3);
 613           insn_constraint = insn_data[(int) icode].operand[!in_p].constraint;
 614           if (!*insn_constraint)
 615             insn_class = ALL_REGS;
 616           else
 617             {
 618               if (in_p)
 619                 {
 620                   gcc_assert (*insn_constraint == '=');
 621                   insn_constraint++;
 622                 }
 623               insn_letter = *insn_constraint;
 624               insn_class
 625                 = (insn_letter == 'r' ? GENERAL_REGS
 626                    : REG_CLASS_FROM_CONSTRAINT ((unsigned char) insn_letter,
 627                                                 insn_constraint));
 628               gcc_assert (insn_class != NO_REGS);
 629             }
 630
 631           scratch_constraint = insn_data[(int) icode].operand[2].constraint;
 632           /* The scratch register's constraint must start with "=&",
 633              except for an input reload, where only "=" is necessary,
 634              and where it might be beneficial to re-use registers from
 635              the input.  */
 636           gcc_assert (scratch_constraint[0] == '='
 637                       && (in_p || scratch_constraint[1] == '&'));
 638           scratch_constraint++;
 639           if (*scratch_constraint == '&')
 640             scratch_constraint++;
 641           scratch_letter = *scratch_constraint;
 642           scratch_class
 643             = (scratch_letter == 'r' ? GENERAL_REGS
 644                : REG_CLASS_FROM_CONSTRAINT ((unsigned char) scratch_letter,
 645                                             scratch_constraint));
 646
 647           if (reg_class_subset_p (reload_class, insn_class))
 648             {
 649               gcc_assert (scratch_class == class);
 650               class = NO_REGS;
 651             }
 652           else
 653             class = insn_class;
 654
 655         }
 656       if (class == NO_REGS)
 657         sri->icode = icode;
 658       else
 659         sri->t_icode = icode;
 660     }
 661   return class;
 662 }
 663
 664 bool
 665 default_handle_c_option (size_t code ATTRIBUTE_UNUSED,
 666                          const char *arg ATTRIBUTE_UNUSED,
 667                          int value ATTRIBUTE_UNUSED)
 668 {
 669   return false;
 670 }
 671
 672 /* By default, if flag_pic is true, then neither local nor global relocs
 673    should be placed in readonly memory.  */
 674
 675 int
 676 default_reloc_rw_mask (void)
 677 {
 678   return flag_pic ? 3 : 0;
 679 }
 680
 681 /* By default, do no modification. */
 682 tree default_mangle_decl_assembler_name (tree decl ATTRIBUTE_UNUSED,
 683                                          tree id)
 684 {
 685    return id;
 686 }
 687
 688 bool
 689 default_builtin_vector_alignment_reachable (const_tree type, bool is_packed)
 690 {
 691   if (is_packed)
 692     return false;
 693
 694   /* Assuming that types whose size is > pointer-size are not guaranteed to be
 695      naturally aligned.  */
 696   if (tree_int_cst_compare (TYPE_SIZE (type), bitsize_int (POINTER_SIZE)) > 0)
 697     return false;
 698
 699   /* Assuming that types whose size is <= pointer-size
 700      are naturally aligned.  */
 701   return true;
 702 }
 703
 704 #include "gt-targhooks.h"