gcc/targhooks.c

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