gcc/targhooks.c

   1 /* Default target hook functions.
   2    Copyright (C) 2003-2013 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 "diagnostic-core.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 "regs.h"
  66 #include "reload.h"
  67 #include "optabs.h"
  68 #include "recog.h"
  69 #include "intl.h"
  70 #include "opts.h"
  71 #include "tree-flow.h"
  72 #include "tree-ssa-alias.h"
  73
  74
  75 bool
  76 default_legitimate_address_p (enum machine_mode mode ATTRIBUTE_UNUSED,
  77                               rtx addr ATTRIBUTE_UNUSED,
  78                               bool strict ATTRIBUTE_UNUSED)
  79 {
  80 #ifdef GO_IF_LEGITIMATE_ADDRESS
  81   /* Defer to the old implementation using a goto.  */
  82   if (strict)
  83     return strict_memory_address_p (mode, addr);
  84   else
  85     return memory_address_p (mode, addr);
  86 #else
  87   gcc_unreachable ();
  88 #endif
  89 }
  90
  91 void
  92 default_external_libcall (rtx fun ATTRIBUTE_UNUSED)
  93 {
  94 #ifdef ASM_OUTPUT_EXTERNAL_LIBCALL
  95   ASM_OUTPUT_EXTERNAL_LIBCALL(asm_out_file, fun);
  96 #endif
  97 }
  98
  99 int
 100 default_unspec_may_trap_p (const_rtx x, unsigned flags)
 101 {
 102   int i;
 103
 104   /* Any floating arithmetic may trap.  */
 105   if ((SCALAR_FLOAT_MODE_P (GET_MODE (x)) && flag_trapping_math))
 106     return 1;
 107
 108   for (i = 0; i < XVECLEN (x, 0); ++i)
 109     {
 110       if (may_trap_p_1 (XVECEXP (x, 0, i), flags))
 111         return 1;
 112     }
 113
 114   return 0;
 115 }
 116
 117 enum machine_mode
 118 default_promote_function_mode (const_tree type ATTRIBUTE_UNUSED,
 119                                enum machine_mode mode,
 120                                int *punsignedp ATTRIBUTE_UNUSED,
 121                                const_tree funtype ATTRIBUTE_UNUSED,
 122                                int for_return ATTRIBUTE_UNUSED)
 123 {
 124   if (type != NULL_TREE && for_return == 2)
 125     return promote_mode (type, mode, punsignedp);
 126   return mode;
 127 }
 128
 129 enum machine_mode
 130 default_promote_function_mode_always_promote (const_tree type,
 131                                               enum machine_mode mode,
 132                                               int *punsignedp,
 133                                               const_tree funtype ATTRIBUTE_UNUSED,
 134                                               int for_return ATTRIBUTE_UNUSED)
 135 {
 136   return promote_mode (type, mode, punsignedp);
 137 }
 138
 139
 140 enum machine_mode
 141 default_cc_modes_compatible (enum machine_mode m1, enum machine_mode m2)
 142 {
 143   if (m1 == m2)
 144     return m1;
 145   return VOIDmode;
 146 }
 147
 148 bool
 149 default_return_in_memory (const_tree type,
 150                           const_tree fntype ATTRIBUTE_UNUSED)
 151 {
 152   return (TYPE_MODE (type) == BLKmode);
 153 }
 154
 155 rtx
 156 default_legitimize_address (rtx x, rtx orig_x ATTRIBUTE_UNUSED,
 157                             enum machine_mode mode ATTRIBUTE_UNUSED)
 158 {
 159   return x;
 160 }
 161
 162 rtx
 163 default_expand_builtin_saveregs (void)
 164 {
 165   error ("__builtin_saveregs not supported by this target");
 166   return const0_rtx;
 167 }
 168
 169 void
 170 default_setup_incoming_varargs (cumulative_args_t ca ATTRIBUTE_UNUSED,
 171                                 enum machine_mode mode ATTRIBUTE_UNUSED,
 172                                 tree type ATTRIBUTE_UNUSED,
 173                                 int *pretend_arg_size ATTRIBUTE_UNUSED,
 174                                 int second_time ATTRIBUTE_UNUSED)
 175 {
 176 }
 177
 178 /* The default implementation of TARGET_BUILTIN_SETJMP_FRAME_VALUE.  */
 179
 180 rtx
 181 default_builtin_setjmp_frame_value (void)
 182 {
 183   return virtual_stack_vars_rtx;
 184 }
 185
 186 /* Generic hook that takes a CUMULATIVE_ARGS pointer and returns false.  */
 187
 188 bool
 189 hook_bool_CUMULATIVE_ARGS_false (cumulative_args_t ca ATTRIBUTE_UNUSED)
 190 {
 191   return false;
 192 }
 193
 194 bool
 195 default_pretend_outgoing_varargs_named (cumulative_args_t ca ATTRIBUTE_UNUSED)
 196 {
 197   return (targetm.calls.setup_incoming_varargs
 198           != default_setup_incoming_varargs);
 199 }
 200
 201 enum machine_mode
 202 default_eh_return_filter_mode (void)
 203 {
 204   return targetm.unwind_word_mode ();
 205 }
 206
 207 enum machine_mode
 208 default_libgcc_cmp_return_mode (void)
 209 {
 210   return word_mode;
 211 }
 212
 213 enum machine_mode
 214 default_libgcc_shift_count_mode (void)
 215 {
 216   return word_mode;
 217 }
 218
 219 enum machine_mode
 220 default_unwind_word_mode (void)
 221 {
 222   return word_mode;
 223 }
 224
 225 /* The default implementation of TARGET_SHIFT_TRUNCATION_MASK.  */
 226
 227 unsigned HOST_WIDE_INT
 228 default_shift_truncation_mask (enum machine_mode mode)
 229 {
 230   return SHIFT_COUNT_TRUNCATED ? GET_MODE_BITSIZE (mode) - 1 : 0;
 231 }
 232
 233 /* The default implementation of TARGET_MIN_DIVISIONS_FOR_RECIP_MUL.  */
 234
 235 unsigned int
 236 default_min_divisions_for_recip_mul (enum machine_mode mode ATTRIBUTE_UNUSED)
 237 {
 238   return have_insn_for (DIV, mode) ? 3 : 2;
 239 }
 240
 241 /* The default implementation of TARGET_MODE_REP_EXTENDED.  */
 242
 243 int
 244 default_mode_rep_extended (enum machine_mode mode ATTRIBUTE_UNUSED,
 245                            enum machine_mode mode_rep ATTRIBUTE_UNUSED)
 246 {
 247   return UNKNOWN;
 248 }
 249
 250 /* Generic hook that takes a CUMULATIVE_ARGS pointer and returns true.  */
 251
 252 bool
 253 hook_bool_CUMULATIVE_ARGS_true (cumulative_args_t a ATTRIBUTE_UNUSED)
 254 {
 255   return true;
 256 }
 257
 258 /* Return machine mode for non-standard suffix
 259    or VOIDmode if non-standard suffixes are unsupported.  */
 260 enum machine_mode
 261 default_mode_for_suffix (char suffix ATTRIBUTE_UNUSED)
 262 {
 263   return VOIDmode;
 264 }
 265
 266 /* The generic C++ ABI specifies this is a 64-bit value.  */
 267 tree
 268 default_cxx_guard_type (void)
 269 {
 270   return long_long_integer_type_node;
 271 }
 272
 273
 274 /* Returns the size of the cookie to use when allocating an array
 275    whose elements have the indicated TYPE.  Assumes that it is already
 276    known that a cookie is needed.  */
 277
 278 tree
 279 default_cxx_get_cookie_size (tree type)
 280 {
 281   tree cookie_size;
 282
 283   /* We need to allocate an additional max (sizeof (size_t), alignof
 284      (true_type)) bytes.  */
 285   tree sizetype_size;
 286   tree type_align;
 287
 288   sizetype_size = size_in_bytes (sizetype);
 289   type_align = size_int (TYPE_ALIGN_UNIT (type));
 290   if (INT_CST_LT_UNSIGNED (type_align, sizetype_size))
 291     cookie_size = sizetype_size;
 292   else
 293     cookie_size = type_align;
 294
 295   return cookie_size;
 296 }
 297
 298 /* Return true if a parameter must be passed by reference.  This version
 299    of the TARGET_PASS_BY_REFERENCE hook uses just MUST_PASS_IN_STACK.  */
 300
 301 bool
 302 hook_pass_by_reference_must_pass_in_stack (cumulative_args_t c ATTRIBUTE_UNUSED,
 303         enum machine_mode mode ATTRIBUTE_UNUSED, const_tree type ATTRIBUTE_UNUSED,
 304         bool named_arg ATTRIBUTE_UNUSED)
 305 {
 306   return targetm.calls.must_pass_in_stack (mode, type);
 307 }
 308
 309 /* Return true if a parameter follows callee copies conventions.  This
 310    version of the hook is true for all named arguments.  */
 311
 312 bool
 313 hook_callee_copies_named (cumulative_args_t ca ATTRIBUTE_UNUSED,
 314                           enum machine_mode mode ATTRIBUTE_UNUSED,
 315                           const_tree type ATTRIBUTE_UNUSED, bool named)
 316 {
 317   return named;
 318 }
 319
 320 /* Emit to STREAM the assembler syntax for insn operand X.  */
 321
 322 void
 323 default_print_operand (FILE *stream ATTRIBUTE_UNUSED, rtx x ATTRIBUTE_UNUSED,
 324                        int code ATTRIBUTE_UNUSED)
 325 {
 326 #ifdef PRINT_OPERAND
 327   PRINT_OPERAND (stream, x, code);
 328 #else
 329   gcc_unreachable ();
 330 #endif
 331 }
 332
 333 /* Emit to STREAM the assembler syntax for an insn operand whose memory
 334    address is X.  */
 335
 336 void
 337 default_print_operand_address (FILE *stream ATTRIBUTE_UNUSED,
 338                                rtx x ATTRIBUTE_UNUSED)
 339 {
 340 #ifdef PRINT_OPERAND_ADDRESS
 341   PRINT_OPERAND_ADDRESS (stream, x);
 342 #else
 343   gcc_unreachable ();
 344 #endif
 345 }
 346
 347 /* Return true if CODE is a valid punctuation character for the
 348    `print_operand' hook.  */
 349
 350 bool
 351 default_print_operand_punct_valid_p (unsigned char code ATTRIBUTE_UNUSED)
 352 {
 353 #ifdef PRINT_OPERAND_PUNCT_VALID_P
 354   return PRINT_OPERAND_PUNCT_VALID_P (code);
 355 #else
 356   return false;
 357 #endif
 358 }
 359
 360 /* The default implementation of TARGET_MANGLE_ASSEMBLER_NAME.  */
 361 tree
 362 default_mangle_assembler_name (const char *name ATTRIBUTE_UNUSED)
 363 {
 364   const char *skipped = name + (*name == '*' ? 1 : 0);
 365   const char *stripped = targetm.strip_name_encoding (skipped);
 366   if (*name != '*' && user_label_prefix[0])
 367     stripped = ACONCAT ((user_label_prefix, stripped, NULL));
 368   return get_identifier (stripped);
 369 }
 370
 371 /* True if MODE is valid for the target.  By "valid", we mean able to
 372    be manipulated in non-trivial ways.  In particular, this means all
 373    the arithmetic is supported.
 374
 375    By default we guess this means that any C type is supported.  If
 376    we can't map the mode back to a type that would be available in C,
 377    then reject it.  Special case, here, is the double-word arithmetic
 378    supported by optabs.c.  */
 379
 380 bool
 381 default_scalar_mode_supported_p (enum machine_mode mode)
 382 {
 383   int precision = GET_MODE_PRECISION (mode);
 384
 385   switch (GET_MODE_CLASS (mode))
 386     {
 387     case MODE_PARTIAL_INT:
 388     case MODE_INT:
 389       if (precision == CHAR_TYPE_SIZE)
 390         return true;
 391       if (precision == SHORT_TYPE_SIZE)
 392         return true;
 393       if (precision == INT_TYPE_SIZE)
 394         return true;
 395       if (precision == LONG_TYPE_SIZE)
 396         return true;
 397       if (precision == LONG_LONG_TYPE_SIZE)
 398         return true;
 399       if (precision == 2 * BITS_PER_WORD)
 400         return true;
 401       return false;
 402
 403     case MODE_FLOAT:
 404       if (precision == FLOAT_TYPE_SIZE)
 405         return true;
 406       if (precision == DOUBLE_TYPE_SIZE)
 407         return true;
 408       if (precision == LONG_DOUBLE_TYPE_SIZE)
 409         return true;
 410       return false;
 411
 412     case MODE_DECIMAL_FLOAT:
 413     case MODE_FRACT:
 414     case MODE_UFRACT:
 415     case MODE_ACCUM:
 416     case MODE_UACCUM:
 417       return false;
 418
 419     default:
 420       gcc_unreachable ();
 421     }
 422 }
 423
 424 /* Make some target macros useable by target-independent code.  */
 425 bool
 426 targhook_words_big_endian (void)
 427 {
 428   return !!WORDS_BIG_ENDIAN;
 429 }
 430
 431 bool
 432 targhook_float_words_big_endian (void)
 433 {
 434   return !!FLOAT_WORDS_BIG_ENDIAN;
 435 }
 436
 437 /* True if the target supports decimal floating point.  */
 438
 439 bool
 440 default_decimal_float_supported_p (void)
 441 {
 442   return ENABLE_DECIMAL_FLOAT;
 443 }
 444
 445 /* True if the target supports fixed-point arithmetic.  */
 446
 447 bool
 448 default_fixed_point_supported_p (void)
 449 {
 450   return ENABLE_FIXED_POINT;
 451 }
 452
 453 /* True if the target supports GNU indirect functions.  */
 454
 455 bool
 456 default_has_ifunc_p (void)
 457 {
 458   return HAVE_GNU_INDIRECT_FUNCTION;
 459 }
 460
 461 /* NULL if INSN insn is valid within a low-overhead loop, otherwise returns
 462    an error message.
 463
 464    This function checks whether a given INSN is valid within a low-overhead
 465    loop.  If INSN is invalid it returns the reason for that, otherwise it
 466    returns NULL. A called function may clobber any special registers required
 467    for low-overhead looping. Additionally, some targets (eg, PPC) use the count
 468    register for branch on table instructions. We reject the doloop pattern in
 469    these cases.  */
 470
 471 const char *
 472 default_invalid_within_doloop (const_rtx insn)
 473 {
 474   if (CALL_P (insn))
 475     return "Function call in loop.";
 476
 477   if (tablejump_p (insn, NULL, NULL) || computed_jump_p (insn))
 478     return "Computed branch in the loop.";
 479
 480   return NULL;
 481 }
 482
 483 /* Mapping of builtin functions to vectorized variants.  */
 484
 485 tree
 486 default_builtin_vectorized_function (tree fndecl ATTRIBUTE_UNUSED,
 487                                      tree type_out ATTRIBUTE_UNUSED,
 488                                      tree type_in ATTRIBUTE_UNUSED)
 489 {
 490   return NULL_TREE;
 491 }
 492
 493 /* Vectorized conversion.  */
 494
 495 tree
 496 default_builtin_vectorized_conversion (unsigned int code ATTRIBUTE_UNUSED,
 497                                        tree dest_type ATTRIBUTE_UNUSED,
 498                                        tree src_type ATTRIBUTE_UNUSED)
 499 {
 500   return NULL_TREE;
 501 }
 502
 503 /* Default vectorizer cost model values.  */
 504
 505 int
 506 default_builtin_vectorization_cost (enum vect_cost_for_stmt type_of_cost,
 507                                     tree vectype,
 508                                     int misalign ATTRIBUTE_UNUSED)
 509 {
 510   unsigned elements;
 511
 512   switch (type_of_cost)
 513     {
 514       case scalar_stmt:
 515       case scalar_load:
 516       case scalar_store:
 517       case vector_stmt:
 518       case vector_load:
 519       case vector_store:
 520       case vec_to_scalar:
 521       case scalar_to_vec:
 522       case cond_branch_not_taken:
 523       case vec_perm:
 524       case vec_promote_demote:
 525         return 1;
 526
 527       case unaligned_load:
 528       case unaligned_store:
 529         return 2;
 530
 531       case cond_branch_taken:
 532         return 3;
 533
 534       case vec_construct:
 535         elements = TYPE_VECTOR_SUBPARTS (vectype);
 536         return elements / 2 + 1;
 537
 538       default:
 539         gcc_unreachable ();
 540     }
 541 }
 542
 543 /* Reciprocal.  */
 544
 545 tree
 546 default_builtin_reciprocal (unsigned int fn ATTRIBUTE_UNUSED,
 547                             bool md_fn ATTRIBUTE_UNUSED,
 548                             bool sqrt ATTRIBUTE_UNUSED)
 549 {
 550   return NULL_TREE;
 551 }
 552
 553 bool
 554 hook_bool_CUMULATIVE_ARGS_mode_tree_bool_false (
 555         cumulative_args_t ca ATTRIBUTE_UNUSED,
 556         enum machine_mode mode ATTRIBUTE_UNUSED,
 557         const_tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED)
 558 {
 559   return false;
 560 }
 561
 562 bool
 563 hook_bool_CUMULATIVE_ARGS_mode_tree_bool_true (
 564         cumulative_args_t ca ATTRIBUTE_UNUSED,
 565         enum machine_mode mode ATTRIBUTE_UNUSED,
 566         const_tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED)
 567 {
 568   return true;
 569 }
 570
 571 int
 572 hook_int_CUMULATIVE_ARGS_mode_tree_bool_0 (
 573         cumulative_args_t ca ATTRIBUTE_UNUSED,
 574         enum machine_mode mode ATTRIBUTE_UNUSED,
 575         tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED)
 576 {
 577   return 0;
 578 }
 579
 580 void
 581 default_function_arg_advance (cumulative_args_t ca ATTRIBUTE_UNUSED,
 582                               enum machine_mode mode ATTRIBUTE_UNUSED,
 583                               const_tree type ATTRIBUTE_UNUSED,
 584                               bool named ATTRIBUTE_UNUSED)
 585 {
 586   gcc_unreachable ();
 587 }
 588
 589 rtx
 590 default_function_arg (cumulative_args_t ca ATTRIBUTE_UNUSED,
 591                       enum machine_mode mode ATTRIBUTE_UNUSED,
 592                       const_tree type ATTRIBUTE_UNUSED,
 593                       bool named ATTRIBUTE_UNUSED)
 594 {
 595   gcc_unreachable ();
 596 }
 597
 598 rtx
 599 default_function_incoming_arg (cumulative_args_t ca ATTRIBUTE_UNUSED,
 600                                enum machine_mode mode ATTRIBUTE_UNUSED,
 601                                const_tree type ATTRIBUTE_UNUSED,
 602                                bool named ATTRIBUTE_UNUSED)
 603 {
 604   gcc_unreachable ();
 605 }
 606
 607 unsigned int
 608 default_function_arg_boundary (enum machine_mode mode ATTRIBUTE_UNUSED,
 609                                const_tree type ATTRIBUTE_UNUSED)
 610 {
 611   return PARM_BOUNDARY;
 612 }
 613
 614 unsigned int
 615 default_function_arg_round_boundary (enum machine_mode mode ATTRIBUTE_UNUSED,
 616                                      const_tree type ATTRIBUTE_UNUSED)
 617 {
 618   return PARM_BOUNDARY;
 619 }
 620
 621 void
 622 hook_void_bitmap (bitmap regs ATTRIBUTE_UNUSED)
 623 {
 624 }
 625
 626 const char *
 627 hook_invalid_arg_for_unprototyped_fn (
 628         const_tree typelist ATTRIBUTE_UNUSED,
 629         const_tree funcdecl ATTRIBUTE_UNUSED,
 630         const_tree val ATTRIBUTE_UNUSED)
 631 {
 632   return NULL;
 633 }
 634
 635 /* Initialize the stack protection decls.  */
 636
 637 /* Stack protection related decls living in libgcc.  */
 638 static GTY(()) tree stack_chk_guard_decl;
 639
 640 tree
 641 default_stack_protect_guard (void)
 642 {
 643   tree t = stack_chk_guard_decl;
 644
 645   if (t == NULL)
 646     {
 647       rtx x;
 648
 649       t = build_decl (UNKNOWN_LOCATION,
 650                       VAR_DECL, get_identifier ("__stack_chk_guard"),
 651                       ptr_type_node);
 652       TREE_STATIC (t) = 1;
 653       TREE_PUBLIC (t) = 1;
 654       DECL_EXTERNAL (t) = 1;
 655       TREE_USED (t) = 1;
 656       TREE_THIS_VOLATILE (t) = 1;
 657       DECL_ARTIFICIAL (t) = 1;
 658       DECL_IGNORED_P (t) = 1;
 659
 660       /* Do not share RTL as the declaration is visible outside of
 661          current function.  */
 662       x = DECL_RTL (t);
 663       RTX_FLAG (x, used) = 1;
 664
 665       stack_chk_guard_decl = t;
 666     }
 667
 668   return t;
 669 }
 670
 671 static GTY(()) tree stack_chk_fail_decl;
 672
 673 tree
 674 default_external_stack_protect_fail (void)
 675 {
 676   tree t = stack_chk_fail_decl;
 677
 678   if (t == NULL_TREE)
 679     {
 680       t = build_function_type_list (void_type_node, NULL_TREE);
 681       t = build_decl (UNKNOWN_LOCATION,
 682                       FUNCTION_DECL, get_identifier ("__stack_chk_fail"), t);
 683       TREE_STATIC (t) = 1;
 684       TREE_PUBLIC (t) = 1;
 685       DECL_EXTERNAL (t) = 1;
 686       TREE_USED (t) = 1;
 687       TREE_THIS_VOLATILE (t) = 1;
 688       TREE_NOTHROW (t) = 1;
 689       DECL_ARTIFICIAL (t) = 1;
 690       DECL_IGNORED_P (t) = 1;
 691       DECL_VISIBILITY (t) = VISIBILITY_DEFAULT;
 692       DECL_VISIBILITY_SPECIFIED (t) = 1;
 693
 694       stack_chk_fail_decl = t;
 695     }
 696
 697   return build_call_expr (t, 0);
 698 }
 699
 700 tree
 701 default_hidden_stack_protect_fail (void)
 702 {
 703 #ifndef HAVE_GAS_HIDDEN
 704   return default_external_stack_protect_fail ();
 705 #else
 706   tree t = stack_chk_fail_decl;
 707
 708   if (!flag_pic)
 709     return default_external_stack_protect_fail ();
 710
 711   if (t == NULL_TREE)
 712     {
 713       t = build_function_type_list (void_type_node, NULL_TREE);
 714       t = build_decl (UNKNOWN_LOCATION, FUNCTION_DECL,
 715                       get_identifier ("__stack_chk_fail_local"), t);
 716       TREE_STATIC (t) = 1;
 717       TREE_PUBLIC (t) = 1;
 718       DECL_EXTERNAL (t) = 1;
 719       TREE_USED (t) = 1;
 720       TREE_THIS_VOLATILE (t) = 1;
 721       TREE_NOTHROW (t) = 1;
 722       DECL_ARTIFICIAL (t) = 1;
 723       DECL_IGNORED_P (t) = 1;
 724       DECL_VISIBILITY_SPECIFIED (t) = 1;
 725       DECL_VISIBILITY (t) = VISIBILITY_HIDDEN;
 726
 727       stack_chk_fail_decl = t;
 728     }
 729
 730   return build_call_expr (t, 0);
 731 #endif
 732 }
 733
 734 bool
 735 hook_bool_const_rtx_commutative_p (const_rtx x,
 736                                    int outer_code ATTRIBUTE_UNUSED)
 737 {
 738   return COMMUTATIVE_P (x);
 739 }
 740
 741 rtx
 742 default_function_value (const_tree ret_type ATTRIBUTE_UNUSED,
 743                         const_tree fn_decl_or_type,
 744                         bool outgoing ATTRIBUTE_UNUSED)
 745 {
 746   /* The old interface doesn't handle receiving the function type.  */
 747   if (fn_decl_or_type
 748       && !DECL_P (fn_decl_or_type))
 749     fn_decl_or_type = NULL;
 750
 751 #ifdef FUNCTION_VALUE
 752   return FUNCTION_VALUE (ret_type, fn_decl_or_type);
 753 #else
 754   gcc_unreachable ();
 755 #endif
 756 }
 757
 758 rtx
 759 default_libcall_value (enum machine_mode mode ATTRIBUTE_UNUSED,
 760                        const_rtx fun ATTRIBUTE_UNUSED)
 761 {
 762 #ifdef LIBCALL_VALUE
 763   return LIBCALL_VALUE (mode);
 764 #else
 765   gcc_unreachable ();
 766 #endif
 767 }
 768
 769 /* The default hook for TARGET_FUNCTION_VALUE_REGNO_P.  */
 770
 771 bool
 772 default_function_value_regno_p (const unsigned int regno ATTRIBUTE_UNUSED)
 773 {
 774 #ifdef FUNCTION_VALUE_REGNO_P
 775   return FUNCTION_VALUE_REGNO_P (regno);
 776 #else
 777   gcc_unreachable ();
 778 #endif
 779 }
 780
 781 rtx
 782 default_internal_arg_pointer (void)
 783 {
 784   /* If the reg that the virtual arg pointer will be translated into is
 785      not a fixed reg or is the stack pointer, make a copy of the virtual
 786      arg pointer, and address parms via the copy.  The frame pointer is
 787      considered fixed even though it is not marked as such.  */
 788   if ((ARG_POINTER_REGNUM == STACK_POINTER_REGNUM
 789        || ! (fixed_regs[ARG_POINTER_REGNUM]
 790              || ARG_POINTER_REGNUM == FRAME_POINTER_REGNUM)))
 791     return copy_to_reg (virtual_incoming_args_rtx);
 792   else
 793     return virtual_incoming_args_rtx;
 794 }
 795
 796 rtx
 797 default_static_chain (const_tree fndecl, bool incoming_p)
 798 {
 799   if (!DECL_STATIC_CHAIN (fndecl))
 800     return NULL;
 801
 802   if (incoming_p)
 803     {
 804 #ifdef STATIC_CHAIN_INCOMING_REGNUM
 805       return gen_rtx_REG (Pmode, STATIC_CHAIN_INCOMING_REGNUM);
 806 #endif
 807     }
 808
 809 #ifdef STATIC_CHAIN_REGNUM
 810   return gen_rtx_REG (Pmode, STATIC_CHAIN_REGNUM);
 811 #endif
 812
 813   {
 814     static bool issued_error;
 815     if (!issued_error)
 816       {
 817         issued_error = true;
 818         sorry ("nested functions not supported on this target");
 819       }
 820
 821     /* It really doesn't matter what we return here, so long at it
 822        doesn't cause the rest of the compiler to crash.  */
 823     return gen_rtx_MEM (Pmode, stack_pointer_rtx);
 824   }
 825 }
 826
 827 void
 828 default_trampoline_init (rtx ARG_UNUSED (m_tramp), tree ARG_UNUSED (t_func),
 829                          rtx ARG_UNUSED (r_chain))
 830 {
 831   sorry ("nested function trampolines not supported on this target");
 832 }
 833
 834 int
 835 default_return_pops_args (tree fundecl ATTRIBUTE_UNUSED,
 836                           tree funtype ATTRIBUTE_UNUSED,
 837                           int size ATTRIBUTE_UNUSED)
 838 {
 839   return 0;
 840 }
 841
 842 reg_class_t
 843 default_branch_target_register_class (void)
 844 {
 845   return NO_REGS;
 846 }
 847
 848 extern bool
 849 default_lra_p (void)
 850 {
 851   return false;
 852 }
 853
 854 int
 855 default_register_priority (int hard_regno ATTRIBUTE_UNUSED)
 856 {
 857   return 0;
 858 }
 859
 860 extern bool
 861 default_different_addr_displacement_p (void)
 862 {
 863   return false;
 864 }
 865
 866 reg_class_t
 867 default_secondary_reload (bool in_p ATTRIBUTE_UNUSED, rtx x ATTRIBUTE_UNUSED,
 868                           reg_class_t reload_class_i ATTRIBUTE_UNUSED,
 869                           enum machine_mode reload_mode ATTRIBUTE_UNUSED,
 870                           secondary_reload_info *sri)
 871 {
 872   enum reg_class rclass = NO_REGS;
 873   enum reg_class reload_class = (enum reg_class) reload_class_i;
 874
 875   if (sri->prev_sri && sri->prev_sri->t_icode != CODE_FOR_nothing)
 876     {
 877       sri->icode = sri->prev_sri->t_icode;
 878       return NO_REGS;
 879     }
 880 #ifdef SECONDARY_INPUT_RELOAD_CLASS
 881   if (in_p)
 882     rclass = SECONDARY_INPUT_RELOAD_CLASS (reload_class, reload_mode, x);
 883 #endif
 884 #ifdef SECONDARY_OUTPUT_RELOAD_CLASS
 885   if (! in_p)
 886     rclass = SECONDARY_OUTPUT_RELOAD_CLASS (reload_class, reload_mode, x);
 887 #endif
 888   if (rclass != NO_REGS)
 889     {
 890       enum insn_code icode
 891         = direct_optab_handler (in_p ? reload_in_optab : reload_out_optab,
 892                                 reload_mode);
 893
 894       if (icode != CODE_FOR_nothing
 895           && !insn_operand_matches (icode, in_p, x))
 896         icode = CODE_FOR_nothing;
 897       else if (icode != CODE_FOR_nothing)
 898         {
 899           const char *insn_constraint, *scratch_constraint;
 900           char insn_letter, scratch_letter;
 901           enum reg_class insn_class, scratch_class;
 902
 903           gcc_assert (insn_data[(int) icode].n_operands == 3);
 904           insn_constraint = insn_data[(int) icode].operand[!in_p].constraint;
 905           if (!*insn_constraint)
 906             insn_class = ALL_REGS;
 907           else
 908             {
 909               if (in_p)
 910                 {
 911                   gcc_assert (*insn_constraint == '=');
 912                   insn_constraint++;
 913                 }
 914               insn_letter = *insn_constraint;
 915               insn_class
 916                 = (insn_letter == 'r' ? GENERAL_REGS
 917                    : REG_CLASS_FROM_CONSTRAINT ((unsigned char) insn_letter,
 918                                                 insn_constraint));
 919               gcc_assert (insn_class != NO_REGS);
 920             }
 921
 922           scratch_constraint = insn_data[(int) icode].operand[2].constraint;
 923           /* The scratch register's constraint must start with "=&",
 924              except for an input reload, where only "=" is necessary,
 925              and where it might be beneficial to re-use registers from
 926              the input.  */
 927           gcc_assert (scratch_constraint[0] == '='
 928                       && (in_p || scratch_constraint[1] == '&'));
 929           scratch_constraint++;
 930           if (*scratch_constraint == '&')
 931             scratch_constraint++;
 932           scratch_letter = *scratch_constraint;
 933           scratch_class
 934             = (scratch_letter == 'r' ? GENERAL_REGS
 935                : REG_CLASS_FROM_CONSTRAINT ((unsigned char) scratch_letter,
 936                                             scratch_constraint));
 937
 938           if (reg_class_subset_p (reload_class, insn_class))
 939             {
 940               gcc_assert (scratch_class == rclass);
 941               rclass = NO_REGS;
 942             }
 943           else
 944             rclass = insn_class;
 945
 946         }
 947       if (rclass == NO_REGS)
 948         sri->icode = icode;
 949       else
 950         sri->t_icode = icode;
 951     }
 952   return rclass;
 953 }
 954
 955 /* By default, if flag_pic is true, then neither local nor global relocs
 956    should be placed in readonly memory.  */
 957
 958 int
 959 default_reloc_rw_mask (void)
 960 {
 961   return flag_pic ? 3 : 0;
 962 }
 963
 964 /* By default, do no modification. */
 965 tree default_mangle_decl_assembler_name (tree decl ATTRIBUTE_UNUSED,
 966                                          tree id)
 967 {
 968    return id;
 969 }
 970
 971 /* Default to natural alignment for vector types.  */
 972 HOST_WIDE_INT
 973 default_vector_alignment (const_tree type)
 974 {
 975   return tree_low_cst (TYPE_SIZE (type), 0);
 976 }
 977
 978 bool
 979 default_builtin_vector_alignment_reachable (const_tree type, bool is_packed)
 980 {
 981   if (is_packed)
 982     return false;
 983
 984   /* Assuming that types whose size is > pointer-size are not guaranteed to be
 985      naturally aligned.  */
 986   if (tree_int_cst_compare (TYPE_SIZE (type), bitsize_int (POINTER_SIZE)) > 0)
 987     return false;
 988
 989   /* Assuming that types whose size is <= pointer-size
 990      are naturally aligned.  */
 991   return true;
 992 }
 993
 994 /* By default, assume that a target supports any factor of misalignment
 995    memory access if it supports movmisalign patten.
 996    is_packed is true if the memory access is defined in a packed struct.  */
 997 bool
 998 default_builtin_support_vector_misalignment (enum machine_mode mode,
 999                                              const_tree type
1000                                              ATTRIBUTE_UNUSED,
1001                                              int misalignment
1002                                              ATTRIBUTE_UNUSED,
1003                                              bool is_packed
1004                                              ATTRIBUTE_UNUSED)
1005 {
1006   if (optab_handler (movmisalign_optab, mode) != CODE_FOR_nothing)
1007     return true;
1008   return false;
1009 }
1010
1011 /* By default, only attempt to parallelize bitwise operations, and
1012    possibly adds/subtracts using bit-twiddling.  */
1013
1014 enum machine_mode
1015 default_preferred_simd_mode (enum machine_mode mode ATTRIBUTE_UNUSED)
1016 {
1017   return word_mode;
1018 }
1019
1020 /* By default only the size derived from the preferred vector mode
1021    is tried.  */
1022
1023 unsigned int
1024 default_autovectorize_vector_sizes (void)
1025 {
1026   return 0;
1027 }
1028
1029 /* By default, the cost model accumulates three separate costs (prologue,
1030    loop body, and epilogue) for a vectorized loop or block.  So allocate an
1031    array of three unsigned ints, set it to zero, and return its address.  */
1032
1033 void *
1034 default_init_cost (struct loop *loop_info ATTRIBUTE_UNUSED)
1035 {
1036   unsigned *cost = XNEWVEC (unsigned, 3);
1037   cost[vect_prologue] = cost[vect_body] = cost[vect_epilogue] = 0;
1038   return cost;
1039 }
1040
1041 /* By default, the cost model looks up the cost of the given statement
1042    kind and mode, multiplies it by the occurrence count, accumulates
1043    it into the cost specified by WHERE, and returns the cost added.  */
1044
1045 unsigned
1046 default_add_stmt_cost (void *data, int count, enum vect_cost_for_stmt kind,
1047                        struct _stmt_vec_info *stmt_info, int misalign,
1048                        enum vect_cost_model_location where)
1049 {
1050   unsigned *cost = (unsigned *) data;
1051   unsigned retval = 0;
1052
1053   if (flag_vect_cost_model)
1054     {
1055       tree vectype = stmt_info ? stmt_vectype (stmt_info) : NULL_TREE;
1056       int stmt_cost = default_builtin_vectorization_cost (kind, vectype,
1057                                                           misalign);
1058       /* Statements in an inner loop relative to the loop being
1059          vectorized are weighted more heavily.  The value here is
1060          arbitrary and could potentially be improved with analysis.  */
1061       if (where == vect_body && stmt_info && stmt_in_inner_loop_p (stmt_info))
1062         count *= 50;  /* FIXME.  */
1063
1064       retval = (unsigned) (count * stmt_cost);
1065       cost[where] += retval;
1066     }
1067
1068   return retval;
1069 }
1070
1071 /* By default, the cost model just returns the accumulated costs.  */
1072
1073 void
1074 default_finish_cost (void *data, unsigned *prologue_cost,
1075                      unsigned *body_cost, unsigned *epilogue_cost)
1076 {
1077   unsigned *cost = (unsigned *) data;
1078   *prologue_cost = cost[vect_prologue];
1079   *body_cost     = cost[vect_body];
1080   *epilogue_cost = cost[vect_epilogue];
1081 }
1082
1083 /* Free the cost data.  */
1084
1085 void
1086 default_destroy_cost_data (void *data)
1087 {
1088   free (data);
1089 }
1090
1091 /* Determine whether or not a pointer mode is valid. Assume defaults
1092    of ptr_mode or Pmode - can be overridden.  */
1093 bool
1094 default_valid_pointer_mode (enum machine_mode mode)
1095 {
1096   return (mode == ptr_mode || mode == Pmode);
1097 }
1098
1099 /* Determine whether the memory reference specified by REF may alias
1100    the C libraries errno location.  */
1101 bool
1102 default_ref_may_alias_errno (ao_ref *ref)
1103 {
1104   tree base = ao_ref_base (ref);
1105   /* The default implementation assumes the errno location is
1106      a declaration of type int or is always accessed via a
1107      pointer to int.  We assume that accesses to errno are
1108      not deliberately obfuscated (even in conforming ways).  */
1109   if (TYPE_UNSIGNED (TREE_TYPE (base))
1110       || TYPE_MODE (TREE_TYPE (base)) != TYPE_MODE (integer_type_node))
1111     return false;
1112   /* The default implementation assumes an errno location
1113      declaration is never defined in the current compilation unit.  */
1114   if (DECL_P (base)
1115       && !TREE_STATIC (base))
1116     return true;
1117   else if (TREE_CODE (base) == MEM_REF
1118            && TREE_CODE (TREE_OPERAND (base, 0)) == SSA_NAME)
1119     {
1120       struct ptr_info_def *pi = SSA_NAME_PTR_INFO (TREE_OPERAND (base, 0));
1121       return !pi || pi->pt.anything || pi->pt.nonlocal;
1122     }
1123   return false;
1124 }
1125
1126 /* Return the mode for a pointer to a given ADDRSPACE, defaulting to ptr_mode
1127    for the generic address space only.  */
1128
1129 enum machine_mode
1130 default_addr_space_pointer_mode (addr_space_t addrspace ATTRIBUTE_UNUSED)
1131 {
1132   gcc_assert (ADDR_SPACE_GENERIC_P (addrspace));
1133   return ptr_mode;
1134 }
1135
1136 /* Return the mode for an address in a given ADDRSPACE, defaulting to Pmode
1137    for the generic address space only.  */
1138
1139 enum machine_mode
1140 default_addr_space_address_mode (addr_space_t addrspace ATTRIBUTE_UNUSED)
1141 {
1142   gcc_assert (ADDR_SPACE_GENERIC_P (addrspace));
1143   return Pmode;
1144 }
1145
1146 /* Named address space version of valid_pointer_mode.  */
1147
1148 bool
1149 default_addr_space_valid_pointer_mode (enum machine_mode mode, addr_space_t as)
1150 {
1151   if (!ADDR_SPACE_GENERIC_P (as))
1152     return (mode == targetm.addr_space.pointer_mode (as)
1153             || mode == targetm.addr_space.address_mode (as));
1154
1155   return targetm.valid_pointer_mode (mode);
1156 }
1157
1158 /* Some places still assume that all pointer or address modes are the
1159    standard Pmode and ptr_mode.  These optimizations become invalid if
1160    the target actually supports multiple different modes.  For now,
1161    we disable such optimizations on such targets, using this function.  */
1162
1163 bool
1164 target_default_pointer_address_modes_p (void)
1165 {
1166   if (targetm.addr_space.address_mode != default_addr_space_address_mode)
1167     return false;
1168   if (targetm.addr_space.pointer_mode != default_addr_space_pointer_mode)
1169     return false;
1170
1171   return true;
1172 }
1173
1174 /* Named address space version of legitimate_address_p.  */
1175
1176 bool
1177 default_addr_space_legitimate_address_p (enum machine_mode mode, rtx mem,
1178                                          bool strict, addr_space_t as)
1179 {
1180   if (!ADDR_SPACE_GENERIC_P (as))
1181     gcc_unreachable ();
1182
1183   return targetm.legitimate_address_p (mode, mem, strict);
1184 }
1185
1186 /* Named address space version of LEGITIMIZE_ADDRESS.  */
1187
1188 rtx
1189 default_addr_space_legitimize_address (rtx x, rtx oldx,
1190                                        enum machine_mode mode, addr_space_t as)
1191 {
1192   if (!ADDR_SPACE_GENERIC_P (as))
1193     return x;
1194
1195   return targetm.legitimize_address (x, oldx, mode);
1196 }
1197
1198 /* The default hook for determining if one named address space is a subset of
1199    another and to return which address space to use as the common address
1200    space.  */
1201
1202 bool
1203 default_addr_space_subset_p (addr_space_t subset, addr_space_t superset)
1204 {
1205   return (subset == superset);
1206 }
1207
1208 /* The default hook for TARGET_ADDR_SPACE_CONVERT. This hook should never be
1209    called for targets with only a generic address space.  */
1210
1211 rtx
1212 default_addr_space_convert (rtx op ATTRIBUTE_UNUSED,
1213                             tree from_type ATTRIBUTE_UNUSED,
1214                             tree to_type ATTRIBUTE_UNUSED)
1215 {
1216   gcc_unreachable ();
1217 }
1218
1219 bool
1220 default_hard_regno_scratch_ok (unsigned int regno ATTRIBUTE_UNUSED)
1221 {
1222   return true;
1223 }
1224
1225 /* The default implementation of TARGET_MODE_DEPENDENT_ADDRESS_P.  */
1226
1227 bool
1228 default_mode_dependent_address_p (const_rtx addr ATTRIBUTE_UNUSED,
1229                                   addr_space_t addrspace ATTRIBUTE_UNUSED)
1230 {
1231   return false;
1232 }
1233
1234 bool
1235 default_target_option_valid_attribute_p (tree ARG_UNUSED (fndecl),
1236                                          tree ARG_UNUSED (name),
1237                                          tree ARG_UNUSED (args),
1238                                          int ARG_UNUSED (flags))
1239 {
1240   warning (OPT_Wattributes,
1241            "target attribute is not supported on this machine");
1242
1243   return false;
1244 }
1245
1246 bool
1247 default_target_option_pragma_parse (tree ARG_UNUSED (args),
1248                                     tree ARG_UNUSED (pop_target))
1249 {
1250   warning (OPT_Wpragmas,
1251            "#pragma GCC target is not supported for this machine");
1252
1253   return false;
1254 }
1255
1256 bool
1257 default_target_can_inline_p (tree caller, tree callee)
1258 {
1259   bool ret = false;
1260   tree callee_opts = DECL_FUNCTION_SPECIFIC_TARGET (callee);
1261   tree caller_opts = DECL_FUNCTION_SPECIFIC_TARGET (caller);
1262
1263   /* If callee has no option attributes, then it is ok to inline */
1264   if (!callee_opts)
1265     ret = true;
1266
1267   /* If caller has no option attributes, but callee does then it is not ok to
1268      inline */
1269   else if (!caller_opts)
1270     ret = false;
1271
1272   /* If both caller and callee have attributes, assume that if the
1273      pointer is different, the two functions have different target
1274      options since build_target_option_node uses a hash table for the
1275      options.  */
1276   else
1277     ret = (callee_opts == caller_opts);
1278
1279   return ret;
1280 }
1281
1282 #ifndef HAVE_casesi
1283 # define HAVE_casesi 0
1284 #endif
1285
1286 /* If the machine does not have a case insn that compares the bounds,
1287    this means extra overhead for dispatch tables, which raises the
1288    threshold for using them.  */
1289
1290 unsigned int
1291 default_case_values_threshold (void)
1292 {
1293   return (HAVE_casesi ? 4 : 5);
1294 }
1295
1296 bool
1297 default_have_conditional_execution (void)
1298 {
1299 #ifdef HAVE_conditional_execution
1300   return HAVE_conditional_execution;
1301 #else
1302   return false;
1303 #endif
1304 }
1305
1306 tree
1307 default_builtin_tm_load_store (tree ARG_UNUSED (type))
1308 {
1309   return NULL_TREE;
1310 }
1311
1312 /* Compute cost of moving registers to/from memory.  */
1313
1314 int
1315 default_memory_move_cost (enum machine_mode mode ATTRIBUTE_UNUSED,
1316                           reg_class_t rclass ATTRIBUTE_UNUSED,
1317                           bool in ATTRIBUTE_UNUSED)
1318 {
1319 #ifndef MEMORY_MOVE_COST
1320     return (4 + memory_move_secondary_cost (mode, (enum reg_class) rclass, in));
1321 #else
1322     return MEMORY_MOVE_COST (mode, (enum reg_class) rclass, in);
1323 #endif
1324 }
1325
1326 /* Compute cost of moving data from a register of class FROM to one of
1327    TO, using MODE.  */
1328
1329 int
1330 default_register_move_cost (enum machine_mode mode ATTRIBUTE_UNUSED,
1331                             reg_class_t from ATTRIBUTE_UNUSED,
1332                             reg_class_t to ATTRIBUTE_UNUSED)
1333 {
1334 #ifndef REGISTER_MOVE_COST
1335   return 2;
1336 #else
1337   return REGISTER_MOVE_COST (mode, (enum reg_class) from, (enum reg_class) to);
1338 #endif
1339 }
1340
1341 bool
1342 default_profile_before_prologue (void)
1343 {
1344 #ifdef PROFILE_BEFORE_PROLOGUE
1345   return true;
1346 #else
1347   return false;
1348 #endif
1349 }
1350
1351 /* The default implementation of TARGET_PREFERRED_RELOAD_CLASS.  */
1352
1353 reg_class_t
1354 default_preferred_reload_class (rtx x ATTRIBUTE_UNUSED,
1355                                 reg_class_t rclass)
1356 {
1357 #ifdef PREFERRED_RELOAD_CLASS
1358   return (reg_class_t) PREFERRED_RELOAD_CLASS (x, (enum reg_class) rclass);
1359 #else
1360   return rclass;
1361 #endif
1362 }
1363
1364 /* The default implementation of TARGET_OUTPUT_PREFERRED_RELOAD_CLASS.  */
1365
1366 reg_class_t
1367 default_preferred_output_reload_class (rtx x ATTRIBUTE_UNUSED,
1368                                        reg_class_t rclass)
1369 {
1370   return rclass;
1371 }
1372
1373 /* The default implementation of TARGET_PREFERRED_RENAME_CLASS.  */
1374 reg_class_t
1375 default_preferred_rename_class (reg_class_t rclass ATTRIBUTE_UNUSED)
1376 {
1377   return NO_REGS;
1378 }
1379
1380 /* The default implementation of TARGET_CLASS_LIKELY_SPILLED_P.  */
1381
1382 bool
1383 default_class_likely_spilled_p (reg_class_t rclass)
1384 {
1385   return (reg_class_size[(int) rclass] == 1);
1386 }
1387
1388 /* The default implementation of TARGET_CLASS_MAX_NREGS.  */
1389
1390 unsigned char
1391 default_class_max_nregs (reg_class_t rclass ATTRIBUTE_UNUSED,
1392                          enum machine_mode mode ATTRIBUTE_UNUSED)
1393 {
1394 #ifdef CLASS_MAX_NREGS
1395   return (unsigned char) CLASS_MAX_NREGS ((enum reg_class) rclass, mode);
1396 #else
1397   return ((GET_MODE_SIZE (mode) + UNITS_PER_WORD - 1) / UNITS_PER_WORD);
1398 #endif
1399 }
1400
1401 /* Determine the debugging unwind mechanism for the target.  */
1402
1403 enum unwind_info_type
1404 default_debug_unwind_info (void)
1405 {
1406   /* If the target wants to force the use of dwarf2 unwind info, let it.  */
1407   /* ??? Change all users to the hook, then poison this.  */
1408 #ifdef DWARF2_FRAME_INFO
1409   if (DWARF2_FRAME_INFO)
1410     return UI_DWARF2;
1411 #endif
1412
1413   /* Otherwise, only turn it on if dwarf2 debugging is enabled.  */
1414 #ifdef DWARF2_DEBUGGING_INFO
1415   if (write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
1416     return UI_DWARF2;
1417 #endif
1418
1419   return UI_NONE;
1420 }
1421
1422 /* To be used by targets where reg_raw_mode doesn't return the right
1423    mode for registers used in apply_builtin_return and apply_builtin_arg.  */
1424
1425 enum machine_mode
1426 default_get_reg_raw_mode(int regno)
1427 {
1428   return reg_raw_mode[regno];
1429 }
1430
1431 /* Return true if the state of option OPTION should be stored in PCH files
1432    and checked by default_pch_valid_p.  Store the option's current state
1433    in STATE if so.  */
1434
1435 static inline bool
1436 option_affects_pch_p (int option, struct cl_option_state *state)
1437 {
1438   if ((cl_options[option].flags & CL_TARGET) == 0)
1439     return false;
1440   if (option_flag_var (option, &global_options) == &target_flags)
1441     if (targetm.check_pch_target_flags)
1442       return false;
1443   return get_option_state (&global_options, option, state);
1444 }
1445
1446 /* Default version of get_pch_validity.
1447    By default, every flag difference is fatal; that will be mostly right for
1448    most targets, but completely right for very few.  */
1449
1450 void *
1451 default_get_pch_validity (size_t *sz)
1452 {
1453   struct cl_option_state state;
1454   size_t i;
1455   char *result, *r;
1456
1457   *sz = 2;
1458   if (targetm.check_pch_target_flags)
1459     *sz += sizeof (target_flags);
1460   for (i = 0; i < cl_options_count; i++)
1461     if (option_affects_pch_p (i, &state))
1462       *sz += state.size;
1463
1464   result = r = XNEWVEC (char, *sz);
1465   r[0] = flag_pic;
1466   r[1] = flag_pie;
1467   r += 2;
1468   if (targetm.check_pch_target_flags)
1469     {
1470       memcpy (r, &target_flags, sizeof (target_flags));
1471       r += sizeof (target_flags);
1472     }
1473
1474   for (i = 0; i < cl_options_count; i++)
1475     if (option_affects_pch_p (i, &state))
1476       {
1477         memcpy (r, state.data, state.size);
1478         r += state.size;
1479       }
1480
1481   return result;
1482 }
1483
1484 /* Return a message which says that a PCH file was created with a different
1485    setting of OPTION.  */
1486
1487 static const char *
1488 pch_option_mismatch (const char *option)
1489 {
1490   char *r;
1491
1492   asprintf (&r, _("created and used with differing settings of '%s'"), option);
1493   if (r == NULL)
1494     return _("out of memory");
1495   return r;
1496 }
1497
1498 /* Default version of pch_valid_p.  */
1499
1500 const char *
1501 default_pch_valid_p (const void *data_p, size_t len)
1502 {
1503   struct cl_option_state state;
1504   const char *data = (const char *)data_p;
1505   size_t i;
1506
1507   /* -fpic and -fpie also usually make a PCH invalid.  */
1508   if (data[0] != flag_pic)
1509     return _("created and used with different settings of -fpic");
1510   if (data[1] != flag_pie)
1511     return _("created and used with different settings of -fpie");
1512   data += 2;
1513
1514   /* Check target_flags.  */
1515   if (targetm.check_pch_target_flags)
1516     {
1517       int tf;
1518       const char *r;
1519
1520       memcpy (&tf, data, sizeof (target_flags));
1521       data += sizeof (target_flags);
1522       len -= sizeof (target_flags);
1523       r = targetm.check_pch_target_flags (tf);
1524       if (r != NULL)
1525         return r;
1526     }
1527
1528   for (i = 0; i < cl_options_count; i++)
1529     if (option_affects_pch_p (i, &state))
1530       {
1531         if (memcmp (data, state.data, state.size) != 0)
1532           return pch_option_mismatch (cl_options[i].opt_text);
1533         data += state.size;
1534         len -= state.size;
1535       }
1536
1537   return NULL;
1538 }
1539
1540 /* Default version of member_type_forces_blk.  */
1541
1542 bool
1543 default_member_type_forces_blk (const_tree, enum machine_mode)
1544 {
1545   return false;
1546 }
1547
1548 /* Default version of canonicalize_comparison.  */
1549
1550 void
1551 default_canonicalize_comparison (int *, rtx *, rtx *, bool)
1552 {
1553 }
1554
1555 #include "gt-targhooks.h"