gcc/targhooks.c

   1 /* Default target hook functions.
   2    Copyright (C) 2003-2017 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 "target.h"
  53 #include "function.h"
  54 #include "rtl.h"
  55 #include "tree.h"
  56 #include "tree-ssa-alias.h"
  57 #include "gimple-expr.h"
  58 #include "memmodel.h"
  59 #include "tm_p.h"
  60 #include "stringpool.h"
  61 #include "tree-vrp.h"
  62 #include "tree-ssanames.h"
  63 #include "optabs.h"
  64 #include "regs.h"
  65 #include "recog.h"
  66 #include "diagnostic-core.h"
  67 #include "fold-const.h"
  68 #include "stor-layout.h"
  69 #include "varasm.h"
  70 #include "flags.h"
  71 #include "explow.h"
  72 #include "calls.h"
  73 #include "expr.h"
  74 #include "output.h"
  75 #include "reload.h"
  76 #include "intl.h"
  77 #include "opts.h"
  78 #include "gimplify.h"
  79 #include "predict.h"
  80 #include "params.h"
  81 #include "real.h"
  82
  83
  84 bool
  85 default_legitimate_address_p (machine_mode mode ATTRIBUTE_UNUSED,
  86                               rtx addr ATTRIBUTE_UNUSED,
  87                               bool strict ATTRIBUTE_UNUSED)
  88 {
  89 #ifdef GO_IF_LEGITIMATE_ADDRESS
  90   /* Defer to the old implementation using a goto.  */
  91   if (strict)
  92     return strict_memory_address_p (mode, addr);
  93   else
  94     return memory_address_p (mode, addr);
  95 #else
  96   gcc_unreachable ();
  97 #endif
  98 }
  99
 100 void
 101 default_external_libcall (rtx fun ATTRIBUTE_UNUSED)
 102 {
 103 #ifdef ASM_OUTPUT_EXTERNAL_LIBCALL
 104   ASM_OUTPUT_EXTERNAL_LIBCALL (asm_out_file, fun);
 105 #endif
 106 }
 107
 108 int
 109 default_unspec_may_trap_p (const_rtx x, unsigned flags)
 110 {
 111   int i;
 112
 113   /* Any floating arithmetic may trap.  */
 114   if ((SCALAR_FLOAT_MODE_P (GET_MODE (x)) && flag_trapping_math))
 115     return 1;
 116
 117   for (i = 0; i < XVECLEN (x, 0); ++i)
 118     {
 119       if (may_trap_p_1 (XVECEXP (x, 0, i), flags))
 120         return 1;
 121     }
 122
 123   return 0;
 124 }
 125
 126 machine_mode
 127 default_promote_function_mode (const_tree type ATTRIBUTE_UNUSED,
 128                                machine_mode mode,
 129                                int *punsignedp ATTRIBUTE_UNUSED,
 130                                const_tree funtype ATTRIBUTE_UNUSED,
 131                                int for_return ATTRIBUTE_UNUSED)
 132 {
 133   if (type != NULL_TREE && for_return == 2)
 134     return promote_mode (type, mode, punsignedp);
 135   return mode;
 136 }
 137
 138 machine_mode
 139 default_promote_function_mode_always_promote (const_tree type,
 140                                               machine_mode mode,
 141                                               int *punsignedp,
 142                                               const_tree funtype ATTRIBUTE_UNUSED,
 143                                               int for_return ATTRIBUTE_UNUSED)
 144 {
 145   return promote_mode (type, mode, punsignedp);
 146 }
 147
 148 machine_mode
 149 default_cc_modes_compatible (machine_mode m1, machine_mode m2)
 150 {
 151   if (m1 == m2)
 152     return m1;
 153   return VOIDmode;
 154 }
 155
 156 bool
 157 default_return_in_memory (const_tree type,
 158                           const_tree fntype ATTRIBUTE_UNUSED)
 159 {
 160   return (TYPE_MODE (type) == BLKmode);
 161 }
 162
 163 rtx
 164 default_legitimize_address (rtx x, rtx orig_x ATTRIBUTE_UNUSED,
 165                             machine_mode mode ATTRIBUTE_UNUSED)
 166 {
 167   return x;
 168 }
 169
 170 bool
 171 default_legitimize_address_displacement (rtx *disp ATTRIBUTE_UNUSED,
 172                                          rtx *offset ATTRIBUTE_UNUSED,
 173                                          machine_mode mode ATTRIBUTE_UNUSED)
 174 {
 175   return false;
 176 }
 177
 178 rtx
 179 default_expand_builtin_saveregs (void)
 180 {
 181   error ("__builtin_saveregs not supported by this target");
 182   return const0_rtx;
 183 }
 184
 185 void
 186 default_setup_incoming_varargs (cumulative_args_t ca ATTRIBUTE_UNUSED,
 187                                 machine_mode mode ATTRIBUTE_UNUSED,
 188                                 tree type ATTRIBUTE_UNUSED,
 189                                 int *pretend_arg_size ATTRIBUTE_UNUSED,
 190                                 int second_time ATTRIBUTE_UNUSED)
 191 {
 192 }
 193
 194 /* The default implementation of TARGET_BUILTIN_SETJMP_FRAME_VALUE.  */
 195
 196 rtx
 197 default_builtin_setjmp_frame_value (void)
 198 {
 199   return virtual_stack_vars_rtx;
 200 }
 201
 202 /* Generic hook that takes a CUMULATIVE_ARGS pointer and returns false.  */
 203
 204 bool
 205 hook_bool_CUMULATIVE_ARGS_false (cumulative_args_t ca ATTRIBUTE_UNUSED)
 206 {
 207   return false;
 208 }
 209
 210 bool
 211 default_pretend_outgoing_varargs_named (cumulative_args_t ca ATTRIBUTE_UNUSED)
 212 {
 213   return (targetm.calls.setup_incoming_varargs
 214           != default_setup_incoming_varargs);
 215 }
 216
 217 machine_mode
 218 default_eh_return_filter_mode (void)
 219 {
 220   return targetm.unwind_word_mode ();
 221 }
 222
 223 machine_mode
 224 default_libgcc_cmp_return_mode (void)
 225 {
 226   return word_mode;
 227 }
 228
 229 machine_mode
 230 default_libgcc_shift_count_mode (void)
 231 {
 232   return word_mode;
 233 }
 234
 235 machine_mode
 236 default_unwind_word_mode (void)
 237 {
 238   return word_mode;
 239 }
 240
 241 /* The default implementation of TARGET_SHIFT_TRUNCATION_MASK.  */
 242
 243 unsigned HOST_WIDE_INT
 244 default_shift_truncation_mask (machine_mode mode)
 245 {
 246   return SHIFT_COUNT_TRUNCATED ? GET_MODE_BITSIZE (mode) - 1 : 0;
 247 }
 248
 249 /* The default implementation of TARGET_MIN_DIVISIONS_FOR_RECIP_MUL.  */
 250
 251 unsigned int
 252 default_min_divisions_for_recip_mul (machine_mode mode ATTRIBUTE_UNUSED)
 253 {
 254   return have_insn_for (DIV, mode) ? 3 : 2;
 255 }
 256
 257 /* The default implementation of TARGET_MODE_REP_EXTENDED.  */
 258
 259 int
 260 default_mode_rep_extended (machine_mode mode ATTRIBUTE_UNUSED,
 261                            machine_mode mode_rep ATTRIBUTE_UNUSED)
 262 {
 263   return UNKNOWN;
 264 }
 265
 266 /* Generic hook that takes a CUMULATIVE_ARGS pointer and returns true.  */
 267
 268 bool
 269 hook_bool_CUMULATIVE_ARGS_true (cumulative_args_t a ATTRIBUTE_UNUSED)
 270 {
 271   return true;
 272 }
 273
 274 /* Return machine mode for non-standard suffix
 275    or VOIDmode if non-standard suffixes are unsupported.  */
 276 machine_mode
 277 default_mode_for_suffix (char suffix ATTRIBUTE_UNUSED)
 278 {
 279   return VOIDmode;
 280 }
 281
 282 /* The generic C++ ABI specifies this is a 64-bit value.  */
 283 tree
 284 default_cxx_guard_type (void)
 285 {
 286   return long_long_integer_type_node;
 287 }
 288
 289 /* Returns the size of the cookie to use when allocating an array
 290    whose elements have the indicated TYPE.  Assumes that it is already
 291    known that a cookie is needed.  */
 292
 293 tree
 294 default_cxx_get_cookie_size (tree type)
 295 {
 296   tree cookie_size;
 297
 298   /* We need to allocate an additional max (sizeof (size_t), alignof
 299      (true_type)) bytes.  */
 300   tree sizetype_size;
 301   tree type_align;
 302
 303   sizetype_size = size_in_bytes (sizetype);
 304   type_align = size_int (TYPE_ALIGN_UNIT (type));
 305   if (tree_int_cst_lt (type_align, sizetype_size))
 306     cookie_size = sizetype_size;
 307   else
 308     cookie_size = type_align;
 309
 310   return cookie_size;
 311 }
 312
 313 /* Return true if a parameter must be passed by reference.  This version
 314    of the TARGET_PASS_BY_REFERENCE hook uses just MUST_PASS_IN_STACK.  */
 315
 316 bool
 317 hook_pass_by_reference_must_pass_in_stack (cumulative_args_t c ATTRIBUTE_UNUSED,
 318         machine_mode mode ATTRIBUTE_UNUSED, const_tree type ATTRIBUTE_UNUSED,
 319         bool named_arg ATTRIBUTE_UNUSED)
 320 {
 321   return targetm.calls.must_pass_in_stack (mode, type);
 322 }
 323
 324 /* Return true if a parameter follows callee copies conventions.  This
 325    version of the hook is true for all named arguments.  */
 326
 327 bool
 328 hook_callee_copies_named (cumulative_args_t ca ATTRIBUTE_UNUSED,
 329                           machine_mode mode ATTRIBUTE_UNUSED,
 330                           const_tree type ATTRIBUTE_UNUSED, bool named)
 331 {
 332   return named;
 333 }
 334
 335 /* Emit to STREAM the assembler syntax for insn operand X.  */
 336
 337 void
 338 default_print_operand (FILE *stream ATTRIBUTE_UNUSED, rtx x ATTRIBUTE_UNUSED,
 339                        int code ATTRIBUTE_UNUSED)
 340 {
 341 #ifdef PRINT_OPERAND
 342   PRINT_OPERAND (stream, x, code);
 343 #else
 344   gcc_unreachable ();
 345 #endif
 346 }
 347
 348 /* Emit to STREAM the assembler syntax for an insn operand whose memory
 349    address is X.  */
 350
 351 void
 352 default_print_operand_address (FILE *stream ATTRIBUTE_UNUSED,
 353                                machine_mode /*mode*/,
 354                                rtx x ATTRIBUTE_UNUSED)
 355 {
 356 #ifdef PRINT_OPERAND_ADDRESS
 357   PRINT_OPERAND_ADDRESS (stream, x);
 358 #else
 359   gcc_unreachable ();
 360 #endif
 361 }
 362
 363 /* Return true if CODE is a valid punctuation character for the
 364    `print_operand' hook.  */
 365
 366 bool
 367 default_print_operand_punct_valid_p (unsigned char code ATTRIBUTE_UNUSED)
 368 {
 369 #ifdef PRINT_OPERAND_PUNCT_VALID_P
 370   return PRINT_OPERAND_PUNCT_VALID_P (code);
 371 #else
 372   return false;
 373 #endif
 374 }
 375
 376 /* The default implementation of TARGET_MANGLE_ASSEMBLER_NAME.  */
 377 tree
 378 default_mangle_assembler_name (const char *name ATTRIBUTE_UNUSED)
 379 {
 380   const char *skipped = name + (*name == '*' ? 1 : 0);
 381   const char *stripped = targetm.strip_name_encoding (skipped);
 382   if (*name != '*' && user_label_prefix[0])
 383     stripped = ACONCAT ((user_label_prefix, stripped, NULL));
 384   return get_identifier (stripped);
 385 }
 386
 387 /* True if MODE is valid for the target.  By "valid", we mean able to
 388    be manipulated in non-trivial ways.  In particular, this means all
 389    the arithmetic is supported.
 390
 391    By default we guess this means that any C type is supported.  If
 392    we can't map the mode back to a type that would be available in C,
 393    then reject it.  Special case, here, is the double-word arithmetic
 394    supported by optabs.c.  */
 395
 396 bool
 397 default_scalar_mode_supported_p (machine_mode mode)
 398 {
 399   int precision = GET_MODE_PRECISION (mode);
 400
 401   switch (GET_MODE_CLASS (mode))
 402     {
 403     case MODE_PARTIAL_INT:
 404     case MODE_INT:
 405       if (precision == CHAR_TYPE_SIZE)
 406         return true;
 407       if (precision == SHORT_TYPE_SIZE)
 408         return true;
 409       if (precision == INT_TYPE_SIZE)
 410         return true;
 411       if (precision == LONG_TYPE_SIZE)
 412         return true;
 413       if (precision == LONG_LONG_TYPE_SIZE)
 414         return true;
 415       if (precision == 2 * BITS_PER_WORD)
 416         return true;
 417       return false;
 418
 419     case MODE_FLOAT:
 420       if (precision == FLOAT_TYPE_SIZE)
 421         return true;
 422       if (precision == DOUBLE_TYPE_SIZE)
 423         return true;
 424       if (precision == LONG_DOUBLE_TYPE_SIZE)
 425         return true;
 426       return false;
 427
 428     case MODE_DECIMAL_FLOAT:
 429     case MODE_FRACT:
 430     case MODE_UFRACT:
 431     case MODE_ACCUM:
 432     case MODE_UACCUM:
 433       return false;
 434
 435     default:
 436       gcc_unreachable ();
 437     }
 438 }
 439
 440 /* Return true if libgcc supports floating-point mode MODE (known to
 441    be supported as a scalar mode).  */
 442
 443 bool
 444 default_libgcc_floating_mode_supported_p (machine_mode mode)
 445 {
 446   switch (mode)
 447     {
 448 #ifdef HAVE_SFmode
 449     case SFmode:
 450 #endif
 451 #ifdef HAVE_DFmode
 452     case DFmode:
 453 #endif
 454 #ifdef HAVE_XFmode
 455     case XFmode:
 456 #endif
 457 #ifdef HAVE_TFmode
 458     case TFmode:
 459 #endif
 460       return true;
 461
 462     default:
 463       return false;
 464     }
 465 }
 466
 467 /* Return the machine mode to use for the type _FloatN, if EXTENDED is
 468    false, or _FloatNx, if EXTENDED is true, or VOIDmode if not
 469    supported.  */
 470 machine_mode
 471 default_floatn_mode (int n, bool extended)
 472 {
 473   if (extended)
 474     {
 475       machine_mode cand1 = VOIDmode, cand2 = VOIDmode;
 476       switch (n)
 477         {
 478         case 32:
 479 #ifdef HAVE_DFmode
 480           cand1 = DFmode;
 481 #endif
 482           break;
 483
 484         case 64:
 485 #ifdef HAVE_XFmode
 486           cand1 = XFmode;
 487 #endif
 488 #ifdef HAVE_TFmode
 489           cand2 = TFmode;
 490 #endif
 491           break;
 492
 493         case 128:
 494           break;
 495
 496         default:
 497           /* Those are the only valid _FloatNx types.  */
 498           gcc_unreachable ();
 499         }
 500       if (cand1 != VOIDmode
 501           && REAL_MODE_FORMAT (cand1)->ieee_bits > n
 502           && targetm.scalar_mode_supported_p (cand1)
 503           && targetm.libgcc_floating_mode_supported_p (cand1))
 504         return cand1;
 505       if (cand2 != VOIDmode
 506           && REAL_MODE_FORMAT (cand2)->ieee_bits > n
 507           && targetm.scalar_mode_supported_p (cand2)
 508           && targetm.libgcc_floating_mode_supported_p (cand2))
 509         return cand2;
 510     }
 511   else
 512     {
 513       machine_mode cand = VOIDmode;
 514       switch (n)
 515         {
 516         case 16:
 517           /* Always enable _Float16 if we have basic support for the mode.
 518              Targets can control the range and precision of operations on
 519              the _Float16 type using TARGET_C_EXCESS_PRECISION.  */
 520 #ifdef HAVE_HFmode
 521           cand = HFmode;
 522 #endif
 523           break;
 524
 525         case 32:
 526 #ifdef HAVE_SFmode
 527           cand = SFmode;
 528 #endif
 529           break;
 530
 531         case 64:
 532 #ifdef HAVE_DFmode
 533           cand = DFmode;
 534 #endif
 535           break;
 536
 537         case 128:
 538 #ifdef HAVE_TFmode
 539           cand = TFmode;
 540 #endif
 541           break;
 542
 543         default:
 544           break;
 545         }
 546       if (cand != VOIDmode
 547           && REAL_MODE_FORMAT (cand)->ieee_bits == n
 548           && targetm.scalar_mode_supported_p (cand)
 549           && targetm.libgcc_floating_mode_supported_p (cand))
 550         return cand;
 551     }
 552   return VOIDmode;
 553 }
 554
 555 /* Make some target macros useable by target-independent code.  */
 556 bool
 557 targhook_words_big_endian (void)
 558 {
 559   return !!WORDS_BIG_ENDIAN;
 560 }
 561
 562 bool
 563 targhook_float_words_big_endian (void)
 564 {
 565   return !!FLOAT_WORDS_BIG_ENDIAN;
 566 }
 567
 568 /* True if the target supports floating-point exceptions and rounding
 569    modes.  */
 570
 571 bool
 572 default_float_exceptions_rounding_supported_p (void)
 573 {
 574 #ifdef HAVE_adddf3
 575   return HAVE_adddf3;
 576 #else
 577   return false;
 578 #endif
 579 }
 580
 581 /* True if the target supports decimal floating point.  */
 582
 583 bool
 584 default_decimal_float_supported_p (void)
 585 {
 586   return ENABLE_DECIMAL_FLOAT;
 587 }
 588
 589 /* True if the target supports fixed-point arithmetic.  */
 590
 591 bool
 592 default_fixed_point_supported_p (void)
 593 {
 594   return ENABLE_FIXED_POINT;
 595 }
 596
 597 /* True if the target supports GNU indirect functions.  */
 598
 599 bool
 600 default_has_ifunc_p (void)
 601 {
 602   return HAVE_GNU_INDIRECT_FUNCTION;
 603 }
 604
 605 /* NULL if INSN insn is valid within a low-overhead loop, otherwise returns
 606    an error message.
 607
 608    This function checks whether a given INSN is valid within a low-overhead
 609    loop.  If INSN is invalid it returns the reason for that, otherwise it
 610    returns NULL. A called function may clobber any special registers required
 611    for low-overhead looping. Additionally, some targets (eg, PPC) use the count
 612    register for branch on table instructions. We reject the doloop pattern in
 613    these cases.  */
 614
 615 const char *
 616 default_invalid_within_doloop (const rtx_insn *insn)
 617 {
 618   if (CALL_P (insn))
 619     return "Function call in loop.";
 620
 621   if (tablejump_p (insn, NULL, NULL) || computed_jump_p (insn))
 622     return "Computed branch in the loop.";
 623
 624   return NULL;
 625 }
 626
 627 /* Mapping of builtin functions to vectorized variants.  */
 628
 629 tree
 630 default_builtin_vectorized_function (unsigned int, tree, tree)
 631 {
 632   return NULL_TREE;
 633 }
 634
 635 /* Mapping of target builtin functions to vectorized variants.  */
 636
 637 tree
 638 default_builtin_md_vectorized_function (tree, tree, tree)
 639 {
 640   return NULL_TREE;
 641 }
 642
 643 /* Vectorized conversion.  */
 644
 645 tree
 646 default_builtin_vectorized_conversion (unsigned int code ATTRIBUTE_UNUSED,
 647                                        tree dest_type ATTRIBUTE_UNUSED,
 648                                        tree src_type ATTRIBUTE_UNUSED)
 649 {
 650   return NULL_TREE;
 651 }
 652
 653 /* Default vectorizer cost model values.  */
 654
 655 int
 656 default_builtin_vectorization_cost (enum vect_cost_for_stmt type_of_cost,
 657                                     tree vectype,
 658                                     int misalign ATTRIBUTE_UNUSED)
 659 {
 660   switch (type_of_cost)
 661     {
 662       case scalar_stmt:
 663       case scalar_load:
 664       case scalar_store:
 665       case vector_stmt:
 666       case vector_load:
 667       case vector_store:
 668       case vec_to_scalar:
 669       case scalar_to_vec:
 670       case cond_branch_not_taken:
 671       case vec_perm:
 672       case vec_promote_demote:
 673         return 1;
 674
 675       case unaligned_load:
 676       case unaligned_store:
 677         return 2;
 678
 679       case cond_branch_taken:
 680         return 3;
 681
 682       case vec_construct:
 683         return TYPE_VECTOR_SUBPARTS (vectype) - 1;
 684
 685       default:
 686         gcc_unreachable ();
 687     }
 688 }
 689
 690 /* Reciprocal.  */
 691
 692 tree
 693 default_builtin_reciprocal (tree)
 694 {
 695   return NULL_TREE;
 696 }
 697
 698 bool
 699 hook_bool_CUMULATIVE_ARGS_mode_tree_bool_false (
 700         cumulative_args_t ca ATTRIBUTE_UNUSED,
 701         machine_mode mode ATTRIBUTE_UNUSED,
 702         const_tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED)
 703 {
 704   return false;
 705 }
 706
 707 bool
 708 hook_bool_CUMULATIVE_ARGS_mode_tree_bool_true (
 709         cumulative_args_t ca ATTRIBUTE_UNUSED,
 710         machine_mode mode ATTRIBUTE_UNUSED,
 711         const_tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED)
 712 {
 713   return true;
 714 }
 715
 716 int
 717 hook_int_CUMULATIVE_ARGS_mode_tree_bool_0 (
 718         cumulative_args_t ca ATTRIBUTE_UNUSED,
 719         machine_mode mode ATTRIBUTE_UNUSED,
 720         tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED)
 721 {
 722   return 0;
 723 }
 724
 725 void
 726 default_function_arg_advance (cumulative_args_t ca ATTRIBUTE_UNUSED,
 727                               machine_mode mode ATTRIBUTE_UNUSED,
 728                               const_tree type ATTRIBUTE_UNUSED,
 729                               bool named ATTRIBUTE_UNUSED)
 730 {
 731   gcc_unreachable ();
 732 }
 733
 734 rtx
 735 default_function_arg (cumulative_args_t ca ATTRIBUTE_UNUSED,
 736                       machine_mode mode ATTRIBUTE_UNUSED,
 737                       const_tree type ATTRIBUTE_UNUSED,
 738                       bool named ATTRIBUTE_UNUSED)
 739 {
 740   gcc_unreachable ();
 741 }
 742
 743 rtx
 744 default_function_incoming_arg (cumulative_args_t ca ATTRIBUTE_UNUSED,
 745                                machine_mode mode ATTRIBUTE_UNUSED,
 746                                const_tree type ATTRIBUTE_UNUSED,
 747                                bool named ATTRIBUTE_UNUSED)
 748 {
 749   gcc_unreachable ();
 750 }
 751
 752 unsigned int
 753 default_function_arg_boundary (machine_mode mode ATTRIBUTE_UNUSED,
 754                                const_tree type ATTRIBUTE_UNUSED)
 755 {
 756   return PARM_BOUNDARY;
 757 }
 758
 759 unsigned int
 760 default_function_arg_round_boundary (machine_mode mode ATTRIBUTE_UNUSED,
 761                                      const_tree type ATTRIBUTE_UNUSED)
 762 {
 763   return PARM_BOUNDARY;
 764 }
 765
 766 void
 767 hook_void_bitmap (bitmap regs ATTRIBUTE_UNUSED)
 768 {
 769 }
 770
 771 const char *
 772 hook_invalid_arg_for_unprototyped_fn (
 773         const_tree typelist ATTRIBUTE_UNUSED,
 774         const_tree funcdecl ATTRIBUTE_UNUSED,
 775         const_tree val ATTRIBUTE_UNUSED)
 776 {
 777   return NULL;
 778 }
 779
 780 /* Initialize the stack protection decls.  */
 781
 782 /* Stack protection related decls living in libgcc.  */
 783 static GTY(()) tree stack_chk_guard_decl;
 784
 785 tree
 786 default_stack_protect_guard (void)
 787 {
 788   tree t = stack_chk_guard_decl;
 789
 790   if (t == NULL)
 791     {
 792       rtx x;
 793
 794       t = build_decl (UNKNOWN_LOCATION,
 795                       VAR_DECL, get_identifier ("__stack_chk_guard"),
 796                       ptr_type_node);
 797       TREE_STATIC (t) = 1;
 798       TREE_PUBLIC (t) = 1;
 799       DECL_EXTERNAL (t) = 1;
 800       TREE_USED (t) = 1;
 801       TREE_THIS_VOLATILE (t) = 1;
 802       DECL_ARTIFICIAL (t) = 1;
 803       DECL_IGNORED_P (t) = 1;
 804
 805       /* Do not share RTL as the declaration is visible outside of
 806          current function.  */
 807       x = DECL_RTL (t);
 808       RTX_FLAG (x, used) = 1;
 809
 810       stack_chk_guard_decl = t;
 811     }
 812
 813   return t;
 814 }
 815
 816 static GTY(()) tree stack_chk_fail_decl;
 817
 818 tree
 819 default_external_stack_protect_fail (void)
 820 {
 821   tree t = stack_chk_fail_decl;
 822
 823   if (t == NULL_TREE)
 824     {
 825       t = build_function_type_list (void_type_node, NULL_TREE);
 826       t = build_decl (UNKNOWN_LOCATION,
 827                       FUNCTION_DECL, get_identifier ("__stack_chk_fail"), t);
 828       TREE_STATIC (t) = 1;
 829       TREE_PUBLIC (t) = 1;
 830       DECL_EXTERNAL (t) = 1;
 831       TREE_USED (t) = 1;
 832       TREE_THIS_VOLATILE (t) = 1;
 833       TREE_NOTHROW (t) = 1;
 834       DECL_ARTIFICIAL (t) = 1;
 835       DECL_IGNORED_P (t) = 1;
 836       DECL_VISIBILITY (t) = VISIBILITY_DEFAULT;
 837       DECL_VISIBILITY_SPECIFIED (t) = 1;
 838
 839       stack_chk_fail_decl = t;
 840     }
 841
 842   return build_call_expr (t, 0);
 843 }
 844
 845 tree
 846 default_hidden_stack_protect_fail (void)
 847 {
 848 #ifndef HAVE_GAS_HIDDEN
 849   return default_external_stack_protect_fail ();
 850 #else
 851   tree t = stack_chk_fail_decl;
 852
 853   if (!flag_pic)
 854     return default_external_stack_protect_fail ();
 855
 856   if (t == NULL_TREE)
 857     {
 858       t = build_function_type_list (void_type_node, NULL_TREE);
 859       t = build_decl (UNKNOWN_LOCATION, FUNCTION_DECL,
 860                       get_identifier ("__stack_chk_fail_local"), t);
 861       TREE_STATIC (t) = 1;
 862       TREE_PUBLIC (t) = 1;
 863       DECL_EXTERNAL (t) = 1;
 864       TREE_USED (t) = 1;
 865       TREE_THIS_VOLATILE (t) = 1;
 866       TREE_NOTHROW (t) = 1;
 867       DECL_ARTIFICIAL (t) = 1;
 868       DECL_IGNORED_P (t) = 1;
 869       DECL_VISIBILITY_SPECIFIED (t) = 1;
 870       DECL_VISIBILITY (t) = VISIBILITY_HIDDEN;
 871
 872       stack_chk_fail_decl = t;
 873     }
 874
 875   return build_call_expr (t, 0);
 876 #endif
 877 }
 878
 879 bool
 880 hook_bool_const_rtx_commutative_p (const_rtx x,
 881                                    int outer_code ATTRIBUTE_UNUSED)
 882 {
 883   return COMMUTATIVE_P (x);
 884 }
 885
 886 rtx
 887 default_function_value (const_tree ret_type ATTRIBUTE_UNUSED,
 888                         const_tree fn_decl_or_type,
 889                         bool outgoing ATTRIBUTE_UNUSED)
 890 {
 891   /* The old interface doesn't handle receiving the function type.  */
 892   if (fn_decl_or_type
 893       && !DECL_P (fn_decl_or_type))
 894     fn_decl_or_type = NULL;
 895
 896 #ifdef FUNCTION_VALUE
 897   return FUNCTION_VALUE (ret_type, fn_decl_or_type);
 898 #else
 899   gcc_unreachable ();
 900 #endif
 901 }
 902
 903 rtx
 904 default_libcall_value (machine_mode mode ATTRIBUTE_UNUSED,
 905                        const_rtx fun ATTRIBUTE_UNUSED)
 906 {
 907 #ifdef LIBCALL_VALUE
 908   return LIBCALL_VALUE (mode);
 909 #else
 910   gcc_unreachable ();
 911 #endif
 912 }
 913
 914 /* The default hook for TARGET_FUNCTION_VALUE_REGNO_P.  */
 915
 916 bool
 917 default_function_value_regno_p (const unsigned int regno ATTRIBUTE_UNUSED)
 918 {
 919 #ifdef FUNCTION_VALUE_REGNO_P
 920   return FUNCTION_VALUE_REGNO_P (regno);
 921 #else
 922   gcc_unreachable ();
 923 #endif
 924 }
 925
 926 rtx
 927 default_internal_arg_pointer (void)
 928 {
 929   /* If the reg that the virtual arg pointer will be translated into is
 930      not a fixed reg or is the stack pointer, make a copy of the virtual
 931      arg pointer, and address parms via the copy.  The frame pointer is
 932      considered fixed even though it is not marked as such.  */
 933   if ((ARG_POINTER_REGNUM == STACK_POINTER_REGNUM
 934        || ! (fixed_regs[ARG_POINTER_REGNUM]
 935              || ARG_POINTER_REGNUM == FRAME_POINTER_REGNUM)))
 936     return copy_to_reg (virtual_incoming_args_rtx);
 937   else
 938     return virtual_incoming_args_rtx;
 939 }
 940
 941 rtx
 942 default_static_chain (const_tree ARG_UNUSED (fndecl_or_type), bool incoming_p)
 943 {
 944   if (incoming_p)
 945     {
 946 #ifdef STATIC_CHAIN_INCOMING_REGNUM
 947       return gen_rtx_REG (Pmode, STATIC_CHAIN_INCOMING_REGNUM);
 948 #endif
 949     }
 950
 951 #ifdef STATIC_CHAIN_REGNUM
 952   return gen_rtx_REG (Pmode, STATIC_CHAIN_REGNUM);
 953 #endif
 954
 955   {
 956     static bool issued_error;
 957     if (!issued_error)
 958       {
 959         issued_error = true;
 960         sorry ("nested functions not supported on this target");
 961       }
 962
 963     /* It really doesn't matter what we return here, so long at it
 964        doesn't cause the rest of the compiler to crash.  */
 965     return gen_rtx_MEM (Pmode, stack_pointer_rtx);
 966   }
 967 }
 968
 969 void
 970 default_trampoline_init (rtx ARG_UNUSED (m_tramp), tree ARG_UNUSED (t_func),
 971                          rtx ARG_UNUSED (r_chain))
 972 {
 973   sorry ("nested function trampolines not supported on this target");
 974 }
 975
 976 int
 977 default_return_pops_args (tree fundecl ATTRIBUTE_UNUSED,
 978                           tree funtype ATTRIBUTE_UNUSED,
 979                           int size ATTRIBUTE_UNUSED)
 980 {
 981   return 0;
 982 }
 983
 984 reg_class_t
 985 default_branch_target_register_class (void)
 986 {
 987   return NO_REGS;
 988 }
 989
 990 reg_class_t
 991 default_ira_change_pseudo_allocno_class (int regno ATTRIBUTE_UNUSED,
 992                                          reg_class_t cl,
 993                                          reg_class_t best_cl ATTRIBUTE_UNUSED)
 994 {
 995   return cl;
 996 }
 997
 998 extern bool
 999 default_lra_p (void)
