gcc/targhooks.c

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