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-ssa.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   tree vectype = stmt_info ? stmt_vectype (stmt_info) : NULL_TREE;
1061   int stmt_cost = default_builtin_vectorization_cost (kind, vectype,
1062                                                           misalign);
1063    /* Statements in an inner loop relative to the loop being
1064       vectorized are weighted more heavily.  The value here is
1065       arbitrary and could potentially be improved with analysis.  */
1066   if (where == vect_body && stmt_info && stmt_in_inner_loop_p (stmt_info))
1067     count *= 50;  /* FIXME.  */
1068
1069   retval = (unsigned) (count * stmt_cost);
1070   cost[where] += retval;
1071
1072   return retval;
1073 }
1074
1075 /* By default, the cost model just returns the accumulated costs.  */
1076
1077 void
1078 default_finish_cost (void *data, unsigned *prologue_cost,
1079                      unsigned *body_cost, unsigned *epilogue_cost)
1080 {
1081   unsigned *cost = (unsigned *) data;
1082   *prologue_cost = cost[vect_prologue];
1083   *body_cost     = cost[vect_body];
1084   *epilogue_cost = cost[vect_epilogue];
1085 }
1086
1087 /* Free the cost data.  */
1088
1089 void
1090 default_destroy_cost_data (void *data)
1091 {
1092   free (data);
1093 }
1094
1095 /* Determine whether or not a pointer mode is valid. Assume defaults
1096    of ptr_mode or Pmode - can be overridden.  */
1097 bool
1098 default_valid_pointer_mode (enum machine_mode mode)
1099 {
1100   return (mode == ptr_mode || mode == Pmode);
1101 }
1102
1103 /* Determine whether the memory reference specified by REF may alias
1104    the C libraries errno location.  */
1105 bool
1106 default_ref_may_alias_errno (ao_ref *ref)
1107 {
1108   tree base = ao_ref_base (ref);
1109   /* The default implementation assumes the errno location is
1110      a declaration of type int or is always accessed via a
1111      pointer to int.  We assume that accesses to errno are
1112      not deliberately obfuscated (even in conforming ways).  */
1113   if (TYPE_UNSIGNED (TREE_TYPE (base))
1114       || TYPE_MODE (TREE_TYPE (base)) != TYPE_MODE (integer_type_node))
1115     return false;
1116   /* The default implementation assumes an errno location
1117      declaration is never defined in the current compilation unit.  */
1118   if (DECL_P (base)
1119       && !TREE_STATIC (base))
1120     return true;
1121   else if (TREE_CODE (base) == MEM_REF
1122            && TREE_CODE (TREE_OPERAND (base, 0)) == SSA_NAME)
1123     {
1124       struct ptr_info_def *pi = SSA_NAME_PTR_INFO (TREE_OPERAND (base, 0));
1125       return !pi || pi->pt.anything || pi->pt.nonlocal;
1126     }
1127   return false;
1128 }
1129
1130 /* Return the mode for a pointer to a given ADDRSPACE, defaulting to ptr_mode
1131    for the generic address space only.  */
1132
1133 enum machine_mode
1134 default_addr_space_pointer_mode (addr_space_t addrspace ATTRIBUTE_UNUSED)
1135 {
1136   gcc_assert (ADDR_SPACE_GENERIC_P (addrspace));
1137   return ptr_mode;
1138 }
1139
1140 /* Return the mode for an address in a given ADDRSPACE, defaulting to Pmode
1141    for the generic address space only.  */
1142
1143 enum machine_mode
1144 default_addr_space_address_mode (addr_space_t addrspace ATTRIBUTE_UNUSED)
1145 {
1146   gcc_assert (ADDR_SPACE_GENERIC_P (addrspace));
1147   return Pmode;
1148 }
1149
1150 /* Named address space version of valid_pointer_mode.  */
1151
1152 bool
1153 default_addr_space_valid_pointer_mode (enum machine_mode mode, addr_space_t as)
1154 {
1155   if (!ADDR_SPACE_GENERIC_P (as))
1156     return (mode == targetm.addr_space.pointer_mode (as)
1157             || mode == targetm.addr_space.address_mode (as));
1158
1159   return targetm.valid_pointer_mode (mode);
1160 }
1161
1162 /* Some places still assume that all pointer or address modes are the
1163    standard Pmode and ptr_mode.  These optimizations become invalid if
1164    the target actually supports multiple different modes.  For now,
1165    we disable such optimizations on such targets, using this function.  */
1166
1167 bool
1168 target_default_pointer_address_modes_p (void)
1169 {
1170   if (targetm.addr_space.address_mode != default_addr_space_address_mode)
1171     return false;
1172   if (targetm.addr_space.pointer_mode != default_addr_space_pointer_mode)
1173     return false;
1174
1175   return true;
1176 }
1177
1178 /* Named address space version of legitimate_address_p.  */
1179
1180 bool
1181 default_addr_space_legitimate_address_p (enum machine_mode mode, rtx mem,
1182                                          bool strict, addr_space_t as)
1183 {
1184   if (!ADDR_SPACE_GENERIC_P (as))
1185     gcc_unreachable ();
1186
1187   return targetm.legitimate_address_p (mode, mem, strict);
1188 }
1189
1190 /* Named address space version of LEGITIMIZE_ADDRESS.  */
1191
1192 rtx
1193 default_addr_space_legitimize_address (rtx x, rtx oldx,
1194                                        enum machine_mode mode, addr_space_t as)
1195 {
1196   if (!ADDR_SPACE_GENERIC_P (as))
1197     return x;
1198
1199   return targetm.legitimize_address (x, oldx, mode);
1200 }
1201
1202 /* The default hook for determining if one named address space is a subset of
1203    another and to return which address space to use as the common address
1204    space.  */
1205
1206 bool
1207 default_addr_space_subset_p (addr_space_t subset, addr_space_t superset)
1208 {
1209   return (subset == superset);
1210 }
1211
1212 /* The default hook for TARGET_ADDR_SPACE_CONVERT. This hook should never be
1213    called for targets with only a generic address space.  */
1214
1215 rtx
1216 default_addr_space_convert (rtx op ATTRIBUTE_UNUSED,
1217                             tree from_type ATTRIBUTE_UNUSED,
1218                             tree to_type ATTRIBUTE_UNUSED)
1219 {
1220   gcc_unreachable ();
1221 }
1222
1223 bool
1224 default_hard_regno_scratch_ok (unsigned int regno ATTRIBUTE_UNUSED)
1225 {
1226   return true;
1227 }
1228
1229 /* The default implementation of TARGET_MODE_DEPENDENT_ADDRESS_P.  */
1230
1231 bool
1232 default_mode_dependent_address_p (const_rtx addr ATTRIBUTE_UNUSED,
1233                                   addr_space_t addrspace ATTRIBUTE_UNUSED)
1234 {
1235   return false;
1236 }
1237
1238 bool
1239 default_target_option_valid_attribute_p (tree ARG_UNUSED (fndecl),
1240                                          tree ARG_UNUSED (name),
1241                                          tree ARG_UNUSED (args),
1242                                          int ARG_UNUSED (flags))
1243 {
1244   warning (OPT_Wattributes,
1245            "target attribute is not supported on this machine");
1246
1247   return false;
1248 }
1249
1250 bool
1251 default_target_option_pragma_parse (tree ARG_UNUSED (args),
1252                                     tree ARG_UNUSED (pop_target))
1253 {
1254   warning (OPT_Wpragmas,
1255            "#pragma GCC target is not supported for this machine");
1256
1257   return false;
1258 }
1259
1260 bool
1261 default_target_can_inline_p (tree caller, tree callee)
1262 {
1263   bool ret = false;
1264   tree callee_opts = DECL_FUNCTION_SPECIFIC_TARGET (callee);
1265   tree caller_opts = DECL_FUNCTION_SPECIFIC_TARGET (caller);
1266
1267   /* If callee has no option attributes, then it is ok to inline */
1268   if (!callee_opts)
1269     ret = true;
1270
1271   /* If caller has no option attributes, but callee does then it is not ok to
1272      inline */
1273   else if (!caller_opts)
1274     ret = false;
1275
1276   /* If both caller and callee have attributes, assume that if the
1277      pointer is different, the two functions have different target
1278      options since build_target_option_node uses a hash table for the
1279      options.  */
1280   else
1281     ret = (callee_opts == caller_opts);
1282
1283   return ret;
1284 }
1285
1286 #ifndef HAVE_casesi
1287 # define HAVE_casesi 0
1288 #endif
1289
1290 /* If the machine does not have a case insn that compares the bounds,
1291    this means extra overhead for dispatch tables, which raises the
1292    threshold for using them.  */
1293
1294 unsigned int
1295 default_case_values_threshold (void)
1296 {
1297   return (HAVE_casesi ? 4 : 5);
1298 }
1299
1300 bool
1301 default_have_conditional_execution (void)
1302 {
1303 #ifdef HAVE_conditional_execution
1304   return HAVE_conditional_execution;
1305 #else
1306   return false;
1307 #endif
1308 }
1309
1310 tree
1311 default_builtin_tm_load_store (tree ARG_UNUSED (type))
1312 {
1313   return NULL_TREE;
1314 }
1315
1316 /* Compute cost of moving registers to/from memory.  */
1317
1318 int
1319 default_memory_move_cost (enum machine_mode mode ATTRIBUTE_UNUSED,
1320                           reg_class_t rclass ATTRIBUTE_UNUSED,
1321                           bool in ATTRIBUTE_UNUSED)
1322 {
1323 #ifndef MEMORY_MOVE_COST
1324     return (4 + memory_move_secondary_cost (mode, (enum reg_class) rclass, in));
1325 #else
1326     return MEMORY_MOVE_COST (mode, (enum reg_class) rclass, in);
1327 #endif
1328 }
1329
1330 /* Compute cost of moving data from a register of class FROM to one of
1331    TO, using MODE.  */
1332
1333 int
1334 default_register_move_cost (enum machine_mode mode ATTRIBUTE_UNUSED,
1335                             reg_class_t from ATTRIBUTE_UNUSED,
1336                             reg_class_t to ATTRIBUTE_UNUSED)
1337 {
1338 #ifndef REGISTER_MOVE_COST
1339   return 2;
1340 #else
1341   return REGISTER_MOVE_COST (mode, (enum reg_class) from, (enum reg_class) to);
1342 #endif
1343 }
1344
1345 bool
1346 default_profile_before_prologue (void)
1347 {
1348 #ifdef PROFILE_BEFORE_PROLOGUE
1349   return true;
1350 #else
1351   return false;
1352 #endif
1353 }
1354
1355 /* The default implementation of TARGET_PREFERRED_RELOAD_CLASS.  */
1356
1357 reg_class_t
1358 default_preferred_reload_class (rtx x ATTRIBUTE_UNUSED,
1359                                 reg_class_t rclass)
1360 {
1361 #ifdef PREFERRED_RELOAD_CLASS
1362   return (reg_class_t) PREFERRED_RELOAD_CLASS (x, (enum reg_class) rclass);
1363 #else
1364   return rclass;
1365 #endif
1366 }
1367
1368 /* The default implementation of TARGET_OUTPUT_PREFERRED_RELOAD_CLASS.  */
1369
1370 reg_class_t
1371 default_preferred_output_reload_class (rtx x ATTRIBUTE_UNUSED,
1372                                        reg_class_t rclass)
1373 {
1374   return rclass;
1375 }
1376
1377 /* The default implementation of TARGET_PREFERRED_RENAME_CLASS.  */
1378 reg_class_t
1379 default_preferred_rename_class (reg_class_t rclass ATTRIBUTE_UNUSED)
1380 {
1381   return NO_REGS;
1382 }
1383
1384 /* The default implementation of TARGET_CLASS_LIKELY_SPILLED_P.  */
1385
1386 bool
1387 default_class_likely_spilled_p (reg_class_t rclass)
1388 {
1389   return (reg_class_size[(int) rclass] == 1);
1390 }
1391
1392 /* The default implementation of TARGET_CLASS_MAX_NREGS.  */
1393
1394 unsigned char
1395 default_class_max_nregs (reg_class_t rclass ATTRIBUTE_UNUSED,
1396                          enum machine_mode mode ATTRIBUTE_UNUSED)
1397 {
1398 #ifdef CLASS_MAX_NREGS
1399   return (unsigned char) CLASS_MAX_NREGS ((enum reg_class) rclass, mode);
1400 #else
1401   return ((GET_MODE_SIZE (mode) + UNITS_PER_WORD - 1) / UNITS_PER_WORD);
1402 #endif
1403 }
1404
1405 /* Determine the debugging unwind mechanism for the target.  */
1406
1407 enum unwind_info_type
1408 default_debug_unwind_info (void)
1409 {
1410   /* If the target wants to force the use of dwarf2 unwind info, let it.  */
1411   /* ??? Change all users to the hook, then poison this.  */
1412 #ifdef DWARF2_FRAME_INFO
1413   if (DWARF2_FRAME_INFO)
1414     return UI_DWARF2;
1415 #endif
1416
1417   /* Otherwise, only turn it on if dwarf2 debugging is enabled.  */
1418 #ifdef DWARF2_DEBUGGING_INFO
1419   if (write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
1420     return UI_DWARF2;
1421 #endif
1422
1423   return UI_NONE;
1424 }
1425
1426 /* To be used by targets where reg_raw_mode doesn't return the right
1427    mode for registers used in apply_builtin_return and apply_builtin_arg.  */
1428
1429 enum machine_mode
1430 default_get_reg_raw_mode (int regno)
1431 {
1432   return reg_raw_mode[regno];
1433 }
1434
1435 /* Return true if the state of option OPTION should be stored in PCH files
1436    and checked by default_pch_valid_p.  Store the option's current state
1437    in STATE if so.  */
1438
1439 static inline bool
1440 option_affects_pch_p (int option, struct cl_option_state *state)
1441 {
1442   if ((cl_options[option].flags & CL_TARGET) == 0)
1443     return false;
1444   if (option_flag_var (option, &global_options) == &target_flags)
1445     if (targetm.check_pch_target_flags)
1446       return false;
1447   return get_option_state (&global_options, option, state);
1448 }
1449
1450 /* Default version of get_pch_validity.
1451    By default, every flag difference is fatal; that will be mostly right for
1452    most targets, but completely right for very few.  */
1453
1454 void *
1455 default_get_pch_validity (size_t *sz)
1456 {
1457   struct cl_option_state state;
1458   size_t i;
1459   char *result, *r;
1460
1461   *sz = 2;
1462   if (targetm.check_pch_target_flags)
1463     *sz += sizeof (target_flags);
1464   for (i = 0; i < cl_options_count; i++)
1465     if (option_affects_pch_p (i, &state))
1466       *sz += state.size;
1467
1468   result = r = XNEWVEC (char, *sz);
1469   r[0] = flag_pic;
1470   r[1] = flag_pie;
1471   r += 2;
1472   if (targetm.check_pch_target_flags)
1473     {
1474       memcpy (r, &target_flags, sizeof (target_flags));
1475       r += sizeof (target_flags);
1476     }
1477
1478   for (i = 0; i < cl_options_count; i++)
1479     if (option_affects_pch_p (i, &state))
1480       {
1481         memcpy (r, state.data, state.size);
1482         r += state.size;
1483       }
1484
1485   return result;
1486 }
1487
1488 /* Return a message which says that a PCH file was created with a different
1489    setting of OPTION.  */
1490
1491 static const char *
1492 pch_option_mismatch (const char *option)
1493 {
1494   char *r;
1495
1496   asprintf (&r, _("created and used with differing settings of '%s'"), option);
1497   if (r == NULL)
1498     return _("out of memory");
1499   return r;
1500 }
1501
1502 /* Default version of pch_valid_p.  */
1503
1504 const char *
1505 default_pch_valid_p (const void *data_p, size_t len)
1506 {
1507   struct cl_option_state state;
1508   const char *data = (const char *)data_p;
1509   size_t i;
1510
1511   /* -fpic and -fpie also usually make a PCH invalid.  */
1512   if (data[0] != flag_pic)
1513     return _("created and used with different settings of -fpic");
1514   if (data[1] != flag_pie)
1515     return _("created and used with different settings of -fpie");
1516   data += 2;
1517
1518   /* Check target_flags.  */
1519   if (targetm.check_pch_target_flags)
1520     {
1521       int tf;
1522       const char *r;
1523
1524       memcpy (&tf, data, sizeof (target_flags));
1525       data += sizeof (target_flags);
1526       len -= sizeof (target_flags);
1527       r = targetm.check_pch_target_flags (tf);
1528       if (r != NULL)
1529         return r;
1530     }
1531
1532   for (i = 0; i < cl_options_count; i++)
1533     if (option_affects_pch_p (i, &state))
1534       {
1535         if (memcmp (data, state.data, state.size) != 0)
1536           return pch_option_mismatch (cl_options[i].opt_text);
1537         data += state.size;
1538         len -= state.size;
1539       }
1540
1541   return NULL;
1542 }
1543
1544 /* Default version of cstore_mode.  */
1545
1546 enum machine_mode
1547 default_cstore_mode (enum insn_code icode)
1548 {
1549   return insn_data[(int) icode].operand[0].mode;
1550 }
1551
1552 /* Default version of member_type_forces_blk.  */
1553
1554 bool
1555 default_member_type_forces_blk (const_tree, enum machine_mode)
1556 {
1557   return false;
1558 }
1559
1560 /* Default version of canonicalize_comparison.  */
1561
1562 void
1563 default_canonicalize_comparison (int *, rtx *, rtx *, bool)
1564 {
1565 }
1566
1567 #include "gt-targhooks.h"