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_different_addr_displacement_p (void)
 863 {
 864   return false;
 865 }
 866
 867 reg_class_t
 868 default_secondary_reload (bool in_p ATTRIBUTE_UNUSED, rtx x ATTRIBUTE_UNUSED,
 869                           reg_class_t reload_class_i ATTRIBUTE_UNUSED,
 870                           enum machine_mode reload_mode ATTRIBUTE_UNUSED,
 871                           secondary_reload_info *sri)
 872 {
 873   enum reg_class rclass = NO_REGS;
 874   enum reg_class reload_class = (enum reg_class) reload_class_i;
 875
 876   if (sri->prev_sri && sri->prev_sri->t_icode != CODE_FOR_nothing)
 877     {
 878       sri->icode = sri->prev_sri->t_icode;
 879       return NO_REGS;
 880     }
 881 #ifdef SECONDARY_INPUT_RELOAD_CLASS
 882   if (in_p)
 883     rclass = SECONDARY_INPUT_RELOAD_CLASS (reload_class, reload_mode, x);
 884 #endif
 885 #ifdef SECONDARY_OUTPUT_RELOAD_CLASS
 886   if (! in_p)
 887     rclass = SECONDARY_OUTPUT_RELOAD_CLASS (reload_class, reload_mode, x);
 888 #endif
 889   if (rclass != NO_REGS)
 890     {
 891       enum insn_code icode
 892         = direct_optab_handler (in_p ? reload_in_optab : reload_out_optab,
 893                                 reload_mode);
 894
 895       if (icode != CODE_FOR_nothing
 896           && !insn_operand_matches (icode, in_p, x))
 897         icode = CODE_FOR_nothing;
 898       else if (icode != CODE_FOR_nothing)
 899         {
 900           const char *insn_constraint, *scratch_constraint;
 901           char insn_letter, scratch_letter;
 902           enum reg_class insn_class, scratch_class;
 903
 904           gcc_assert (insn_data[(int) icode].n_operands == 3);
 905           insn_constraint = insn_data[(int) icode].operand[!in_p].constraint;
 906           if (!*insn_constraint)
 907             insn_class = ALL_REGS;
 908           else
 909             {
 910               if (in_p)
 911                 {
 912                   gcc_assert (*insn_constraint == '=');
 913                   insn_constraint++;
 914                 }
 915               insn_letter = *insn_constraint;
 916               insn_class
 917                 = (insn_letter == 'r' ? GENERAL_REGS
 918                    : REG_CLASS_FROM_CONSTRAINT ((unsigned char) insn_letter,
 919                                                 insn_constraint));
 920               gcc_assert (insn_class != NO_REGS);
 921             }
 922
 923           scratch_constraint = insn_data[(int) icode].operand[2].constraint;
 924           /* The scratch register's constraint must start with "=&",
 925              except for an input reload, where only "=" is necessary,
 926              and where it might be beneficial to re-use registers from
 927              the input.  */
 928           gcc_assert (scratch_constraint[0] == '='
 929                       && (in_p || scratch_constraint[1] == '&'));
 930           scratch_constraint++;
 931           if (*scratch_constraint == '&')
 932             scratch_constraint++;
 933           scratch_letter = *scratch_constraint;
 934           scratch_class
 935             = (scratch_letter == 'r' ? GENERAL_REGS
 936                : REG_CLASS_FROM_CONSTRAINT ((unsigned char) scratch_letter,
 937                                             scratch_constraint));
 938
 939           if (reg_class_subset_p (reload_class, insn_class))
 940             {
 941               gcc_assert (scratch_class == rclass);
 942               rclass = NO_REGS;
 943             }
 944           else
 945             rclass = insn_class;
 946
 947         }
 948       if (rclass == NO_REGS)
 949         sri->icode = icode;
 950       else
 951         sri->t_icode = icode;
 952     }
 953   return rclass;
 954 }
 955
 956 /* By default, if flag_pic is true, then neither local nor global relocs
 957    should be placed in readonly memory.  */
 958
 959 int
 960 default_reloc_rw_mask (void)
 961 {
 962   return flag_pic ? 3 : 0;
 963 }
 964
 965 /* By default, do no modification. */
 966 tree default_mangle_decl_assembler_name (tree decl ATTRIBUTE_UNUSED,
 967                                          tree id)
 968 {
 969    return id;
 970 }
 971
 972 /* Default to natural alignment for vector types.  */
 973 HOST_WIDE_INT
 974 default_vector_alignment (const_tree type)
 975 {
 976   return tree_low_cst (TYPE_SIZE (type), 0);
 977 }
 978
 979 bool
 980 default_builtin_vector_alignment_reachable (const_tree type, bool is_packed)
 981 {
 982   if (is_packed)
 983     return false;
 984
 985   /* Assuming that types whose size is > pointer-size are not guaranteed to be
 986      naturally aligned.  */
 987   if (tree_int_cst_compare (TYPE_SIZE (type), bitsize_int (POINTER_SIZE)) > 0)
 988     return false;
 989
 990   /* Assuming that types whose size is <= pointer-size
 991      are naturally aligned.  */
 992   return true;
 993 }
 994
 995 /* By default, assume that a target supports any factor of misalignment
 996    memory access if it supports movmisalign patten.
 997    is_packed is true if the memory access is defined in a packed struct.  */
 998 bool
 999 default_builtin_support_vector_misalignment (enum machine_mode mode,
1000                                              const_tree type
1001                                              ATTRIBUTE_UNUSED,
1002                                              int misalignment
1003                                              ATTRIBUTE_UNUSED,
1004                                              bool is_packed
1005                                              ATTRIBUTE_UNUSED)
1006 {
1007   if (optab_handler (movmisalign_optab, mode) != CODE_FOR_nothing)
1008     return true;
1009   return false;
1010 }
1011
1012 /* By default, only attempt to parallelize bitwise operations, and
1013    possibly adds/subtracts using bit-twiddling.  */
1014
1015 enum machine_mode
1016 default_preferred_simd_mode (enum machine_mode mode ATTRIBUTE_UNUSED)
1017 {
1018   return word_mode;
1019 }
1020
1021 /* By default only the size derived from the preferred vector mode
1022    is tried.  */
1023
1024 unsigned int
1025 default_autovectorize_vector_sizes (void)
1026 {
1027   return 0;
1028 }
1029
1030 /* By default, the cost model accumulates three separate costs (prologue,
1031    loop body, and epilogue) for a vectorized loop or block.  So allocate an
1032    array of three unsigned ints, set it to zero, and return its address.  */
1033
1034 void *
1035 default_init_cost (struct loop *loop_info ATTRIBUTE_UNUSED)
1036 {
1037   unsigned *cost = XNEWVEC (unsigned, 3);
1038   cost[vect_prologue] = cost[vect_body] = cost[vect_epilogue] = 0;
1039   return cost;
1040 }
1041
1042 /* By default, the cost model looks up the cost of the given statement
1043    kind and mode, multiplies it by the occurrence count, accumulates
1044    it into the cost specified by WHERE, and returns the cost added.  */
1045
1046 unsigned
1047 default_add_stmt_cost (void *data, int count, enum vect_cost_for_stmt kind,
1048                        struct _stmt_vec_info *stmt_info, int misalign,
1049                        enum vect_cost_model_location where)
1050 {
1051   unsigned *cost = (unsigned *) data;
1052   unsigned retval = 0;
1053
1054   if (flag_vect_cost_model)
1055     {
1056       tree vectype = stmt_info ? stmt_vectype (stmt_info) : NULL_TREE;
1057       int stmt_cost = default_builtin_vectorization_cost (kind, vectype,
1058                                                           misalign);
1059       /* Statements in an inner loop relative to the loop being
1060          vectorized are weighted more heavily.  The value here is
1061          arbitrary and could potentially be improved with analysis.  */
1062       if (where == vect_body && stmt_info && stmt_in_inner_loop_p (stmt_info))
1063         count *= 50;  /* FIXME.  */
1064
1065       retval = (unsigned) (count * stmt_cost);
1066       cost[where] += retval;
1067     }
1068
1069   return retval;
1070 }
1071
1072 /* By default, the cost model just returns the accumulated costs.  */
1073
1074 void
1075 default_finish_cost (void *data, unsigned *prologue_cost,
1076                      unsigned *body_cost, unsigned *epilogue_cost)
1077 {
1078   unsigned *cost = (unsigned *) data;
1079   *prologue_cost = cost[vect_prologue];
1080   *body_cost     = cost[vect_body];
1081   *epilogue_cost = cost[vect_epilogue];
1082 }
1083
1084 /* Free the cost data.  */
1085
1086 void
1087 default_destroy_cost_data (void *data)
1088 {
1089   free (data);
1090 }
1091
1092 /* Determine whether or not a pointer mode is valid. Assume defaults
1093    of ptr_mode or Pmode - can be overridden.  */
1094 bool
1095 default_valid_pointer_mode (enum machine_mode mode)
1096 {
1097   return (mode == ptr_mode || mode == Pmode);
1098 }
1099
1100 /* Determine whether the memory reference specified by REF may alias
1101    the C libraries errno location.  */
1102 bool
1103 default_ref_may_alias_errno (ao_ref *ref)
1104 {
1105   tree base = ao_ref_base (ref);
1106   /* The default implementation assumes the errno location is
1107      a declaration of type int or is always accessed via a
1108      pointer to int.  We assume that accesses to errno are
1109      not deliberately obfuscated (even in conforming ways).  */
1110   if (TYPE_UNSIGNED (TREE_TYPE (base))
1111       || TYPE_MODE (TREE_TYPE (base)) != TYPE_MODE (integer_type_node))
1112     return false;
1113   /* The default implementation assumes an errno location
1114      declaration is never defined in the current compilation unit.  */
1115   if (DECL_P (base)
1116       && !TREE_STATIC (base))
1117     return true;
1118   else if (TREE_CODE (base) == MEM_REF
1119            && TREE_CODE (TREE_OPERAND (base, 0)) == SSA_NAME)
1120     {
1121       struct ptr_info_def *pi = SSA_NAME_PTR_INFO (TREE_OPERAND (base, 0));
1122       return !pi || pi->pt.anything || pi->pt.nonlocal;
1123     }
1124   return false;
1125 }
1126
1127 /* Return the mode for a pointer to a given ADDRSPACE, defaulting to ptr_mode
1128    for the generic address space only.  */
1129
1130 enum machine_mode
1131 default_addr_space_pointer_mode (addr_space_t addrspace ATTRIBUTE_UNUSED)
1132 {
1133   gcc_assert (ADDR_SPACE_GENERIC_P (addrspace));
1134   return ptr_mode;
1135 }
1136
1137 /* Return the mode for an address in a given ADDRSPACE, defaulting to Pmode
1138    for the generic address space only.  */
1139
1140 enum machine_mode
1141 default_addr_space_address_mode (addr_space_t addrspace ATTRIBUTE_UNUSED)
1142 {
1143   gcc_assert (ADDR_SPACE_GENERIC_P (addrspace));
1144   return Pmode;
1145 }
1146
1147 /* Named address space version of valid_pointer_mode.  */
1148
1149 bool
1150 default_addr_space_valid_pointer_mode (enum machine_mode mode, addr_space_t as)
1151 {
1152   if (!ADDR_SPACE_GENERIC_P (as))
1153     return (mode == targetm.addr_space.pointer_mode (as)
1154             || mode == targetm.addr_space.address_mode (as));
1155
1156   return targetm.valid_pointer_mode (mode);
1157 }
1158
1159 /* Some places still assume that all pointer or address modes are the
1160    standard Pmode and ptr_mode.  These optimizations become invalid if
1161    the target actually supports multiple different modes.  For now,
1162    we disable such optimizations on such targets, using this function.  */
1163
1164 bool
1165 target_default_pointer_address_modes_p (void)
1166 {
1167   if (targetm.addr_space.address_mode != default_addr_space_address_mode)
1168     return false;
1169   if (targetm.addr_space.pointer_mode != default_addr_space_pointer_mode)
1170     return false;
1171
1172   return true;
1173 }
1174
1175 /* Named address space version of legitimate_address_p.  */
1176
1177 bool
1178 default_addr_space_legitimate_address_p (enum machine_mode mode, rtx mem,
1179                                          bool strict, addr_space_t as)
1180 {
1181   if (!ADDR_SPACE_GENERIC_P (as))
1182     gcc_unreachable ();
1183
1184   return targetm.legitimate_address_p (mode, mem, strict);
1185 }
1186
1187 /* Named address space version of LEGITIMIZE_ADDRESS.  */
1188
1189 rtx
1190 default_addr_space_legitimize_address (rtx x, rtx oldx,
1191                                        enum machine_mode mode, addr_space_t as)
1192 {
1193   if (!ADDR_SPACE_GENERIC_P (as))
1194     return x;
1195
1196   return targetm.legitimize_address (x, oldx, mode);
1197 }
1198
1199 /* The default hook for determining if one named address space is a subset of
1200    another and to return which address space to use as the common address
1201    space.  */
1202
1203 bool
1204 default_addr_space_subset_p (addr_space_t subset, addr_space_t superset)
1205 {
1206   return (subset == superset);
1207 }
1208
1209 /* The default hook for TARGET_ADDR_SPACE_CONVERT. This hook should never be
1210    called for targets with only a generic address space.  */
1211
1212 rtx
1213 default_addr_space_convert (rtx op ATTRIBUTE_UNUSED,
1214                             tree from_type ATTRIBUTE_UNUSED,
1215                             tree to_type ATTRIBUTE_UNUSED)
1216 {
1217   gcc_unreachable ();
1218 }
1219
1220 bool
1221 default_hard_regno_scratch_ok (unsigned int regno ATTRIBUTE_UNUSED)
1222 {
1223   return true;
1224 }
1225
1226 /* The default implementation of TARGET_MODE_DEPENDENT_ADDRESS_P.  */
1227
1228 bool
1229 default_mode_dependent_address_p (const_rtx addr ATTRIBUTE_UNUSED,
1230                                   addr_space_t addrspace ATTRIBUTE_UNUSED)
1231 {
1232   return false;
1233 }
1234
1235 bool
1236 default_target_option_valid_attribute_p (tree ARG_UNUSED (fndecl),
1237                                          tree ARG_UNUSED (name),
1238                                          tree ARG_UNUSED (args),
1239                                          int ARG_UNUSED (flags))
1240 {
1241   warning (OPT_Wattributes,
1242            "target attribute is not supported on this machine");
1243
1244   return false;
1245 }
1246
1247 bool
1248 default_target_option_pragma_parse (tree ARG_UNUSED (args),
1249                                     tree ARG_UNUSED (pop_target))
1250 {
1251   warning (OPT_Wpragmas,
1252            "#pragma GCC target is not supported for this machine");
1253
1254   return false;
1255 }
1256
1257 bool
1258 default_target_can_inline_p (tree caller, tree callee)
1259 {
1260   bool ret = false;
1261   tree callee_opts = DECL_FUNCTION_SPECIFIC_TARGET (callee);
1262   tree caller_opts = DECL_FUNCTION_SPECIFIC_TARGET (caller);
1263
1264   /* If callee has no option attributes, then it is ok to inline */
1265   if (!callee_opts)
1266     ret = true;
1267
1268   /* If caller has no option attributes, but callee does then it is not ok to
1269      inline */
1270   else if (!caller_opts)
1271     ret = false;
1272
1273   /* If both caller and callee have attributes, assume that if the
1274      pointer is different, the two functions have different target
1275      options since build_target_option_node uses a hash table for the
1276      options.  */
1277   else
1278     ret = (callee_opts == caller_opts);
1279
1280   return ret;
1281 }
1282
1283 #ifndef HAVE_casesi
1284 # define HAVE_casesi 0
1285 #endif
1286
1287 /* If the machine does not have a case insn that compares the bounds,
1288    this means extra overhead for dispatch tables, which raises the
1289    threshold for using them.  */
1290
1291 unsigned int
1292 default_case_values_threshold (void)
1293 {
1294   return (HAVE_casesi ? 4 : 5);
1295 }
1296
1297 bool
1298 default_have_conditional_execution (void)
1299 {
1300 #ifdef HAVE_conditional_execution
1301   return HAVE_conditional_execution;
1302 #else
1303   return false;
1304 #endif
1305 }
1306
1307 tree
1308 default_builtin_tm_load_store (tree ARG_UNUSED (type))
1309 {
1310   return NULL_TREE;
1311 }
1312
1313 /* Compute cost of moving registers to/from memory.  */
1314
1315 int
1316 default_memory_move_cost (enum machine_mode mode ATTRIBUTE_UNUSED,
1317                           reg_class_t rclass ATTRIBUTE_UNUSED,
1318                           bool in ATTRIBUTE_UNUSED)
1319 {
1320 #ifndef MEMORY_MOVE_COST
1321     return (4 + memory_move_secondary_cost (mode, (enum reg_class) rclass, in));
1322 #else
1323     return MEMORY_MOVE_COST (mode, (enum reg_class) rclass, in);
1324 #endif
1325 }
1326
1327 /* Compute cost of moving data from a register of class FROM to one of
1328    TO, using MODE.  */
1329
1330 int
1331 default_register_move_cost (enum machine_mode mode ATTRIBUTE_UNUSED,
1332                             reg_class_t from ATTRIBUTE_UNUSED,
1333                             reg_class_t to ATTRIBUTE_UNUSED)
1334 {
1335 #ifndef REGISTER_MOVE_COST
1336   return 2;
1337 #else
1338   return REGISTER_MOVE_COST (mode, (enum reg_class) from, (enum reg_class) to);
1339 #endif
1340 }
1341
1342 bool
1343 default_profile_before_prologue (void)
1344 {
1345 #ifdef PROFILE_BEFORE_PROLOGUE
1346   return true;
1347 #else
1348   return false;
1349 #endif
1350 }
1351
1352 /* The default implementation of TARGET_PREFERRED_RELOAD_CLASS.  */
1353
1354 reg_class_t
1355 default_preferred_reload_class (rtx x ATTRIBUTE_UNUSED,
1356                                 reg_class_t rclass)
1357 {
1358 #ifdef PREFERRED_RELOAD_CLASS
1359   return (reg_class_t) PREFERRED_RELOAD_CLASS (x, (enum reg_class) rclass);
1360 #else
1361   return rclass;
1362 #endif
1363 }
1364
1365 /* The default implementation of TARGET_OUTPUT_PREFERRED_RELOAD_CLASS.  */
1366
1367 reg_class_t
1368 default_preferred_output_reload_class (rtx x ATTRIBUTE_UNUSED,
1369                                        reg_class_t rclass)
1370 {
1371   return rclass;
1372 }
1373
1374 /* The default implementation of TARGET_PREFERRED_RENAME_CLASS.  */
1375 reg_class_t
1376 default_preferred_rename_class (reg_class_t rclass ATTRIBUTE_UNUSED)
1377 {
1378   return NO_REGS;
1379 }
1380
1381 /* The default implementation of TARGET_CLASS_LIKELY_SPILLED_P.  */
1382
1383 bool
1384 default_class_likely_spilled_p (reg_class_t rclass)
1385 {
1386   return (reg_class_size[(int) rclass] == 1);
1387 }
1388
1389 /* The default implementation of TARGET_CLASS_MAX_NREGS.  */
1390
1391 unsigned char
1392 default_class_max_nregs (reg_class_t rclass ATTRIBUTE_UNUSED,
1393                          enum machine_mode mode ATTRIBUTE_UNUSED)
1394 {
1395 #ifdef CLASS_MAX_NREGS
1396   return (unsigned char) CLASS_MAX_NREGS ((enum reg_class) rclass, mode);
1397 #else
1398   return ((GET_MODE_SIZE (mode) + UNITS_PER_WORD - 1) / UNITS_PER_WORD);
1399 #endif
1400 }
1401
1402 /* Determine the debugging unwind mechanism for the target.  */
1403
1404 enum unwind_info_type
1405 default_debug_unwind_info (void)
1406 {
1407   /* If the target wants to force the use of dwarf2 unwind info, let it.  */
1408   /* ??? Change all users to the hook, then poison this.  */
1409 #ifdef DWARF2_FRAME_INFO
1410   if (DWARF2_FRAME_INFO)
1411     return UI_DWARF2;
1412 #endif
1413
1414   /* Otherwise, only turn it on if dwarf2 debugging is enabled.  */
1415 #ifdef DWARF2_DEBUGGING_INFO
1416   if (write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
1417     return UI_DWARF2;
1418 #endif
1419
1420   return UI_NONE;
1421 }
1422
1423 /* To be used by targets where reg_raw_mode doesn't return the right
1424    mode for registers used in apply_builtin_return and apply_builtin_arg.  */
1425
1426 enum machine_mode
1427 default_get_reg_raw_mode(int regno)
1428 {
1429   return reg_raw_mode[regno];
1430 }
1431
1432 /* Return true if the state of option OPTION should be stored in PCH files
1433    and checked by default_pch_valid_p.  Store the option's current state
1434    in STATE if so.  */
1435
1436 static inline bool
1437 option_affects_pch_p (int option, struct cl_option_state *state)
1438 {
1439   if ((cl_options[option].flags & CL_TARGET) == 0)
1440     return false;
1441   if (option_flag_var (option, &global_options) == &target_flags)
1442     if (targetm.check_pch_target_flags)
1443       return false;
1444   return get_option_state (&global_options, option, state);
1445 }
1446
1447 /* Default version of get_pch_validity.
1448    By default, every flag difference is fatal; that will be mostly right for
1449    most targets, but completely right for very few.  */
1450
1451 void *
1452 default_get_pch_validity (size_t *sz)
1453 {
1454   struct cl_option_state state;
1455   size_t i;
1456   char *result, *r;
1457
1458   *sz = 2;
1459   if (targetm.check_pch_target_flags)
1460     *sz += sizeof (target_flags);
1461   for (i = 0; i < cl_options_count; i++)
1462     if (option_affects_pch_p (i, &state))
1463       *sz += state.size;
1464
1465   result = r = XNEWVEC (char, *sz);
1466   r[0] = flag_pic;
1467   r[1] = flag_pie;
1468   r += 2;
1469   if (targetm.check_pch_target_flags)
1470     {
1471       memcpy (r, &target_flags, sizeof (target_flags));
1472       r += sizeof (target_flags);
1473     }
1474
1475   for (i = 0; i < cl_options_count; i++)
1476     if (option_affects_pch_p (i, &state))
1477       {
1478         memcpy (r, state.data, state.size);
1479         r += state.size;
1480       }
1481
1482   return result;
1483 }
1484
1485 /* Return a message which says that a PCH file was created with a different
1486    setting of OPTION.  */
1487
1488 static const char *
1489 pch_option_mismatch (const char *option)
1490 {
1491   char *r;
1492
1493   asprintf (&r, _("created and used with differing settings of '%s'"), option);
1494   if (r == NULL)
1495     return _("out of memory");
1496   return r;
1497 }
1498
1499 /* Default version of pch_valid_p.  */
1500
1501 const char *
1502 default_pch_valid_p (const void *data_p, size_t len)
1503 {
1504   struct cl_option_state state;
1505   const char *data = (const char *)data_p;
1506   size_t i;
1507
1508   /* -fpic and -fpie also usually make a PCH invalid.  */
1509   if (data[0] != flag_pic)
1510     return _("created and used with different settings of -fpic");
1511   if (data[1] != flag_pie)
1512     return _("created and used with different settings of -fpie");
1513   data += 2;
1514
1515   /* Check target_flags.  */
1516   if (targetm.check_pch_target_flags)
1517     {
1518       int tf;
1519       const char *r;
1520
1521       memcpy (&tf, data, sizeof (target_flags));
1522       data += sizeof (target_flags);
1523       len -= sizeof (target_flags);
1524       r = targetm.check_pch_target_flags (tf);
1525       if (r != NULL)
1526         return r;
1527     }
1528
1529   for (i = 0; i < cl_options_count; i++)
1530     if (option_affects_pch_p (i, &state))
1531       {
1532         if (memcmp (data, state.data, state.size) != 0)
1533           return pch_option_mismatch (cl_options[i].opt_text);
1534         data += state.size;
1535         len -= state.size;
1536       }
1537
1538   return NULL;
1539 }
1540
1541 /* Default version of cstore_mode.  */
1542
1543 enum machine_mode
1544 default_cstore_mode (enum insn_code icode)
1545 {
1546   return insn_data[(int) icode].operand[0].mode;
1547 }
1548
1549 /* Default version of member_type_forces_blk.  */
1550
1551 bool
1552 default_member_type_forces_blk (const_tree, enum machine_mode)
1553 {
1554   return false;
1555 }
1556
1557 /* Default version of canonicalize_comparison.  */
1558
1559 void
1560 default_canonicalize_comparison (int *, rtx *, rtx *, bool)
1561 {
1562 }
1563
1564 #include "gt-targhooks.h"