gcc/targhooks.c

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