LCOV - code coverage report
Current view: top level - gcc - optabs-tree.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 182 211 86.3 %
Date: 2020-04-04 11:58:09 Functions: 7 8 87.5 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Tree-based target query functions relating to optabs
       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 "rtl.h"
      27                 :            : #include "tree.h"
      28                 :            : #include "memmodel.h"
      29                 :            : #include "optabs.h"
      30                 :            : #include "optabs-tree.h"
      31                 :            : #include "stor-layout.h"
      32                 :            : 
      33                 :            : /* Return the optab used for computing the operation given by the tree code,
      34                 :            :    CODE and the tree EXP.  This function is not always usable (for example, it
      35                 :            :    cannot give complete results for multiplication or division) but probably
      36                 :            :    ought to be relied on more widely throughout the expander.  */
      37                 :            : optab
      38                 :    3471080 : optab_for_tree_code (enum tree_code code, const_tree type,
      39                 :            :                      enum optab_subtype subtype)
      40                 :            : {
      41                 :    3471080 :   bool trapv;
      42                 :    3471080 :   switch (code)
      43                 :            :     {
      44                 :            :     case BIT_AND_EXPR:
      45                 :            :       return and_optab;
      46                 :            : 
      47                 :      89913 :     case BIT_IOR_EXPR:
      48                 :      89913 :       return ior_optab;
      49                 :            : 
      50                 :        548 :     case BIT_NOT_EXPR:
      51                 :        548 :       return one_cmpl_optab;
      52                 :            : 
      53                 :      32486 :     case BIT_XOR_EXPR:
      54                 :      32486 :       return xor_optab;
      55                 :            : 
      56                 :        334 :     case MULT_HIGHPART_EXPR:
      57                 :        334 :       return TYPE_UNSIGNED (type) ? umul_highpart_optab : smul_highpart_optab;
      58                 :            : 
      59                 :        700 :     case TRUNC_MOD_EXPR:
      60                 :        700 :     case CEIL_MOD_EXPR:
      61                 :        700 :     case FLOOR_MOD_EXPR:
      62                 :        700 :     case ROUND_MOD_EXPR:
      63                 :        700 :       return TYPE_UNSIGNED (type) ? umod_optab : smod_optab;
      64                 :            : 
      65                 :      20287 :     case RDIV_EXPR:
      66                 :      20287 :     case TRUNC_DIV_EXPR:
      67                 :      20287 :     case CEIL_DIV_EXPR:
      68                 :      20287 :     case FLOOR_DIV_EXPR:
      69                 :      20287 :     case ROUND_DIV_EXPR:
      70                 :      20287 :     case EXACT_DIV_EXPR:
      71                 :      20287 :       if (TYPE_SATURATING (type))
      72                 :          0 :         return TYPE_UNSIGNED (type) ? usdiv_optab : ssdiv_optab;
      73                 :      20287 :       return TYPE_UNSIGNED (type) ? udiv_optab : sdiv_optab;
      74                 :            : 
      75                 :      28123 :     case LSHIFT_EXPR:
      76                 :      28123 :       if (TREE_CODE (type) == VECTOR_TYPE)
      77                 :            :         {
      78                 :      27946 :           if (subtype == optab_vector)
      79                 :       7690 :             return TYPE_SATURATING (type) ? unknown_optab : vashl_optab;
      80                 :            : 
      81                 :      20256 :           gcc_assert (subtype == optab_scalar);
      82                 :            :         }
      83                 :      20433 :       if (TYPE_SATURATING (type))
      84                 :          0 :         return TYPE_UNSIGNED (type) ? usashl_optab : ssashl_optab;
      85                 :            :       return ashl_optab;
      86                 :            : 
      87                 :      11194 :     case RSHIFT_EXPR:
      88                 :      11194 :       if (TREE_CODE (type) == VECTOR_TYPE)
      89                 :            :         {
      90                 :      11194 :           if (subtype == optab_vector)
      91                 :       4378 :             return TYPE_UNSIGNED (type) ? vlshr_optab : vashr_optab;
      92                 :            : 
      93                 :       6816 :           gcc_assert (subtype == optab_scalar);
      94                 :            :         }
      95                 :       6816 :       return TYPE_UNSIGNED (type) ? lshr_optab : ashr_optab;
      96                 :            : 
      97                 :         48 :     case LROTATE_EXPR:
      98                 :         48 :       if (TREE_CODE (type) == VECTOR_TYPE)
      99                 :            :         {
     100                 :         48 :           if (subtype == optab_vector)
     101                 :            :             return vrotl_optab;
     102                 :            : 
     103                 :         20 :           gcc_assert (subtype == optab_scalar);
     104                 :            :         }
     105                 :            :       return rotl_optab;
     106                 :            : 
     107                 :        292 :     case RROTATE_EXPR:
     108                 :        292 :       if (TREE_CODE (type) == VECTOR_TYPE)
     109                 :            :         {
     110                 :        292 :           if (subtype == optab_vector)
     111                 :            :             return vrotr_optab;
     112                 :            : 
     113                 :        148 :           gcc_assert (subtype == optab_scalar);
     114                 :            :         }
     115                 :            :       return rotr_optab;
     116                 :            : 
     117                 :      39780 :     case MAX_EXPR:
     118                 :      39780 :       return TYPE_UNSIGNED (type) ? umax_optab : smax_optab;
     119                 :            : 
     120                 :      27374 :     case MIN_EXPR:
     121                 :      27374 :       return TYPE_UNSIGNED (type) ? umin_optab : smin_optab;
     122                 :            : 
     123                 :          0 :     case REALIGN_LOAD_EXPR:
     124                 :          0 :       return vec_realign_load_optab;
     125                 :            : 
     126                 :        393 :     case WIDEN_SUM_EXPR:
     127                 :        393 :       return TYPE_UNSIGNED (type) ? usum_widen_optab : ssum_widen_optab;
     128                 :            : 
     129                 :        190 :     case DOT_PROD_EXPR:
     130                 :        190 :       return TYPE_UNSIGNED (type) ? udot_prod_optab : sdot_prod_optab;
     131                 :            : 
     132                 :        409 :     case SAD_EXPR:
     133                 :        409 :       return TYPE_UNSIGNED (type) ? usad_optab : ssad_optab;
     134                 :            : 
     135                 :       9265 :     case WIDEN_MULT_PLUS_EXPR:
     136                 :       9265 :       return (TYPE_UNSIGNED (type)
     137                 :       2644 :               ? (TYPE_SATURATING (type)
     138                 :       2644 :                  ? usmadd_widen_optab : umadd_widen_optab)
     139                 :       6621 :               : (TYPE_SATURATING (type)
     140                 :      15886 :                  ? ssmadd_widen_optab : smadd_widen_optab));
     141                 :            : 
     142                 :        113 :     case WIDEN_MULT_MINUS_EXPR:
     143                 :        113 :       return (TYPE_UNSIGNED (type)
     144                 :         57 :               ? (TYPE_SATURATING (type)
     145                 :         57 :                  ? usmsub_widen_optab : umsub_widen_optab)
     146                 :         56 :               : (TYPE_SATURATING (type)
     147                 :        169 :                  ? ssmsub_widen_optab : smsub_widen_optab));
     148                 :            : 
     149                 :      13141 :     case VEC_WIDEN_MULT_HI_EXPR:
     150                 :      13141 :       return (TYPE_UNSIGNED (type)
     151                 :      13141 :               ? vec_widen_umult_hi_optab : vec_widen_smult_hi_optab);
     152                 :            : 
     153                 :      13139 :     case VEC_WIDEN_MULT_LO_EXPR:
     154                 :      13139 :       return (TYPE_UNSIGNED (type)
     155                 :      13139 :               ? vec_widen_umult_lo_optab : vec_widen_smult_lo_optab);
     156                 :            : 
     157                 :          0 :     case VEC_WIDEN_MULT_EVEN_EXPR:
     158                 :          0 :       return (TYPE_UNSIGNED (type)
     159                 :          0 :               ? vec_widen_umult_even_optab : vec_widen_smult_even_optab);
     160                 :            : 
     161                 :          0 :     case VEC_WIDEN_MULT_ODD_EXPR:
     162                 :          0 :       return (TYPE_UNSIGNED (type)
     163                 :          0 :               ? vec_widen_umult_odd_optab : vec_widen_smult_odd_optab);
     164                 :            : 
     165                 :        361 :     case VEC_WIDEN_LSHIFT_HI_EXPR:
     166                 :        361 :       return (TYPE_UNSIGNED (type)
     167                 :        361 :               ? vec_widen_ushiftl_hi_optab : vec_widen_sshiftl_hi_optab);
     168                 :            : 
     169                 :        361 :     case VEC_WIDEN_LSHIFT_LO_EXPR:
     170                 :        361 :       return (TYPE_UNSIGNED (type)
     171                 :        361 :               ? vec_widen_ushiftl_lo_optab : vec_widen_sshiftl_lo_optab);
     172                 :            : 
     173                 :       7269 :     case VEC_UNPACK_HI_EXPR:
     174                 :       7269 :       return (TYPE_UNSIGNED (type)
     175                 :       7269 :               ? vec_unpacku_hi_optab : vec_unpacks_hi_optab);
     176                 :            : 
     177                 :       7252 :     case VEC_UNPACK_LO_EXPR:
     178                 :       7252 :       return (TYPE_UNSIGNED (type)
     179                 :       7252 :               ? vec_unpacku_lo_optab : vec_unpacks_lo_optab);
     180                 :            : 
     181                 :       1042 :     case VEC_UNPACK_FLOAT_HI_EXPR:
     182                 :            :       /* The signedness is determined from input operand.  */
     183                 :       1042 :       return (TYPE_UNSIGNED (type)
     184                 :       1042 :               ? vec_unpacku_float_hi_optab : vec_unpacks_float_hi_optab);
     185                 :            : 
     186                 :       1042 :     case VEC_UNPACK_FLOAT_LO_EXPR:
     187                 :            :       /* The signedness is determined from input operand.  */
     188                 :       1042 :       return (TYPE_UNSIGNED (type)
     189                 :       1042 :               ? vec_unpacku_float_lo_optab : vec_unpacks_float_lo_optab);
     190                 :            : 
     191                 :         52 :     case VEC_UNPACK_FIX_TRUNC_HI_EXPR:
     192                 :            :       /* The signedness is determined from output operand.  */
     193                 :         52 :       return (TYPE_UNSIGNED (type)
     194                 :         52 :               ? vec_unpack_ufix_trunc_hi_optab
     195                 :         52 :               : vec_unpack_sfix_trunc_hi_optab);
     196                 :            : 
     197                 :         52 :     case VEC_UNPACK_FIX_TRUNC_LO_EXPR:
     198                 :            :       /* The signedness is determined from output operand.  */
     199                 :         52 :       return (TYPE_UNSIGNED (type)
     200                 :         52 :               ? vec_unpack_ufix_trunc_lo_optab
     201                 :         52 :               : vec_unpack_sfix_trunc_lo_optab);
     202                 :            : 
     203                 :      10067 :     case VEC_PACK_TRUNC_EXPR:
     204                 :      10067 :       return vec_pack_trunc_optab;
     205                 :            : 
     206                 :          0 :     case VEC_PACK_SAT_EXPR:
     207                 :          0 :       return TYPE_UNSIGNED (type) ? vec_pack_usat_optab : vec_pack_ssat_optab;
     208                 :            : 
     209                 :        291 :     case VEC_PACK_FIX_TRUNC_EXPR:
     210                 :            :       /* The signedness is determined from output operand.  */
     211                 :        291 :       return (TYPE_UNSIGNED (type)
     212                 :        291 :               ? vec_pack_ufix_trunc_optab : vec_pack_sfix_trunc_optab);
     213                 :            : 
     214                 :         54 :     case VEC_PACK_FLOAT_EXPR:
     215                 :            :       /* The signedness is determined from input operand.  */
     216                 :         54 :       return (TYPE_UNSIGNED (type)
     217                 :         54 :               ? vec_packu_float_optab : vec_packs_float_optab);
     218                 :            : 
     219                 :          0 :     case VEC_DUPLICATE_EXPR:
     220                 :          0 :       return vec_duplicate_optab;
     221                 :            : 
     222                 :          0 :     case VEC_SERIES_EXPR:
     223                 :          0 :       return vec_series_optab;
     224                 :            : 
     225                 :    2939480 :     default:
     226                 :    2939480 :       break;
     227                 :            :     }
     228                 :            : 
     229                 :    2939480 :   trapv = INTEGRAL_TYPE_P (type) && TYPE_OVERFLOW_TRAPS (type);
     230                 :    2939480 :   switch (code)
     231                 :            :     {
     232                 :    2430010 :     case POINTER_PLUS_EXPR:
     233                 :    2430010 :     case PLUS_EXPR:
     234                 :    2430010 :       if (TYPE_SATURATING (type))
     235                 :          0 :         return TYPE_UNSIGNED (type) ? usadd_optab : ssadd_optab;
     236                 :    2430010 :       return trapv ? addv_optab : add_optab;
     237                 :            : 
     238                 :     334617 :     case POINTER_DIFF_EXPR:
     239                 :     334617 :     case MINUS_EXPR:
     240                 :     334617 :       if (TYPE_SATURATING (type))
     241                 :          0 :         return TYPE_UNSIGNED (type) ? ussub_optab : sssub_optab;
     242                 :     334617 :       return trapv ? subv_optab : sub_optab;
     243                 :            : 
     244                 :     121861 :     case MULT_EXPR:
     245                 :     121861 :       if (TYPE_SATURATING (type))
     246                 :          0 :         return TYPE_UNSIGNED (type) ? usmul_optab : ssmul_optab;
     247                 :     121861 :       return trapv ? smulv_optab : smul_optab;
     248                 :            : 
     249                 :      35404 :     case NEGATE_EXPR:
     250                 :      35404 :       if (TYPE_SATURATING (type))
     251                 :          0 :         return TYPE_UNSIGNED (type) ? usneg_optab : ssneg_optab;
     252                 :      35404 :       return trapv ? negv_optab : neg_optab;
     253                 :            : 
     254                 :        212 :     case ABS_EXPR:
     255                 :        212 :       return trapv ? absv_optab : abs_optab;
     256                 :            : 
     257                 :            :     case ABSU_EXPR:
     258                 :            :       return abs_optab;
     259                 :      17315 :     default:
     260                 :      17315 :       return unknown_optab;
     261                 :            :     }
     262                 :            : }
     263                 :            : 
     264                 :            : /* Function supportable_convert_operation
     265                 :            : 
     266                 :            :    Check whether an operation represented by the code CODE is a
     267                 :            :    convert operation that is supported by the target platform in
     268                 :            :    vector form (i.e., when operating on arguments of type VECTYPE_IN
     269                 :            :    producing a result of type VECTYPE_OUT).
     270                 :            : 
     271                 :            :    Convert operations we currently support directly are FIX_TRUNC and FLOAT.
     272                 :            :    This function checks if these operations are supported
     273                 :            :    by the target platform directly (via vector tree-codes).
     274                 :            : 
     275                 :            :    Output:
     276                 :            :    - CODE1 is code of vector operation to be used when
     277                 :            :    vectorizing the operation, if available.  */
     278                 :            : 
     279                 :            : bool
     280                 :      13784 : supportable_convert_operation (enum tree_code code,
     281                 :            :                                tree vectype_out, tree vectype_in,
     282                 :            :                                enum tree_code *code1)
     283                 :            : {
     284                 :      13784 :   machine_mode m1,m2;
     285                 :      13784 :   bool truncp;
     286                 :            : 
     287                 :      13784 :   gcc_assert (VECTOR_TYPE_P (vectype_out) && VECTOR_TYPE_P (vectype_in));
     288                 :            : 
     289                 :      13784 :   m1 = TYPE_MODE (vectype_out);
     290                 :      13784 :   m2 = TYPE_MODE (vectype_in);
     291                 :            : 
     292                 :      13784 :   if (!VECTOR_MODE_P (m1) || !VECTOR_MODE_P (m2))
     293                 :            :     return false;
     294                 :            : 
     295                 :            :   /* First check if we can done conversion directly.  */
     296                 :      13362 :   if ((code == FIX_TRUNC_EXPR
     297                 :        275 :        && can_fix_p (m1,m2,TYPE_UNSIGNED (vectype_out), &truncp)
     298                 :            :           != CODE_FOR_nothing)
     299                 :      13400 :       || (code == FLOAT_EXPR
     300                 :       1928 :           && can_float_p (m1,m2,TYPE_UNSIGNED (vectype_in))
     301                 :            :              != CODE_FOR_nothing))
     302                 :            :     {
     303                 :       1993 :       *code1 = code;
     304                 :       1993 :       return true;
     305                 :            :     }
     306                 :            : 
     307                 :      22738 :   if (GET_MODE_UNIT_PRECISION (m1) > GET_MODE_UNIT_PRECISION (m2)
     308                 :      11586 :       && can_extend_p (m1, m2, TYPE_UNSIGNED (vectype_in)))
     309                 :            :     {
     310                 :          0 :       *code1 = code;
     311                 :          0 :       return true;
     312                 :            :     }
     313                 :            : 
     314                 :      22738 :   if (GET_MODE_UNIT_PRECISION (m1) < GET_MODE_UNIT_PRECISION (m2)
     315                 :      11369 :       && convert_optab_handler (trunc_optab, m1, m2) != CODE_FOR_nothing)
     316                 :            :     {
     317                 :          0 :       *code1 = code;
     318                 :          0 :       return true;
     319                 :            :     }
     320                 :            : 
     321                 :            :   return false;
     322                 :            : }
     323                 :            : 
     324                 :            : /* Return TRUE if appropriate vector insn is available
     325                 :            :    for vector comparison expr with vector type VALUE_TYPE
     326                 :            :    and resulting mask with MASK_TYPE.  */
     327                 :            : 
     328                 :            : bool
     329                 :      26308 : expand_vec_cmp_expr_p (tree value_type, tree mask_type, enum tree_code code)
     330                 :            : {
     331                 :     105232 :   if (get_vec_cmp_icode (TYPE_MODE (value_type), TYPE_MODE (mask_type),
     332                 :      26308 :                          TYPE_UNSIGNED (value_type)) != CODE_FOR_nothing)
     333                 :            :     return true;
     334                 :       5464 :   if ((code == EQ_EXPR || code == NE_EXPR)
     335                 :      12601 :       && (get_vec_cmp_eq_icode (TYPE_MODE (value_type), TYPE_MODE (mask_type))
     336                 :            :           != CODE_FOR_nothing))
     337                 :          0 :     return true;
     338                 :            :   return false;
     339                 :            : }
     340                 :            : 
     341                 :            : /* Return true iff vcond_optab/vcondu_optab can handle a vector
     342                 :            :    comparison for code CODE, comparing operands of type CMP_OP_TYPE and
     343                 :            :    producing a result of type VALUE_TYPE.  */
     344                 :            : 
     345                 :            : static bool
     346                 :       8749 : vcond_icode_p (tree value_type, tree cmp_op_type, enum tree_code code)
     347                 :            : {
     348                 :      17498 :   return can_vcond_compare_p (get_rtx_code (code, TYPE_UNSIGNED (cmp_op_type)),
     349                 :      17498 :                               TYPE_MODE (value_type), TYPE_MODE (cmp_op_type));
     350                 :            : }
     351                 :            : 
     352                 :            : /* Return true iff vcondeq_optab can handle a vector comparison for code CODE,
     353                 :            :    comparing operands of type CMP_OP_TYPE and producing a result of type
     354                 :            :    VALUE_TYPE.  */
     355                 :            : 
     356                 :            : static bool
     357                 :       2951 : vcond_eq_icode_p (tree value_type, tree cmp_op_type, enum tree_code code)
     358                 :            : {
     359                 :       2951 :   if (code != EQ_EXPR && code != NE_EXPR)
     360                 :            :     return false;
     361                 :            : 
     362                 :       2732 :   return get_vcond_eq_icode (TYPE_MODE (value_type), TYPE_MODE (cmp_op_type))
     363                 :       1366 :          != CODE_FOR_nothing;
     364                 :            : }
     365                 :            : 
     366                 :            : /* Return TRUE iff, appropriate vector insns are available
     367                 :            :    for vector cond expr with vector type VALUE_TYPE and a comparison
     368                 :            :    with operand vector types in CMP_OP_TYPE.  */
     369                 :            : 
     370                 :            : bool
     371                 :      13658 : expand_vec_cond_expr_p (tree value_type, tree cmp_op_type, enum tree_code code)
     372                 :            : {
     373                 :      13658 :   machine_mode value_mode = TYPE_MODE (value_type);
     374                 :      13658 :   machine_mode cmp_op_mode = TYPE_MODE (cmp_op_type);
     375                 :      13658 :   if (VECTOR_BOOLEAN_TYPE_P (cmp_op_type)
     376                 :      18199 :       && get_vcond_mask_icode (TYPE_MODE (value_type),
     377                 :       4541 :                                TYPE_MODE (cmp_op_type)) != CODE_FOR_nothing)
     378                 :            :     return true;
     379                 :            : 
     380                 :      27360 :   if (maybe_ne (GET_MODE_SIZE (value_mode), GET_MODE_SIZE (cmp_op_mode))
     381                 :      27234 :       || maybe_ne (GET_MODE_NUNITS (value_mode), GET_MODE_NUNITS (cmp_op_mode)))
     382                 :        368 :     return false;
     383                 :            : 
     384                 :       8752 :   if (TREE_CODE_CLASS (code) != tcc_comparison)
     385                 :            :     /* This may happen, for example, if code == SSA_NAME, in which case we
     386                 :            :        cannot be certain whether a vector insn is available.  */
     387                 :            :     return false;
     388                 :            : 
     389                 :       8749 :   return vcond_icode_p (value_type, cmp_op_type, code)
     390                 :       8749 :          || vcond_eq_icode_p (value_type, cmp_op_type, code);
     391                 :            : }
     392                 :            : 
     393                 :            : /* Use the current target and options to initialize
     394                 :            :    TREE_OPTIMIZATION_OPTABS (OPTNODE).  */
     395                 :            : 
     396                 :            : void
     397                 :     992243 : init_tree_optimization_optabs (tree optnode)
     398                 :            : {
     399                 :            :   /* Quick exit if we have already computed optabs for this target.  */
     400                 :     992243 :   if (TREE_OPTIMIZATION_BASE_OPTABS (optnode) == this_target_optabs)
     401                 :            :     return;
     402                 :            : 
     403                 :            :   /* Forget any previous information and set up for the current target.  */
     404                 :      10404 :   TREE_OPTIMIZATION_BASE_OPTABS (optnode) = this_target_optabs;
     405                 :      10404 :   struct target_optabs *tmp_optabs = (struct target_optabs *)
     406                 :      10404 :     TREE_OPTIMIZATION_OPTABS (optnode);
     407                 :      10404 :   if (tmp_optabs)
     408                 :        173 :     memset (tmp_optabs, 0, sizeof (struct target_optabs));
     409                 :            :   else
     410                 :      10231 :     tmp_optabs = ggc_cleared_alloc<target_optabs> ();
     411                 :            : 
     412                 :            :   /* Generate a new set of optabs into tmp_optabs.  */
     413                 :      10404 :   init_all_optabs (tmp_optabs);
     414                 :            : 
     415                 :            :   /* If the optabs changed, record it.  */
     416                 :      10404 :   if (memcmp (tmp_optabs, this_target_optabs, sizeof (struct target_optabs)))
     417                 :        205 :     TREE_OPTIMIZATION_OPTABS (optnode) = tmp_optabs;
     418                 :            :   else
     419                 :            :     {
     420                 :      10199 :       TREE_OPTIMIZATION_OPTABS (optnode) = NULL;
     421                 :      10199 :       ggc_free (tmp_optabs);
     422                 :            :     }
     423                 :            : }
     424                 :            : 
     425                 :            : /* Return TRUE if the target has support for vector right shift of an
     426                 :            :    operand of type TYPE.  If OT_TYPE is OPTAB_DEFAULT, check for existence
     427                 :            :    of a shift by either a scalar or a vector.  Otherwise, check only
     428                 :            :    for a shift that matches OT_TYPE.  */
     429                 :            : 
     430                 :            : bool
     431                 :          0 : target_supports_op_p (tree type, enum tree_code code,
     432                 :            :                       enum optab_subtype ot_subtype)
     433                 :            : {
     434                 :          0 :   optab ot = optab_for_tree_code (code, type, ot_subtype);
     435                 :          0 :   return (ot != unknown_optab
     436                 :          0 :           && optab_handler (ot, TYPE_MODE (type)) != CODE_FOR_nothing);
     437                 :            : }
     438                 :            : 

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.