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 #include "insn-codes.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 /* True if the target supports GNU indirect functions.  */
 455
 456 bool
 457 default_has_ifunc_p (void)
 458 {
 459   return HAVE_GNU_INDIRECT_FUNCTION;
 460 }
 461
 462 /* NULL if INSN insn is valid within a low-overhead loop, otherwise returns
 463    an error message.
 464
 465    This function checks whether a given INSN is valid within a low-overhead
 466    loop.  If INSN is invalid it returns the reason for that, otherwise it
 467    returns NULL. A called function may clobber any special registers required
 468    for low-overhead looping. Additionally, some targets (eg, PPC) use the count
 469    register for branch on table instructions. We reject the doloop pattern in
 470    these cases.  */
 471
 472 const char *
 473 default_invalid_within_doloop (const_rtx insn)
 474 {
 475   if (CALL_P (insn))
 476     return "Function call in loop.";
 477
 478   if (tablejump_p (insn, NULL, NULL) || computed_jump_p (insn))
 479     return "Computed branch in the loop.";
 480
 481   return NULL;
 482 }
 483
 484 /* Mapping of builtin functions to vectorized variants.  */
 485
 486 tree
 487 default_builtin_vectorized_function (tree fndecl ATTRIBUTE_UNUSED,
 488                                      tree type_out ATTRIBUTE_UNUSED,
 489                                      tree type_in ATTRIBUTE_UNUSED)
 490 {
 491   return NULL_TREE;
 492 }
 493
 494 /* Vectorized conversion.  */
 495
 496 tree
 497 default_builtin_vectorized_conversion (unsigned int code ATTRIBUTE_UNUSED,
 498                                        tree dest_type ATTRIBUTE_UNUSED,
 499                                        tree src_type ATTRIBUTE_UNUSED)
 500 {
 501   return NULL_TREE;
 502 }
 503
 504 /* Default vectorizer cost model values.  */
 505
 506 int
 507 default_builtin_vectorization_cost (enum vect_cost_for_stmt type_of_cost,
 508                                     tree vectype,
 509                                     int misalign ATTRIBUTE_UNUSED)
 510 {
 511   unsigned elements;
 512
 513   switch (type_of_cost)
 514     {
 515       case scalar_stmt:
 516       case scalar_load:
 517       case scalar_store:
 518       case vector_stmt:
 519       case vector_load:
 520       case vector_store:
 521       case vec_to_scalar:
 522       case scalar_to_vec:
 523       case cond_branch_not_taken:
 524       case vec_perm:
 525       case vec_promote_demote:
 526         return 1;
 527
 528       case unaligned_load:
 529       case unaligned_store:
 530         return 2;
 531
 532       case cond_branch_taken:
 533         return 3;
 534
 535       case vec_construct:
 536         elements = TYPE_VECTOR_SUBPARTS (vectype);
 537         return elements / 2 + 1;
 538
 539       default:
 540         gcc_unreachable ();
 541     }
 542 }
 543
 544 /* Reciprocal.  */
 545
 546 tree
 547 default_builtin_reciprocal (unsigned int fn ATTRIBUTE_UNUSED,
 548                             bool md_fn ATTRIBUTE_UNUSED,
 549                             bool sqrt ATTRIBUTE_UNUSED)
 550 {
 551   return NULL_TREE;
 552 }
 553
 554 bool
 555 hook_bool_CUMULATIVE_ARGS_mode_tree_bool_false (
 556         cumulative_args_t ca ATTRIBUTE_UNUSED,
 557         enum machine_mode mode ATTRIBUTE_UNUSED,
 558         const_tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED)
 559 {
 560   return false;
 561 }
 562
 563 bool
 564 hook_bool_CUMULATIVE_ARGS_mode_tree_bool_true (
 565         cumulative_args_t ca ATTRIBUTE_UNUSED,
 566         enum machine_mode mode ATTRIBUTE_UNUSED,
 567         const_tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED)
 568 {
 569   return true;
 570 }
 571
 572 int
 573 hook_int_CUMULATIVE_ARGS_mode_tree_bool_0 (
 574         cumulative_args_t ca ATTRIBUTE_UNUSED,
 575         enum machine_mode mode ATTRIBUTE_UNUSED,
 576         tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED)
 577 {
 578   return 0;
 579 }
 580
 581 void
 582 default_function_arg_advance (cumulative_args_t ca ATTRIBUTE_UNUSED,
 583                               enum machine_mode mode ATTRIBUTE_UNUSED,
 584                               const_tree type ATTRIBUTE_UNUSED,
 585                               bool named ATTRIBUTE_UNUSED)
 586 {
 587   gcc_unreachable ();
 588 }
 589
 590 rtx
 591 default_function_arg (cumulative_args_t ca ATTRIBUTE_UNUSED,
 592                       enum machine_mode mode ATTRIBUTE_UNUSED,
 593                       const_tree type ATTRIBUTE_UNUSED,
 594                       bool named ATTRIBUTE_UNUSED)
 595 {
 596   gcc_unreachable ();
 597 }
 598
 599 rtx
 600 default_function_incoming_arg (cumulative_args_t ca ATTRIBUTE_UNUSED,
 601                                enum machine_mode mode ATTRIBUTE_UNUSED,
 602                                const_tree type ATTRIBUTE_UNUSED,
 603                                bool named ATTRIBUTE_UNUSED)
 604 {
 605   gcc_unreachable ();
 606 }
 607
 608 unsigned int
 609 default_function_arg_boundary (enum machine_mode mode ATTRIBUTE_UNUSED,
 610                                const_tree type ATTRIBUTE_UNUSED)
 611 {
 612   return PARM_BOUNDARY;
 613 }
 614
 615 unsigned int
 616 default_function_arg_round_boundary (enum machine_mode mode ATTRIBUTE_UNUSED,
 617                                      const_tree type ATTRIBUTE_UNUSED)
 618 {
 619   return PARM_BOUNDARY;
 620 }
 621
 622 void
 623 hook_void_bitmap (bitmap regs ATTRIBUTE_UNUSED)
 624 {
 625 }
 626
 627 const char *
 628 hook_invalid_arg_for_unprototyped_fn (
 629         const_tree typelist ATTRIBUTE_UNUSED,
 630         const_tree funcdecl ATTRIBUTE_UNUSED,
 631         const_tree val ATTRIBUTE_UNUSED)
 632 {
 633   return NULL;
 634 }
 635
 636 /* Initialize the stack protection decls.  */
 637
 638 /* Stack protection related decls living in libgcc.  */
 639 static GTY(()) tree stack_chk_guard_decl;
 640
 641 tree
 642 default_stack_protect_guard (void)
 643 {
 644   tree t = stack_chk_guard_decl;
 645
 646   if (t == NULL)
 647     {
 648       rtx x;
 649
 650       t = build_decl (UNKNOWN_LOCATION,
 651                       VAR_DECL, get_identifier ("__stack_chk_guard"),
 652                       ptr_type_node);
 653       TREE_STATIC (t) = 1;
 654       TREE_PUBLIC (t) = 1;
 655       DECL_EXTERNAL (t) = 1;
 656       TREE_USED (t) = 1;
 657       TREE_THIS_VOLATILE (t) = 1;
 658       DECL_ARTIFICIAL (t) = 1;
 659       DECL_IGNORED_P (t) = 1;
 660
 661       /* Do not share RTL as the declaration is visible outside of
 662          current function.  */
 663       x = DECL_RTL (t);
 664       RTX_FLAG (x, used) = 1;
 665
 666       stack_chk_guard_decl = t;
 667     }
 668
 669   return t;
 670 }
 671
 672 static GTY(()) tree stack_chk_fail_decl;
 673
 674 tree
 675 default_external_stack_protect_fail (void)
 676 {
 677   tree t = stack_chk_fail_decl;
 678
 679   if (t == NULL_TREE)
 680     {
 681       t = build_function_type_list (void_type_node, NULL_TREE);
 682       t = build_decl (UNKNOWN_LOCATION,
 683                       FUNCTION_DECL, get_identifier ("__stack_chk_fail"), t);
 684       TREE_STATIC (t) = 1;
 685       TREE_PUBLIC (t) = 1;
 686       DECL_EXTERNAL (t) = 1;
 687       TREE_USED (t) = 1;
 688       TREE_THIS_VOLATILE (t) = 1;
 689       TREE_NOTHROW (t) = 1;
 690       DECL_ARTIFICIAL (t) = 1;
 691       DECL_IGNORED_P (t) = 1;
 692       DECL_VISIBILITY (t) = VISIBILITY_DEFAULT;
 693       DECL_VISIBILITY_SPECIFIED (t) = 1;
 694
 695       stack_chk_fail_decl = t;
 696     }
 697
 698   return build_call_expr (t, 0);
 699 }
 700
 701 tree
 702 default_hidden_stack_protect_fail (void)
 703 {
 704 #ifndef HAVE_GAS_HIDDEN
 705   return default_external_stack_protect_fail ();
 706 #else
 707   tree t = stack_chk_fail_decl;
 708
 709   if (!flag_pic)
 710     return default_external_stack_protect_fail ();
 711
 712   if (t == NULL_TREE)
 713     {
 714       t = build_function_type_list (void_type_node, NULL_TREE);
 715       t = build_decl (UNKNOWN_LOCATION, FUNCTION_DECL,
 716                       get_identifier ("__stack_chk_fail_local"), t);
 717       TREE_STATIC (t) = 1;
 718       TREE_PUBLIC (t) = 1;
 719       DECL_EXTERNAL (t) = 1;
 720       TREE_USED (t) = 1;
 721       TREE_THIS_VOLATILE (t) = 1;
 722       TREE_NOTHROW (t) = 1;
 723       DECL_ARTIFICIAL (t) = 1;
 724       DECL_IGNORED_P (t) = 1;
 725       DECL_VISIBILITY_SPECIFIED (t) = 1;
 726       DECL_VISIBILITY (t) = VISIBILITY_HIDDEN;
 727
 728       stack_chk_fail_decl = t;
 729     }
 730
 731   return build_call_expr (t, 0);
 732 #endif
 733 }
 734
 735 bool
 736 hook_bool_const_rtx_commutative_p (const_rtx x,
 737                                    int outer_code ATTRIBUTE_UNUSED)
 738 {
 739   return COMMUTATIVE_P (x);
 740 }
 741
 742 rtx
 743 default_function_value (const_tree ret_type ATTRIBUTE_UNUSED,
 744                         const_tree fn_decl_or_type,
 745                         bool outgoing ATTRIBUTE_UNUSED)
 746 {
 747   /* The old interface doesn't handle receiving the function type.  */
 748   if (fn_decl_or_type
 749       && !DECL_P (fn_decl_or_type))
 750     fn_decl_or_type = NULL;
 751
 752 #ifdef FUNCTION_VALUE
 753   return FUNCTION_VALUE (ret_type, fn_decl_or_type);
 754 #else
 755   gcc_unreachable ();
 756 #endif
 757 }
 758
 759 rtx
 760 default_libcall_value (enum machine_mode mode ATTRIBUTE_UNUSED,
 761                        const_rtx fun ATTRIBUTE_UNUSED)
 762 {
 763 #ifdef LIBCALL_VALUE
 764   return LIBCALL_VALUE (mode);
 765 #else
 766   gcc_unreachable ();
 767 #endif
 768 }
 769
 770 /* The default hook for TARGET_FUNCTION_VALUE_REGNO_P.  */
 771
 772 bool
 773 default_function_value_regno_p (const unsigned int regno ATTRIBUTE_UNUSED)
 774 {
 775 #ifdef FUNCTION_VALUE_REGNO_P
 776   return FUNCTION_VALUE_REGNO_P (regno);
 777 #else
 778   gcc_unreachable ();
 779 #endif
 780 }
 781
 782 rtx
 783 default_internal_arg_pointer (void)
 784 {
 785   /* If the reg that the virtual arg pointer will be translated into is
 786      not a fixed reg or is the stack pointer, make a copy of the virtual
 787      arg pointer, and address parms via the copy.  The frame pointer is
 788      considered fixed even though it is not marked as such.  */
 789   if ((ARG_POINTER_REGNUM == STACK_POINTER_REGNUM
 790        || ! (fixed_regs[ARG_POINTER_REGNUM]
 791              || ARG_POINTER_REGNUM == FRAME_POINTER_REGNUM)))
 792     return copy_to_reg (virtual_incoming_args_rtx);
 793   else
 794     return virtual_incoming_args_rtx;
 795 }
 796
 797 rtx
 798 default_static_chain (const_tree fndecl, bool incoming_p)
 799 {
 800   if (!DECL_STATIC_CHAIN (fndecl))
 801     return NULL;
 802
 803   if (incoming_p)
 804     {
 805 #ifdef STATIC_CHAIN_INCOMING_REGNUM
 806       return gen_rtx_REG (Pmode, STATIC_CHAIN_INCOMING_REGNUM);
 807 #endif
 808     }
 809
 810 #ifdef STATIC_CHAIN_REGNUM
 811   return gen_rtx_REG (Pmode, STATIC_CHAIN_REGNUM);
 812 #endif
 813
 814   {
 815     static bool issued_error;
 816     if (!issued_error)
 817       {
 818         issued_error = true;
 819         sorry ("nested functions not supported on this target");
 820       }
 821
 822     /* It really doesn't matter what we return here, so long at it
 823        doesn't cause the rest of the compiler to crash.  */
 824     return gen_rtx_MEM (Pmode, stack_pointer_rtx);
 825   }
 826 }
 827
 828 void
 829 default_trampoline_init (rtx ARG_UNUSED (m_tramp), tree ARG_UNUSED (t_func),
 830                          rtx ARG_UNUSED (r_chain))
 831 {
 832   sorry ("nested function trampolines not supported on this target");
 833 }
 834
 835 int
 836 default_return_pops_args (tree fundecl ATTRIBUTE_UNUSED,
 837                           tree funtype ATTRIBUTE_UNUSED,
 838                           int size ATTRIBUTE_UNUSED)
 839 {
 840   return 0;
 841 }
 842
 843 reg_class_t
 844 default_branch_target_register_class (void)
 845 {
 846   return NO_REGS;
 847 }
 848
 849 extern bool
 850 default_lra_p (void)
 851 {
 852   return false;
 853 }
 854
 855 int
 856 default_register_priority (int hard_regno ATTRIBUTE_UNUSED)
 857 {
 858   return 0;
 859 }
 860
 861 extern bool
 862 default_register_usage_leveling_p (void)
 863 {
 864   return false;
 865 }
 866
 867 extern bool
 868 default_different_addr_displacement_p (void)
 869 {
 870   return false;
 871 }
 872
 873 reg_class_t
 874 default_secondary_reload (bool in_p ATTRIBUTE_UNUSED, rtx x ATTRIBUTE_UNUSED,
 875                           reg_class_t reload_class_i ATTRIBUTE_UNUSED,
 876                           enum machine_mode reload_mode ATTRIBUTE_UNUSED,
 877                           secondary_reload_info *sri)
 878 {
 879   enum reg_class rclass = NO_REGS;
 880   enum reg_class reload_class = (enum reg_class) reload_class_i;
 881
 882   if (sri->prev_sri && sri->prev_sri->t_icode != CODE_FOR_nothing)
 883     {
 884       sri->icode = sri->prev_sri->t_icode;
 885       return NO_REGS;
 886     }
 887 #ifdef SECONDARY_INPUT_RELOAD_CLASS
 888   if (in_p)
 889     rclass = SECONDARY_INPUT_RELOAD_CLASS (reload_class, reload_mode, x);
 890 #endif
 891 #ifdef SECONDARY_OUTPUT_RELOAD_CLASS
 892   if (! in_p)
 893     rclass = SECONDARY_OUTPUT_RELOAD_CLASS (reload_class, reload_mode, x);
 894 #endif
 895   if (rclass != NO_REGS)
 896     {
 897       enum insn_code icode
 898         = direct_optab_handler (in_p ? reload_in_optab : reload_out_optab,
 899                                 reload_mode);
 900
 901       if (icode != CODE_FOR_nothing
 902           && !insn_operand_matches (icode, in_p, x))
 903         icode = CODE_FOR_nothing;
 904       else if (icode != CODE_FOR_nothing)
 905         {
 906           const char *insn_constraint, *scratch_constraint;
 907           char insn_letter, scratch_letter;
 908           enum reg_class insn_class, scratch_class;
 909
 910           gcc_assert (insn_data[(int) icode].n_operands == 3);
 911           insn_constraint = insn_data[(int) icode].operand[!in_p].constraint;
 912           if (!*insn_constraint)
 913             insn_class = ALL_REGS;
 914           else
 915             {
 916               if (in_p)
 917                 {
 918                   gcc_assert (*insn_constraint == '=');
 919                   insn_constraint++;
 920                 }
 921               insn_letter = *insn_constraint;
 922               insn_class
 923                 = (insn_letter == 'r' ? GENERAL_REGS
 924                    : REG_CLASS_FROM_CONSTRAINT ((unsigned char) insn_letter,
 925                                                 insn_constraint));
 926               gcc_assert (insn_class != NO_REGS);
 927             }
 928
 929           scratch_constraint = insn_data[(int) icode].operand[2].constraint;
 930           /* The scratch register's constraint must start with "=&",
 931              except for an input reload, where only "=" is necessary,
 932              and where it might be beneficial to re-use registers from
 933              the input.  */
 934           gcc_assert (scratch_constraint[0] == '='
 935                       && (in_p || scratch_constraint[1] == '&'));
 936           scratch_constraint++;
 937           if (*scratch_constraint == '&')
 938             scratch_constraint++;
 939           scratch_letter = *scratch_constraint;
 940           scratch_class
 941             = (scratch_letter == 'r' ? GENERAL_REGS
 942                : REG_CLASS_FROM_CONSTRAINT ((unsigned char) scratch_letter,
 943                                             scratch_constraint));
 944
 945           if (reg_class_subset_p (reload_class, insn_class))
 946             {
 947               gcc_assert (scratch_class == rclass);
 948               rclass = NO_REGS;
 949             }
 950           else
 951             rclass = insn_class;
 952
 953         }
 954       if (rclass == NO_REGS)
 955         sri->icode = icode;
 956       else
 957         sri->t_icode = icode;
 958     }
 959   return rclass;
 960 }
 961
 962 /* By default, if flag_pic is true, then neither local nor global relocs
 963    should be placed in readonly memory.  */
 964
 965 int
 966 default_reloc_rw_mask (void)
 967 {
 968   return flag_pic ? 3 : 0;
 969 }
 970
 971 /* By default, do no modification. */
 972 tree default_mangle_decl_assembler_name (tree decl ATTRIBUTE_UNUSED,
 973                                          tree id)
 974 {
 975    return id;
 976 }
 977
 978 /* Default to natural alignment for vector types.  */
 979 HOST_WIDE_INT
 980 default_vector_alignment (const_tree type)
 981 {
 982   return tree_low_cst (TYPE_SIZE (type), 0);
 983 }
 984
 985 bool
 986 default_builtin_vector_alignment_reachable (const_tree type, bool is_packed)
 987 {
 988   if (is_packed)
 989     return false;
 990
 991   /* Assuming that types whose size is > pointer-size are not guaranteed to be
 992      naturally aligned.  */
 993   if (tree_int_cst_compare (TYPE_SIZE (type), bitsize_int (POINTER_SIZE)) > 0)
 994     return false;
 995
 996   /* Assuming that types whose size is <= pointer-size
 997      are naturally aligned.  */
 998   return true;
 999 }
