LCOV - code coverage report
Current view: top level - gcc - optabs-libfuncs.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 315 417 75.5 %
Date: 2020-04-04 11:58:09 Functions: 27 40 67.5 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Mapping from optabs to underlying library functions
       2                 :            :    Copyright (C) 1987-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                 :            : 
      21                 :            : #include "config.h"
      22                 :            : #include "system.h"
      23                 :            : #include "coretypes.h"
      24                 :            : #include "target.h"
      25                 :            : #include "insn-codes.h"
      26                 :            : #include "optabs-libfuncs.h"
      27                 :            : #include "libfuncs.h"
      28                 :            : #include "optabs-query.h"
      29                 :            : #include "tree.h"
      30                 :            : #include "stringpool.h"
      31                 :            : #include "varasm.h"
      32                 :            : #include "stor-layout.h"
      33                 :            : #include "rtl.h"
      34                 :            : 
      35                 :            : struct target_libfuncs default_target_libfuncs;
      36                 :            : #if SWITCHABLE_TARGET
      37                 :            : struct target_libfuncs *this_target_libfuncs = &default_target_libfuncs;
      38                 :            : #endif
      39                 :            : 
      40                 :            : #define libfunc_hash \
      41                 :            :   (this_target_libfuncs->x_libfunc_hash)
      42                 :            : 
      43                 :            : /* Prefixes for the current version of decimal floating point (BID vs. DPD) */
      44                 :            : #if ENABLE_DECIMAL_BID_FORMAT
      45                 :            : #define DECIMAL_PREFIX "bid_"
      46                 :            : #else
      47                 :            : #define DECIMAL_PREFIX "dpd_"
      48                 :            : #endif
      49                 :            : 
      50                 :            : /* Used for libfunc_hash.  */
      51                 :            : 
      52                 :            : hashval_t
      53                 :    9015540 : libfunc_hasher::hash (libfunc_entry *e)
      54                 :            : {
      55                 :    9015540 :   return ((e->mode1 + e->mode2 * NUM_MACHINE_MODES) ^ e->op);
      56                 :            : }
      57                 :            : 
      58                 :            : /* Used for libfunc_hash.  */
      59                 :            : 
      60                 :            : bool
      61                 :    7234090 : libfunc_hasher::equal (libfunc_entry *e1, libfunc_entry *e2)
      62                 :            : {
      63                 :    7234090 :   return e1->op == e2->op && e1->mode1 == e2->mode1 && e1->mode2 == e2->mode2;
      64                 :            : }
      65                 :            : 
      66                 :            : /* Return libfunc corresponding operation defined by OPTAB converting
      67                 :            :    from MODE2 to MODE1.  Trigger lazy initialization if needed, return NULL
      68                 :            :    if no libfunc is available.  */
      69                 :            : rtx
      70                 :      18982 : convert_optab_libfunc (convert_optab optab, machine_mode mode1,
      71                 :            :                        machine_mode mode2)
      72                 :            : {
      73                 :      18982 :   struct libfunc_entry e;
      74                 :      18982 :   struct libfunc_entry **slot;
      75                 :            : 
      76                 :            :   /* ??? This ought to be an assert, but not all of the places
      77                 :            :      that we expand optabs know about the optabs that got moved
      78                 :            :      to being direct.  */
      79                 :      18982 :   if (!(optab >= FIRST_CONV_OPTAB && optab <= LAST_CONVLIB_OPTAB))
      80                 :            :     return NULL_RTX;
      81                 :            : 
      82                 :      18982 :   e.op = optab;
      83                 :      18982 :   e.mode1 = mode1;
      84                 :      18982 :   e.mode2 = mode2;
      85                 :      18982 :   slot = libfunc_hash->find_slot (&e, NO_INSERT);
      86                 :      18982 :   if (!slot)
      87                 :            :     {
      88                 :       2859 :       const struct convert_optab_libcall_d *d
      89                 :       2859 :         = &convlib_def[optab - FIRST_CONV_OPTAB];
      90                 :            : 
      91                 :       2859 :       if (d->libcall_gen == NULL)
      92                 :            :         return NULL;
      93                 :            : 
      94                 :       2859 :       d->libcall_gen (optab, d->libcall_basename, mode1, mode2);
      95                 :       2859 :       slot = libfunc_hash->find_slot (&e, NO_INSERT);
      96                 :       2859 :       if (!slot)
      97                 :            :         return NULL;
      98                 :            :     }
      99                 :      18982 :   return (*slot)->libfunc;
     100                 :            : }
     101                 :            : 
     102                 :            : /* Return libfunc corresponding operation defined by OPTAB in MODE.
     103                 :            :    Trigger lazy initialization if needed, return NULL if no libfunc is
     104                 :            :    available.  */
     105                 :            : rtx
     106                 :     214680 : optab_libfunc (optab optab, machine_mode mode)
     107                 :            : {
     108                 :     214680 :   struct libfunc_entry e;
     109                 :     214680 :   struct libfunc_entry **slot;
     110                 :            : 
     111                 :            :   /* ??? This ought to be an assert, but not all of the places
     112                 :            :      that we expand optabs know about the optabs that got moved
     113                 :            :      to being direct.  */
     114                 :     214680 :   if (!(optab >= FIRST_NORM_OPTAB && optab <= LAST_NORMLIB_OPTAB))
     115                 :            :     return NULL_RTX;
     116                 :            : 
     117                 :     191220 :   e.op = optab;
     118                 :     191220 :   e.mode1 = mode;
     119                 :     191220 :   e.mode2 = VOIDmode;
     120                 :     191220 :   slot = libfunc_hash->find_slot (&e, NO_INSERT);
     121                 :     191220 :   if (!slot)
     122                 :            :     {
     123                 :      57634 :       const struct optab_libcall_d *d
     124                 :      57634 :         = &normlib_def[optab - FIRST_NORM_OPTAB];
     125                 :            : 
     126                 :      57634 :       if (d->libcall_gen == NULL)
     127                 :            :         return NULL;
     128                 :            : 
     129                 :      49432 :       d->libcall_gen (optab, d->libcall_basename, d->libcall_suffix, mode);
     130                 :      49432 :       slot = libfunc_hash->find_slot (&e, NO_INSERT);
     131                 :      49432 :       if (!slot)
     132                 :            :         return NULL;
     133                 :            :     }
     134                 :     156394 :   return (*slot)->libfunc;
     135                 :            : }
     136                 :            : 
     137                 :            : /* Initialize the libfunc fields of an entire group of entries in some
     138                 :            :    optab.  Each entry is set equal to a string consisting of a leading
     139                 :            :    pair of underscores followed by a generic operation name followed by
     140                 :            :    a mode name (downshifted to lowercase) followed by a single character
     141                 :            :    representing the number of operands for the given operation (which is
     142                 :            :    usually one of the characters '2', '3', or '4').
     143                 :            : 
     144                 :            :    OPTABLE is the table in which libfunc fields are to be initialized.
     145                 :            :    OPNAME is the generic (string) name of the operation.
     146                 :            :    SUFFIX is the character which specifies the number of operands for
     147                 :            :      the given generic operation.
     148                 :            :    MODE is the mode to generate for.  */
     149                 :            : 
     150                 :            : static void
     151                 :      22808 : gen_libfunc (optab optable, const char *opname, int suffix,
     152                 :            :              machine_mode mode)
     153                 :            : {
     154                 :      22808 :   unsigned opname_len = strlen (opname);
     155                 :      22808 :   const char *mname = GET_MODE_NAME (mode);
     156                 :      22808 :   unsigned mname_len = strlen (mname);
     157                 :      22808 :   int prefix_len = targetm.libfunc_gnu_prefix ? 6 : 2;
     158                 :      22808 :   int len = prefix_len + opname_len + mname_len + 1 + 1;
     159                 :      22808 :   char *libfunc_name = XALLOCAVEC (char, len);
     160                 :      22808 :   char *p;
     161                 :      22808 :   const char *q;
     162                 :            : 
     163                 :      22808 :   p = libfunc_name;
     164                 :      22808 :   *p++ = '_';
     165                 :      22808 :   *p++ = '_';
     166                 :      22808 :   if (targetm.libfunc_gnu_prefix)
     167                 :            :     {
     168                 :          0 :       *p++ = 'g';
     169                 :          0 :       *p++ = 'n';
     170                 :          0 :       *p++ = 'u';
     171                 :          0 :       *p++ = '_';
     172                 :            :     }
     173                 :     105787 :   for (q = opname; *q;)
     174                 :      82979 :     *p++ = *q++;
     175                 :      68424 :   for (q = mname; *q; q++)
     176                 :      45616 :     *p++ = TOLOWER (*q);
     177                 :      22808 :   *p++ = suffix;
     178                 :      22808 :   *p = '\0';
     179                 :            : 
     180                 :      22808 :   set_optab_libfunc (optable, mode,
     181                 :      22808 :                      ggc_alloc_string (libfunc_name, p - libfunc_name));
     182                 :      22808 : }
     183                 :            : 
     184                 :            : /* Like gen_libfunc, but verify that integer operation is involved.  */
     185                 :            : 
     186                 :            : void
     187                 :      44458 : gen_int_libfunc (optab optable, const char *opname, char suffix,
     188                 :            :                  machine_mode mode)
     189                 :            : {
     190                 :      44458 :   int maxsize = 2 * BITS_PER_WORD;
     191                 :      44458 :   int minsize = BITS_PER_WORD;
     192                 :      44458 :   scalar_int_mode int_mode;
     193                 :            : 
     194                 :      44458 :   if (!is_int_mode (mode, &int_mode))
     195                 :      44458 :     return;
     196                 :      44458 :   if (maxsize < LONG_LONG_TYPE_SIZE)
     197                 :            :     maxsize = LONG_LONG_TYPE_SIZE;
     198                 :      44458 :   if (minsize > INT_TYPE_SIZE
     199                 :      86892 :       && (trapv_binoptab_p (optable)
     200                 :      42434 :           || trapv_unoptab_p (optable)))
     201                 :            :     minsize = INT_TYPE_SIZE;
     202                 :      44458 :   if (GET_MODE_BITSIZE (int_mode) < minsize
     203                 :      62292 :       || GET_MODE_BITSIZE (int_mode) > maxsize)
     204                 :            :     return;
     205                 :      17834 :   gen_libfunc (optable, opname, suffix, int_mode);
     206                 :            : }
     207                 :            : 
     208                 :            : /* Like gen_libfunc, but verify that FP and set decimal prefix if needed.  */
     209                 :            : 
     210                 :            : void
     211                 :       4974 : gen_fp_libfunc (optab optable, const char *opname, char suffix,
     212                 :            :                 machine_mode mode)
     213                 :            : {
     214                 :       4974 :   char *dec_opname;
     215                 :            : 
     216                 :       4974 :   if (GET_MODE_CLASS (mode) == MODE_FLOAT)
     217                 :       3161 :     gen_libfunc (optable, opname, suffix, mode);
     218                 :       4974 :   if (DECIMAL_FLOAT_MODE_P (mode))
     219                 :            :     {
     220                 :       1813 :       dec_opname = XALLOCAVEC (char, sizeof (DECIMAL_PREFIX) + strlen (opname));
     221                 :            :       /* For BID support, change the name to have either a bid_ or dpd_ prefix
     222                 :            :          depending on the low level floating format used.  */
     223                 :       1813 :       memcpy (dec_opname, DECIMAL_PREFIX, sizeof (DECIMAL_PREFIX) - 1);
     224                 :       1813 :       strcpy (dec_opname + sizeof (DECIMAL_PREFIX) - 1, opname);
     225                 :       1813 :       gen_libfunc (optable, dec_opname, suffix, mode);
     226                 :            :     }
     227                 :       4974 : }
     228                 :            : 
     229                 :            : /* Like gen_libfunc, but verify that fixed-point operation is involved.  */
     230                 :            : 
     231                 :            : void
     232                 :          0 : gen_fixed_libfunc (optab optable, const char *opname, char suffix,
     233                 :            :                    machine_mode mode)
     234                 :            : {
     235                 :          0 :   if (!ALL_FIXED_POINT_MODE_P (mode))
     236                 :            :     return;
     237                 :          0 :   gen_libfunc (optable, opname, suffix, mode);
     238                 :            : }
     239                 :            : 
     240                 :            : /* Like gen_libfunc, but verify that signed fixed-point operation is
     241                 :            :    involved.  */
     242                 :            : 
     243                 :            : void
     244                 :          0 : gen_signed_fixed_libfunc (optab optable, const char *opname, char suffix,
     245                 :            :                           machine_mode mode)
     246                 :            : {
     247                 :          0 :   if (!SIGNED_FIXED_POINT_MODE_P (mode))
     248                 :            :     return;
     249                 :          0 :   gen_libfunc (optable, opname, suffix, mode);
     250                 :            : }
     251                 :            : 
     252                 :            : /* Like gen_libfunc, but verify that unsigned fixed-point operation is
     253                 :            :    involved.  */
     254                 :            : 
     255                 :            : void
     256                 :          0 : gen_unsigned_fixed_libfunc (optab optable, const char *opname, char suffix,
     257                 :            :                             machine_mode mode)
     258                 :            : {
     259                 :          0 :   if (!UNSIGNED_FIXED_POINT_MODE_P (mode))
     260                 :            :     return;
     261                 :          0 :   gen_libfunc (optable, opname, suffix, mode);
     262                 :            : }
     263                 :            : 
     264                 :            : /* Like gen_libfunc, but verify that FP or INT operation is involved.  */
     265                 :            : 
     266                 :            : void
     267                 :      13224 : gen_int_fp_libfunc (optab optable, const char *name, char suffix,
     268                 :            :                     machine_mode mode)
     269                 :            : {
     270                 :      13224 :   if (DECIMAL_FLOAT_MODE_P (mode) || GET_MODE_CLASS (mode) == MODE_FLOAT)
     271                 :          5 :     gen_fp_libfunc (optable, name, suffix, mode);
     272                 :      13224 :   if (INTEGRAL_MODE_P (mode))
     273                 :      13219 :     gen_int_libfunc (optable, name, suffix, mode);
     274                 :      13224 : }
     275                 :            : 
     276                 :            : /* Like gen_libfunc, but verify that FP or INT operation is involved
     277                 :            :    and add 'v' suffix for integer operation.  */
     278                 :            : 
     279                 :            : void
     280                 :        100 : gen_intv_fp_libfunc (optab optable, const char *name, char suffix,
     281                 :            :                      machine_mode mode)
     282                 :            : {
     283                 :        100 :   if (DECIMAL_FLOAT_MODE_P (mode) || GET_MODE_CLASS (mode) == MODE_FLOAT)
     284                 :          0 :     gen_fp_libfunc (optable, name, suffix, mode);
     285                 :        100 :   if (GET_MODE_CLASS (mode) == MODE_INT)
     286                 :            :     {
     287                 :        100 :       int len = strlen (name);
     288                 :        100 :       char *v_name = XALLOCAVEC (char, len + 2);
     289                 :        100 :       strcpy (v_name, name);
     290                 :        100 :       v_name[len] = 'v';
     291                 :        100 :       v_name[len + 1] = 0;
     292                 :        100 :       gen_int_libfunc (optable, v_name, suffix, mode);
     293                 :            :     }
     294                 :        100 : }
     295                 :            : 
     296                 :            : /* Like gen_libfunc, but verify that FP or INT or FIXED operation is
     297                 :            :    involved.  */
     298                 :            : 
     299                 :            : void
     300                 :       1628 : gen_int_fp_fixed_libfunc (optab optable, const char *name, char suffix,
     301                 :            :                           machine_mode mode)
     302                 :            : {
     303                 :       1628 :   if (DECIMAL_FLOAT_MODE_P (mode) || GET_MODE_CLASS (mode) == MODE_FLOAT)
     304                 :       1628 :     gen_fp_libfunc (optable, name, suffix, mode);
     305                 :       1628 :   if (INTEGRAL_MODE_P (mode))
     306                 :          0 :     gen_int_libfunc (optable, name, suffix, mode);
     307                 :       1628 :   if (ALL_FIXED_POINT_MODE_P (mode))
     308                 :          0 :     gen_fixed_libfunc (optable, name, suffix, mode);
     309                 :       1628 : }
     310                 :            : 
     311                 :            : /* Like gen_libfunc, but verify that FP or INT or signed FIXED operation is
     312                 :            :    involved.  */
     313                 :            : 
     314                 :            : void
     315                 :      10015 : gen_int_fp_signed_fixed_libfunc (optab optable, const char *name, char suffix,
     316                 :            :                                  machine_mode mode)
     317                 :            : {
     318                 :      10015 :   if (DECIMAL_FLOAT_MODE_P (mode) || GET_MODE_CLASS (mode) == MODE_FLOAT)
     319                 :        326 :     gen_fp_libfunc (optable, name, suffix, mode);
     320                 :      10015 :   if (INTEGRAL_MODE_P (mode))
     321                 :       9689 :     gen_int_libfunc (optable, name, suffix, mode);
     322                 :      10015 :   if (SIGNED_FIXED_POINT_MODE_P (mode))
     323                 :          0 :     gen_signed_fixed_libfunc (optable, name, suffix, mode);
     324                 :      10015 : }
     325                 :            : 
     326                 :            : /* Like gen_libfunc, but verify that INT or FIXED operation is
     327                 :            :    involved.  */
     328                 :            : 
     329                 :            : void
     330                 :          0 : gen_int_fixed_libfunc (optab optable, const char *name, char suffix,
     331                 :            :                        machine_mode mode)
     332                 :            : {
     333                 :          0 :   if (INTEGRAL_MODE_P (mode))
     334                 :          0 :     gen_int_libfunc (optable, name, suffix, mode);
     335                 :          0 :   if (ALL_FIXED_POINT_MODE_P (mode))
     336                 :          0 :     gen_fixed_libfunc (optable, name, suffix, mode);
     337                 :          0 : }
     338                 :            : 
     339                 :            : /* Like gen_libfunc, but verify that INT or signed FIXED operation is
     340                 :            :    involved.  */
     341                 :            : 
     342                 :            : void
     343                 :          0 : gen_int_signed_fixed_libfunc (optab optable, const char *name, char suffix,
     344                 :            :                               machine_mode mode)
     345                 :            : {
     346                 :          0 :   if (INTEGRAL_MODE_P (mode))
     347                 :          0 :     gen_int_libfunc (optable, name, suffix, mode);
     348                 :          0 :   if (SIGNED_FIXED_POINT_MODE_P (mode))
     349                 :          0 :     gen_signed_fixed_libfunc (optable, name, suffix, mode);
     350                 :          0 : }
     351                 :            : 
     352                 :            : /* Like gen_libfunc, but verify that INT or unsigned FIXED operation is
     353                 :            :    involved.  */
     354                 :            : 
     355                 :            : void
     356                 :       5277 : gen_int_unsigned_fixed_libfunc (optab optable, const char *name, char suffix,
     357                 :            :                                 machine_mode mode)
     358                 :            : {
     359                 :       5277 :   if (INTEGRAL_MODE_P (mode))
     360                 :       5277 :     gen_int_libfunc (optable, name, suffix, mode);
     361                 :       5277 :   if (UNSIGNED_FIXED_POINT_MODE_P (mode))
     362                 :          0 :     gen_unsigned_fixed_libfunc (optable, name, suffix, mode);
     363                 :       5277 : }
     364                 :            : 
     365                 :            : /* Initialize the libfunc fields of an entire group of entries of an
     366                 :            :    inter-mode-class conversion optab.  The string formation rules are
     367                 :            :    similar to the ones for init_libfuncs, above, but instead of having
     368                 :            :    a mode name and an operand count these functions have two mode names
     369                 :            :    and no operand count.  */
     370                 :            : 
     371                 :            : void
     372                 :       2287 : gen_interclass_conv_libfunc (convert_optab tab,
     373                 :            :                              const char *opname,
     374                 :            :                              machine_mode tmode,
     375                 :            :                              machine_mode fmode)
     376                 :            : {
     377                 :       2287 :   size_t opname_len = strlen (opname);
     378                 :       2287 :   size_t mname_len = 0;
     379                 :            : 
     380                 :       2287 :   const char *fname, *tname;
     381                 :       2287 :   const char *q;
     382                 :       2287 :   int prefix_len = targetm.libfunc_gnu_prefix ? 6 : 2;
     383                 :       2287 :   char *libfunc_name, *suffix;
     384                 :       2287 :   char *nondec_name, *dec_name, *nondec_suffix, *dec_suffix;
     385                 :       2287 :   char *p;
     386                 :            : 
     387                 :            :   /* If this is a decimal conversion, add the current BID vs. DPD prefix that
     388                 :            :      depends on which underlying decimal floating point format is used.  */
     389                 :       2287 :   const size_t dec_len = sizeof (DECIMAL_PREFIX) - 1;
     390                 :            : 
     391                 :       2287 :   mname_len = strlen (GET_MODE_NAME (tmode)) + strlen (GET_MODE_NAME (fmode));
     392                 :            : 
     393                 :       2287 :   nondec_name = XALLOCAVEC (char, prefix_len + opname_len + mname_len + 1 + 1);
     394                 :       2287 :   nondec_name[0] = '_';
     395                 :       2287 :   nondec_name[1] = '_';
     396                 :       2287 :   if (targetm.libfunc_gnu_prefix)
     397                 :            :     {
     398                 :          0 :       nondec_name[2] = 'g';
     399                 :          0 :       nondec_name[3] = 'n';
     400                 :          0 :       nondec_name[4] = 'u';
     401                 :          0 :       nondec_name[5] = '_';
     402                 :            :     }
     403                 :            : 
     404                 :       2287 :   memcpy (&nondec_name[prefix_len], opname, opname_len);
     405                 :       2287 :   nondec_suffix = nondec_name + opname_len + prefix_len;
     406                 :            : 
     407                 :       2287 :   dec_name = XALLOCAVEC (char, 2 + dec_len + opname_len + mname_len + 1 + 1);
     408                 :       2287 :   dec_name[0] = '_';
     409                 :       2287 :   dec_name[1] = '_';
     410                 :       2287 :   memcpy (&dec_name[2], DECIMAL_PREFIX, dec_len);
     411                 :       2287 :   memcpy (&dec_name[2+dec_len], opname, opname_len);
     412                 :       2287 :   dec_suffix = dec_name + dec_len + opname_len + 2;
     413                 :            : 
     414                 :       2287 :   fname = GET_MODE_NAME (fmode);
     415                 :       2287 :   tname = GET_MODE_NAME (tmode);
     416                 :            : 
     417                 :       2287 :   if (DECIMAL_FLOAT_MODE_P (fmode) || DECIMAL_FLOAT_MODE_P (tmode))
     418                 :            :     {
     419                 :            :       libfunc_name = dec_name;
     420                 :            :       suffix = dec_suffix;
     421                 :            :     }
     422                 :            :   else
     423                 :            :     {
     424                 :       1041 :       libfunc_name = nondec_name;
     425                 :       1041 :       suffix = nondec_suffix;
     426                 :            :     }
     427                 :            : 
     428                 :       2287 :   p = suffix;
     429                 :       6861 :   for (q = fname; *q; p++, q++)
     430                 :       4574 :     *p = TOLOWER (*q);
     431                 :       6861 :   for (q = tname; *q; p++, q++)
     432                 :       4574 :     *p = TOLOWER (*q);
     433                 :            : 
     434                 :       2287 :   *p = '\0';
     435                 :            : 
     436                 :       2287 :   set_conv_libfunc (tab, tmode, fmode,
     437                 :       2287 :                     ggc_alloc_string (libfunc_name, p - libfunc_name));
     438                 :       2287 : }
     439                 :            : 
     440                 :            : /* Same as gen_interclass_conv_libfunc but verify that we are producing
     441                 :            :    int->fp conversion.  */
     442                 :            : 
     443                 :            : void
     444                 :        694 : gen_int_to_fp_conv_libfunc (convert_optab tab,
     445                 :            :                             const char *opname,
     446                 :            :                             machine_mode tmode,
     447                 :            :                             machine_mode fmode)
     448                 :            : {
     449                 :        694 :   if (GET_MODE_CLASS (fmode) != MODE_INT)
     450                 :            :     return;
     451                 :        694 :   if (GET_MODE_CLASS (tmode) != MODE_FLOAT && !DECIMAL_FLOAT_MODE_P (tmode))
     452                 :            :     return;
     453                 :        694 :   gen_interclass_conv_libfunc (tab, opname, tmode, fmode);
     454                 :            : }
     455                 :            : 
     456                 :            : /* ufloat_optab is special by using floatun for FP and floatuns decimal fp
     457                 :            :    naming scheme.  */
     458                 :            : 
     459                 :            : void
     460                 :        258 : gen_ufloat_conv_libfunc (convert_optab tab,
     461                 :            :                          const char *opname ATTRIBUTE_UNUSED,
     462                 :            :                          machine_mode tmode,
     463                 :            :                          machine_mode fmode)
     464                 :            : {
     465                 :        258 :   if (DECIMAL_FLOAT_MODE_P (tmode))
     466                 :         81 :     gen_int_to_fp_conv_libfunc (tab, "floatuns", tmode, fmode);
     467                 :            :   else
     468                 :        177 :     gen_int_to_fp_conv_libfunc (tab, "floatun", tmode, fmode);
     469                 :        258 : }
     470                 :            : 
     471                 :            : /* Same as gen_interclass_conv_libfunc but verify that we are producing
     472                 :            :    fp->int conversion.  */
     473                 :            : 
     474                 :            : void
     475                 :          0 : gen_int_to_fp_nondecimal_conv_libfunc (convert_optab tab,
     476                 :            :                                        const char *opname,
     477                 :            :                                        machine_mode tmode,
     478                 :            :                                        machine_mode fmode)
     479                 :            : {
     480                 :          0 :   if (GET_MODE_CLASS (fmode) != MODE_INT)
     481                 :            :     return;
     482                 :          0 :   if (GET_MODE_CLASS (tmode) != MODE_FLOAT)
     483                 :            :     return;
     484                 :          0 :   gen_interclass_conv_libfunc (tab, opname, tmode, fmode);
     485                 :            : }
     486                 :            : 
     487                 :            : /* Same as gen_interclass_conv_libfunc but verify that we are producing
     488                 :            :    fp->int conversion with no decimal floating point involved.  */
     489                 :            : 
     490                 :            : void
     491                 :        862 : gen_fp_to_int_conv_libfunc (convert_optab tab,
     492                 :            :                             const char *opname,
     493                 :            :                             machine_mode tmode,
     494                 :            :                             machine_mode fmode)
     495                 :            : {
     496                 :        862 :   if (GET_MODE_CLASS (fmode) != MODE_FLOAT && !DECIMAL_FLOAT_MODE_P (fmode))
     497                 :            :     return;
     498                 :        862 :   if (GET_MODE_CLASS (tmode) != MODE_INT)
     499                 :            :     return;
     500                 :        862 :   gen_interclass_conv_libfunc (tab, opname, tmode, fmode);
     501                 :            : }
     502                 :            : 
     503                 :            : /* Initialize the libfunc fields of an of an intra-mode-class conversion optab.
     504                 :            :    The string formation rules are
     505                 :            :    similar to the ones for init_libfunc, above.  */
     506                 :            : 
     507                 :            : void
     508                 :        572 : gen_intraclass_conv_libfunc (convert_optab tab, const char *opname,
     509                 :            :                              machine_mode tmode, machine_mode fmode)
     510                 :            : {
     511                 :        572 :   size_t opname_len = strlen (opname);
     512                 :        572 :   size_t mname_len = 0;
     513                 :            : 
     514                 :        572 :   const char *fname, *tname;
     515                 :        572 :   const char *q;
     516                 :        572 :   int prefix_len = targetm.libfunc_gnu_prefix ? 6 : 2;
     517                 :        572 :   char *nondec_name, *dec_name, *nondec_suffix, *dec_suffix;
     518                 :        572 :   char *libfunc_name, *suffix;
     519                 :        572 :   char *p;
     520                 :            : 
     521                 :            :   /* If this is a decimal conversion, add the current BID vs. DPD prefix that
     522                 :            :      depends on which underlying decimal floating point format is used.  */
     523                 :        572 :   const size_t dec_len = sizeof (DECIMAL_PREFIX) - 1;
     524                 :            : 
     525                 :        572 :   mname_len = strlen (GET_MODE_NAME (tmode)) + strlen (GET_MODE_NAME (fmode));
     526                 :            : 
     527                 :        572 :   nondec_name = XALLOCAVEC (char, 2 + opname_len + mname_len + 1 + 1);
     528                 :        572 :   nondec_name[0] = '_';
     529                 :        572 :   nondec_name[1] = '_';
     530                 :        572 :   if (targetm.libfunc_gnu_prefix)
     531                 :            :     {
     532                 :          0 :       nondec_name[2] = 'g';
     533                 :          0 :       nondec_name[3] = 'n';
     534                 :          0 :       nondec_name[4] = 'u';
     535                 :          0 :       nondec_name[5] = '_';
     536                 :            :     }
     537                 :        572 :   memcpy (&nondec_name[prefix_len], opname, opname_len);
     538                 :        572 :   nondec_suffix = nondec_name + opname_len + prefix_len;
     539                 :            : 
     540                 :        572 :   dec_name = XALLOCAVEC (char, 2 + dec_len + opname_len + mname_len + 1 + 1);
     541                 :        572 :   dec_name[0] = '_';
     542                 :        572 :   dec_name[1] = '_';
     543                 :        572 :   memcpy (&dec_name[2], DECIMAL_PREFIX, dec_len);
     544                 :        572 :   memcpy (&dec_name[2 + dec_len], opname, opname_len);
     545                 :        572 :   dec_suffix = dec_name + dec_len + opname_len + 2;
     546                 :            : 
     547                 :        572 :   fname = GET_MODE_NAME (fmode);
     548                 :        572 :   tname = GET_MODE_NAME (tmode);
     549                 :            : 
     550                 :        572 :   if (DECIMAL_FLOAT_MODE_P (fmode) || DECIMAL_FLOAT_MODE_P (tmode))
     551                 :            :     {
     552                 :            :       libfunc_name = dec_name;
     553                 :            :       suffix = dec_suffix;
     554                 :            :     }
     555                 :            :   else
     556                 :            :     {
     557                 :        177 :       libfunc_name = nondec_name;
     558                 :        177 :       suffix = nondec_suffix;
     559                 :            :     }
     560                 :            : 
     561                 :        572 :   p = suffix;
     562                 :       1716 :   for (q = fname; *q; p++, q++)
     563                 :       1144 :     *p = TOLOWER (*q);
     564                 :       1716 :   for (q = tname; *q; p++, q++)
     565                 :       1144 :     *p = TOLOWER (*q);
     566                 :            : 
     567                 :        572 :   *p++ = '2';
     568                 :        572 :   *p = '\0';
     569                 :            : 
     570                 :        572 :   set_conv_libfunc (tab, tmode, fmode,
     571                 :        572 :                     ggc_alloc_string (libfunc_name, p - libfunc_name));
     572                 :        572 : }
     573                 :            : 
     574                 :            : /* Pick proper libcall for trunc_optab.  We need to chose if we do
     575                 :            :    truncation or extension and interclass or intraclass.  */
     576                 :            : 
     577                 :            : void
     578                 :        617 : gen_trunc_conv_libfunc (convert_optab tab,
     579                 :            :                         const char *opname,
     580                 :            :                         machine_mode tmode,
     581                 :            :                         machine_mode fmode)
     582                 :            : {
     583                 :        617 :   scalar_float_mode float_tmode, float_fmode;
     584                 :        617 :   if (!is_a <scalar_float_mode> (fmode, &float_fmode)
     585                 :        617 :       || !is_a <scalar_float_mode> (tmode, &float_tmode)
     586                 :        617 :       || float_tmode == float_fmode)
     587                 :        617 :     return;
     588                 :            : 
     589                 :        617 :   if (GET_MODE_CLASS (float_tmode) != GET_MODE_CLASS (float_fmode))
     590                 :        381 :     gen_interclass_conv_libfunc (tab, opname, float_tmode, float_fmode);
     591                 :            : 
     592                 :        617 :   if (GET_MODE_PRECISION (float_fmode) <= GET_MODE_PRECISION (float_tmode))
     593                 :            :     return;
     594                 :            : 
     595                 :        515 :   if (GET_MODE_CLASS (float_tmode) == GET_MODE_CLASS (float_fmode))
     596                 :        236 :     gen_intraclass_conv_libfunc (tab, opname, float_tmode, float_fmode);
     597                 :            : }
     598                 :            : 
     599                 :            : /* Pick proper libcall for extend_optab.  We need to chose if we do
     600                 :            :    truncation or extension and interclass or intraclass.  */
     601                 :            : 
     602                 :            : void
     603                 :        686 : gen_extend_conv_libfunc (convert_optab tab,
     604                 :            :                          const char *opname ATTRIBUTE_UNUSED,
     605                 :            :                          machine_mode tmode,
     606                 :            :                          machine_mode fmode)
     607                 :            : {
     608                 :        686 :   scalar_float_mode float_tmode, float_fmode;
     609                 :        686 :   if (!is_a <scalar_float_mode> (fmode, &float_fmode)
     610                 :        686 :       || !is_a <scalar_float_mode> (tmode, &float_tmode)
     611                 :        686 :       || float_tmode == float_fmode)
     612                 :        686 :     return;
     613                 :            : 
     614                 :        686 :   if (GET_MODE_CLASS (float_tmode) != GET_MODE_CLASS (float_fmode))
     615                 :        350 :     gen_interclass_conv_libfunc (tab, opname, float_tmode, float_fmode);
     616                 :            : 
     617                 :        686 :   if (GET_MODE_PRECISION (float_fmode) > GET_MODE_PRECISION (float_tmode))
     618                 :            :     return;
     619                 :            : 
     620                 :        686 :   if (GET_MODE_CLASS (float_tmode) == GET_MODE_CLASS (float_fmode))
     621                 :        336 :     gen_intraclass_conv_libfunc (tab, opname, tmode, fmode);
     622                 :            : }
     623                 :            : 
     624                 :            : /* Pick proper libcall for fract_optab.  We need to chose if we do
     625                 :            :    interclass or intraclass.  */
     626                 :            : 
     627                 :            : void
     628                 :          0 : gen_fract_conv_libfunc (convert_optab tab,
     629                 :            :                         const char *opname,
     630                 :            :                         machine_mode tmode,
     631                 :            :                         machine_mode fmode)
     632                 :            : {
     633                 :          0 :   if (tmode == fmode)
     634                 :            :     return;
     635                 :          0 :   if (!(ALL_FIXED_POINT_MODE_P (tmode) || ALL_FIXED_POINT_MODE_P (fmode)))
     636                 :            :     return;
     637                 :            : 
     638                 :          0 :   if (GET_MODE_CLASS (tmode) == GET_MODE_CLASS (fmode))
     639                 :          0 :     gen_intraclass_conv_libfunc (tab, opname, tmode, fmode);
     640                 :            :   else
     641                 :          0 :     gen_interclass_conv_libfunc (tab, opname, tmode, fmode);
     642                 :            : }
     643                 :            : 
     644                 :            : /* Pick proper libcall for fractuns_optab.  */
     645                 :            : 
     646                 :            : void
     647                 :          0 : gen_fractuns_conv_libfunc (convert_optab tab,
     648                 :            :                            const char *opname,
     649                 :            :                            machine_mode tmode,
     650                 :            :                            machine_mode fmode)
     651                 :            : {
     652                 :          0 :   if (tmode == fmode)
     653                 :            :     return;
     654                 :            :   /* One mode must be a fixed-point mode, and the other must be an integer
     655                 :            :      mode.  */
     656                 :          0 :   if (!((ALL_FIXED_POINT_MODE_P (tmode) && GET_MODE_CLASS (fmode) == MODE_INT)
     657                 :          0 :         || (ALL_FIXED_POINT_MODE_P (fmode)
     658                 :          0 :             && GET_MODE_CLASS (tmode) == MODE_INT)))
     659                 :            :     return;
     660                 :            : 
     661                 :          0 :   gen_interclass_conv_libfunc (tab, opname, tmode, fmode);
     662                 :            : }
     663                 :            : 
     664                 :            : /* Pick proper libcall for satfract_optab.  We need to chose if we do
     665                 :            :    interclass or intraclass.  */
     666                 :            : 
     667                 :            : void
     668                 :          0 : gen_satfract_conv_libfunc (convert_optab tab,
     669                 :            :                            const char *opname,
     670                 :            :                            machine_mode tmode,
     671                 :            :                            machine_mode fmode)
     672                 :            : {
     673                 :          0 :   if (tmode == fmode)
     674                 :            :     return;
     675                 :            :   /* TMODE must be a fixed-point mode.  */
     676                 :          0 :   if (!ALL_FIXED_POINT_MODE_P (tmode))
     677                 :            :     return;
     678                 :            : 
     679                 :          0 :   if (GET_MODE_CLASS (tmode) == GET_MODE_CLASS (fmode))
     680                 :          0 :     gen_intraclass_conv_libfunc (tab, opname, tmode, fmode);
     681                 :            :   else
     682                 :          0 :     gen_interclass_conv_libfunc (tab, opname, tmode, fmode);
     683                 :            : }
     684                 :            : 
     685                 :            : /* Pick proper libcall for satfractuns_optab.  */
     686                 :            : 
     687                 :            : void
     688                 :          0 : gen_satfractuns_conv_libfunc (convert_optab tab,
     689                 :            :                               const char *opname,
     690                 :            :                               machine_mode tmode,
     691                 :            :                               machine_mode fmode)
     692                 :            : {
     693                 :          0 :   if (tmode == fmode)
     694                 :            :     return;
     695                 :            :   /* TMODE must be a fixed-point mode, and FMODE must be an integer mode.  */
     696                 :          0 :   if (!(ALL_FIXED_POINT_MODE_P (tmode) && GET_MODE_CLASS (fmode) == MODE_INT))
     697                 :            :     return;
     698                 :            : 
     699                 :          0 :   gen_interclass_conv_libfunc (tab, opname, tmode, fmode);
     700                 :            : }
     701                 :            : 
     702                 :            : /* Hashtable callbacks for libfunc_decls.  */
     703                 :            : 
     704                 :            : struct libfunc_decl_hasher : ggc_ptr_hash<tree_node>
     705                 :            : {
     706                 :            :   static hashval_t
     707                 :    2237880 :   hash (tree entry)
     708                 :            :   {
     709                 :    2237880 :     return IDENTIFIER_HASH_VALUE (DECL_NAME (entry));
     710                 :            :   }
     711                 :            : 
     712                 :            :   static bool
     713                 :    5587100 :   equal (tree decl, tree name)
     714                 :            :   {
     715                 :    5587100 :     return DECL_NAME (decl) == name;
     716                 :            :   }
     717                 :            : };
     718                 :            : 
     719                 :            : /* A table of previously-created libfuncs, hashed by name.  */
     720                 :            : static GTY (()) hash_table<libfunc_decl_hasher> *libfunc_decls;
     721                 :            : 
     722                 :            : /* Build a decl for a libfunc named NAME with visibility VIS.  */
     723                 :            : 
     724                 :            : tree
     725                 :    1609970 : build_libfunc_function_visibility (const char *name, symbol_visibility vis)
     726                 :            : {
     727                 :            :   /* ??? We don't have any type information; pretend this is "int foo ()".  */
     728                 :    1609970 :   tree decl = build_decl (UNKNOWN_LOCATION, FUNCTION_DECL,
     729                 :            :                           get_identifier (name),
     730                 :            :                           build_function_type (integer_type_node, NULL_TREE));
     731                 :    1609970 :   DECL_EXTERNAL (decl) = 1;
     732                 :    1609970 :   TREE_PUBLIC (decl) = 1;
     733                 :    1609970 :   DECL_ARTIFICIAL (decl) = 1;
     734                 :    1609970 :   DECL_VISIBILITY (decl) = vis;
     735                 :    1609970 :   DECL_VISIBILITY_SPECIFIED (decl) = 1;
     736                 :    1609970 :   gcc_assert (DECL_ASSEMBLER_NAME (decl));
     737                 :            : 
     738                 :    1609970 :   return decl;
     739                 :            : }
     740                 :            : 
     741                 :            : /* Build a decl for a libfunc named NAME.  */
     742                 :            : 
     743                 :            : tree
     744                 :          0 : build_libfunc_function (const char *name)
     745                 :            : {
     746                 :          0 :   return build_libfunc_function_visibility (name, VISIBILITY_DEFAULT);
     747                 :            : }
     748                 :            : 
     749                 :            : /* Return a libfunc for NAME, creating one if we don't already have one.
     750                 :            :    The decl is given visibility VIS.  The returned rtx is a SYMBOL_REF.  */
     751                 :            : 
     752                 :            : rtx
     753                 :    3609690 : init_one_libfunc_visibility (const char *name, symbol_visibility vis)
     754                 :            : {
     755                 :    3609690 :   tree id, decl;
     756                 :    3609690 :   hashval_t hash;
     757                 :            : 
     758                 :    3609690 :   if (libfunc_decls == NULL)
     759                 :     197754 :     libfunc_decls = hash_table<libfunc_decl_hasher>::create_ggc (37);
     760                 :            : 
     761                 :            :   /* See if we have already created a libfunc decl for this function.  */
     762                 :    3609690 :   id = get_identifier (name);
     763                 :    3609690 :   hash = IDENTIFIER_HASH_VALUE (id);
     764                 :    3609690 :   tree *slot = libfunc_decls->find_slot_with_hash (id, hash, INSERT);
     765                 :    3609690 :   decl = *slot;
     766                 :    3609690 :   if (decl == NULL)
     767                 :            :     {
     768                 :            :       /* Create a new decl, so that it can be passed to
     769                 :            :          targetm.encode_section_info.  */
     770                 :    1609970 :       decl = build_libfunc_function_visibility (name, vis);
     771                 :    1609970 :       *slot = decl;
     772                 :            :     }
     773                 :    3609690 :   return XEXP (DECL_RTL (decl), 0);
     774                 :            : }
     775                 :            : 
     776                 :            : rtx
     777                 :    3609690 : init_one_libfunc (const char *name)
     778                 :            : {
     779                 :    3609690 :   return init_one_libfunc_visibility (name, VISIBILITY_DEFAULT);
     780                 :            : }
     781                 :            : 
     782                 :            : /* Adjust the assembler name of libfunc NAME to ASMSPEC.  */
     783                 :            : 
     784                 :            : rtx
     785                 :          1 : set_user_assembler_libfunc (const char *name, const char *asmspec)
     786                 :            : {
     787                 :          1 :   tree id, decl;
     788                 :          1 :   hashval_t hash;
     789                 :            : 
     790                 :          1 :   id = get_identifier (name);
     791                 :          1 :   hash = IDENTIFIER_HASH_VALUE (id);
     792                 :          1 :   tree *slot = libfunc_decls->find_slot_with_hash (id, hash, NO_INSERT);
     793                 :          1 :   gcc_assert (slot);
     794                 :          1 :   decl = (tree) *slot;
     795                 :          1 :   set_user_assembler_name (decl, asmspec);
     796                 :          1 :   return XEXP (DECL_RTL (decl), 0);
     797                 :            : }
     798                 :            : 
     799                 :            : /* Call this to reset the function entry for one optab (OPTABLE) in mode
     800                 :            :    MODE to NAME, which should be either 0 or a string constant.  */
     801                 :            : 
     802                 :            : void
     803                 :    2707310 : set_optab_libfunc (optab op, machine_mode mode, const char *name)
     804                 :            : {
     805                 :    2707310 :   rtx val;
     806                 :    2707310 :   struct libfunc_entry e;
     807                 :    2707310 :   struct libfunc_entry **slot;
     808                 :            : 
     809                 :    2707310 :   e.op = op;
     810                 :    2707310 :   e.mode1 = mode;
     811                 :    2707310 :   e.mode2 = VOIDmode;
     812                 :            : 
     813                 :    2707310 :   if (name)
     814                 :    2707310 :     val = init_one_libfunc (name);
     815                 :            :   else
     816                 :            :     val = 0;
     817                 :    2707310 :   slot = libfunc_hash->find_slot (&e, INSERT);
     818                 :    2707310 :   if (*slot == NULL)
     819                 :    2707310 :     *slot = ggc_alloc<libfunc_entry> ();
     820                 :    2707310 :   (*slot)->op = op;
     821                 :    2707310 :   (*slot)->mode1 = mode;
     822                 :    2707310 :   (*slot)->mode2 = VOIDmode;
     823                 :    2707310 :   (*slot)->libfunc = val;
     824                 :    2707310 : }
     825                 :            : 
     826                 :            : /* Call this to reset the function entry for one conversion optab
     827                 :            :    (OPTABLE) from mode FMODE to mode TMODE to NAME, which should be
     828                 :            :    either 0 or a string constant.  */
     829                 :            : 
     830                 :            : void
     831                 :       2859 : set_conv_libfunc (convert_optab optab, machine_mode tmode,
     832                 :            :                   machine_mode fmode, const char *name)
     833                 :            : {
     834                 :       2859 :   rtx val;
     835                 :       2859 :   struct libfunc_entry e;
     836                 :       2859 :   struct libfunc_entry **slot;
     837                 :            : 
     838                 :       2859 :   e.op = optab;
     839                 :       2859 :   e.mode1 = tmode;
     840                 :       2859 :   e.mode2 = fmode;
     841                 :            : 
     842                 :       2859 :   if (name)
     843                 :       2859 :     val = init_one_libfunc (name);
     844                 :            :   else
     845                 :            :     val = 0;
     846                 :       2859 :   slot = libfunc_hash->find_slot (&e, INSERT);
     847                 :       2859 :   if (*slot == NULL)
     848                 :       2859 :     *slot = ggc_alloc<libfunc_entry> ();
     849                 :       2859 :   (*slot)->op = optab;
     850                 :       2859 :   (*slot)->mode1 = tmode;
     851                 :       2859 :   (*slot)->mode2 = fmode;
     852                 :       2859 :   (*slot)->libfunc = val;
     853                 :       2859 : }
     854                 :            : 
     855                 :            : /* Call this to initialize the contents of the optabs
     856                 :            :    appropriately for the current target machine.  */
     857                 :            : 
     858                 :            : void
     859                 :     448991 : init_optabs (void)
     860                 :            : {
     861                 :     448991 :   if (libfunc_hash)
     862                 :        828 :     libfunc_hash->empty ();
     863                 :            :   else
     864                 :     448163 :     libfunc_hash = hash_table<libfunc_hasher>::create_ggc (10);
     865                 :            : 
     866                 :            :   /* Fill in the optabs with the insns we support.  */
     867                 :     448991 :   init_all_optabs (this_fn_optabs);
     868                 :            : 
     869                 :            :   /* The ffs function operates on `int'.  Fall back on it if we do not
     870                 :            :      have a libgcc2 function for that width.  */
     871                 :     448991 :   if (INT_TYPE_SIZE < BITS_PER_WORD)
     872                 :            :     {
     873                 :     879092 :       scalar_int_mode mode = int_mode_for_size (INT_TYPE_SIZE, 0).require ();
     874                 :     439546 :       set_optab_libfunc (ffs_optab, mode, "ffs");
     875                 :            :     }
     876                 :            : 
     877                 :            :   /* Explicitly initialize the bswap libfuncs since we need them to be
     878                 :            :      valid for things other than word_mode.  */
     879                 :     448991 :   if (targetm.libfunc_gnu_prefix)
     880                 :            :     {
     881                 :          0 :       set_optab_libfunc (bswap_optab, SImode, "__gnu_bswapsi2");
     882                 :          0 :       set_optab_libfunc (bswap_optab, DImode, "__gnu_bswapdi2");
     883                 :            :     }
     884                 :            :   else
     885                 :            :     {
     886                 :     448991 :       set_optab_libfunc (bswap_optab, SImode, "__bswapsi2");
     887                 :     448991 :       set_optab_libfunc (bswap_optab, DImode, "__bswapdi2");
     888                 :            :     }
     889                 :            : 
     890                 :            :   /* Use cabs for double complex abs, since systems generally have cabs.
     891                 :            :      Don't define any libcall for float complex, so that cabs will be used.  */
     892                 :     448991 :   if (complex_double_type_node)
     893                 :     448991 :     set_optab_libfunc (abs_optab, TYPE_MODE (complex_double_type_node),
     894                 :            :                        "cabs");
     895                 :            : 
     896                 :     448991 :   unwind_sjlj_register_libfunc = init_one_libfunc ("_Unwind_SjLj_Register");
     897                 :     448991 :   unwind_sjlj_unregister_libfunc
     898                 :     448991 :     = init_one_libfunc ("_Unwind_SjLj_Unregister");
     899                 :            : 
     900                 :            :   /* Allow the target to add more libcalls or rename some, etc.  */
     901                 :     448991 :   targetm.init_libfuncs ();
     902                 :     448991 : }
     903                 :            : 
     904                 :            : /* A helper function for init_sync_libfuncs.  Using the basename BASE,
     905                 :            :    install libfuncs into TAB for BASE_N for 1 <= N <= MAX.  */
     906                 :            : 
     907                 :            : static void
     908                 :          0 : init_sync_libfuncs_1 (optab tab, const char *base, int max)
     909                 :            : {
     910                 :          0 :   machine_mode mode;
     911                 :          0 :   char buf[64];
     912                 :          0 :   size_t len = strlen (base);
     913                 :          0 :   int i;
     914                 :            : 
     915                 :          0 :   gcc_assert (max <= 8);
     916                 :          0 :   gcc_assert (len + 3 < sizeof (buf));
     917                 :            : 
     918                 :          0 :   memcpy (buf, base, len);
     919                 :          0 :   buf[len] = '_';
     920                 :          0 :   buf[len + 1] = '0';
     921                 :          0 :   buf[len + 2] = '\0';
     922                 :            : 
     923                 :          0 :   mode = QImode;
     924                 :          0 :   for (i = 1; i <= max; i *= 2)
     925                 :            :     {
     926                 :          0 :       if (i > 1)
     927                 :          0 :         mode = GET_MODE_2XWIDER_MODE (mode).require ();
     928                 :          0 :       buf[len + 1] = '0' + i;
     929                 :          0 :       set_optab_libfunc (tab, mode, buf);
     930                 :            :     }
     931                 :          0 : }
     932                 :            : 
     933                 :            : void
     934                 :          0 : init_sync_libfuncs (int max)
     935                 :            : {
     936                 :          0 :   if (!flag_sync_libcalls)
     937                 :            :     return;
     938                 :            : 
     939                 :          0 :   init_sync_libfuncs_1 (sync_compare_and_swap_optab,
     940                 :            :                         "__sync_val_compare_and_swap", max);
     941                 :          0 :   init_sync_libfuncs_1 (sync_lock_test_and_set_optab,
     942                 :            :                         "__sync_lock_test_and_set", max);
     943                 :            : 
     944                 :          0 :   init_sync_libfuncs_1 (sync_old_add_optab, "__sync_fetch_and_add", max);
     945                 :          0 :   init_sync_libfuncs_1 (sync_old_sub_optab, "__sync_fetch_and_sub", max);
     946                 :          0 :   init_sync_libfuncs_1 (sync_old_ior_optab, "__sync_fetch_and_or", max);
     947                 :          0 :   init_sync_libfuncs_1 (sync_old_and_optab, "__sync_fetch_and_and", max);
     948                 :          0 :   init_sync_libfuncs_1 (sync_old_xor_optab, "__sync_fetch_and_xor", max);
     949                 :          0 :   init_sync_libfuncs_1 (sync_old_nand_optab, "__sync_fetch_and_nand", max);
     950                 :            : 
     951                 :          0 :   init_sync_libfuncs_1 (sync_new_add_optab, "__sync_add_and_fetch", max);
     952                 :          0 :   init_sync_libfuncs_1 (sync_new_sub_optab, "__sync_sub_and_fetch", max);
     953                 :          0 :   init_sync_libfuncs_1 (sync_new_ior_optab, "__sync_or_and_fetch", max);
     954                 :          0 :   init_sync_libfuncs_1 (sync_new_and_optab, "__sync_and_and_fetch", max);
     955                 :          0 :   init_sync_libfuncs_1 (sync_new_xor_optab, "__sync_xor_and_fetch", max);
     956                 :          0 :   init_sync_libfuncs_1 (sync_new_nand_optab, "__sync_nand_and_fetch", max);
     957                 :            : }
     958                 :            : 
     959                 :            : #include "gt-optabs-libfuncs.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.