LCOV - code coverage report
Current view: top level - gcc - targhooks.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 393 705 55.7 %
Date: 2020-04-04 11:58:09 Functions: 78 170 45.9 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       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                 :          0 : 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                 :          0 :   gcc_unreachable ();
     100                 :            : #endif
     101                 :            : }
     102                 :            : 
     103                 :            : void
     104                 :      20057 : default_external_libcall (rtx fun ATTRIBUTE_UNUSED)
     105                 :            : {
     106                 :            : #ifdef ASM_OUTPUT_EXTERNAL_LIBCALL
     107                 :      20057 :   ASM_OUTPUT_EXTERNAL_LIBCALL (asm_out_file, fun);
     108                 :            : #endif
     109                 :      20057 : }
     110                 :            : 
     111                 :            : int
     112                 :    3193320 : default_unspec_may_trap_p (const_rtx x, unsigned flags)
     113                 :            : {
     114                 :    3193320 :   int i;
     115                 :            : 
     116                 :            :   /* Any floating arithmetic may trap.  */
     117                 :    3193320 :   if ((SCALAR_FLOAT_MODE_P (GET_MODE (x)) && flag_trapping_math))
     118                 :            :     return 1;
     119                 :            : 
     120                 :    5420020 :   for (i = 0; i < XVECLEN (x, 0); ++i)
     121                 :            :     {
     122                 :    3858570 :       if (may_trap_p_1 (XVECEXP (x, 0, i), flags))
     123                 :            :         return 1;
     124                 :            :     }
     125                 :            : 
     126                 :            :   return 0;
     127                 :            : }
     128                 :            : 
     129                 :            : machine_mode
     130                 :   10421600 : 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                 :   10421600 :   if (type != NULL_TREE && for_return == 2)
     137                 :    2722790 :     return promote_mode (type, mode, punsignedp);
     138                 :            :   return mode;
     139                 :            : }
     140                 :            : 
     141                 :            : machine_mode
     142                 :          0 : 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                 :          0 :   return promote_mode (type, mode, punsignedp);
     149                 :            : }
     150                 :            : 
     151                 :            : machine_mode
     152                 :          0 : default_cc_modes_compatible (machine_mode m1, machine_mode m2)
     153                 :            : {
     154                 :          0 :   if (m1 == m2)
     155                 :          0 :     return m1;
     156                 :            :   return VOIDmode;
     157                 :            : }
     158                 :            : 
     159                 :            : bool
     160                 :          0 : default_return_in_memory (const_tree type,
     161                 :            :                           const_tree fntype ATTRIBUTE_UNUSED)
     162                 :            : {
     163                 :          0 :   return (TYPE_MODE (type) == BLKmode);
     164                 :            : }
     165                 :            : 
     166                 :            : rtx
     167                 :          0 : default_legitimize_address (rtx x, rtx orig_x ATTRIBUTE_UNUSED,
     168                 :            :                             machine_mode mode ATTRIBUTE_UNUSED)
     169                 :            : {
     170                 :          0 :   return x;
     171                 :            : }
     172                 :            : 
     173                 :            : bool
     174                 :         45 : default_legitimize_address_displacement (rtx *, rtx *, poly_int64,
     175                 :            :                                          machine_mode)
     176                 :            : {
     177                 :         45 :   return false;
     178                 :            : }
     179                 :            : 
     180                 :            : bool
     181                 :          0 : default_const_not_ok_for_debug_p (rtx x)
     182                 :            : {
     183                 :          0 :   if (GET_CODE (x) == UNSPEC)
     184                 :          0 :     return true;
     185                 :            :   return false;
     186                 :            : }
     187                 :            : 
     188                 :            : rtx
     189                 :          0 : default_expand_builtin_saveregs (void)
     190                 :            : {
     191                 :          0 :   error ("%<__builtin_saveregs%> not supported by this target");
     192                 :          0 :   return const0_rtx;
     193                 :            : }
     194                 :            : 
     195                 :            : void
     196                 :          0 : default_setup_incoming_varargs (cumulative_args_t,
     197                 :            :                                 const function_arg_info &, int *, int)
     198                 :            : {
     199                 :          0 : }
     200                 :            : 
     201                 :            : /* The default implementation of TARGET_BUILTIN_SETJMP_FRAME_VALUE.  */
     202                 :            : 
     203                 :            : rtx
     204                 :          0 : default_builtin_setjmp_frame_value (void)
     205                 :            : {
     206                 :          0 :   return virtual_stack_vars_rtx;
     207                 :            : }
     208                 :            : 
     209                 :            : /* Generic hook that takes a CUMULATIVE_ARGS pointer and returns false.  */
     210                 :            : 
     211                 :            : bool
     212                 :          0 : hook_bool_CUMULATIVE_ARGS_false (cumulative_args_t ca ATTRIBUTE_UNUSED)
     213                 :            : {
     214                 :          0 :   return false;
     215                 :            : }
     216                 :            : 
     217                 :            : bool
     218                 :          0 : default_pretend_outgoing_varargs_named (cumulative_args_t ca ATTRIBUTE_UNUSED)
     219                 :            : {
     220                 :          0 :   return (targetm.calls.setup_incoming_varargs
     221                 :          0 :           != default_setup_incoming_varargs);
     222                 :            : }
     223                 :            : 
     224                 :            : scalar_int_mode
     225                 :     364164 : default_eh_return_filter_mode (void)
     226                 :            : {
     227                 :     364164 :   return targetm.unwind_word_mode ();
     228                 :            : }
     229                 :            : 
     230                 :            : scalar_int_mode
     231                 :      40416 : default_libgcc_cmp_return_mode (void)
     232                 :            : {
     233                 :      40416 :   return word_mode;
     234                 :            : }
     235                 :            : 
     236                 :            : scalar_int_mode
     237                 :        296 : default_libgcc_shift_count_mode (void)
     238                 :            : {
     239                 :        296 :   return word_mode;
     240                 :            : }
     241                 :            : 
     242                 :            : scalar_int_mode
     243                 :     535660 : default_unwind_word_mode (void)
     244                 :            : {
     245                 :     535660 :   return word_mode;
     246                 :            : }
     247                 :            : 
     248                 :            : /* The default implementation of TARGET_SHIFT_TRUNCATION_MASK.  */
     249                 :            : 
     250                 :            : unsigned HOST_WIDE_INT
     251                 :          5 : default_shift_truncation_mask (machine_mode mode)
     252                 :            : {
     253                 :          5 :   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                 :     174340 : default_min_divisions_for_recip_mul (machine_mode mode ATTRIBUTE_UNUSED)
     260                 :            : {
     261                 :     174340 :   return have_insn_for (DIV, mode) ? 3 : 2;
     262                 :            : }
     263                 :            : 
     264                 :            : /* The default implementation of TARGET_MODE_REP_EXTENDED.  */
     265                 :            : 
     266                 :            : int
     267                 :   15302400 : default_mode_rep_extended (scalar_int_mode, scalar_int_mode)
     268                 :            : {
     269                 :   15302400 :   return UNKNOWN;
     270                 :            : }
     271                 :            : 
     272                 :            : /* Generic hook that takes a CUMULATIVE_ARGS pointer and returns true.  */
     273                 :            : 
     274                 :            : bool
     275                 :    3884520 : hook_bool_CUMULATIVE_ARGS_true (cumulative_args_t a ATTRIBUTE_UNUSED)
     276                 :            : {
     277                 :    3884520 :   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                 :          0 : default_mode_for_suffix (char suffix ATTRIBUTE_UNUSED)
     284                 :            : {
     285                 :          0 :   return VOIDmode;
     286                 :            : }
     287                 :            : 
     288                 :            : /* The generic C++ ABI specifies this is a 64-bit value.  */
     289                 :            : tree
     290                 :       3366 : default_cxx_guard_type (void)
     291                 :            : {
     292                 :       3366 :   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                 :       8911 : default_cxx_get_cookie_size (tree type)
     301                 :            : {
     302                 :       8911 :   tree cookie_size;
     303                 :            : 
     304                 :            :   /* We need to allocate an additional max (sizeof (size_t), alignof
     305                 :            :      (true_type)) bytes.  */
     306                 :       8911 :   tree sizetype_size;
     307                 :       8911 :   tree type_align;
     308                 :            : 
     309                 :       8911 :   sizetype_size = size_in_bytes (sizetype);
     310                 :       8911 :   type_align = size_int (TYPE_ALIGN_UNIT (type));
     311                 :       8911 :   if (tree_int_cst_lt (type_align, sizetype_size))
     312                 :            :     cookie_size = sizetype_size;
     313                 :            :   else
     314                 :       1349 :     cookie_size = type_align;
     315                 :            : 
     316                 :       8911 :   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                 :          0 : hook_pass_by_reference_must_pass_in_stack (cumulative_args_t,
     324                 :            :                                            const function_arg_info &arg)
     325                 :            : {
     326                 :          0 :   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                 :          0 : hook_callee_copies_named (cumulative_args_t, const function_arg_info &arg)
     334                 :            : {
     335                 :          0 :   return arg.named;
     336                 :            : }
     337                 :            : 
     338                 :            : /* Emit to STREAM the assembler syntax for insn operand X.  */
     339                 :            : 
     340                 :            : void
     341                 :          0 : 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                 :          0 :   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                 :          0 : 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                 :          0 :   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                 :          0 : 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                 :          0 :   return false;
     376                 :            : #endif
     377                 :            : }
     378                 :            : 
     379                 :            : /* The default implementation of TARGET_MANGLE_ASSEMBLER_NAME.  */
     380                 :            : tree
     381                 :     516397 : default_mangle_assembler_name (const char *name ATTRIBUTE_UNUSED)
     382                 :            : {
     383                 :     516397 :   const char *skipped = name + (*name == '*' ? 1 : 0);
     384                 :     516397 :   const char *stripped = targetm.strip_name_encoding (skipped);
     385                 :     516397 :   if (*name != '*' && user_label_prefix[0])
     386                 :          0 :     stripped = ACONCAT ((user_label_prefix, stripped, NULL));
     387                 :     516397 :   return get_identifier (stripped);
     388                 :            : }
     389                 :            : 
     390                 :            : /* The default implementation of TARGET_TRANSLATE_MODE_ATTRIBUTE.  */
     391                 :            : 
     392                 :            : machine_mode
     393                 :      43931 : default_translate_mode_attribute (machine_mode mode)
     394                 :            : {
     395                 :      43931 :   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                 :    1801410 : default_scalar_mode_supported_p (scalar_mode mode)
     409                 :            : {
     410                 :    1801410 :   int precision = GET_MODE_PRECISION (mode);
     411                 :            : 
     412                 :    1801410 :   switch (GET_MODE_CLASS (mode))
     413                 :            :     {
     414                 :     918208 :     case MODE_PARTIAL_INT:
     415                 :     918208 :     case MODE_INT:
     416                 :     918208 :       if (precision == CHAR_TYPE_SIZE)
     417                 :            :         return true;
     418                 :     888638 :       if (precision == SHORT_TYPE_SIZE)
     419                 :            :         return true;
     420                 :     856467 :       if (precision == INT_TYPE_SIZE)
     421                 :            :         return true;
     422                 :     839075 :       if (precision == LONG_TYPE_SIZE)
     423                 :            :         return true;
     424                 :     769076 :       if (precision == LONG_LONG_TYPE_SIZE)
     425                 :            :         return true;
     426                 :     787223 :       if (precision == 2 * BITS_PER_WORD)
     427                 :     688218 :         return true;
     428                 :            :       return false;
     429                 :            : 
     430                 :     883206 :     case MODE_FLOAT:
     431                 :     883206 :       if (precision == FLOAT_TYPE_SIZE)
     432                 :            :         return true;
     433                 :     655537 :       if (precision == DOUBLE_TYPE_SIZE)
     434                 :            :         return true;
     435                 :     454647 :       if (precision == LONG_DOUBLE_TYPE_SIZE)
     436                 :     227314 :         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                 :          0 :     default:
     447                 :          0 :       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                 :    1106540 : default_libgcc_floating_mode_supported_p (scalar_float_mode mode)
     456                 :            : {
     457                 :    1106540 :   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                 :          0 :     default:
     474                 :          0 :       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                 :    1403740 : default_floatn_mode (int n, bool extended)
     483                 :            : {
     484                 :    1403740 :   if (extended)
     485                 :            :     {
     486                 :     601605 :       opt_scalar_float_mode cand1, cand2;
     487                 :     601605 :       scalar_float_mode mode;
     488                 :     601605 :       switch (n)
     489                 :            :         {
     490                 :     200535 :         case 32:
     491                 :            : #ifdef HAVE_DFmode
     492                 :     200535 :           cand1 = DFmode;
     493                 :            : #endif
     494                 :     200535 :           break;
     495                 :            : 
     496                 :     200535 :         case 64:
     497                 :            : #ifdef HAVE_XFmode
     498                 :     200535 :           cand1 = XFmode;
     499                 :            : #endif
     500                 :            : #ifdef HAVE_TFmode
     501                 :     200535 :           cand2 = TFmode;
     502                 :            : #endif
     503                 :     200535 :           break;
     504                 :            : 
     505                 :            :         case 128:
     506                 :            :           break;
     507                 :            : 
     508                 :          0 :         default:
     509                 :            :           /* Those are the only valid _FloatNx types.  */
     510                 :          0 :           gcc_unreachable ();
     511                 :            :         }
     512                 :     601605 :       if (cand1.exists (&mode)
     513                 :     401070 :           && REAL_MODE_FORMAT (mode)->ieee_bits > n
     514                 :     401070 :           && targetm.scalar_mode_supported_p (mode)
     515                 :     401051 :           && targetm.libgcc_floating_mode_supported_p (mode))
     516                 :     401051 :         return cand1;
     517                 :     200554 :       if (cand2.exists (&mode)
     518                 :         19 :           && REAL_MODE_FORMAT (mode)->ieee_bits > n
     519                 :     200554 :           && targetm.scalar_mode_supported_p (mode)
     520                 :         19 :           && targetm.libgcc_floating_mode_supported_p (mode))
     521                 :         19 :         return cand2;
     522                 :            :     }
     523                 :            :   else
     524                 :            :     {
     525                 :     802140 :       opt_scalar_float_mode cand;
     526                 :     802140 :       scalar_float_mode mode;
     527                 :     802140 :       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                 :     200535 :         case 32:
     539                 :            : #ifdef HAVE_SFmode
     540                 :     200535 :           cand = SFmode;
     541                 :            : #endif
     542                 :     200535 :           break;
     543                 :            : 
     544                 :     200535 :         case 64:
     545                 :            : #ifdef HAVE_DFmode
     546                 :     200535 :           cand = DFmode;
     547                 :            : #endif
     548                 :     200535 :           break;
     549                 :            : 
     550                 :     200535 :         case 128:
     551                 :            : #ifdef HAVE_TFmode
     552                 :     200535 :           cand = TFmode;
     553                 :            : #endif
     554                 :     200535 :           break;
     555                 :            : 
     556                 :            :         default:
     557                 :            :           break;
     558                 :            :         }
     559                 :     802140 :       if (cand.exists (&mode)
     560                 :     601605 :           && REAL_MODE_FORMAT (mode)->ieee_bits == n
     561                 :     802140 :           && targetm.scalar_mode_supported_p (mode)
     562                 :     601605 :           && targetm.libgcc_floating_mode_supported_p (mode))
     563                 :     601605 :         return cand;
     564                 :            :     }
     565                 :     401070 :   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                 :   16779400 : default_floatn_builtin_p (int func ATTRIBUTE_UNUSED)
     577                 :            : {
     578                 :   16779400 :   static bool first_time_p = true;
     579                 :   16779400 :   static bool c_or_objective_c;
     580                 :            : 
     581                 :   16779400 :   if (first_time_p)
     582                 :            :     {
     583                 :     171218 :       first_time_p = false;
     584                 :     171218 :       c_or_objective_c = lang_GNU_C () || lang_GNU_OBJC ();
     585                 :            :     }
     586                 :            : 
     587                 :   16779400 :   return c_or_objective_c;
     588                 :            : }
     589                 :            : 
     590                 :            : /* Make some target macros useable by target-independent code.  */
     591                 :            : bool
     592                 :          0 : targhook_words_big_endian (void)
     593                 :            : {
     594                 :          0 :   return !!WORDS_BIG_ENDIAN;
     595                 :            : }
     596                 :            : 
     597                 :            : bool
     598                 :     157877 : targhook_float_words_big_endian (void)
     599                 :            : {
     600                 :     157877 :   return !!FLOAT_WORDS_BIG_ENDIAN;
     601                 :            : }
     602                 :            : 
     603                 :            : /* True if the target supports floating-point exceptions and rounding
     604                 :            :    modes.  */
     605                 :            : 
     606                 :            : bool
     607                 :          0 : default_float_exceptions_rounding_supported_p (void)
     608                 :            : {
     609                 :            : #ifdef HAVE_adddf3
     610                 :          0 :   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                 :     931063 : default_decimal_float_supported_p (void)
     620                 :            : {
     621                 :     931063 :   return ENABLE_DECIMAL_FLOAT;
     622                 :            : }
     623                 :            : 
     624                 :            : /* True if the target supports fixed-point arithmetic.  */
     625                 :            : 
     626                 :            : bool
     627                 :     314142 : default_fixed_point_supported_p (void)
     628                 :            : {
     629                 :     314142 :   return ENABLE_FIXED_POINT;
     630                 :            : }
     631                 :            : 
     632                 :            : /* True if the target supports GNU indirect functions.  */
     633                 :            : 
     634                 :            : bool
     635                 :        491 : default_has_ifunc_p (void)
     636                 :            : {
     637                 :        491 :   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                 :     264253 : default_predict_doloop_p (class loop *loop ATTRIBUTE_UNUSED)
     649                 :            : {
     650                 :     264253 :   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                 :          0 : default_invalid_within_doloop (const rtx_insn *insn)
     665                 :            : {
     666                 :          0 :   if (CALL_P (insn))
     667                 :            :     return "Function call in loop.";
     668                 :            : 
     669                 :          0 :   if (tablejump_p (insn, NULL, NULL) || computed_jump_p (insn))
     670                 :          0 :     return "Computed branch in the loop.";
     671                 :            : 
     672                 :            :   return NULL;
     673                 :            : }
     674                 :            : 
     675                 :            : /* Mapping of builtin functions to vectorized variants.  */
     676                 :            : 
     677                 :            : tree
     678                 :          0 : default_builtin_vectorized_function (unsigned int, tree, tree)
     679                 :            : {
     680                 :          0 :   return NULL_TREE;
     681                 :            : }
     682                 :            : 
     683                 :            : /* Mapping of target builtin functions to vectorized variants.  */
     684                 :            : 
     685                 :            : tree
     686                 :          0 : default_builtin_md_vectorized_function (tree, tree, tree)
     687                 :            : {
     688                 :          0 :   return NULL_TREE;
     689                 :            : }
     690                 :            : 
     691                 :            : /* Default vectorizer cost model values.  */
     692                 :            : 
     693                 :            : int
     694                 :          0 : default_builtin_vectorization_cost (enum vect_cost_for_stmt type_of_cost,
     695                 :            :                                     tree vectype,
     696                 :            :                                     int misalign ATTRIBUTE_UNUSED)
     697                 :            : {
     698                 :          0 :   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                 :          0 :       case unaligned_load:
     714                 :          0 :       case unaligned_store:
     715                 :          0 :         return 2;
     716                 :            : 
     717                 :          0 :       case cond_branch_taken:
     718                 :          0 :         return 3;
     719                 :            : 
     720                 :          0 :       case vec_construct:
     721                 :          0 :         return estimated_poly_value (TYPE_VECTOR_SUBPARTS (vectype)) - 1;
     722                 :            : 
     723                 :          0 :       default:
     724                 :          0 :         gcc_unreachable ();
     725                 :            :     }
     726                 :            : }
     727                 :            : 
     728                 :            : /* Reciprocal.  */
     729                 :            : 
     730                 :            : tree
     731                 :          0 : default_builtin_reciprocal (tree)
     732                 :            : {
     733                 :          0 :   return NULL_TREE;
     734                 :            : }
     735                 :            : 
     736                 :            : bool
     737                 :        379 : hook_bool_CUMULATIVE_ARGS_arg_info_false (cumulative_args_t,
     738                 :            :                                           const function_arg_info &)
     739                 :            : {
     740                 :        379 :   return false;
     741                 :            : }
     742                 :            : 
     743                 :            : bool
     744                 :          0 : hook_bool_CUMULATIVE_ARGS_arg_info_true (cumulative_args_t,
     745                 :            :                                          const function_arg_info &)
     746                 :            : {
     747                 :          0 :   return true;
     748                 :            : }
     749                 :            : 
     750                 :            : int
     751                 :    7149460 : hook_int_CUMULATIVE_ARGS_arg_info_0 (cumulative_args_t,
     752                 :            :                                      const function_arg_info &)
     753                 :            : {
     754                 :    7149460 :   return 0;
     755                 :            : }
     756                 :            : 
     757                 :            : void
     758                 :          0 : hook_void_CUMULATIVE_ARGS_tree (cumulative_args_t ca ATTRIBUTE_UNUSED,
     759                 :            :                                 tree ATTRIBUTE_UNUSED)
     760                 :            : {
     761                 :          0 : }
     762                 :            : 
     763                 :            : void
     764                 :          0 : default_function_arg_advance (cumulative_args_t, const function_arg_info &)
     765                 :            : {
     766                 :          0 :   gcc_unreachable ();
     767                 :            : }
     768                 :            : 
     769                 :            : /* Default implementation of TARGET_FUNCTION_ARG_OFFSET.  */
     770                 :            : 
     771                 :            : HOST_WIDE_INT
     772                 :    3702390 : default_function_arg_offset (machine_mode, const_tree)
     773                 :            : {
     774                 :    3702390 :   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                 :    8505870 : default_function_arg_padding (machine_mode mode, const_tree type)
     782                 :            : {
     783                 :    8505870 :   if (!BYTES_BIG_ENDIAN)
     784                 :    8505870 :     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                 :          0 : default_function_arg (cumulative_args_t, const function_arg_info &)
     806                 :            : {
     807                 :          0 :   gcc_unreachable ();
     808                 :            : }
     809                 :            : 
     810                 :            : rtx
     811                 :          0 : default_function_incoming_arg (cumulative_args_t, const function_arg_info &)
     812                 :            : {
     813                 :          0 :   gcc_unreachable ();
     814                 :            : }
     815                 :            : 
     816                 :            : unsigned int
     817                 :          0 : default_function_arg_boundary (machine_mode mode ATTRIBUTE_UNUSED,
     818                 :            :                                const_tree type ATTRIBUTE_UNUSED)
     819                 :            : {
     820                 :          0 :   return PARM_BOUNDARY;
     821                 :            : }
     822                 :            : 
     823                 :            : unsigned int
     824                 :    3702390 : default_function_arg_round_boundary (machine_mode mode ATTRIBUTE_UNUSED,
     825                 :            :                                      const_tree type ATTRIBUTE_UNUSED)
     826                 :            : {
     827                 :    3702390 :   return PARM_BOUNDARY;
     828                 :            : }
     829                 :            : 
     830                 :            : void
     831                 :          0 : hook_void_bitmap (bitmap regs ATTRIBUTE_UNUSED)
     832                 :            : {
     833                 :          0 : }
     834                 :            : 
     835                 :            : const char *
     836                 :     368350 : 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                 :     368350 :   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                 :          0 : default_stack_protect_guard (void)
     851                 :            : {
     852                 :          0 :   tree t = stack_chk_guard_decl;
     853                 :            : 
     854                 :          0 :   if (t == NULL)
     855                 :            :     {
     856                 :          0 :       rtx x;
     857                 :            : 
     858                 :          0 :       t = build_decl (UNKNOWN_LOCATION,
     859                 :            :                       VAR_DECL, get_identifier ("__stack_chk_guard"),
     860                 :            :                       ptr_type_node);
     861                 :          0 :       TREE_STATIC (t) = 1;
     862                 :          0 :       TREE_PUBLIC (t) = 1;
     863                 :          0 :       DECL_EXTERNAL (t) = 1;
     864                 :          0 :       TREE_USED (t) = 1;
     865                 :          0 :       TREE_THIS_VOLATILE (t) = 1;
     866                 :          0 :       DECL_ARTIFICIAL (t) = 1;
     867                 :          0 :       DECL_IGNORED_P (t) = 1;
     868                 :            : 
     869                 :            :       /* Do not share RTL as the declaration is visible outside of
     870                 :            :          current function.  */
     871                 :          0 :       x = DECL_RTL (t);
     872                 :          0 :       RTX_FLAG (x, used) = 1;
     873                 :            : 
     874                 :          0 :       stack_chk_guard_decl = t;
     875                 :            :     }
     876                 :            : 
     877                 :          0 :   return t;
     878                 :            : }
     879                 :            : 
     880                 :            : static GTY(()) tree stack_chk_fail_decl;
     881                 :            : 
     882                 :            : tree
     883                 :        165 : default_external_stack_protect_fail (void)
     884                 :            : {
     885                 :        165 :   tree t = stack_chk_fail_decl;
     886                 :            : 
     887                 :        165 :   if (t == NULL_TREE)
     888                 :            :     {
     889                 :        108 :       t = build_function_type_list (void_type_node, NULL_TREE);
     890                 :        108 :       t = build_decl (UNKNOWN_LOCATION,
     891                 :            :                       FUNCTION_DECL, get_identifier ("__stack_chk_fail"), t);
     892                 :        108 :       TREE_STATIC (t) = 1;
     893                 :        108 :       TREE_PUBLIC (t) = 1;
     894                 :        108 :       DECL_EXTERNAL (t) = 1;
     895                 :        108 :       TREE_USED (t) = 1;
     896                 :        108 :       TREE_THIS_VOLATILE (t) = 1;
     897                 :        108 :       TREE_NOTHROW (t) = 1;
     898                 :        108 :       DECL_ARTIFICIAL (t) = 1;
     899                 :        108 :       DECL_IGNORED_P (t) = 1;
     900                 :        108 :       DECL_VISIBILITY (t) = VISIBILITY_DEFAULT;
     901                 :        108 :       DECL_VISIBILITY_SPECIFIED (t) = 1;
     902                 :            : 
     903                 :        108 :       stack_chk_fail_decl = t;
     904                 :            :     }
     905                 :            : 
     906                 :        165 :   return build_call_expr (t, 0);
     907                 :            : }
     908                 :            : 
     909                 :            : tree
     910                 :          1 : default_hidden_stack_protect_fail (void)
     911                 :            : {
     912                 :            : #ifndef HAVE_GAS_HIDDEN
     913                 :            :   return default_external_stack_protect_fail ();
     914                 :            : #else
     915                 :          1 :   tree t = stack_chk_fail_decl;
     916                 :            : 
     917                 :          1 :   if (!flag_pic)
     918                 :          1 :     return default_external_stack_protect_fail ();
     919                 :            : 
     920                 :          0 :   if (t == NULL_TREE)
     921                 :            :     {
     922                 :          0 :       t = build_function_type_list (void_type_node, NULL_TREE);
     923                 :          0 :       t = build_decl (UNKNOWN_LOCATION, FUNCTION_DECL,
     924                 :            :                       get_identifier ("__stack_chk_fail_local"), t);
     925                 :          0 :       TREE_STATIC (t) = 1;
     926                 :          0 :       TREE_PUBLIC (t) = 1;
     927                 :          0 :       DECL_EXTERNAL (t) = 1;
     928                 :          0 :       TREE_USED (t) = 1;
     929                 :          0 :       TREE_THIS_VOLATILE (t) = 1;
     930                 :          0 :       TREE_NOTHROW (t) = 1;
     931                 :          0 :       DECL_ARTIFICIAL (t) = 1;
     932                 :          0 :       DECL_IGNORED_P (t) = 1;
     933                 :          0 :       DECL_VISIBILITY_SPECIFIED (t) = 1;
     934                 :          0 :       DECL_VISIBILITY (t) = VISIBILITY_HIDDEN;
     935                 :            : 
     936                 :          0 :       stack_chk_fail_decl = t;
     937                 :            :     }
     938                 :            : 
     939                 :          0 :   return build_call_expr (t, 0);
     940                 :            : #endif
     941                 :            : }
     942                 :            : 
     943                 :            : bool
     944                 :   38316000 : hook_bool_const_rtx_commutative_p (const_rtx x,
     945                 :            :                                    int outer_code ATTRIBUTE_UNUSED)
     946                 :            : {
     947                 :   38316000 :   return COMMUTATIVE_P (x);
     948                 :            : }
     949                 :            : 
     950                 :            : rtx
     951                 :          0 : 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                 :          0 :   if (fn_decl_or_type
     957                 :            :       && !DECL_P (fn_decl_or_type))
     958                 :          0 :     fn_decl_or_type = NULL;
     959                 :            : 
     960                 :            : #ifdef FUNCTION_VALUE
     961                 :            :   return FUNCTION_VALUE (ret_type, fn_decl_or_type);
     962                 :            : #else
     963                 :          0 :   gcc_unreachable ();
     964                 :            : #endif
     965                 :            : }
     966                 :            : 
     967                 :            : rtx
     968                 :      76709 : default_libcall_value (machine_mode mode ATTRIBUTE_UNUSED,
     969                 :            :                        const_rtx fun ATTRIBUTE_UNUSED)
     970                 :            : {
     971                 :            : #ifdef LIBCALL_VALUE
     972                 :      76709 :   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                 :          0 : 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                 :          0 :   gcc_unreachable ();
     987                 :            : #endif
     988                 :            : }
     989                 :            : 
     990                 :            : rtx
     991                 :          0 : 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                 :          0 :   if ((ARG_POINTER_REGNUM == STACK_POINTER_REGNUM
     998                 :          0 :        || ! (fixed_regs[ARG_POINTER_REGNUM]
     999                 :            :              || ARG_POINTER_REGNUM == FRAME_POINTER_REGNUM)))
    1000                 :          0 :     return copy_to_reg (virtual_incoming_args_rtx);
    1001                 :            :   else
    1002                 :          0 :     return virtual_incoming_args_rtx;
    1003                 :            : }
    1004                 :            : 
    1005                 :            : rtx
    1006                 :          0 : default_static_chain (const_tree ARG_UNUSED (fndecl_or_type), bool incoming_p)
    1007                 :            : {
    1008                 :          0 :   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                 :          0 :   {
    1020                 :          0 :     static bool issued_error;
    1021                 :          0 :     if (!issued_error)
    1022                 :            :       {
    1023                 :          0 :         issued_error = true;
    1024                 :          0 :         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                 :          0 :     return gen_rtx_MEM (Pmode, stack_pointer_rtx);
    1030                 :            :   }
    1031                 :            : }
    1032                 :            : 
    1033                 :            : void
    1034                 :          0 : default_trampoline_init (rtx ARG_UNUSED (m_tramp), tree ARG_UNUSED (t_func),
    1035                 :            :                          rtx ARG_UNUSED (r_chain))
    1036                 :            : {
    1037                 :          0 :   sorry ("nested function trampolines not supported on this target");
    1038                 :          0 : }
    1039                 :            : 
    1040                 :            : poly_int64
    1041                 :          0 : default_return_pops_args (tree, tree, poly_int64)
    1042                 :            : {
    1043                 :          0 :   return 0;
    1044                 :            : }
    1045                 :            : 
    1046                 :            : reg_class_t
    1047                 :   31223800 : 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                 :   31223800 :   return cl;
    1052                 :            : }
    1053                 :            : 
    1054                 :            : extern bool
    1055                 :  191575000 : default_lra_p (void)
    1056                 :            : {
    1057                 :  191575000 :   return true;
    1058                 :            : }
    1059                 :            : 
    1060                 :            : int
    1061                 :          0 : default_register_priority (int hard_regno ATTRIBUTE_UNUSED)
    1062                 :            : {
    1063                 :          0 :   return 0;
    1064                 :            : }
    1065                 :            : 
    1066                 :            : extern bool
    1067                 :          0 : default_register_usage_leveling_p (void)
    1068                 :            : {
    1069                 :          0 :   return false;
    1070                 :            : }
    1071                 :            : 
    1072                 :            : extern bool
    1073                 :    2928060 : default_different_addr_displacement_p (void)
    1074                 :            : {
    1075                 :    2928060 :   return false;
    1076                 :            : }
    1077                 :            : 
    1078                 :            : reg_class_t
    1079                 :          0 : 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                 :          0 :   enum reg_class rclass = NO_REGS;
    1085                 :          0 :   enum reg_class reload_class = (enum reg_class) reload_class_i;
    1086                 :            : 
    1087                 :          0 :   if (sri->prev_sri && sri->prev_sri->t_icode != CODE_FOR_nothing)
    1088                 :            :     {
    1089                 :          0 :       sri->icode = sri->prev_sri->t_icode;
    1090                 :          0 :       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                 :          0 : default_secondary_memory_needed_mode (machine_mode mode)
    1166                 :            : {
    1167                 :          0 :   if (!targetm.lra_p ()
    1168                 :          0 :       && known_lt (GET_MODE_BITSIZE (mode), BITS_PER_WORD)
    1169                 :          0 :       && INTEGRAL_MODE_P (mode))
    1170                 :          0 :     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                 :    4110930 : default_reloc_rw_mask (void)
    1179                 :            : {
    1180                 :    4110930 :   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                 :       1079 : default_generate_pic_addr_diff_vec (void)
    1188                 :            : {
    1189                 :       1079 :   return flag_pic;
    1190                 :            : }
    1191                 :            : 
    1192                 :            : /* By default, do no modification. */
    1193                 :          0 : tree default_mangle_decl_assembler_name (tree decl ATTRIBUTE_UNUSED,
    1194                 :            :                                          tree id)
    1195                 :            : {
    1196                 :          0 :    return id;
    1197                 :            : }
    1198                 :            : 
    1199                 :            : /* The default implementation of TARGET_STATIC_RTX_ALIGNMENT.  */
    1200                 :            : 
    1201                 :            : HOST_WIDE_INT
    1202                 :          0 : default_static_rtx_alignment (machine_mode mode)
    1203                 :            : {
    1204                 :          0 :   return GET_MODE_ALIGNMENT (mode);
    1205                 :            : }
    1206                 :            : 
    1207                 :            : /* The default implementation of TARGET_CONSTANT_ALIGNMENT.  */
    1208                 :            : 
    1209                 :            : HOST_WIDE_INT
    1210                 :          0 : default_constant_alignment (const_tree, HOST_WIDE_INT align)
    1211                 :            : {
    1212                 :          0 :   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                 :          0 : constant_alignment_word_strings (const_tree exp, HOST_WIDE_INT align)
    1220                 :            : {
    1221                 :          0 :   if (TREE_CODE (exp) == STRING_CST)
    1222                 :          0 :     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                 :   11096900 : default_vector_alignment (const_tree type)
    1231                 :            : {
    1232                 :   11096900 :   unsigned HOST_WIDE_INT align = MAX_OFILE_ALIGNMENT;
    1233                 :   11096900 :   tree size = TYPE_SIZE (type);
    1234                 :   11096900 :   if (tree_fits_uhwi_p (size))
    1235                 :   11096900 :     align = tree_to_uhwi (size);
    1236                 :            : 
    1237                 :   11096900 :   return align < MAX_OFILE_ALIGNMENT ? align : MAX_OFILE_ALIGNMENT;
    1238                 :            : }
    1239                 :            : 
    1240                 :            : /* The default implementation of
    1241                 :            :    TARGET_VECTORIZE_PREFERRED_VECTOR_ALIGNMENT.  */
    1242                 :            : 
    1243                 :            : poly_uint64
    1244                 :     222297 : default_preferred_vector_alignment (const_tree type)
    1245                 :            : {
    1246                 :     222297 :   return TYPE_ALIGN (type);
    1247                 :            : }
    1248                 :            : 
    1249                 :            : /* By default assume vectors of element TYPE require a multiple of the natural
    1250                 :            :    alignment of TYPE.  TYPE is naturally aligned if IS_PACKED is false.  */
    1251                 :            : bool
    1252                 :      22764 : default_builtin_vector_alignment_reachable (const_tree /*type*/, bool is_packed)
    1253                 :            : {
    1254                 :      22764 :   return ! is_packed;
    1255                 :            : }
    1256                 :            : 
    1257                 :            : /* By default, assume that a target supports any factor of misalignment
    1258                 :            :    memory access if it supports movmisalign patten.
    1259                 :            :    is_packed is true if the memory access is defined in a packed struct.  */
    1260                 :            : bool
    1261                 :     334447 : default_builtin_support_vector_misalignment (machine_mode mode,
    1262                 :            :                                              const_tree type
    1263                 :            :                                              ATTRIBUTE_UNUSED,
    1264                 :            :                                              int misalignment
    1265                 :            :                                              ATTRIBUTE_UNUSED,
    1266                 :            :                                              bool is_packed
    1267                 :            :                                              ATTRIBUTE_UNUSED)
    1268                 :            : {
    1269                 :     334447 :   if (optab_handler (movmisalign_optab, mode) != CODE_FOR_nothing)
    1270                 :     329457 :     return true;
    1271                 :            :   return false;
    1272                 :            : }
    1273                 :            : 
    1274                 :            : /* By default, only attempt to parallelize bitwise operations, and
    1275                 :            :    possibly adds/subtracts using bit-twiddling.  */
    1276                 :            : 
    1277                 :            : machine_mode
    1278                 :          0 : default_preferred_simd_mode (scalar_mode)
    1279                 :            : {
    1280                 :          0 :   return word_mode;
    1281                 :            : }
    1282                 :            : 
    1283                 :            : /* By default do not split reductions further.  */
    1284                 :            : 
    1285                 :            : machine_mode
    1286                 :          0 : default_split_reduction (machine_mode mode)
    1287                 :            : {
    1288                 :          0 :   return mode;
    1289                 :            : }
    1290                 :            : 
    1291                 :            : /* By default only the preferred vector mode is tried.  */
    1292                 :            : 
    1293                 :            : unsigned int
    1294                 :          0 : default_autovectorize_vector_modes (vector_modes *, bool)
    1295                 :            : {
    1296                 :          0 :   return 0;
    1297                 :            : }
    1298                 :            : 
    1299                 :            : /* The default implementation of TARGET_VECTORIZE_RELATED_MODE.  */
    1300                 :            : 
    1301                 :            : opt_machine_mode
    1302                 :    3230240 : default_vectorize_related_mode (machine_mode vector_mode,
    1303                 :            :                                 scalar_mode element_mode,
    1304                 :            :                                 poly_uint64 nunits)
    1305                 :            : {
    1306                 :    3230240 :   machine_mode result_mode;
    1307                 :    3230240 :   if ((maybe_ne (nunits, 0U)
    1308                 :    2707540 :        || multiple_p (GET_MODE_SIZE (vector_mode),
    1309                 :    2707540 :                       GET_MODE_SIZE (element_mode), &nunits))
    1310                 :    3396980 :       && mode_for_vector (element_mode, nunits).exists (&result_mode)
    1311                 :    3219740 :       && VECTOR_MODE_P (result_mode)
    1312                 :    6446520 :       && targetm.vector_mode_supported_p (result_mode))
    1313                 :    3052990 :     return result_mode;
    1314                 :            : 
    1315                 :     177245 :   return opt_machine_mode ();
    1316                 :            : }
    1317                 :            : 
    1318                 :            : /* By default a vector of integers is used as a mask.  */
    1319                 :            : 
    1320                 :            : opt_machine_mode
    1321                 :          0 : default_get_mask_mode (machine_mode mode)
    1322                 :            : {
    1323                 :          0 :   return related_int_vector_mode (mode);
    1324                 :            : }
    1325                 :            : 
    1326                 :            : /* By default consider masked stores to be expensive.  */
    1327                 :            : 
    1328                 :            : bool
    1329                 :        193 : default_empty_mask_is_expensive (unsigned ifn)
    1330                 :            : {
    1331                 :        193 :   return ifn == IFN_MASK_STORE;
    1332                 :            : }
    1333                 :            : 
    1334                 :            : /* By default, the cost model accumulates three separate costs (prologue,
    1335                 :            :    loop body, and epilogue) for a vectorized loop or block.  So allocate an
    1336                 :            :    array of three unsigned ints, set it to zero, and return its address.  */
    1337                 :            : 
    1338                 :            : void *
    1339                 :          0 : default_init_cost (class loop *loop_info ATTRIBUTE_UNUSED)
    1340                 :            : {
    1341                 :          0 :   unsigned *cost = XNEWVEC (unsigned, 3);
    1342                 :          0 :   cost[vect_prologue] = cost[vect_body] = cost[vect_epilogue] = 0;
    1343                 :          0 :   return cost;
    1344                 :            : }
    1345                 :            : 
    1346                 :            : /* By default, the cost model looks up the cost of the given statement
    1347                 :            :    kind and mode, multiplies it by the occurrence count, accumulates
    1348                 :            :    it into the cost specified by WHERE, and returns the cost added.  */
    1349                 :            : 
    1350                 :            : unsigned
    1351                 :          0 : default_add_stmt_cost (void *data, int count, enum vect_cost_for_stmt kind,
    1352                 :            :                        class _stmt_vec_info *stmt_info, int misalign,
    1353                 :            :                        enum vect_cost_model_location where)
    1354                 :            : {
    1355                 :          0 :   unsigned *cost = (unsigned *) data;
    1356                 :          0 :   unsigned retval = 0;
    1357                 :            : 
    1358                 :          0 :   tree vectype = stmt_info ? stmt_vectype (stmt_info) : NULL_TREE;
    1359                 :          0 :   int stmt_cost = targetm.vectorize.builtin_vectorization_cost (kind, vectype,
    1360                 :            :                                                                 misalign);
    1361                 :            :    /* Statements in an inner loop relative to the loop being
    1362                 :            :       vectorized are weighted more heavily.  The value here is
    1363                 :            :       arbitrary and could potentially be improved with analysis.  */
    1364                 :          0 :   if (where == vect_body && stmt_info && stmt_in_inner_loop_p (stmt_info))
    1365                 :          0 :     count *= 50;  /* FIXME.  */
    1366                 :            : 
    1367                 :          0 :   retval = (unsigned) (count * stmt_cost);
    1368                 :          0 :   cost[where] += retval;
    1369                 :            : 
    1370                 :          0 :   return retval;
    1371                 :            : }
    1372                 :            : 
    1373                 :            : /* By default, the cost model just returns the accumulated costs.  */
    1374                 :            : 
    1375                 :            : void
    1376                 :          0 : default_finish_cost (void *data, unsigned *prologue_cost,
    1377                 :            :                      unsigned *body_cost, unsigned *epilogue_cost)
    1378                 :            : {
    1379                 :          0 :   unsigned *cost = (unsigned *) data;
    1380                 :          0 :   *prologue_cost = cost[vect_prologue];
    1381                 :          0 :   *body_cost     = cost[vect_body];
    1382                 :          0 :   *epilogue_cost = cost[vect_epilogue];
    1383                 :          0 : }
    1384                 :            : 
    1385                 :            : /* Free the cost data.  */
    1386                 :            : 
    1387                 :            : void
    1388                 :          0 : default_destroy_cost_data (void *data)
    1389                 :            : {
    1390                 :          0 :   free (data);
    1391                 :          0 : }
    1392                 :            : 
    1393                 :            : /* Determine whether or not a pointer mode is valid. Assume defaults
    1394                 :            :    of ptr_mode or Pmode - can be overridden.  */
    1395                 :            : bool
    1396                 :    3970840 : default_valid_pointer_mode (scalar_int_mode mode)
    1397                 :            : {
    1398                 :    3970840 :   return (mode == ptr_mode || mode == Pmode);
    1399                 :            : }
    1400                 :            : 
    1401                 :            : /* Determine whether the memory reference specified by REF may alias
    1402                 :            :    the C libraries errno location.  */
    1403                 :            : bool
    1404                 :      77212 : default_ref_may_alias_errno (ao_ref *ref)
    1405                 :            : {
    1406                 :      77212 :   tree base = ao_ref_base (ref);
    1407                 :            :   /* The default implementation assumes the errno location is
    1408                 :            :      a declaration of type int or is always accessed via a
    1409                 :            :      pointer to int.  We assume that accesses to errno are
    1410                 :            :      not deliberately obfuscated (even in conforming ways).  */
    1411                 :      77212 :   if (TYPE_UNSIGNED (TREE_TYPE (base))
    1412                 :      77212 :       || TYPE_MODE (TREE_TYPE (base)) != TYPE_MODE (integer_type_node))
    1413                 :      61400 :     return false;
    1414                 :            :   /* The default implementation assumes an errno location declaration
    1415                 :            :      is never defined in the current compilation unit and may not be
    1416                 :            :      aliased by a local variable.  */
    1417                 :      15812 :   if (DECL_P (base)
    1418                 :      13686 :       && DECL_EXTERNAL (base)
    1419                 :      15880 :       && !TREE_STATIC (base))
    1420                 :            :     return true;
    1421                 :      15744 :   else if (TREE_CODE (base) == MEM_REF
    1422                 :      15744 :            && TREE_CODE (TREE_OPERAND (base, 0)) == SSA_NAME)
    1423                 :            :     {
    1424                 :       2010 :       struct ptr_info_def *pi = SSA_NAME_PTR_INFO (TREE_OPERAND (base, 0));
    1425                 :       3102 :       return !pi || pi->pt.anything || pi->pt.nonlocal;
    1426                 :            :     }
    1427                 :            :   return false;
    1428                 :            : }
    1429                 :            : 
    1430                 :            : /* Return the mode for a pointer to a given ADDRSPACE,
    1431                 :            :    defaulting to ptr_mode for all address spaces.  */
    1432                 :            : 
    1433                 :            : scalar_int_mode
    1434                 :  548078000 : default_addr_space_pointer_mode (addr_space_t addrspace ATTRIBUTE_UNUSED)
    1435                 :            : {
    1436                 :  548078000 :   return ptr_mode;
    1437                 :            : }
    1438                 :            : 
    1439                 :            : /* Return the mode for an address in a given ADDRSPACE,
    1440                 :            :    defaulting to Pmode for all address spaces.  */
    1441                 :            : 
    1442                 :            : scalar_int_mode
    1443                 :   63482900 : default_addr_space_address_mode (addr_space_t addrspace ATTRIBUTE_UNUSED)
    1444                 :            : {
    1445                 :   63482900 :   return Pmode;
    1446                 :            : }
    1447                 :            : 
    1448                 :            : /* Named address space version of valid_pointer_mode.
    1449                 :            :    To match the above, the same modes apply to all address spaces.  */
    1450                 :            : 
    1451                 :            : bool
    1452                 :    3970840 : default_addr_space_valid_pointer_mode (scalar_int_mode mode,
    1453                 :            :                                        addr_space_t as ATTRIBUTE_UNUSED)
    1454                 :            : {
    1455                 :    3970840 :   return targetm.valid_pointer_mode (mode);
    1456                 :            : }
    1457                 :            : 
    1458                 :            : /* Some places still assume that all pointer or address modes are the
    1459                 :            :    standard Pmode and ptr_mode.  These optimizations become invalid if
    1460                 :            :    the target actually supports multiple different modes.  For now,
    1461                 :            :    we disable such optimizations on such targets, using this function.  */
    1462                 :            : 
    1463                 :            : bool
    1464                 :  406028000 : target_default_pointer_address_modes_p (void)
    1465                 :            : {
    1466                 :  406028000 :   if (targetm.addr_space.address_mode != default_addr_space_address_mode)
    1467                 :            :     return false;
    1468                 :  406028000 :   if (targetm.addr_space.pointer_mode != default_addr_space_pointer_mode)
    1469                 :          0 :     return false;
    1470                 :            : 
    1471                 :            :   return true;
    1472                 :            : }
    1473                 :            : 
    1474                 :            : /* Named address space version of legitimate_address_p.
    1475                 :            :    By default, all address spaces have the same form.  */
    1476                 :            : 
    1477                 :            : bool
    1478                 :  836143000 : default_addr_space_legitimate_address_p (machine_mode mode, rtx mem,
    1479                 :            :                                          bool strict,
    1480                 :            :                                          addr_space_t as ATTRIBUTE_UNUSED)
    1481                 :            : {
    1482                 :  836143000 :   return targetm.legitimate_address_p (mode, mem, strict);
    1483                 :            : }
    1484                 :            : 
    1485                 :            : /* Named address space version of LEGITIMIZE_ADDRESS.
    1486                 :            :    By default, all address spaces have the same form.  */
    1487                 :            : 
    1488                 :            : rtx
    1489                 :     395943 : default_addr_space_legitimize_address (rtx x, rtx oldx, machine_mode mode,
    1490                 :            :                                        addr_space_t as ATTRIBUTE_UNUSED)
    1491                 :            : {
    1492                 :     395943 :   return targetm.legitimize_address (x, oldx, mode);
    1493                 :            : }
    1494                 :            : 
    1495                 :            : /* The default hook for determining if one named address space is a subset of
    1496                 :            :    another and to return which address space to use as the common address
    1497                 :            :    space.  */
    1498                 :            : 
    1499                 :            : bool
    1500                 :          0 : default_addr_space_subset_p (addr_space_t subset, addr_space_t superset)
    1501                 :            : {
    1502                 :          0 :   return (subset == superset);
    1503                 :            : }
    1504                 :            : 
    1505                 :            : /* The default hook for determining if 0 within a named address
    1506                 :            :    space is a valid address.  */
    1507                 :            : 
    1508                 :            : bool
    1509                 :          0 : default_addr_space_zero_address_valid (addr_space_t as ATTRIBUTE_UNUSED)
    1510                 :            : {
    1511                 :          0 :   return false;
    1512                 :            : }
    1513                 :            : 
    1514                 :            : /* The default hook for debugging the address space is to return the
    1515                 :            :    address space number to indicate DW_AT_address_class.  */
    1516                 :            : int
    1517                 :          0 : default_addr_space_debug (addr_space_t as)
    1518                 :            : {
    1519                 :          0 :   return as;
    1520                 :            : }
    1521                 :            : 
    1522                 :            : /* The default hook implementation for TARGET_ADDR_SPACE_DIAGNOSE_USAGE.
    1523                 :            :    Don't complain about any address space.  */
    1524                 :            : 
    1525                 :            : void
    1526                 :         29 : default_addr_space_diagnose_usage (addr_space_t, location_t)
    1527                 :            : {
    1528                 :         29 : }
    1529                 :            :          
    1530                 :            : 
    1531                 :            : /* The default hook for TARGET_ADDR_SPACE_CONVERT. This hook should never be
    1532                 :            :    called for targets with only a generic address space.  */
    1533                 :            : 
    1534                 :            : rtx
    1535                 :          0 : default_addr_space_convert (rtx op ATTRIBUTE_UNUSED,
    1536                 :            :                             tree from_type ATTRIBUTE_UNUSED,
    1537                 :            :                             tree to_type ATTRIBUTE_UNUSED)
    1538                 :            : {
    1539                 :          0 :   gcc_unreachable ();
    1540                 :            : }
    1541                 :            : 
    1542                 :            : /* The defualt implementation of TARGET_HARD_REGNO_NREGS.  */
    1543                 :            : 
    1544                 :            : unsigned int
    1545                 :          0 : default_hard_regno_nregs (unsigned int, machine_mode mode)
    1546                 :            : {
    1547                 :            :   /* Targets with variable-sized modes must provide their own definition
    1548                 :            :      of this hook.  */
    1549                 :          0 :   return CEIL (GET_MODE_SIZE (mode).to_constant (), UNITS_PER_WORD);
    1550                 :            : }
    1551                 :            : 
    1552                 :            : bool
    1553                 :          0 : default_hard_regno_scratch_ok (unsigned int regno ATTRIBUTE_UNUSED)
    1554                 :            : {
    1555                 :          0 :   return true;
    1556                 :            : }
    1557                 :            : 
    1558                 :            : /* The default implementation of TARGET_MODE_DEPENDENT_ADDRESS_P.  */
    1559                 :            : 
    1560                 :            : bool
    1561                 :   20720200 : default_mode_dependent_address_p (const_rtx addr ATTRIBUTE_UNUSED,
    1562                 :            :                                   addr_space_t addrspace ATTRIBUTE_UNUSED)
    1563                 :            : {
    1564                 :   20720200 :   return false;
    1565                 :            : }
    1566                 :            : 
    1567                 :            : bool
    1568                 :          0 : default_target_option_valid_attribute_p (tree ARG_UNUSED (fndecl),
    1569                 :            :                                          tree ARG_UNUSED (name),
    1570                 :            :                                          tree ARG_UNUSED (args),
    1571                 :            :                                          int ARG_UNUSED (flags))
    1572                 :            : {
    1573                 :          0 :   warning (OPT_Wattributes,
    1574                 :            :            "target attribute is not supported on this machine");
    1575                 :            : 
    1576                 :          0 :   return false;
    1577                 :            : }
    1578                 :            : 
    1579                 :            : bool
    1580                 :          0 : default_target_option_pragma_parse (tree ARG_UNUSED (args),
    1581                 :            :                                     tree ARG_UNUSED (pop_target))
    1582                 :            : {
    1583                 :            :   /* If args is NULL the caller is handle_pragma_pop_options ().  In that case,
    1584                 :            :      emit no warning because "#pragma GCC pop_target" is valid on targets that
    1585                 :            :      do not have the "target" pragma.  */
    1586                 :          0 :   if (args)
    1587                 :          0 :     warning (OPT_Wpragmas,
    1588                 :            :              "%<#pragma GCC target%> is not supported for this machine");
    1589                 :            : 
    1590                 :          0 :   return false;
    1591                 :            : }
    1592                 :            : 
    1593                 :            : bool
    1594                 :          0 : default_target_can_inline_p (tree caller, tree callee)
    1595                 :            : {
    1596                 :          0 :   tree callee_opts = DECL_FUNCTION_SPECIFIC_TARGET (callee);
    1597                 :          0 :   tree caller_opts = DECL_FUNCTION_SPECIFIC_TARGET (caller);
    1598                 :          0 :   if (! callee_opts)
    1599                 :          0 :     callee_opts = target_option_default_node;
    1600                 :          0 :   if (! caller_opts)
    1601                 :          0 :     caller_opts = target_option_default_node;
    1602                 :            : 
    1603                 :            :   /* If both caller and callee have attributes, assume that if the
    1604                 :            :      pointer is different, the two functions have different target
    1605                 :            :      options since build_target_option_node uses a hash table for the
    1606                 :            :      options.  */
    1607                 :          0 :   return callee_opts == caller_opts;
    1608                 :            : }
    1609                 :            : 
    1610                 :            : /* If the machine does not have a case insn that compares the bounds,
    1611                 :            :    this means extra overhead for dispatch tables, which raises the
    1612                 :            :    threshold for using them.  */
    1613                 :            : 
    1614                 :            : unsigned int
    1615                 :    2343460 : default_case_values_threshold (void)
    1616                 :            : {
    1617                 :    2343460 :   return (targetm.have_casesi () ? 4 : 5);
    1618                 :            : }
    1619                 :            : 
    1620                 :            : bool
    1621                 :   73188800 : default_have_conditional_execution (void)
    1622                 :            : {
    1623                 :   73188800 :   return HAVE_conditional_execution;
    1624                 :            : }
    1625                 :            : 
    1626                 :            : /* By default we assume that c99 functions are present at the runtime,
    1627                 :            :    but sincos is not.  */
    1628                 :            : bool
    1629                 :          0 : default_libc_has_function (enum function_class fn_class)
    1630                 :            : {
    1631                 :          0 :   if (fn_class == function_c94
    1632                 :            :       || fn_class == function_c99_misc
    1633                 :            :       || fn_class == function_c99_math_complex)
    1634                 :          0 :     return true;
    1635                 :            : 
    1636                 :            :   return false;
    1637                 :            : }
    1638                 :            : 
    1639                 :            : /* By default assume that libc has not a fast implementation.  */
    1640                 :            : 
    1641                 :            : bool
    1642                 :          0 : default_libc_has_fast_function (int fcode ATTRIBUTE_UNUSED)
    1643                 :            : {
    1644                 :          0 :   return false;
    1645                 :            : }
    1646                 :            : 
    1647                 :            : bool
    1648                 :          0 : gnu_libc_has_function (enum function_class fn_class ATTRIBUTE_UNUSED)
    1649                 :            : {
    1650                 :          0 :   return true;
    1651                 :            : }
    1652                 :            : 
    1653                 :            : bool
    1654                 :          0 : no_c99_libc_has_function (enum function_class fn_class ATTRIBUTE_UNUSED)
    1655                 :            : {
    1656                 :          0 :   return false;
    1657                 :            : }
    1658                 :            : 
    1659                 :            : tree
    1660                 :          0 : default_builtin_tm_load_store (tree ARG_UNUSED (type))
    1661                 :            : {
    1662                 :          0 :   return NULL_TREE;
    1663                 :            : }
    1664                 :            : 
    1665                 :            : /* Compute cost of moving registers to/from memory.  */
    1666                 :            : 
    1667                 :            : int
    1668                 :          0 : default_memory_move_cost (machine_mode mode ATTRIBUTE_UNUSED,
    1669                 :            :                           reg_class_t rclass ATTRIBUTE_UNUSED,
    1670                 :            :                           bool in ATTRIBUTE_UNUSED)
    1671                 :            : {
    1672                 :            : #ifndef MEMORY_MOVE_COST
    1673                 :          0 :     return (4 + memory_move_secondary_cost (mode, (enum reg_class) rclass, in));
    1674                 :            : #else
    1675                 :            :     return MEMORY_MOVE_COST (MACRO_MODE (mode), (enum reg_class) rclass, in);
    1676                 :            : #endif
    1677                 :            : }
    1678                 :            : 
    1679                 :            : /* Compute cost of moving data from a register of class FROM to one of
    1680                 :            :    TO, using MODE.  */
    1681                 :            : 
    1682                 :            : int
    1683                 :          0 : default_register_move_cost (machine_mode mode ATTRIBUTE_UNUSED,
    1684                 :            :                             reg_class_t from ATTRIBUTE_UNUSED,
    1685                 :            :                             reg_class_t to ATTRIBUTE_UNUSED)
    1686                 :            : {
    1687                 :            : #ifndef REGISTER_MOVE_COST
    1688                 :          0 :   return 2;
    1689                 :            : #else
    1690                 :            :   return REGISTER_MOVE_COST (MACRO_MODE (mode),
    1691                 :            :                              (enum reg_class) from, (enum reg_class) to);
    1692                 :            : #endif
    1693                 :            : }
    1694                 :            : 
    1695                 :            : /* The default implementation of TARGET_SLOW_UNALIGNED_ACCESS.  */
    1696                 :            : 
    1697                 :            : bool
    1698                 :    6522670 : default_slow_unaligned_access (machine_mode, unsigned int)
    1699                 :            : {
    1700                 :    6522670 :   return STRICT_ALIGNMENT;
    1701                 :            : }
    1702                 :            : 
    1703                 :            : /* The default implementation of TARGET_ESTIMATED_POLY_VALUE.  */
    1704                 :            : 
    1705                 :            : HOST_WIDE_INT
    1706                 :          0 : default_estimated_poly_value (poly_int64 x)
    1707                 :            : {
    1708                 :          0 :   return x.coeffs[0];
    1709                 :            : }
    1710                 :            : 
    1711                 :            : /* For hooks which use the MOVE_RATIO macro, this gives the legacy default
    1712                 :            :    behavior.  SPEED_P is true if we are compiling for speed.  */
    1713                 :            : 
    1714                 :            : unsigned int
    1715                 :    1219780 : get_move_ratio (bool speed_p ATTRIBUTE_UNUSED)
    1716                 :            : {
    1717                 :    1219780 :   unsigned int move_ratio;
    1718                 :            : #ifdef MOVE_RATIO
    1719                 :    1219780 :   move_ratio = (unsigned int) MOVE_RATIO (speed_p);
    1720                 :            : #else
    1721                 :            : #if defined (HAVE_cpymemqi) || defined (HAVE_cpymemhi) || defined (HAVE_cpymemsi) || defined (HAVE_cpymemdi) || defined (HAVE_cpymemti)
    1722                 :            :   move_ratio = 2;
    1723                 :            : #else /* No cpymem patterns, pick a default.  */
    1724                 :            :   move_ratio = ((speed_p) ? 15 : 3);
    1725                 :            : #endif
    1726                 :            : #endif
    1727                 :    1219780 :   return move_ratio;
    1728                 :            : }
    1729                 :            : 
    1730                 :            : /* Return TRUE if the move_by_pieces/set_by_pieces infrastructure should be
    1731                 :            :    used; return FALSE if the cpymem/setmem optab should be expanded, or
    1732                 :            :    a call to memcpy emitted.  */
    1733                 :            : 
    1734                 :            : bool
    1735                 :     831127 : default_use_by_pieces_infrastructure_p (unsigned HOST_WIDE_INT size,
    1736                 :            :                                         unsigned int alignment,
    1737                 :            :                                         enum by_pieces_operation op,
    1738                 :            :                                         bool speed_p)
    1739                 :            : {
    1740                 :     831127 :   unsigned int max_size = 0;
    1741                 :     831127 :   unsigned int ratio = 0;
    1742                 :            : 
    1743                 :     831127 :   switch (op)
    1744                 :            :     {
    1745                 :      39495 :     case CLEAR_BY_PIECES:
    1746                 :      69214 :       max_size = STORE_MAX_PIECES;
    1747                 :      39495 :       ratio = CLEAR_RATIO (speed_p);
    1748                 :            :       break;
    1749                 :     730412 :     case MOVE_BY_PIECES:
    1750                 :    1220220 :       max_size = MOVE_MAX_PIECES;
    1751                 :     730412 :       ratio = get_move_ratio (speed_p);
    1752                 :     730412 :       break;
    1753                 :      12241 :     case SET_BY_PIECES:
    1754                 :      24353 :       max_size = STORE_MAX_PIECES;
    1755                 :      12241 :       ratio = SET_RATIO (speed_p);
    1756                 :            :       break;
    1757                 :      39792 :     case STORE_BY_PIECES:
    1758                 :      79253 :       max_size = STORE_MAX_PIECES;
    1759                 :      39792 :       ratio = get_move_ratio (speed_p);
    1760                 :      39792 :       break;
    1761                 :       9187 :     case COMPARE_BY_PIECES:
    1762                 :      18358 :       max_size = COMPARE_MAX_PIECES;
    1763                 :            :       /* Pick a likely default, just as in get_move_ratio.  */
    1764                 :       9187 :       ratio = speed_p ? 15 : 3;
    1765                 :            :       break;
    1766                 :            :     }
    1767                 :            : 
    1768                 :     831127 :   return by_pieces_ninsns (size, alignment, max_size + 1, op) < ratio;
    1769                 :            : }
    1770                 :            : 
    1771                 :            : /* This hook controls code generation for expanding a memcmp operation by
    1772                 :            :    pieces.  Return 1 for the normal pattern of compare/jump after each pair
    1773                 :            :    of loads, or a higher number to reduce the number of branches.  */
    1774                 :            : 
    1775                 :            : int
    1776                 :      55735 : default_compare_by_pieces_branch_ratio (machine_mode)
    1777                 :            : {
    1778                 :      55735 :   return 1;
    1779                 :            : }
    1780                 :            : 
    1781                 :            : /* Write PATCH_AREA_SIZE NOPs into the asm outfile FILE around a function
    1782                 :            :    entry.  If RECORD_P is true and the target supports named sections,
    1783                 :            :    the location of the NOPs will be recorded in a special object section
    1784                 :            :    called "__patchable_function_entries".  This routine may be called
    1785                 :            :    twice per function to put NOPs before and after the function
    1786                 :            :    entry.  */
    1787                 :            : 
    1788                 :            : void
    1789                 :         20 : default_print_patchable_function_entry (FILE *file,
    1790                 :            :                                         unsigned HOST_WIDE_INT patch_area_size,
    1791                 :            :                                         bool record_p)
    1792                 :            : {
    1793                 :         20 :   const char *nop_templ = 0;
    1794                 :         20 :   int code_num;
    1795                 :         20 :   rtx_insn *my_nop = make_insn_raw (gen_nop ());
    1796                 :            : 
    1797                 :            :   /* We use the template alone, relying on the (currently sane) assumption
    1798                 :            :      that the NOP template does not have variable operands.  */
    1799                 :         20 :   code_num = recog_memoized (my_nop);
    1800                 :         20 :   nop_templ = get_insn_template (code_num, my_nop);
    1801                 :            : 
    1802                 :         20 :   if (record_p && targetm_common.have_named_sections)
    1803                 :            :     {
    1804                 :         15 :       char buf[256];
    1805                 :         15 :       static int patch_area_number;
    1806                 :         15 :       section *previous_section = in_section;
    1807                 :         15 :       const char *asm_op = integer_asm_op (POINTER_SIZE_UNITS, false);
    1808                 :            : 
    1809                 :         15 :       gcc_assert (asm_op != NULL);
    1810                 :         15 :       patch_area_number++;
    1811                 :         15 :       ASM_GENERATE_INTERNAL_LABEL (buf, "LPFE", patch_area_number);
    1812                 :            : 
    1813                 :         15 :       switch_to_section (get_section ("__patchable_function_entries",
    1814                 :            :                                       SECTION_WRITE | SECTION_RELRO, NULL));
    1815                 :         15 :       assemble_align (POINTER_SIZE);
    1816                 :         15 :       fputs (asm_op, file);
    1817                 :         15 :       assemble_name_raw (file, buf);
    1818                 :         15 :       fputc ('\n', file);
    1819                 :            : 
    1820                 :         15 :       switch_to_section (previous_section);
    1821                 :         15 :       ASM_OUTPUT_LABEL (file, buf);
    1822                 :            :     }
    1823                 :            : 
    1824                 :            :   unsigned i;
    1825                 :         50 :   for (i = 0; i < patch_area_size; ++i)
    1826                 :         30 :     output_asm_insn (nop_templ, NULL);
    1827                 :         20 : }
    1828                 :            : 
    1829                 :            : bool
    1830                 :          0 : default_profile_before_prologue (void)
    1831                 :            : {
    1832                 :            : #ifdef PROFILE_BEFORE_PROLOGUE
    1833                 :            :   return true;
    1834                 :            : #else
    1835                 :          0 :   return false;
    1836                 :            : #endif
    1837                 :            : }
    1838                 :            : 
    1839                 :            : /* The default implementation of TARGET_PREFERRED_RELOAD_CLASS.  */
    1840                 :            : 
    1841                 :            : reg_class_t
    1842                 :          0 : default_preferred_reload_class (rtx x ATTRIBUTE_UNUSED,
    1843                 :            :                                 reg_class_t rclass)
    1844                 :            : {
    1845                 :            : #ifdef PREFERRED_RELOAD_CLASS 
    1846                 :            :   return (reg_class_t) PREFERRED_RELOAD_CLASS (x, (enum reg_class) rclass);
    1847                 :            : #else
    1848                 :          0 :   return rclass;
    1849                 :            : #endif
    1850                 :            : }
    1851                 :            : 
    1852                 :            : /* The default implementation of TARGET_OUTPUT_PREFERRED_RELOAD_CLASS.  */
    1853                 :            : 
    1854                 :            : reg_class_t
    1855                 :          0 : default_preferred_output_reload_class (rtx x ATTRIBUTE_UNUSED,
    1856                 :            :                                        reg_class_t rclass)
    1857                 :            : {
    1858                 :          0 :   return rclass;
    1859                 :            : }
    1860                 :            : 
    1861                 :            : /* The default implementation of TARGET_PREFERRED_RENAME_CLASS.  */
    1862                 :            : reg_class_t
    1863                 :     782403 : default_preferred_rename_class (reg_class_t rclass ATTRIBUTE_UNUSED)
    1864                 :            : {
    1865                 :     782403 :   return NO_REGS;
    1866                 :            : }
    1867                 :            : 
    1868                 :            : /* The default implementation of TARGET_CLASS_LIKELY_SPILLED_P.  */
    1869                 :            : 
    1870                 :            : bool
    1871                 :          0 : default_class_likely_spilled_p (reg_class_t rclass)
    1872                 :            : {
    1873                 :          0 :   return (reg_class_size[(int) rclass] == 1);
    1874                 :            : }
    1875                 :            : 
    1876                 :            : /* The default implementation of TARGET_CLASS_MAX_NREGS.  */
    1877                 :            : 
    1878                 :            : unsigned char
    1879                 :          0 : default_class_max_nregs (reg_class_t rclass ATTRIBUTE_UNUSED,
    1880                 :            :                          machine_mode mode ATTRIBUTE_UNUSED)
    1881                 :            : {
    1882                 :            : #ifdef CLASS_MAX_NREGS
    1883                 :            :   return (unsigned char) CLASS_MAX_NREGS ((enum reg_class) rclass,
    1884                 :            :                                           MACRO_MODE (mode));
    1885                 :            : #else
    1886                 :            :   /* Targets with variable-sized modes must provide their own definition
    1887                 :            :      of this hook.  */
    1888                 :          0 :   unsigned int size = GET_MODE_SIZE (mode).to_constant ();
    1889                 :          0 :   return (size + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
    1890                 :            : #endif
    1891                 :            : }
    1892                 :            : 
    1893                 :            : /* Determine the debugging unwind mechanism for the target.  */
    1894                 :            : 
    1895                 :            : enum unwind_info_type
    1896                 :     866782 : default_debug_unwind_info (void)
    1897                 :            : {
    1898                 :            :   /* If the target wants to force the use of dwarf2 unwind info, let it.  */
    1899                 :            :   /* ??? Change all users to the hook, then poison this.  */
    1900                 :            : #ifdef DWARF2_FRAME_INFO
    1901                 :            :   if (DWARF2_FRAME_INFO)
    1902                 :            :     return UI_DWARF2;
    1903                 :            : #endif
    1904                 :            : 
    1905                 :            :   /* Otherwise, only turn it on if dwarf2 debugging is enabled.  */
    1906                 :            : #ifdef DWARF2_DEBUGGING_INFO
    1907                 :     866782 :   if (write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
    1908                 :     434934 :     return UI_DWARF2;
    1909                 :            : #endif
    1910                 :            : 
    1911                 :            :   return UI_NONE;
    1912                 :            : }
    1913                 :            : 
    1914                 :            : /* Targets that set NUM_POLY_INT_COEFFS to something greater than 1
    1915                 :            :    must define this hook.  */
    1916                 :            : 
    1917                 :            : unsigned int
    1918                 :          0 : default_dwarf_poly_indeterminate_value (unsigned int, unsigned int *, int *)
    1919                 :            : {
    1920                 :          0 :   gcc_unreachable ();
    1921                 :            : }
    1922                 :            : 
    1923                 :            : /* Determine the correct mode for a Dwarf frame register that represents
    1924                 :            :    register REGNO.  */
    1925                 :            : 
    1926                 :            : machine_mode
    1927                 :        608 : default_dwarf_frame_reg_mode (int regno)
    1928                 :            : {
    1929                 :        608 :   machine_mode save_mode = reg_raw_mode[regno];
    1930                 :            : 
    1931                 :        608 :   if (targetm.hard_regno_call_part_clobbered (eh_edge_abi.id (),
    1932                 :            :                                               regno, save_mode))
    1933                 :          0 :     save_mode = choose_hard_reg_mode (regno, 1, &eh_edge_abi);
    1934                 :        608 :   return save_mode;
    1935                 :            : }
    1936                 :            : 
    1937                 :            : /* To be used by targets where reg_raw_mode doesn't return the right
    1938                 :            :    mode for registers used in apply_builtin_return and apply_builtin_arg.  */
    1939                 :            : 
    1940                 :            : fixed_size_mode
    1941                 :       4817 : default_get_reg_raw_mode (int regno)
    1942                 :            : {
    1943                 :            :   /* Targets must override this hook if the underlying register is
    1944                 :            :      variable-sized.  */
    1945                 :       4817 :   return as_a <fixed_size_mode> (reg_raw_mode[regno]);
    1946                 :            : }
    1947                 :            : 
    1948                 :            : /* Return true if a leaf function should stay leaf even with profiling
    1949                 :            :    enabled.  */
    1950                 :            : 
    1951                 :            : bool
    1952                 :        424 : default_keep_leaf_when_profiled ()
    1953                 :            : {
    1954                 :        424 :   return false;
    1955                 :            : }
    1956                 :            : 
    1957                 :            : /* Return true if the state of option OPTION should be stored in PCH files
    1958                 :            :    and checked by default_pch_valid_p.  Store the option's current state
    1959                 :            :    in STATE if so.  */
    1960                 :            : 
    1961                 :            : static inline bool
    1962                 :   25381300 : option_affects_pch_p (int option, struct cl_option_state *state)
    1963                 :            : {
    1964                 :   25381300 :   if ((cl_options[option].flags & CL_TARGET) == 0)
    1965                 :            :     return false;
    1966                 :    2490440 :   if ((cl_options[option].flags & CL_PCH_IGNORE) != 0)
    1967                 :            :     return false;
    1968                 :    2490440 :   if (option_flag_var (option, &global_options) == &target_flags)
    1969                 :     503386 :     if (targetm.check_pch_target_flags)
    1970                 :            :       return false;
    1971                 :    2490440 :   return get_option_state (&global_options, option, state);
    1972                 :            : }
    1973                 :            : 
    1974                 :            : /* Default version of get_pch_validity.
    1975                 :            :    By default, every flag difference is fatal; that will be mostly right for
    1976                 :            :    most targets, but completely right for very few.  */
    1977                 :            : 
    1978                 :            : void *
    1979                 :        347 : default_get_pch_validity (size_t *sz)
    1980                 :            : {
    1981                 :        347 :   struct cl_option_state state;
    1982                 :        347 :   size_t i;
    1983                 :        347 :   char *result, *r;
    1984                 :            : 
    1985                 :        347 :   *sz = 2;
    1986                 :        347 :   if (targetm.check_pch_target_flags)
    1987                 :          0 :     *sz += sizeof (target_flags);
    1988                 :     665199 :   for (i = 0; i < cl_options_count; i++)
    1989                 :     664852 :     if (option_affects_pch_p (i, &state))
    1990                 :      63501 :       *sz += state.size;
    1991                 :            : 
    1992                 :        347 :   result = r = XNEWVEC (char, *sz);
    1993                 :        347 :   r[0] = flag_pic;
    1994                 :        347 :   r[1] = flag_pie;
    1995                 :        347 :   r += 2;
    1996                 :        347 :   if (targetm.check_pch_target_flags)
    1997                 :            :     {
    1998                 :          0 :       memcpy (r, &target_flags, sizeof (target_flags));
    1999                 :          0 :       r += sizeof (target_flags);
    2000                 :            :     }
    2001                 :            : 
    2002                 :     665199 :   for (i = 0; i < cl_options_count; i++)
    2003                 :     664852 :     if (option_affects_pch_p (i, &state))
    2004                 :            :       {
    2005                 :      63501 :         memcpy (r, state.data, state.size);
    2006                 :      63501 :         r += state.size;
    2007                 :            :       }
    2008                 :            : 
    2009                 :        347 :   return result;
    2010                 :            : }
    2011                 :            : 
    2012                 :            : /* Return a message which says that a PCH file was created with a different
    2013                 :            :    setting of OPTION.  */
    2014                 :            : 
    2015                 :            : static const char *
    2016                 :          0 : pch_option_mismatch (const char *option)
    2017                 :            : {
    2018                 :          0 :   return xasprintf (_("created and used with differing settings of '%s'"),
    2019                 :          0 :                     option);
    2020                 :            : }
    2021                 :            : 
    2022                 :            : /* Default version of pch_valid_p.  */
    2023                 :            : 
    2024                 :            : const char *
    2025                 :      12553 : default_pch_valid_p (const void *data_p, size_t len)
    2026                 :            : {
    2027                 :      12553 :   struct cl_option_state state;
    2028                 :      12553 :   const char *data = (const char *)data_p;
    2029                 :      12553 :   size_t i;
    2030                 :            : 
    2031                 :            :   /* -fpic and -fpie also usually make a PCH invalid.  */
    2032                 :      12553 :   if (data[0] != flag_pic)
    2033                 :          0 :     return _("created and used with different settings of %<-fpic%>");
    2034                 :      12553 :   if (data[1] != flag_pie)
    2035                 :          0 :     return _("created and used with different settings of %<-fpie%>");
    2036                 :      12553 :   data += 2;
    2037                 :            : 
    2038                 :            :   /* Check target_flags.  */
    2039                 :      12553 :   if (targetm.check_pch_target_flags)
    2040                 :            :     {
    2041                 :          0 :       int tf;
    2042                 :          0 :       const char *r;
    2043                 :            : 
    2044                 :          0 :       memcpy (&tf, data, sizeof (target_flags));
    2045                 :          0 :       data += sizeof (target_flags);
    2046                 :          0 :       len -= sizeof (target_flags);
    2047                 :          0 :       r = targetm.check_pch_target_flags (tf);
    2048                 :          0 :       if (r != NULL)
    2049                 :      12553 :         return r;
    2050                 :            :     }
    2051                 :            : 
    2052                 :   24064100 :   for (i = 0; i < cl_options_count; i++)
    2053                 :   24051500 :     if (option_affects_pch_p (i, &state))
    2054                 :            :       {
    2055                 :    2297200 :         if (memcmp (data, state.data, state.size) != 0)
    2056                 :          0 :           return pch_option_mismatch (cl_options[i].opt_text);
    2057                 :    2297200 :         data += state.size;
    2058                 :    2297200 :         len -= state.size;
    2059                 :            :       }
    2060                 :            : 
    2061                 :            :   return NULL;
    2062                 :            : }
    2063                 :            : 
    2064                 :            : /* Default version of cstore_mode.  */
    2065                 :            : 
    2066                 :            : scalar_int_mode
    2067                 :     423129 : default_cstore_mode (enum insn_code icode)
    2068                 :            : {
    2069                 :     423129 :   return as_a <scalar_int_mode> (insn_data[(int) icode].operand[0].mode);
    2070                 :            : }
    2071                 :            : 
    2072                 :            : /* Default version of member_type_forces_blk.  */
    2073                 :            : 
    2074                 :            : bool
    2075                 :          0 : default_member_type_forces_blk (const_tree, machine_mode)
    2076                 :            : {
    2077                 :          0 :   return false;
    2078                 :            : }
    2079                 :            : 
    2080                 :            : rtx
    2081                 :          0 : default_load_bounds_for_arg (rtx addr ATTRIBUTE_UNUSED,
    2082                 :            :                              rtx ptr ATTRIBUTE_UNUSED,
    2083                 :            :                              rtx bnd ATTRIBUTE_UNUSED)
    2084                 :            : {
    2085                 :          0 :   gcc_unreachable ();
    2086                 :            : }
    2087                 :            : 
    2088                 :            : void
    2089                 :          0 : default_store_bounds_for_arg (rtx val ATTRIBUTE_UNUSED,
    2090                 :            :                               rtx addr ATTRIBUTE_UNUSED,
    2091                 :            :                               rtx bounds ATTRIBUTE_UNUSED,
    2092                 :            :                               rtx to ATTRIBUTE_UNUSED)
    2093                 :            : {
    2094                 :          0 :   gcc_unreachable ();
    2095                 :            : }
    2096                 :            : 
    2097                 :            : rtx
    2098                 :          0 : default_load_returned_bounds (rtx slot ATTRIBUTE_UNUSED)
    2099                 :            : {
    2100                 :          0 :   gcc_unreachable ();
    2101                 :            : }
    2102                 :            : 
    2103                 :            : void
    2104                 :          0 : default_store_returned_bounds (rtx slot ATTRIBUTE_UNUSED,
    2105                 :            :                                rtx bounds ATTRIBUTE_UNUSED)
    2106                 :            : {
    2107                 :          0 :   gcc_unreachable ();
    2108                 :            : }
    2109                 :            : 
    2110                 :            : /* Default version of canonicalize_comparison.  */
    2111                 :            : 
    2112                 :            : void
    2113                 :          0 : default_canonicalize_comparison (int *, rtx *, rtx *, bool)
    2114                 :            : {
    2115                 :          0 : }
    2116                 :            : 
    2117                 :            : /* Default implementation of TARGET_ATOMIC_ASSIGN_EXPAND_FENV.  */
    2118                 :            : 
    2119                 :            : void
    2120                 :          0 : default_atomic_assign_expand_fenv (tree *, tree *, tree *)
    2121                 :            : {
    2122                 :          0 : }
    2123                 :            : 
    2124                 :            : #ifndef PAD_VARARGS_DOWN
    2125                 :            : #define PAD_VARARGS_DOWN BYTES_BIG_ENDIAN
    2126                 :            : #endif
    2127                 :            : 
    2128                 :            : /* Build an indirect-ref expression over the given TREE, which represents a
    2129                 :            :    piece of a va_arg() expansion.  */
    2130                 :            : tree
    2131                 :      38144 : build_va_arg_indirect_ref (tree addr)
    2132                 :            : {
    2133                 :      38144 :   addr = build_simple_mem_ref_loc (EXPR_LOCATION (addr), addr);
    2134                 :      38144 :   return addr;
    2135                 :            : }
    2136                 :            : 
    2137                 :            : /* The "standard" implementation of va_arg: read the value from the
    2138                 :            :    current (padded) address and increment by the (padded) size.  */
    2139                 :            : 
    2140                 :            : tree
    2141                 :        207 : std_gimplify_va_arg_expr (tree valist, tree type, gimple_seq *pre_p,
    2142                 :            :                           gimple_seq *post_p)
    2143                 :            : {
    2144                 :        207 :   tree addr, t, type_size, rounded_size, valist_tmp;
    2145                 :        207 :   unsigned HOST_WIDE_INT align, boundary;
    2146                 :        207 :   bool indirect;
    2147                 :            : 
    2148                 :            :   /* All of the alignment and movement below is for args-grow-up machines.
    2149                 :            :      As of 2004, there are only 3 ARGS_GROW_DOWNWARD targets, and they all
    2150                 :            :      implement their own specialized gimplify_va_arg_expr routines.  */
    2151                 :        207 :   if (ARGS_GROW_DOWNWARD)
    2152                 :            :     gcc_unreachable ();
    2153                 :            : 
    2154                 :        207 :   indirect = pass_va_arg_by_reference (type);
    2155                 :        207 :   if (indirect)
    2156                 :         33 :     type = build_pointer_type (type);
    2157                 :            : 
    2158                 :        207 :   if (targetm.calls.split_complex_arg
    2159                 :          0 :       && TREE_CODE (type) == COMPLEX_TYPE
    2160                 :        207 :       && targetm.calls.split_complex_arg (type))
    2161                 :            :     {
    2162                 :          0 :       tree real_part, imag_part;
    2163                 :            : 
    2164                 :          0 :       real_part = std_gimplify_va_arg_expr (valist,
    2165                 :          0 :                                             TREE_TYPE (type), pre_p, NULL);
    2166                 :          0 :       real_part = get_initialized_tmp_var (real_part, pre_p);
    2167                 :            : 
    2168                 :          0 :       imag_part = std_gimplify_va_arg_expr (unshare_expr (valist),
    2169                 :          0 :                                             TREE_TYPE (type), pre_p, NULL);
    2170                 :          0 :       imag_part = get_initialized_tmp_var (imag_part, pre_p);
    2171                 :            : 
    2172                 :          0 :       return build2 (COMPLEX_EXPR, type, real_part, imag_part);
    2173                 :            :    }
    2174                 :            : 
    2175                 :        207 :   align = PARM_BOUNDARY / BITS_PER_UNIT;
    2176                 :        207 :   boundary = targetm.calls.function_arg_boundary (TYPE_MODE (type), type);
    2177                 :            : 
    2178                 :            :   /* When we align parameter on stack for caller, if the parameter
    2179                 :            :      alignment is beyond MAX_SUPPORTED_STACK_ALIGNMENT, it will be
    2180                 :            :      aligned at MAX_SUPPORTED_STACK_ALIGNMENT.  We will match callee
    2181                 :            :      here with caller.  */
    2182                 :        207 :   if (boundary > MAX_SUPPORTED_STACK_ALIGNMENT)
    2183                 :            :     boundary = MAX_SUPPORTED_STACK_ALIGNMENT;
    2184                 :            : 
    2185                 :        207 :   boundary /= BITS_PER_UNIT;
    2186                 :            : 
    2187                 :            :   /* Hoist the valist value into a temporary for the moment.  */
    2188                 :        207 :   valist_tmp = get_initialized_tmp_var (valist, pre_p);
    2189                 :            : 
    2190                 :            :   /* va_list pointer is aligned to PARM_BOUNDARY.  If argument actually
    2191                 :            :      requires greater alignment, we must perform dynamic alignment.  */
    2192                 :        207 :   if (boundary > align
    2193                 :          4 :       && !TYPE_EMPTY_P (type)
    2194                 :        211 :       && !integer_zerop (TYPE_SIZE (type)))
    2195                 :            :     {
    2196                 :          4 :       t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
    2197                 :          4 :                   fold_build_pointer_plus_hwi (valist_tmp, boundary - 1));
    2198                 :          4 :       gimplify_and_add (t, pre_p);
    2199                 :            : 
    2200                 :          8 :       t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
    2201                 :          8 :                   fold_build2 (BIT_AND_EXPR, TREE_TYPE (valist),
    2202                 :            :                                valist_tmp,
    2203                 :            :                                build_int_cst (TREE_TYPE (valist), -boundary)));
    2204                 :          4 :       gimplify_and_add (t, pre_p);
    2205                 :            :     }
    2206                 :            :   else
    2207                 :            :     boundary = align;
    2208                 :            : 
    2209                 :            :   /* If the actual alignment is less than the alignment of the type,
    2210                 :            :      adjust the type accordingly so that we don't assume strict alignment
    2211                 :            :      when dereferencing the pointer.  */
    2212                 :        207 :   boundary *= BITS_PER_UNIT;
    2213                 :        207 :   if (boundary < TYPE_ALIGN (type))
    2214                 :            :     {
    2215                 :         22 :       type = build_variant_type_copy (type);
    2216                 :         22 :       SET_TYPE_ALIGN (type, boundary);
    2217                 :            :     }
    2218                 :            : 
    2219                 :            :   /* Compute the rounded size of the type.  */
    2220                 :        207 :   type_size = arg_size_in_bytes (type);
    2221                 :        207 :   rounded_size = round_up (type_size, align);
    2222                 :            : 
    2223                 :            :   /* Reduce rounded_size so it's sharable with the postqueue.  */
    2224                 :        207 :   gimplify_expr (&rounded_size, pre_p, post_p, is_gimple_val, fb_rvalue);
    2225                 :            : 
    2226                 :            :   /* Get AP.  */
    2227                 :        207 :   addr = valist_tmp;
    2228                 :        207 :   if (PAD_VARARGS_DOWN && !integer_zerop (rounded_size))
    2229                 :            :     {
    2230                 :            :       /* Small args are padded downward.  */
    2231                 :            :       t = fold_build2_loc (input_location, GT_EXPR, sizetype,
    2232                 :            :                        rounded_size, size_int (align));
    2233                 :            :       t = fold_build3 (COND_EXPR, sizetype, t, size_zero_node,
    2234                 :            :                        size_binop (MINUS_EXPR, rounded_size, type_size));
    2235                 :            :       addr = fold_build_pointer_plus (addr, t);
    2236                 :            :     }
    2237                 :            : 
    2238                 :            :   /* Compute new value for AP.  */
    2239                 :        207 :   t = fold_build_pointer_plus (valist_tmp, rounded_size);
    2240                 :        207 :   t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist, t);
    2241                 :        207 :   gimplify_and_add (t, pre_p);
    2242                 :            : 
    2243                 :        207 :   addr = fold_convert (build_pointer_type (type), addr);
    2244                 :            : 
    2245                 :        207 :   if (indirect)
    2246                 :         33 :     addr = build_va_arg_indirect_ref (addr);
    2247                 :            : 
    2248                 :        207 :   return build_va_arg_indirect_ref (addr);
    2249                 :            : }
    2250                 :            : 
    2251                 :            : /* An implementation of TARGET_CAN_USE_DOLOOP_P for targets that do
    2252                 :            :    not support nested low-overhead loops.  */
    2253                 :            : 
    2254                 :            : bool
    2255                 :          0 : can_use_doloop_if_innermost (const widest_int &, const widest_int &,
    2256                 :            :                              unsigned int loop_depth, bool)
    2257                 :            : {
    2258                 :          0 :   return loop_depth == 1;
    2259                 :            : }
    2260                 :            : 
    2261                 :            : /* Default implementation of TARGET_OPTAB_SUPPORTED_P.  */
    2262                 :            : 
    2263                 :            : bool
    2264                 :          0 : default_optab_supported_p (int, machine_mode, machine_mode, optimization_type)
    2265                 :            : {
    2266                 :          0 :   return true;
    2267                 :            : }
    2268                 :            : 
    2269                 :            : /* Default implementation of TARGET_MAX_NOCE_IFCVT_SEQ_COST.  */
    2270                 :            : 
    2271                 :            : unsigned int
    2272                 :          0 : default_max_noce_ifcvt_seq_cost (edge e)
    2273                 :            : {
    2274                 :          0 :   bool predictable_p = predictable_edge_p (e);
    2275                 :            : 
    2276                 :          0 :   if (predictable_p)
    2277                 :            :     {
    2278                 :          0 :       if (global_options_set.x_param_max_rtl_if_conversion_predictable_cost)
    2279                 :          0 :         return param_max_rtl_if_conversion_predictable_cost;
    2280                 :            :     }
    2281                 :            :   else
    2282                 :            :     {
    2283                 :          0 :       if (global_options_set.x_param_max_rtl_if_conversion_unpredictable_cost)
    2284                 :          0 :         return param_max_rtl_if_conversion_unpredictable_cost;
    2285                 :            :     }
    2286                 :            : 
    2287                 :          0 :   return BRANCH_COST (true, predictable_p) * COSTS_N_INSNS (3);
    2288                 :            : }
    2289                 :            : 
    2290                 :            : /* Default implementation of TARGET_MIN_ARITHMETIC_PRECISION.  */
    2291                 :            : 
    2292                 :            : unsigned int
    2293                 :      68144 : default_min_arithmetic_precision (void)
    2294                 :            : {
    2295                 :      68144 :   return WORD_REGISTER_OPERATIONS ? BITS_PER_WORD : BITS_PER_UNIT;
    2296                 :            : }
    2297                 :            : 
    2298                 :            : /* Default implementation of TARGET_C_EXCESS_PRECISION.  */
    2299                 :            : 
    2300                 :            : enum flt_eval_method
    2301                 :          0 : default_excess_precision (enum excess_precision_type ATTRIBUTE_UNUSED)
    2302                 :            : {
    2303                 :          0 :   return FLT_EVAL_METHOD_PROMOTE_TO_FLOAT;
    2304                 :            : }
    2305                 :            : 
    2306                 :            : /* Default implementation for
    2307                 :            :   TARGET_STACK_CLASH_PROTECTION_ALLOCA_PROBE_RANGE.  */
    2308                 :            : HOST_WIDE_INT
    2309                 :         16 : default_stack_clash_protection_alloca_probe_range (void)
    2310                 :            : {
    2311                 :         16 :   return 0;
    2312                 :            : }
    2313                 :            : 
    2314                 :            : /* The default implementation of TARGET_EARLY_REMAT_MODES.  */
    2315                 :            : 
    2316                 :            : void
    2317                 :          0 : default_select_early_remat_modes (sbitmap)
    2318                 :            : {
    2319                 :          0 : }
    2320                 :            : 
    2321                 :            : /* The default implementation of TARGET_PREFERRED_ELSE_VALUE.  */
    2322                 :            : 
    2323                 :            : tree
    2324                 :          0 : default_preferred_else_value (unsigned, tree type, unsigned, tree *)
    2325                 :            : {
    2326                 :          0 :   return build_zero_cst (type);
    2327                 :            : }
    2328                 :            : 
    2329                 :            : /* Default implementation of TARGET_HAVE_SPECULATION_SAFE_VALUE.  */
    2330                 :            : bool
    2331                 :     156997 : default_have_speculation_safe_value (bool active ATTRIBUTE_UNUSED)
    2332                 :            : {
    2333                 :            : #ifdef HAVE_speculation_barrier
    2334                 :     156997 :   return active ? HAVE_speculation_barrier : true;
    2335                 :            : #else
    2336                 :            :   return false;
    2337                 :            : #endif
    2338                 :            : }
    2339                 :            : /* Alternative implementation of TARGET_HAVE_SPECULATION_SAFE_VALUE
    2340                 :            :    that can be used on targets that never have speculative execution.  */
    2341                 :            : bool
    2342                 :          0 : speculation_safe_value_not_needed (bool active)
    2343                 :            : {
    2344                 :          0 :   return !active;
    2345                 :            : }
    2346                 :            : 
    2347                 :            : /* Default implementation of the speculation-safe-load builtin.  This
    2348                 :            :    implementation simply copies val to result and generates a
    2349                 :            :    speculation_barrier insn, if such a pattern is defined.  */
    2350                 :            : rtx
    2351                 :         41 : default_speculation_safe_value (machine_mode mode ATTRIBUTE_UNUSED,
    2352                 :            :                                 rtx result, rtx val,
    2353                 :            :                                 rtx failval ATTRIBUTE_UNUSED)
    2354                 :            : {
    2355                 :         41 :   emit_move_insn (result, val);
    2356                 :            : 
    2357                 :            : #ifdef HAVE_speculation_barrier
    2358                 :            :   /* Assume the target knows what it is doing: if it defines a
    2359                 :            :      speculation barrier, but it is not enabled, then assume that one
    2360                 :            :      isn't needed.  */
    2361                 :         41 :   if (HAVE_speculation_barrier)
    2362                 :         41 :     emit_insn (gen_speculation_barrier ());
    2363                 :            : #endif
    2364                 :            : 
    2365                 :         41 :   return result;
    2366                 :            : }
    2367                 :            : 
    2368                 :            : #include "gt-targhooks.h"

Generated by: LCOV version 1.0

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto --enable-host-shared. GCC test suite is run with the built compiler.