1000
1001 /* By default, assume that a target supports any factor of misalignment
1002    memory access if it supports movmisalign patten.
1003    is_packed is true if the memory access is defined in a packed struct.  */
1004 bool
1005 default_builtin_support_vector_misalignment (enum machine_mode mode,
1006                                              const_tree type
1007                                              ATTRIBUTE_UNUSED,
1008                                              int misalignment
1009                                              ATTRIBUTE_UNUSED,
1010                                              bool is_packed
1011                                              ATTRIBUTE_UNUSED)
1012 {
1013   if (optab_handler (movmisalign_optab, mode) != CODE_FOR_nothing)
1014     return true;
1015   return false;
1016 }
1017
1018 /* By default, only attempt to parallelize bitwise operations, and
1019    possibly adds/subtracts using bit-twiddling.  */
1020
1021 enum machine_mode
1022 default_preferred_simd_mode (enum machine_mode mode ATTRIBUTE_UNUSED)
1023 {
1024   return word_mode;
1025 }
1026
1027 /* By default only the size derived from the preferred vector mode
1028    is tried.  */
1029
1030 unsigned int
1031 default_autovectorize_vector_sizes (void)
1032 {
1033   return 0;
1034 }
1035
1036 /* By default, the cost model accumulates three separate costs (prologue,
1037    loop body, and epilogue) for a vectorized loop or block.  So allocate an
1038    array of three unsigned ints, set it to zero, and return its address.  */
1039
1040 void *
1041 default_init_cost (struct loop *loop_info ATTRIBUTE_UNUSED)
1042 {
1043   unsigned *cost = XNEWVEC (unsigned, 3);
1044   cost[vect_prologue] = cost[vect_body] = cost[vect_epilogue] = 0;
1045   return cost;
1046 }
1047
1048 /* By default, the cost model looks up the cost of the given statement
1049    kind and mode, multiplies it by the occurrence count, accumulates
1050    it into the cost specified by WHERE, and returns the cost added.  */
1051
1052 unsigned
1053 default_add_stmt_cost (void *data, int count, enum vect_cost_for_stmt kind,
1054                        struct _stmt_vec_info *stmt_info, int misalign,
1055                        enum vect_cost_model_location where)
1056 {
1057   unsigned *cost = (unsigned *) data;
1058   unsigned retval = 0;
1059
1060   if (flag_vect_cost_model)
1061     {
1062       tree vectype = stmt_info ? stmt_vectype (stmt_info) : NULL_TREE;
1063       int stmt_cost = default_builtin_vectorization_cost (kind, vectype,
1064                                                           misalign);
1065       /* Statements in an inner loop relative to the loop being
1066          vectorized are weighted more heavily.  The value here is
1067          arbitrary and could potentially be improved with analysis.  */
1068       if (where == vect_body && stmt_info && stmt_in_inner_loop_p (stmt_info))
1069         count *= 50;  /* FIXME.  */
1070
1071       retval = (unsigned) (count * stmt_cost);
1072       cost[where] += retval;
1073     }
1074
1075   return retval;
1076 }
1077
1078 /* By default, the cost model just returns the accumulated costs.  */
1079
1080 void
1081 default_finish_cost (void *data, unsigned *prologue_cost,
1082                      unsigned *body_cost, unsigned *epilogue_cost)
1083 {
1084   unsigned *cost = (unsigned *) data;
1085   *prologue_cost = cost[vect_prologue];
1086   *body_cost     = cost[vect_body];
1087   *epilogue_cost = cost[vect_epilogue];
1088 }
1089
1090 /* Free the cost data.  */
1091
1092 void
1093 default_destroy_cost_data (void *data)
1094 {
1095   free (data);
1096 }
1097
1098 /* Determine whether or not a pointer mode is valid. Assume defaults
1099    of ptr_mode or Pmode - can be overridden.  */
1100 bool
1101 default_valid_pointer_mode (enum machine_mode mode)
1102 {
1103   return (mode == ptr_mode || mode == Pmode);
1104 }
1105
1106 /* Determine whether the memory reference specified by REF may alias
1107    the C libraries errno location.  */
1108 bool
1109 default_ref_may_alias_errno (ao_ref *ref)
1110 {
1111   tree base = ao_ref_base (ref);
1112   /* The default implementation assumes the errno location is
1113      a declaration of type int or is always accessed via a
1114      pointer to int.  We assume that accesses to errno are
1115      not deliberately obfuscated (even in conforming ways).  */
1116   if (TYPE_UNSIGNED (TREE_TYPE (base))
1117       || TYPE_MODE (TREE_TYPE (base)) != TYPE_MODE (integer_type_node))
1118     return false;
1119   /* The default implementation assumes an errno location
1120      declaration is never defined in the current compilation unit.  */
1121   if (DECL_P (base)
1122       && !TREE_STATIC (base))
1123     return true;
1124   else if (TREE_CODE (base) == MEM_REF
1125            && TREE_CODE (TREE_OPERAND (base, 0)) == SSA_NAME)
1126     {
1127       struct ptr_info_def *pi = SSA_NAME_PTR_INFO (TREE_OPERAND (base, 0));
1128       return !pi || pi->pt.anything || pi->pt.nonlocal;
1129     }
1130   return false;
1131 }
1132
1133 /* Return the mode for a pointer to a given ADDRSPACE, defaulting to ptr_mode
1134    for the generic address space only.  */
1135
1136 enum machine_mode
1137 default_addr_space_pointer_mode (addr_space_t addrspace ATTRIBUTE_UNUSED)
1138 {
1139   gcc_assert (ADDR_SPACE_GENERIC_P (addrspace));
1140   return ptr_mode;
1141 }
1142
1143 /* Return the mode for an address in a given ADDRSPACE, defaulting to Pmode
1144    for the generic address space only.  */
1145
1146 enum machine_mode
1147 default_addr_space_address_mode (addr_space_t addrspace ATTRIBUTE_UNUSED)
1148 {
1149   gcc_assert (ADDR_SPACE_GENERIC_P (addrspace));
1150   return Pmode;
1151 }
1152
1153 /* Named address space version of valid_pointer_mode.  */
1154
1155 bool
1156 default_addr_space_valid_pointer_mode (enum machine_mode mode, addr_space_t as)
1157 {
1158   if (!ADDR_SPACE_GENERIC_P (as))
1159     return (mode == targetm.addr_space.pointer_mode (as)
1160             || mode == targetm.addr_space.address_mode (as));
1161
1162   return targetm.valid_pointer_mode (mode);
1163 }
1164
1165 /* Some places still assume that all pointer or address modes are the
1166    standard Pmode and ptr_mode.  These optimizations become invalid if
1167    the target actually supports multiple different modes.  For now,
1168    we disable such optimizations on such targets, using this function.  */
1169
1170 bool
1171 target_default_pointer_address_modes_p (void)
1172 {
1173   if (targetm.addr_space.address_mode != default_addr_space_address_mode)
1174     return false;
1175   if (targetm.addr_space.pointer_mode != default_addr_space_pointer_mode)
1176     return false;
1177
1178   return true;
1179 }
1180
1181 /* Named address space version of legitimate_address_p.  */
1182
1183 bool
1184 default_addr_space_legitimate_address_p (enum machine_mode mode, rtx mem,
1185                                          bool strict, addr_space_t as)
1186 {
1187   if (!ADDR_SPACE_GENERIC_P (as))
1188     gcc_unreachable ();
1189
1190   return targetm.legitimate_address_p (mode, mem, strict);
1191 }
1192
1193 /* Named address space version of LEGITIMIZE_ADDRESS.  */
1194
1195 rtx
1196 default_addr_space_legitimize_address (rtx x, rtx oldx,
1197                                        enum machine_mode mode, addr_space_t as)
1198 {
1199   if (!ADDR_SPACE_GENERIC_P (as))
1200     return x;
1201
1202   return targetm.legitimize_address (x, oldx, mode);
1203 }
1204
1205 /* The default hook for determining if one named address space is a subset of
1206    another and to return which address space to use as the common address
1207    space.  */
1208
1209 bool
1210 default_addr_space_subset_p (addr_space_t subset, addr_space_t superset)
1211 {
1212   return (subset == superset);
1213 }
1214
1215 /* The default hook for TARGET_ADDR_SPACE_CONVERT. This hook should never be
1216    called for targets with only a generic address space.  */
1217
1218 rtx
1219 default_addr_space_convert (rtx op ATTRIBUTE_UNUSED,
1220                             tree from_type ATTRIBUTE_UNUSED,
1221                             tree to_type ATTRIBUTE_UNUSED)
1222 {
1223   gcc_unreachable ();
1224 }
1225
1226 bool
1227 default_hard_regno_scratch_ok (unsigned int regno ATTRIBUTE_UNUSED)
1228 {
1229   return true;
1230 }
1231
1232 /* The default implementation of TARGET_MODE_DEPENDENT_ADDRESS_P.  */
1233
1234 bool
1235 default_mode_dependent_address_p (const_rtx addr ATTRIBUTE_UNUSED,
1236                                   addr_space_t addrspace ATTRIBUTE_UNUSED)
1237 {
1238   return false;
1239 }
1240
1241 bool
1242 default_target_option_valid_attribute_p (tree ARG_UNUSED (fndecl),
1243                                          tree ARG_UNUSED (name),
1244                                          tree ARG_UNUSED (args),
1245                                          int ARG_UNUSED (flags))
1246 {
1247   warning (OPT_Wattributes,
1248            "target attribute is not supported on this machine");
1249
1250   return false;
1251 }
1252
1253 bool
1254 default_target_option_pragma_parse (tree ARG_UNUSED (args),
1255                                     tree ARG_UNUSED (pop_target))
1256 {
1257   warning (OPT_Wpragmas,
1258            "#pragma GCC target is not supported for this machine");
1259
1260   return false;
1261 }
1262
1263 bool
1264 default_target_can_inline_p (tree caller, tree callee)
1265 {
1266   bool ret = false;
1267   tree callee_opts = DECL_FUNCTION_SPECIFIC_TARGET (callee);
1268   tree caller_opts = DECL_FUNCTION_SPECIFIC_TARGET (caller);
1269
1270   /* If callee has no option attributes, then it is ok to inline */
1271   if (!callee_opts)
1272     ret = true;
1273
1274   /* If caller has no option attributes, but callee does then it is not ok to
1275      inline */
1276   else if (!caller_opts)
1277     ret = false;
1278
1279   /* If both caller and callee have attributes, assume that if the
1280      pointer is different, the two functions have different target
1281      options since build_target_option_node uses a hash table for the
1282      options.  */
1283   else
1284     ret = (callee_opts == caller_opts);
1285
1286   return ret;
1287 }
1288
1289 #ifndef HAVE_casesi
1290 # define HAVE_casesi 0
1291 #endif
1292
1293 /* If the machine does not have a case insn that compares the bounds,
1294    this means extra overhead for dispatch tables, which raises the
1295    threshold for using them.  */
1296
1297 unsigned int
1298 default_case_values_threshold (void)
1299 {
1300   return (HAVE_casesi ? 4 : 5);
1301 }
1302
1303 bool
1304 default_have_conditional_execution (void)
1305 {
1306 #ifdef HAVE_conditional_execution
1307   return HAVE_conditional_execution;
1308 #else
1309   return false;
1310 #endif
1311 }
1312
1313 tree
1314 default_builtin_tm_load_store (tree ARG_UNUSED (type))
1315 {
1316   return NULL_TREE;
1317 }
1318
1319 /* Compute cost of moving registers to/from memory.  */
1320
1321 int
1322 default_memory_move_cost (enum machine_mode mode ATTRIBUTE_UNUSED,
1323                           reg_class_t rclass ATTRIBUTE_UNUSED,
1324                           bool in ATTRIBUTE_UNUSED)
1325 {
1326 #ifndef MEMORY_MOVE_COST
1327     return (4 + memory_move_secondary_cost (mode, (enum reg_class) rclass, in));
1328 #else
1329     return MEMORY_MOVE_COST (mode, (enum reg_class) rclass, in);
1330 #endif
1331 }
1332
1333 /* Compute cost of moving data from a register of class FROM to one of
1334    TO, using MODE.  */
1335
1336 int
1337 default_register_move_cost (enum machine_mode mode ATTRIBUTE_UNUSED,
1338                             reg_class_t from ATTRIBUTE_UNUSED,
1339                             reg_class_t to ATTRIBUTE_UNUSED)
1340 {
1341 #ifndef REGISTER_MOVE_COST
1342   return 2;
1343 #else
1344   return REGISTER_MOVE_COST (mode, (enum reg_class) from, (enum reg_class) to);
1345 #endif
1346 }
1347
1348 bool
1349 default_profile_before_prologue (void)
1350 {
1351 #ifdef PROFILE_BEFORE_PROLOGUE
1352   return true;
1353 #else
1354   return false;
1355 #endif
1356 }
1357
1358 /* The default implementation of TARGET_PREFERRED_RELOAD_CLASS.  */
1359
1360 reg_class_t
1361 default_preferred_reload_class (rtx x ATTRIBUTE_UNUSED,
1362                                 reg_class_t rclass)
1363 {
1364 #ifdef PREFERRED_RELOAD_CLASS
1365   return (reg_class_t) PREFERRED_RELOAD_CLASS (x, (enum reg_class) rclass);
1366 #else
1367   return rclass;
1368 #endif
1369 }
1370
1371 /* The default implementation of TARGET_OUTPUT_PREFERRED_RELOAD_CLASS.  */
1372
1373 reg_class_t
1374 default_preferred_output_reload_class (rtx x ATTRIBUTE_UNUSED,
1375                                        reg_class_t rclass)
1376 {
1377   return rclass;
1378 }
1379
1380 /* The default implementation of TARGET_PREFERRED_RENAME_CLASS.  */
1381 reg_class_t
1382 default_preferred_rename_class (reg_class_t rclass ATTRIBUTE_UNUSED)
1383 {
1384   return NO_REGS;
1385 }
1386
1387 /* The default implementation of TARGET_CLASS_LIKELY_SPILLED_P.  */
1388
1389 bool
1390 default_class_likely_spilled_p (reg_class_t rclass)
1391 {
1392   return (reg_class_size[(int) rclass] == 1);
1393 }
1394
1395 /* The default implementation of TARGET_CLASS_MAX_NREGS.  */
1396
1397 unsigned char
1398 default_class_max_nregs (reg_class_t rclass ATTRIBUTE_UNUSED,
1399                          enum machine_mode mode ATTRIBUTE_UNUSED)
1400 {
1401 #ifdef CLASS_MAX_NREGS
1402   return (unsigned char) CLASS_MAX_NREGS ((enum reg_class) rclass, mode);
1403 #else
1404   return ((GET_MODE_SIZE (mode) + UNITS_PER_WORD - 1) / UNITS_PER_WORD);
1405 #endif
1406 }
1407
1408 /* Determine the debugging unwind mechanism for the target.  */
1409
1410 enum unwind_info_type
1411 default_debug_unwind_info (void)
1412 {
1413   /* If the target wants to force the use of dwarf2 unwind info, let it.  */
1414   /* ??? Change all users to the hook, then poison this.  */
1415 #ifdef DWARF2_FRAME_INFO
1416   if (DWARF2_FRAME_INFO)
1417     return UI_DWARF2;
1418 #endif
1419
1420   /* Otherwise, only turn it on if dwarf2 debugging is enabled.  */
1421 #ifdef DWARF2_DEBUGGING_INFO
1422   if (write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
1423     return UI_DWARF2;
1424 #endif
1425
1426   return UI_NONE;
1427 }
1428
1429 /* To be used by targets where reg_raw_mode doesn't return the right
1430    mode for registers used in apply_builtin_return and apply_builtin_arg.  */
1431
1432 enum machine_mode
1433 default_get_reg_raw_mode(int regno)
1434 {
1435   return reg_raw_mode[regno];
1436 }
1437
1438 /* Return true if the state of option OPTION should be stored in PCH files
1439    and checked by default_pch_valid_p.  Store the option's current state
1440    in STATE if so.  */
1441
1442 static inline bool
1443 option_affects_pch_p (int option, struct cl_option_state *state)
1444 {
1445   if ((cl_options[option].flags & CL_TARGET) == 0)
1446     return false;
1447   if (option_flag_var (option, &global_options) == &target_flags)
1448     if (targetm.check_pch_target_flags)
1449       return false;
1450   return get_option_state (&global_options, option, state);
1451 }
1452
1453 /* Default version of get_pch_validity.
1454    By default, every flag difference is fatal; that will be mostly right for
1455    most targets, but completely right for very few.  */
1456
1457 void *
1458 default_get_pch_validity (size_t *sz)
1459 {
1460   struct cl_option_state state;
1461   size_t i;
1462   char *result, *r;
1463
1464   *sz = 2;
1465   if (targetm.check_pch_target_flags)
1466     *sz += sizeof (target_flags);
1467   for (i = 0; i < cl_options_count; i++)
1468     if (option_affects_pch_p (i, &state))
1469       *sz += state.size;
1470
1471   result = r = XNEWVEC (char, *sz);
1472   r[0] = flag_pic;
1473   r[1] = flag_pie;
1474   r += 2;
1475   if (targetm.check_pch_target_flags)
1476     {
1477       memcpy (r, &target_flags, sizeof (target_flags));
1478       r += sizeof (target_flags);
1479     }
1480
1481   for (i = 0; i < cl_options_count; i++)
1482     if (option_affects_pch_p (i, &state))
1483       {
1484         memcpy (r, state.data, state.size);
1485         r += state.size;
1486       }
1487
1488   return result;
1489 }
1490
1491 /* Return a message which says that a PCH file was created with a different
1492    setting of OPTION.  */
1493
1494 static const char *
1495 pch_option_mismatch (const char *option)
1496 {
1497   char *r;
1498
1499   asprintf (&r, _("created and used with differing settings of '%s'"), option);
1500   if (r == NULL)
1501     return _("out of memory");
1502   return r;
1503 }
1504
1505 /* Default version of pch_valid_p.  */
1506
1507 const char *
1508 default_pch_valid_p (const void *data_p, size_t len)
1509 {
1510   struct cl_option_state state;
1511   const char *data = (const char *)data_p;
1512   size_t i;
1513
1514   /* -fpic and -fpie also usually make a PCH invalid.  */
1515   if (data[0] != flag_pic)
1516     return _("created and used with different settings of -fpic");
1517   if (data[1] != flag_pie)
1518     return _("created and used with different settings of -fpie");
1519   data += 2;
1520
1521   /* Check target_flags.  */
1522   if (targetm.check_pch_target_flags)
1523     {
1524       int tf;
1525       const char *r;
1526
1527       memcpy (&tf, data, sizeof (target_flags));
1528       data += sizeof (target_flags);
1529       len -= sizeof (target_flags);
1530       r = targetm.check_pch_target_flags (tf);
1531       if (r != NULL)
1532         return r;
1533     }
1534
1535   for (i = 0; i < cl_options_count; i++)
1536     if (option_affects_pch_p (i, &state))
1537       {
1538         if (memcmp (data, state.data, state.size) != 0)
1539           return pch_option_mismatch (cl_options[i].opt_text);
1540         data += state.size;
1541         len -= state.size;
1542       }
1543
1544   return NULL;
1545 }
1546
1547 /* Default version of cstore_mode.  */
1548
1549 enum machine_mode
1550 default_cstore_mode (enum insn_code icode)
1551 {
1552   return insn_data[(int) icode].operand[0].mode;
1553 }
1554
1555 /* Default version of member_type_forces_blk.  */
1556
1557 bool
1558 default_member_type_forces_blk (const_tree, enum machine_mode)
1559 {
1560   return false;
1561 }
1562
1563 /* Default version of canonicalize_comparison.  */
1564
1565 void
1566 default_canonicalize_comparison (int *, rtx *, rtx *, bool)
1567 {
1568 }
1569
1570 #include "gt-targhooks.h"