1000 {
1001   return true;
1002 }
1003
1004 int
1005 default_register_priority (int hard_regno ATTRIBUTE_UNUSED)
1006 {
1007   return 0;
1008 }
1009
1010 extern bool
1011 default_register_usage_leveling_p (void)
1012 {
1013   return false;
1014 }
1015
1016 extern bool
1017 default_different_addr_displacement_p (void)
1018 {
1019   return false;
1020 }
1021
1022 reg_class_t
1023 default_secondary_reload (bool in_p ATTRIBUTE_UNUSED, rtx x ATTRIBUTE_UNUSED,
1024                           reg_class_t reload_class_i ATTRIBUTE_UNUSED,
1025                           machine_mode reload_mode ATTRIBUTE_UNUSED,
1026                           secondary_reload_info *sri)
1027 {
1028   enum reg_class rclass = NO_REGS;
1029   enum reg_class reload_class = (enum reg_class) reload_class_i;
1030
1031   if (sri->prev_sri && sri->prev_sri->t_icode != CODE_FOR_nothing)
1032     {
1033       sri->icode = sri->prev_sri->t_icode;
1034       return NO_REGS;
1035     }
1036 #ifdef SECONDARY_INPUT_RELOAD_CLASS
1037   if (in_p)
1038     rclass = SECONDARY_INPUT_RELOAD_CLASS (reload_class, reload_mode, x);
1039 #endif
1040 #ifdef SECONDARY_OUTPUT_RELOAD_CLASS
1041   if (! in_p)
1042     rclass = SECONDARY_OUTPUT_RELOAD_CLASS (reload_class, reload_mode, x);
1043 #endif
1044   if (rclass != NO_REGS)
1045     {
1046       enum insn_code icode
1047         = direct_optab_handler (in_p ? reload_in_optab : reload_out_optab,
1048                                 reload_mode);
1049
1050       if (icode != CODE_FOR_nothing
1051           && !insn_operand_matches (icode, in_p, x))
1052         icode = CODE_FOR_nothing;
1053       else if (icode != CODE_FOR_nothing)
1054         {
1055           const char *insn_constraint, *scratch_constraint;
1056           enum reg_class insn_class, scratch_class;
1057
1058           gcc_assert (insn_data[(int) icode].n_operands == 3);
1059           insn_constraint = insn_data[(int) icode].operand[!in_p].constraint;
1060           if (!*insn_constraint)
1061             insn_class = ALL_REGS;
1062           else
1063             {
1064               if (in_p)
1065                 {
1066                   gcc_assert (*insn_constraint == '=');
1067                   insn_constraint++;
1068                 }
1069               insn_class = (reg_class_for_constraint
1070                             (lookup_constraint (insn_constraint)));
1071               gcc_assert (insn_class != NO_REGS);
1072             }
1073
1074           scratch_constraint = insn_data[(int) icode].operand[2].constraint;
1075           /* The scratch register's constraint must start with "=&",
1076              except for an input reload, where only "=" is necessary,
1077              and where it might be beneficial to re-use registers from
1078              the input.  */
1079           gcc_assert (scratch_constraint[0] == '='
1080                       && (in_p || scratch_constraint[1] == '&'));
1081           scratch_constraint++;
1082           if (*scratch_constraint == '&')
1083             scratch_constraint++;
1084           scratch_class = (reg_class_for_constraint
1085                            (lookup_constraint (scratch_constraint)));
1086
1087           if (reg_class_subset_p (reload_class, insn_class))
1088             {
1089               gcc_assert (scratch_class == rclass);
1090               rclass = NO_REGS;
1091             }
1092           else
1093             rclass = insn_class;
1094
1095         }
1096       if (rclass == NO_REGS)
1097         sri->icode = icode;
1098       else
1099         sri->t_icode = icode;
1100     }
1101   return rclass;
1102 }
1103
1104 /* By default, if flag_pic is true, then neither local nor global relocs
1105    should be placed in readonly memory.  */
1106
1107 int
1108 default_reloc_rw_mask (void)
1109 {
1110   return flag_pic ? 3 : 0;
1111 }
1112
1113 /* By default, do no modification. */
1114 tree default_mangle_decl_assembler_name (tree decl ATTRIBUTE_UNUSED,
1115                                          tree id)
1116 {
1117    return id;
1118 }
1119
1120 /* Default to natural alignment for vector types.  */
1121 HOST_WIDE_INT
1122 default_vector_alignment (const_tree type)
1123 {
1124   HOST_WIDE_INT align = tree_to_shwi (TYPE_SIZE (type));
1125   if (align > MAX_OFILE_ALIGNMENT)
1126     align = MAX_OFILE_ALIGNMENT;
1127   return align;
1128 }
1129
1130 bool
1131 default_builtin_vector_alignment_reachable (const_tree type, bool is_packed)
1132 {
1133   if (is_packed)
1134     return false;
1135
1136   /* Assuming that types whose size is > pointer-size are not guaranteed to be
1137      naturally aligned.  */
1138   if (tree_int_cst_compare (TYPE_SIZE (type), bitsize_int (POINTER_SIZE)) > 0)
1139     return false;
1140
1141   /* Assuming that types whose size is <= pointer-size
1142      are naturally aligned.  */
1143   return true;
1144 }
1145
1146 /* By default, assume that a target supports any factor of misalignment
1147    memory access if it supports movmisalign patten.
1148    is_packed is true if the memory access is defined in a packed struct.  */
1149 bool
1150 default_builtin_support_vector_misalignment (machine_mode mode,
1151                                              const_tree type
1152                                              ATTRIBUTE_UNUSED,
1153                                              int misalignment
1154                                              ATTRIBUTE_UNUSED,
1155                                              bool is_packed
1156                                              ATTRIBUTE_UNUSED)
1157 {
1158   if (optab_handler (movmisalign_optab, mode) != CODE_FOR_nothing)
1159     return true;
1160   return false;
1161 }
1162
1163 /* By default, only attempt to parallelize bitwise operations, and
1164    possibly adds/subtracts using bit-twiddling.  */
1165
1166 machine_mode
1167 default_preferred_simd_mode (machine_mode mode ATTRIBUTE_UNUSED)
1168 {
1169   return word_mode;
1170 }
1171
1172 /* By default only the size derived from the preferred vector mode
1173    is tried.  */
1174
1175 unsigned int
1176 default_autovectorize_vector_sizes (void)
1177 {
1178   return 0;
1179 }
1180
1181 /* By defaults a vector of integers is used as a mask.  */
1182
1183 machine_mode
1184 default_get_mask_mode (unsigned nunits, unsigned vector_size)
1185 {
1186   unsigned elem_size = vector_size / nunits;
1187   machine_mode elem_mode
1188     = smallest_mode_for_size (elem_size * BITS_PER_UNIT, MODE_INT);
1189   machine_mode vector_mode;
1190
1191   gcc_assert (elem_size * nunits == vector_size);
1192
1193   vector_mode = mode_for_vector (elem_mode, nunits);
1194   if (!VECTOR_MODE_P (vector_mode)
1195       || !targetm.vector_mode_supported_p (vector_mode))
1196     vector_mode = BLKmode;
1197
1198   return vector_mode;
1199 }
1200
1201 /* By default, the cost model accumulates three separate costs (prologue,
1202    loop body, and epilogue) for a vectorized loop or block.  So allocate an
1203    array of three unsigned ints, set it to zero, and return its address.  */
1204
1205 void *
1206 default_init_cost (struct loop *loop_info ATTRIBUTE_UNUSED)
1207 {
1208   unsigned *cost = XNEWVEC (unsigned, 3);
1209   cost[vect_prologue] = cost[vect_body] = cost[vect_epilogue] = 0;
1210   return cost;
1211 }
1212
1213 /* By default, the cost model looks up the cost of the given statement
1214    kind and mode, multiplies it by the occurrence count, accumulates
1215    it into the cost specified by WHERE, and returns the cost added.  */
1216
1217 unsigned
1218 default_add_stmt_cost (void *data, int count, enum vect_cost_for_stmt kind,
1219                        struct _stmt_vec_info *stmt_info, int misalign,
1220                        enum vect_cost_model_location where)
1221 {
1222   unsigned *cost = (unsigned *) data;
1223   unsigned retval = 0;
1224
1225   tree vectype = stmt_info ? stmt_vectype (stmt_info) : NULL_TREE;
1226   int stmt_cost = targetm.vectorize.builtin_vectorization_cost (kind, vectype,
1227                                                                 misalign);
1228    /* Statements in an inner loop relative to the loop being
1229       vectorized are weighted more heavily.  The value here is
1230       arbitrary and could potentially be improved with analysis.  */
1231   if (where == vect_body && stmt_info && stmt_in_inner_loop_p (stmt_info))
1232     count *= 50;  /* FIXME.  */
1233
1234   retval = (unsigned) (count * stmt_cost);
1235   cost[where] += retval;
1236
1237   return retval;
1238 }
1239
1240 /* By default, the cost model just returns the accumulated costs.  */
1241
1242 void
1243 default_finish_cost (void *data, unsigned *prologue_cost,
1244                      unsigned *body_cost, unsigned *epilogue_cost)
1245 {
1246   unsigned *cost = (unsigned *) data;
1247   *prologue_cost = cost[vect_prologue];
1248   *body_cost     = cost[vect_body];
1249   *epilogue_cost = cost[vect_epilogue];
1250 }
1251
1252 /* Free the cost data.  */
1253
1254 void
1255 default_destroy_cost_data (void *data)
1256 {
1257   free (data);
1258 }
1259
1260 /* Determine whether or not a pointer mode is valid. Assume defaults
1261    of ptr_mode or Pmode - can be overridden.  */
1262 bool
1263 default_valid_pointer_mode (machine_mode mode)
1264 {
1265   return (mode == ptr_mode || mode == Pmode);
1266 }
1267
1268 /* Determine whether the memory reference specified by REF may alias
1269    the C libraries errno location.  */
1270 bool
1271 default_ref_may_alias_errno (ao_ref *ref)
1272 {
1273   tree base = ao_ref_base (ref);
1274   /* The default implementation assumes the errno location is
1275      a declaration of type int or is always accessed via a
1276      pointer to int.  We assume that accesses to errno are
1277      not deliberately obfuscated (even in conforming ways).  */
1278   if (TYPE_UNSIGNED (TREE_TYPE (base))
1279       || TYPE_MODE (TREE_TYPE (base)) != TYPE_MODE (integer_type_node))
1280     return false;
1281   /* The default implementation assumes an errno location
1282      declaration is never defined in the current compilation unit.  */
1283   if (DECL_P (base)
1284       && !TREE_STATIC (base))
1285     return true;
1286   else if (TREE_CODE (base) == MEM_REF
1287            && TREE_CODE (TREE_OPERAND (base, 0)) == SSA_NAME)
1288     {
1289       struct ptr_info_def *pi = SSA_NAME_PTR_INFO (TREE_OPERAND (base, 0));
1290       return !pi || pi->pt.anything || pi->pt.nonlocal;
1291     }
1292   return false;
1293 }
1294
1295 /* Return the mode for a pointer to a given ADDRSPACE,
1296    defaulting to ptr_mode for all address spaces.  */
1297
1298 machine_mode
1299 default_addr_space_pointer_mode (addr_space_t addrspace ATTRIBUTE_UNUSED)
1300 {
1301   return ptr_mode;
1302 }
1303
1304 /* Return the mode for an address in a given ADDRSPACE,
1305    defaulting to Pmode for all address spaces.  */
1306
1307 machine_mode
1308 default_addr_space_address_mode (addr_space_t addrspace ATTRIBUTE_UNUSED)
1309 {
1310   return Pmode;
1311 }
1312
1313 /* Named address space version of valid_pointer_mode.
1314    To match the above, the same modes apply to all address spaces.  */
1315
1316 bool
1317 default_addr_space_valid_pointer_mode (machine_mode mode,
1318                                        addr_space_t as ATTRIBUTE_UNUSED)
1319 {
1320   return targetm.valid_pointer_mode (mode);
1321 }
1322
1323 /* Some places still assume that all pointer or address modes are the
1324    standard Pmode and ptr_mode.  These optimizations become invalid if
1325    the target actually supports multiple different modes.  For now,
1326    we disable such optimizations on such targets, using this function.  */
1327
1328 bool
1329 target_default_pointer_address_modes_p (void)
1330 {
1331   if (targetm.addr_space.address_mode != default_addr_space_address_mode)
1332     return false;
1333   if (targetm.addr_space.pointer_mode != default_addr_space_pointer_mode)
1334     return false;
1335
1336   return true;
1337 }
1338
1339 /* Named address space version of legitimate_address_p.
1340    By default, all address spaces have the same form.  */
1341
1342 bool
1343 default_addr_space_legitimate_address_p (machine_mode mode, rtx mem,
1344                                          bool strict,
1345                                          addr_space_t as ATTRIBUTE_UNUSED)
1346 {
1347   return targetm.legitimate_address_p (mode, mem, strict);
1348 }
1349
1350 /* Named address space version of LEGITIMIZE_ADDRESS.
1351    By default, all address spaces have the same form.  */
1352
1353 rtx
1354 default_addr_space_legitimize_address (rtx x, rtx oldx, machine_mode mode,
1355                                        addr_space_t as ATTRIBUTE_UNUSED)
1356 {
1357   return targetm.legitimize_address (x, oldx, mode);
1358 }
1359
1360 /* The default hook for determining if one named address space is a subset of
1361    another and to return which address space to use as the common address
1362    space.  */
1363
1364 bool
1365 default_addr_space_subset_p (addr_space_t subset, addr_space_t superset)
1366 {
1367   return (subset == superset);
1368 }
1369
1370 /* The default hook for determining if 0 within a named address
1371    space is a valid address.  */
1372
1373 bool
1374 default_addr_space_zero_address_valid (addr_space_t as ATTRIBUTE_UNUSED)
1375 {
1376   return false;
1377 }
1378
1379 /* The default hook for debugging the address space is to return the
1380    address space number to indicate DW_AT_address_class.  */
1381 int
1382 default_addr_space_debug (addr_space_t as)
1383 {
1384   return as;
1385 }
1386
1387 /* The default hook implementation for TARGET_ADDR_SPACE_DIAGNOSE_USAGE.
1388    Don't complain about any address space.  */
1389
1390 void
1391 default_addr_space_diagnose_usage (addr_space_t, location_t)
1392 {
1393 }
1394
1395
1396 /* The default hook for TARGET_ADDR_SPACE_CONVERT. This hook should never be
1397    called for targets with only a generic address space.  */
1398
1399 rtx
1400 default_addr_space_convert (rtx op ATTRIBUTE_UNUSED,
1401                             tree from_type ATTRIBUTE_UNUSED,
1402                             tree to_type ATTRIBUTE_UNUSED)
1403 {
1404   gcc_unreachable ();
1405 }
1406
1407 bool
1408 default_hard_regno_scratch_ok (unsigned int regno ATTRIBUTE_UNUSED)
1409 {
1410   return true;
1411 }
1412
1413 /* The default implementation of TARGET_MODE_DEPENDENT_ADDRESS_P.  */
1414
1415 bool
1416 default_mode_dependent_address_p (const_rtx addr ATTRIBUTE_UNUSED,
1417                                   addr_space_t addrspace ATTRIBUTE_UNUSED)
1418 {
1419   return false;
1420 }
1421
1422 bool
1423 default_target_option_valid_attribute_p (tree ARG_UNUSED (fndecl),
1424                                          tree ARG_UNUSED (name),
1425                                          tree ARG_UNUSED (args),
1426                                          int ARG_UNUSED (flags))
1427 {
1428   warning (OPT_Wattributes,
1429            "target attribute is not supported on this machine");
1430
1431   return false;
1432 }
1433
1434 bool
1435 default_target_option_pragma_parse (tree ARG_UNUSED (args),
1436                                     tree ARG_UNUSED (pop_target))
1437 {
1438   /* If args is NULL the caller is handle_pragma_pop_options ().  In that case,
1439      emit no warning because "#pragma GCC pop_target" is valid on targets that
1440      do not have the "target" pragma.  */
1441   if (args)
1442     warning (OPT_Wpragmas,
1443              "#pragma GCC target is not supported for this machine");
1444
1445   return false;
1446 }
1447
1448 bool
1449 default_target_can_inline_p (tree caller, tree callee)
1450 {
1451   bool ret = false;
1452   tree callee_opts = DECL_FUNCTION_SPECIFIC_TARGET (callee);
1453   tree caller_opts = DECL_FUNCTION_SPECIFIC_TARGET (caller);
1454
1455   /* If callee has no option attributes, then it is ok to inline */
1456   if (!callee_opts)
1457     ret = true;
1458
1459   /* If caller has no option attributes, but callee does then it is not ok to
1460      inline */
1461   else if (!caller_opts)
1462     ret = false;
1463
1464   /* If both caller and callee have attributes, assume that if the
1465      pointer is different, the two functions have different target
1466      options since build_target_option_node uses a hash table for the
1467      options.  */
1468   else
1469     ret = (callee_opts == caller_opts);
1470
1471   return ret;
1472 }
1473
1474 /* If the machine does not have a case insn that compares the bounds,
1475    this means extra overhead for dispatch tables, which raises the
1476    threshold for using them.  */
1477
1478 unsigned int
1479 default_case_values_threshold (void)
1480 {
1481   return (targetm.have_casesi () ? 4 : 5);
1482 }
1483
1484 bool
1485 default_have_conditional_execution (void)
1486 {
1487   return HAVE_conditional_execution;
1488 }
1489
1490 /* By default we assume that c99 functions are present at the runtime,
1491    but sincos is not.  */
1492 bool
1493 default_libc_has_function (enum function_class fn_class)
1494 {
1495   if (fn_class == function_c94
1496       || fn_class == function_c99_misc
1497       || fn_class == function_c99_math_complex)
1498     return true;
1499
1500   return false;
1501 }
1502
1503 bool
1504 gnu_libc_has_function (enum function_class fn_class ATTRIBUTE_UNUSED)
1505 {
1506   return true;
1507 }
1508
1509 bool
1510 no_c99_libc_has_function (enum function_class fn_class ATTRIBUTE_UNUSED)
1511 {
1512   return false;
1513 }
1514
1515 tree
1516 default_builtin_tm_load_store (tree ARG_UNUSED (type))
1517 {
1518   return NULL_TREE;
1519 }
1520
1521 /* Compute cost of moving registers to/from memory.  */
1522
1523 int
1524 default_memory_move_cost (machine_mode mode ATTRIBUTE_UNUSED,
1525                           reg_class_t rclass ATTRIBUTE_UNUSED,
1526                           bool in ATTRIBUTE_UNUSED)
1527 {
1528 #ifndef MEMORY_MOVE_COST
1529     return (4 + memory_move_secondary_cost (mode, (enum reg_class) rclass, in));
1530 #else
1531     return MEMORY_MOVE_COST (mode, (enum reg_class) rclass, in);
1532 #endif
1533 }
1534
1535 /* Compute cost of moving data from a register of class FROM to one of
1536    TO, using MODE.  */
1537
1538 int
1539 default_register_move_cost (machine_mode mode ATTRIBUTE_UNUSED,
1540                             reg_class_t from ATTRIBUTE_UNUSED,
1541                             reg_class_t to ATTRIBUTE_UNUSED)
1542 {
1543 #ifndef REGISTER_MOVE_COST
1544   return 2;
1545 #else
1546   return REGISTER_MOVE_COST (mode, (enum reg_class) from, (enum reg_class) to);
1547 #endif
1548 }
1549
1550 /* For hooks which use the MOVE_RATIO macro, this gives the legacy default
1551    behavior.  SPEED_P is true if we are compiling for speed.  */
1552
1553 unsigned int
1554 get_move_ratio (bool speed_p ATTRIBUTE_UNUSED)
1555 {
1556   unsigned int move_ratio;
1557 #ifdef MOVE_RATIO
1558   move_ratio = (unsigned int) MOVE_RATIO (speed_p);
1559 #else
1560 #if defined (HAVE_movmemqi) || defined (HAVE_movmemhi) || defined (HAVE_movmemsi) || defined (HAVE_movmemdi) || defined (HAVE_movmemti)
1561   move_ratio = 2;
1562 #else /* No movmem patterns, pick a default.  */
1563   move_ratio = ((speed_p) ? 15 : 3);
1564 #endif
1565 #endif
1566   return move_ratio;
1567 }
1568
1569 /* Return TRUE if the move_by_pieces/set_by_pieces infrastructure should be
1570    used; return FALSE if the movmem/setmem optab should be expanded, or
1571    a call to memcpy emitted.  */
1572
1573 bool
1574 default_use_by_pieces_infrastructure_p (unsigned HOST_WIDE_INT size,
1575                                         unsigned int alignment,
1576                                         enum by_pieces_operation op,
1577                                         bool speed_p)
1578 {
1579   unsigned int max_size = 0;
1580   unsigned int ratio = 0;
1581
1582   switch (op)
1583     {
1584     case CLEAR_BY_PIECES:
1585       max_size = STORE_MAX_PIECES;
1586       ratio = CLEAR_RATIO (speed_p);
1587       break;
1588     case MOVE_BY_PIECES:
1589       max_size = MOVE_MAX_PIECES;
1590       ratio = get_move_ratio (speed_p);
1591       break;
1592     case SET_BY_PIECES:
1593       max_size = STORE_MAX_PIECES;
1594       ratio = SET_RATIO (speed_p);
1595       break;
1596     case STORE_BY_PIECES:
1597       max_size = STORE_MAX_PIECES;
1598       ratio = get_move_ratio (speed_p);
1599       break;
1600     case COMPARE_BY_PIECES:
1601       max_size = COMPARE_MAX_PIECES;
1602       /* Pick a likely default, just as in get_move_ratio.  */
1603       ratio = speed_p ? 15 : 3;
1604       break;
1605     }
1606
1607   return by_pieces_ninsns (size, alignment, max_size + 1, op) < ratio;
1608 }
1609
1610 /* This hook controls code generation for expanding a memcmp operation by
1611    pieces.  Return 1 for the normal pattern of compare/jump after each pair
1612    of loads, or a higher number to reduce the number of branches.  */
1613
1614 int
1615 default_compare_by_pieces_branch_ratio (machine_mode)
1616 {
1617   return 1;
1618 }
1619
1620 bool
1621 default_profile_before_prologue (void)
1622 {
1623 #ifdef PROFILE_BEFORE_PROLOGUE
1624   return true;
1625 #else
1626   return false;
1627 #endif
1628 }
1629
1630 /* The default implementation of TARGET_PREFERRED_RELOAD_CLASS.  */
1631
1632 reg_class_t
1633 default_preferred_reload_class (rtx x ATTRIBUTE_UNUSED,
1634                                 reg_class_t rclass)
1635 {
1636 #ifdef PREFERRED_RELOAD_CLASS
1637   return (reg_class_t) PREFERRED_RELOAD_CLASS (x, (enum reg_class) rclass);
1638 #else
1639   return rclass;
1640 #endif
1641 }
1642
1643 /* The default implementation of TARGET_OUTPUT_PREFERRED_RELOAD_CLASS.  */
1644
1645 reg_class_t
1646 default_preferred_output_reload_class (rtx x ATTRIBUTE_UNUSED,
1647                                        reg_class_t rclass)
1648 {
1649   return rclass;
1650 }
1651
1652 /* The default implementation of TARGET_PREFERRED_RENAME_CLASS.  */
1653 reg_class_t
1654 default_preferred_rename_class (reg_class_t rclass ATTRIBUTE_UNUSED)
1655 {
1656   return NO_REGS;
1657 }
1658
1659 /* The default implementation of TARGET_CLASS_LIKELY_SPILLED_P.  */
1660
1661 bool
1662 default_class_likely_spilled_p (reg_class_t rclass)
1663 {
1664   return (reg_class_size[(int) rclass] == 1);
1665 }
1666
1667 /* The default implementation of TARGET_CLASS_MAX_NREGS.  */
1668
1669 unsigned char
1670 default_class_max_nregs (reg_class_t rclass ATTRIBUTE_UNUSED,
1671                          machine_mode mode ATTRIBUTE_UNUSED)
1672 {
1673 #ifdef CLASS_MAX_NREGS
1674   return (unsigned char) CLASS_MAX_NREGS ((enum reg_class) rclass, mode);
1675 #else
1676   return ((GET_MODE_SIZE (mode) + UNITS_PER_WORD - 1) / UNITS_PER_WORD);
1677 #endif
1678 }
1679
1680 /* Determine the debugging unwind mechanism for the target.  */
1681
1682 enum unwind_info_type
1683 default_debug_unwind_info (void)
1684 {
1685   /* If the target wants to force the use of dwarf2 unwind info, let it.  */
1686   /* ??? Change all users to the hook, then poison this.  */
1687 #ifdef DWARF2_FRAME_INFO
1688   if (DWARF2_FRAME_INFO)
1689     return UI_DWARF2;
1690 #endif
1691
1692   /* Otherwise, only turn it on if dwarf2 debugging is enabled.  */
1693 #ifdef DWARF2_DEBUGGING_INFO
1694   if (write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
1695     return UI_DWARF2;
1696 #endif
1697
1698   return UI_NONE;
1699 }
1700
1701 /* Determine the correct mode for a Dwarf frame register that represents
1702    register REGNO.  */
1703
1704 machine_mode
1705 default_dwarf_frame_reg_mode (int regno)
1706 {
1707   machine_mode save_mode = reg_raw_mode[regno];
1708
1709   if (HARD_REGNO_CALL_PART_CLOBBERED (regno, save_mode))
1710     save_mode = choose_hard_reg_mode (regno, 1, true);
1711   return save_mode;
1712 }
1713
1714 /* To be used by targets where reg_raw_mode doesn't return the right
1715    mode for registers used in apply_builtin_return and apply_builtin_arg.  */
1716
1717 machine_mode
1718 default_get_reg_raw_mode (int regno)
1719 {
1720   return reg_raw_mode[regno];
1721 }
1722
1723 /* Return true if a leaf function should stay leaf even with profiling
1724    enabled.  */
1725
1726 bool
1727 default_keep_leaf_when_profiled ()
1728 {
1729   return false;
1730 }
1731
1732 /* Return true if the state of option OPTION should be stored in PCH files
1733    and checked by default_pch_valid_p.  Store the option's current state
1734    in STATE if so.  */
1735
1736 static inline bool
1737 option_affects_pch_p (int option, struct cl_option_state *state)
1738 {
1739   if ((cl_options[option].flags & CL_TARGET) == 0)
1740     return false;
1741   if ((cl_options[option].flags & CL_PCH_IGNORE) != 0)
1742     return false;
1743   if (option_flag_var (option, &global_options) == &target_flags)
1744     if (targetm.check_pch_target_flags)
1745       return false;
1746   return get_option_state (&global_options, option, state);
1747 }
1748
1749 /* Default version of get_pch_validity.
1750    By default, every flag difference is fatal; that will be mostly right for
1751    most targets, but completely right for very few.  */
1752
1753 void *
1754 default_get_pch_validity (size_t *sz)
1755 {
1756   struct cl_option_state state;
1757   size_t i;
1758   char *result, *r;
1759
1760   *sz = 2;
1761   if (targetm.check_pch_target_flags)
1762     *sz += sizeof (target_flags);
1763   for (i = 0; i < cl_options_count; i++)
1764     if (option_affects_pch_p (i, &state))
1765       *sz += state.size;
1766
1767   result = r = XNEWVEC (char, *sz);
1768   r[0] = flag_pic;
1769   r[1] = flag_pie;
1770   r += 2;
1771   if (targetm.check_pch_target_flags)
1772     {
1773       memcpy (r, &target_flags, sizeof (target_flags));
1774       r += sizeof (target_flags);
1775     }
1776
1777   for (i = 0; i < cl_options_count; i++)
1778     if (option_affects_pch_p (i, &state))
1779       {
1780         memcpy (r, state.data, state.size);
1781         r += state.size;
1782       }
1783
1784   return result;
1785 }
1786
1787 /* Return a message which says that a PCH file was created with a different
1788    setting of OPTION.  */
1789
1790 static const char *
1791 pch_option_mismatch (const char *option)
1792 {
1793   return xasprintf (_("created and used with differing settings of '%s'"),
1794                     option);
1795 }
1796
1797 /* Default version of pch_valid_p.  */
1798
1799 const char *
1800 default_pch_valid_p (const void *data_p, size_t len)
1801 {
1802   struct cl_option_state state;
1803   const char *data = (const char *)data_p;
1804   size_t i;
1805
1806   /* -fpic and -fpie also usually make a PCH invalid.  */
1807   if (data[0] != flag_pic)
1808     return _("created and used with different settings of -fpic");
1809   if (data[1] != flag_pie)
1810     return _("created and used with different settings of -fpie");
1811   data += 2;
1812
1813   /* Check target_flags.  */
1814   if (targetm.check_pch_target_flags)
1815     {
1816       int tf;
1817       const char *r;
1818
1819       memcpy (&tf, data, sizeof (target_flags));
1820       data += sizeof (target_flags);
1821       len -= sizeof (target_flags);
1822       r = targetm.check_pch_target_flags (tf);
1823       if (r != NULL)
1824         return r;
1825     }
1826
1827   for (i = 0; i < cl_options_count; i++)
1828     if (option_affects_pch_p (i, &state))
1829       {
1830         if (memcmp (data, state.data, state.size) != 0)
1831           return pch_option_mismatch (cl_options[i].opt_text);
1832         data += state.size;
1833         len -= state.size;
1834       }
1835
1836   return NULL;
1837 }
1838
1839 /* Default version of cstore_mode.  */
1840
1841 machine_mode
1842 default_cstore_mode (enum insn_code icode)
1843 {
1844   return insn_data[(int) icode].operand[0].mode;
1845 }
1846
1847 /* Default version of member_type_forces_blk.  */
1848
1849 bool
1850 default_member_type_forces_blk (const_tree, machine_mode)
1851 {
1852   return false;
1853 }
1854
1855 rtx
1856 default_load_bounds_for_arg (rtx addr ATTRIBUTE_UNUSED,
1857                              rtx ptr ATTRIBUTE_UNUSED,
1858                              rtx bnd ATTRIBUTE_UNUSED)
1859 {
1860   gcc_unreachable ();
1861 }
1862
1863 void
1864 default_store_bounds_for_arg (rtx val ATTRIBUTE_UNUSED,
1865                               rtx addr ATTRIBUTE_UNUSED,
1866                               rtx bounds ATTRIBUTE_UNUSED,
1867                               rtx to ATTRIBUTE_UNUSED)
1868 {
1869   gcc_unreachable ();
1870 }
1871
1872 rtx
1873 default_load_returned_bounds (rtx slot ATTRIBUTE_UNUSED)
1874 {
1875   gcc_unreachable ();
1876 }
1877
1878 void
1879 default_store_returned_bounds (rtx slot ATTRIBUTE_UNUSED,
1880                                rtx bounds ATTRIBUTE_UNUSED)
1881 {
1882   gcc_unreachable ();
1883 }
1884
1885 /* Default version of canonicalize_comparison.  */
1886
1887 void
1888 default_canonicalize_comparison (int *, rtx *, rtx *, bool)
1889 {
1890 }
1891
1892 /* Default implementation of TARGET_ATOMIC_ASSIGN_EXPAND_FENV.  */
1893
1894 void
1895 default_atomic_assign_expand_fenv (tree *, tree *, tree *)
1896 {
1897 }
1898
1899 #ifndef PAD_VARARGS_DOWN
1900 #define PAD_VARARGS_DOWN BYTES_BIG_ENDIAN
1901 #endif
1902
1903 /* Build an indirect-ref expression over the given TREE, which represents a
1904    piece of a va_arg() expansion.  */
1905 tree
1906 build_va_arg_indirect_ref (tree addr)
1907 {
1908   addr = build_simple_mem_ref_loc (EXPR_LOCATION (addr), addr);
1909   return addr;
1910 }
1911
1912 /* The "standard" implementation of va_arg: read the value from the
1913    current (padded) address and increment by the (padded) size.  */
1914
1915 tree
1916 std_gimplify_va_arg_expr (tree valist, tree type, gimple_seq *pre_p,
1917                           gimple_seq *post_p)
1918 {
1919   tree addr, t, type_size, rounded_size, valist_tmp;
1920   unsigned HOST_WIDE_INT align, boundary;
1921   bool indirect;
1922
1923   /* All of the alignment and movement below is for args-grow-up machines.
1924      As of 2004, there are only 3 ARGS_GROW_DOWNWARD targets, and they all
1925      implement their own specialized gimplify_va_arg_expr routines.  */
1926   if (ARGS_GROW_DOWNWARD)
1927     gcc_unreachable ();
1928
1929   indirect = pass_by_reference (NULL, TYPE_MODE (type), type, false);
1930   if (indirect)
1931     type = build_pointer_type (type);
1932
1933   align = PARM_BOUNDARY / BITS_PER_UNIT;
1934   boundary = targetm.calls.function_arg_boundary (TYPE_MODE (type), type);
1935
1936   /* When we align parameter on stack for caller, if the parameter
1937      alignment is beyond MAX_SUPPORTED_STACK_ALIGNMENT, it will be
1938      aligned at MAX_SUPPORTED_STACK_ALIGNMENT.  We will match callee
1939      here with caller.  */
1940   if (boundary > MAX_SUPPORTED_STACK_ALIGNMENT)
1941     boundary = MAX_SUPPORTED_STACK_ALIGNMENT;
1942
1943   boundary /= BITS_PER_UNIT;
1944
1945   /* Hoist the valist value into a temporary for the moment.  */
1946   valist_tmp = get_initialized_tmp_var (valist, pre_p, NULL);
1947
1948   /* va_list pointer is aligned to PARM_BOUNDARY.  If argument actually
1949      requires greater alignment, we must perform dynamic alignment.  */
1950   if (boundary > align
1951       && !integer_zerop (TYPE_SIZE (type)))
1952     {
1953       t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
1954                   fold_build_pointer_plus_hwi (valist_tmp, boundary - 1));
1955       gimplify_and_add (t, pre_p);
1956
1957       t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
1958                   fold_build2 (BIT_AND_EXPR, TREE_TYPE (valist),
1959                                valist_tmp,
1960                                build_int_cst (TREE_TYPE (valist), -boundary)));
1961       gimplify_and_add (t, pre_p);
1962     }
1963   else
1964     boundary = align;
1965
1966   /* If the actual alignment is less than the alignment of the type,
1967      adjust the type accordingly so that we don't assume strict alignment
1968      when dereferencing the pointer.  */
1969   boundary *= BITS_PER_UNIT;
1970   if (boundary < TYPE_ALIGN (type))
1971     {
1972       type = build_variant_type_copy (type);
1973       SET_TYPE_ALIGN (type, boundary);
1974     }
1975
1976   /* Compute the rounded size of the type.  */
1977   type_size = size_in_bytes (type);
1978   rounded_size = round_up (type_size, align);
1979
1980   /* Reduce rounded_size so it's sharable with the postqueue.  */
1981   gimplify_expr (&rounded_size, pre_p, post_p, is_gimple_val, fb_rvalue);
1982
1983   /* Get AP.  */
1984   addr = valist_tmp;
1985   if (PAD_VARARGS_DOWN && !integer_zerop (rounded_size))
1986     {
1987       /* Small args are padded downward.  */
1988       t = fold_build2_loc (input_location, GT_EXPR, sizetype,
1989                        rounded_size, size_int (align));
1990       t = fold_build3 (COND_EXPR, sizetype, t, size_zero_node,
1991                        size_binop (MINUS_EXPR, rounded_size, type_size));
1992       addr = fold_build_pointer_plus (addr, t);
1993     }
1994
1995   /* Compute new value for AP.  */
1996   t = fold_build_pointer_plus (valist_tmp, rounded_size);
1997   t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist, t);
1998   gimplify_and_add (t, pre_p);
1999
2000   addr = fold_convert (build_pointer_type (type), addr);
2001
2002   if (indirect)
2003     addr = build_va_arg_indirect_ref (addr);
2004
2005   return build_va_arg_indirect_ref (addr);
2006 }
2007
2008 tree
2009 default_chkp_bound_type (void)
2010 {
2011   tree res = make_node (POINTER_BOUNDS_TYPE);
2012   TYPE_PRECISION (res) = TYPE_PRECISION (size_type_node) * 2;
2013   TYPE_NAME (res) = get_identifier ("__bounds_type");
2014   SET_TYPE_MODE (res, targetm.chkp_bound_mode ());
2015   layout_type (res);
2016   return res;
2017 }
2018
2019 enum machine_mode
2020 default_chkp_bound_mode (void)
2021 {
2022   return VOIDmode;
2023 }
2024
2025 tree
2026 default_builtin_chkp_function (unsigned int fcode ATTRIBUTE_UNUSED)
2027 {
2028   return NULL_TREE;
2029 }
2030
2031 rtx
2032 default_chkp_function_value_bounds (const_tree ret_type ATTRIBUTE_UNUSED,
2033                                     const_tree fn_decl_or_type ATTRIBUTE_UNUSED,
2034                                     bool outgoing ATTRIBUTE_UNUSED)
2035 {
2036   gcc_unreachable ();
2037 }
2038
2039 tree
2040 default_chkp_make_bounds_constant (HOST_WIDE_INT lb ATTRIBUTE_UNUSED,
2041                                    HOST_WIDE_INT ub ATTRIBUTE_UNUSED)
2042 {
2043   return NULL_TREE;
2044 }
2045
2046 int
2047 default_chkp_initialize_bounds (tree var ATTRIBUTE_UNUSED,
2048                                 tree lb ATTRIBUTE_UNUSED,
2049                                 tree ub ATTRIBUTE_UNUSED,
2050                                 tree *stmts ATTRIBUTE_UNUSED)
2051 {
2052   return 0;
2053 }
2054
2055 void
2056 default_setup_incoming_vararg_bounds (cumulative_args_t ca ATTRIBUTE_UNUSED,
2057                                       enum machine_mode mode ATTRIBUTE_UNUSED,
2058                                       tree type ATTRIBUTE_UNUSED,
2059                                       int *pretend_arg_size ATTRIBUTE_UNUSED,
2060                                       int second_time ATTRIBUTE_UNUSED)
2061 {
2062 }
2063
2064 /* An implementation of TARGET_CAN_USE_DOLOOP_P for targets that do
2065    not support nested low-overhead loops.  */
2066
2067 bool
2068 can_use_doloop_if_innermost (const widest_int &, const widest_int &,
2069                              unsigned int loop_depth, bool)
2070 {
2071   return loop_depth == 1;
2072 }
2073
2074 /* Default implementation of TARGET_OPTAB_SUPPORTED_P.  */
2075
2076 bool
2077 default_optab_supported_p (int, machine_mode, machine_mode, optimization_type)
2078 {
2079   return true;
2080 }
2081
2082 /* Default implementation of TARGET_MAX_NOCE_IFCVT_SEQ_COST.  */
2083
2084 unsigned int
2085 default_max_noce_ifcvt_seq_cost (edge e)
2086 {
2087   bool predictable_p = predictable_edge_p (e);
2088
2089   enum compiler_param param
2090     = (predictable_p
2091        ? PARAM_MAX_RTL_IF_CONVERSION_PREDICTABLE_COST
2092        : PARAM_MAX_RTL_IF_CONVERSION_UNPREDICTABLE_COST);
2093
2094   /* If we have a parameter set, use that, otherwise take a guess using
2095      BRANCH_COST.  */
2096   if (global_options_set.x_param_values[param])
2097     return PARAM_VALUE (param);
2098   else
2099     return BRANCH_COST (true, predictable_p) * COSTS_N_INSNS (3);
2100 }
2101
2102 /* Default implementation of TARGET_MIN_ARITHMETIC_PRECISION.  */
2103
2104 unsigned int
2105 default_min_arithmetic_precision (void)
2106 {
2107   return WORD_REGISTER_OPERATIONS ? BITS_PER_WORD : BITS_PER_UNIT;
2108 }
2109
2110 /* Default implementation of TARGET_C_EXCESS_PRECISION.  */
2111
2112 enum flt_eval_method
2113 default_excess_precision (enum excess_precision_type ATTRIBUTE_UNUSED)
2114 {
2115   return FLT_EVAL_METHOD_PROMOTE_TO_FLOAT;
2116 }
2117
2118 #include "gt-targhooks.h"