LCOV - code coverage report
Current view: top level - gcc - internal-fn.h (source / functions) Hit Total Coverage
Test: gcc.info Lines: 15 15 100.0 %
Date: 2020-03-28 11:57:23 Functions: 0 0 -
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Internal functions.
       2                 :            :    Copyright (C) 2011-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                 :            : #ifndef GCC_INTERNAL_FN_H
      21                 :            : #define GCC_INTERNAL_FN_H
      22                 :            : 
      23                 :            : /* INTEGER_CST values for IFN_UNIQUE function arg-0.
      24                 :            : 
      25                 :            :    UNSPEC: Undifferentiated UNIQUE.
      26                 :            : 
      27                 :            :    FORK and JOIN mark the points at which OpenACC partitioned
      28                 :            :    execution is entered or exited.
      29                 :            :       DEP_VAR = UNIQUE ({FORK,JOIN}, DEP_VAR, AXIS)
      30                 :            : 
      31                 :            :    HEAD_MARK and TAIL_MARK are used to demark the sequence entering
      32                 :            :    or leaving partitioned execution.
      33                 :            :       DEP_VAR = UNIQUE ({HEAD,TAIL}_MARK, REMAINING_MARKS, ...PRIMARY_FLAGS)
      34                 :            : 
      35                 :            :    The PRIMARY_FLAGS only occur on the first HEAD_MARK of a sequence.  */
      36                 :            : #define IFN_UNIQUE_CODES                                  \
      37                 :            :   DEF(UNSPEC),  \
      38                 :            :     DEF(OACC_FORK), DEF(OACC_JOIN),             \
      39                 :            :     DEF(OACC_HEAD_MARK), DEF(OACC_TAIL_MARK)
      40                 :            : 
      41                 :            : enum ifn_unique_kind {
      42                 :            : #define DEF(X) IFN_UNIQUE_##X
      43                 :            :   IFN_UNIQUE_CODES
      44                 :            : #undef DEF
      45                 :            : };
      46                 :            : 
      47                 :            : /* INTEGER_CST values for IFN_GOACC_LOOP arg-0.  Allows the precise
      48                 :            :    stepping of the compute geometry over the loop iterations to be
      49                 :            :    deferred until it is known which compiler is generating the code.
      50                 :            :    The action is encoded in a constant first argument.
      51                 :            : 
      52                 :            :      CHUNK_MAX = LOOP (CODE_CHUNKS, DIR, RANGE, STEP, CHUNK_SIZE, MASK)
      53                 :            :      STEP = LOOP (CODE_STEP, DIR, RANGE, STEP, CHUNK_SIZE, MASK)
      54                 :            :      OFFSET = LOOP (CODE_OFFSET, DIR, RANGE, STEP, CHUNK_SIZE, MASK, CHUNK_NO)
      55                 :            :      BOUND = LOOP (CODE_BOUND, DIR, RANGE, STEP, CHUNK_SIZE, MASK, OFFSET)
      56                 :            : 
      57                 :            :      DIR - +1 for up loop, -1 for down loop
      58                 :            :      RANGE - Range of loop (END - BASE)
      59                 :            :      STEP - iteration step size
      60                 :            :      CHUNKING - size of chunking, (constant zero for no chunking)
      61                 :            :      CHUNK_NO - chunk number
      62                 :            :      MASK - partitioning mask.  */
      63                 :            : 
      64                 :            : #define IFN_GOACC_LOOP_CODES \
      65                 :            :   DEF(CHUNKS), DEF(STEP), DEF(OFFSET), DEF(BOUND)
      66                 :            : enum ifn_goacc_loop_kind {
      67                 :            : #define DEF(X) IFN_GOACC_LOOP_##X
      68                 :            :   IFN_GOACC_LOOP_CODES
      69                 :            : #undef DEF
      70                 :            : };
      71                 :            : 
      72                 :            : /* The GOACC_REDUCTION function defines a generic interface to support
      73                 :            :    gang, worker and vector reductions.  All calls are of the following
      74                 :            :    form:
      75                 :            : 
      76                 :            :      V = REDUCTION (CODE, REF_TO_RES, LOCAL_VAR, LEVEL, OP, OFFSET)
      77                 :            : 
      78                 :            :    REF_TO_RES - is a reference to the original reduction varl, may be NULL
      79                 :            :    LOCAL_VAR is the intermediate reduction variable
      80                 :            :    LEVEL corresponds to the GOMP_DIM of the reduction
      81                 :            :    OP is the tree code of the reduction operation
      82                 :            :    OFFSET may be used as an offset into a reduction array for the
      83                 :            :           reductions occuring at this level.
      84                 :            :    In general the return value is LOCAL_VAR, which creates a data
      85                 :            :    dependency between calls operating on the same reduction.  */
      86                 :            : 
      87                 :            : #define IFN_GOACC_REDUCTION_CODES \
      88                 :            :   DEF(SETUP), DEF(INIT), DEF(FINI), DEF(TEARDOWN)
      89                 :            : enum ifn_goacc_reduction_kind {
      90                 :            : #define DEF(X) IFN_GOACC_REDUCTION_##X
      91                 :            :   IFN_GOACC_REDUCTION_CODES
      92                 :            : #undef DEF
      93                 :            : };
      94                 :            : 
      95                 :            : /* Initialize internal function tables.  */
      96                 :            : 
      97                 :            : extern void init_internal_fns ();
      98                 :            : 
      99                 :            : /* Return the name of internal function FN.  The name is only meaningful
     100                 :            :    for dumps; it has no linkage.  */
     101                 :            : 
     102                 :            : extern const char *const internal_fn_name_array[];
     103                 :            : 
     104                 :            : static inline const char *
     105                 :      15935 : internal_fn_name (enum internal_fn fn)
     106                 :            : {
     107                 :      15935 :   return internal_fn_name_array[(int) fn];
     108                 :            : }
     109                 :            : 
     110                 :            : extern internal_fn lookup_internal_fn (const char *);
     111                 :            : 
     112                 :            : /* Return the ECF_* flags for function FN.  */
     113                 :            : 
     114                 :            : extern const int internal_fn_flags_array[];
     115                 :            : 
     116                 :            : static inline int
     117                 :   37100891 : internal_fn_flags (enum internal_fn fn)
     118                 :            : {
     119                 :   37100891 :   return internal_fn_flags_array[(int) fn];
     120                 :            : }
     121                 :            : 
     122                 :            : /* Return fnspec for function FN.  */
     123                 :            : 
     124                 :            : extern GTY(()) const_tree internal_fn_fnspec_array[IFN_LAST + 1];
     125                 :            : 
     126                 :            : static inline const_tree
     127                 :     763718 : internal_fn_fnspec (enum internal_fn fn)
     128                 :            : {
     129                 :     763718 :   return internal_fn_fnspec_array[(int) fn];
     130                 :            : }
     131                 :            : 
     132                 :            : /* Describes an internal function that maps directly to an optab.  */
     133                 :            : struct direct_internal_fn_info
     134                 :            : {
     135                 :            :   /* optabs can be parameterized by one or two modes.  These fields describe
     136                 :            :      how to select those modes from the types of the return value and
     137                 :            :      arguments.  A value of -1 says that the mode is determined by the
     138                 :            :      return type while a value N >= 0 says that the mode is determined by
     139                 :            :      the type of argument N.  A value of -2 says that this internal
     140                 :            :      function isn't directly mapped to an optab.  */
     141                 :            :   signed int type0 : 8;
     142                 :            :   signed int type1 : 8;
     143                 :            :   /* True if the function is pointwise, so that it can be vectorized by
     144                 :            :      converting the return type and all argument types to vectors of the
     145                 :            :      same number of elements.  E.g. we can vectorize an IFN_SQRT on
     146                 :            :      floats as an IFN_SQRT on vectors of N floats.
     147                 :            : 
     148                 :            :      This only needs 1 bit, but occupies the full 16 to ensure a nice
     149                 :            :      layout.  */
     150                 :            :   unsigned int vectorizable : 16;
     151                 :            : };
     152                 :            : 
     153                 :            : extern const direct_internal_fn_info direct_internal_fn_array[IFN_LAST + 1];
     154                 :            : 
     155                 :            : /* Return true if FN is mapped directly to an optab.  */
     156                 :            : 
     157                 :            : inline bool
     158                 :     623029 : direct_internal_fn_p (internal_fn fn)
     159                 :            : {
     160                 :     622635 :   return direct_internal_fn_array[fn].type0 >= -1;
     161                 :            : }
     162                 :            : 
     163                 :            : /* Return true if FN is a direct internal function that can be vectorized by
     164                 :            :    converting the return type and all argument types to vectors of the same
     165                 :            :    number of elements.  E.g. we can vectorize an IFN_SQRT on floats as an
     166                 :            :    IFN_SQRT on vectors of N floats.  */
     167                 :            : 
     168                 :            : inline bool
     169                 :          2 : vectorizable_internal_fn_p (internal_fn fn)
     170                 :            : {
     171                 :          2 :   return direct_internal_fn_array[fn].vectorizable;
     172                 :            : }
     173                 :            : 
     174                 :            : /* Return optab information about internal function FN.  Only meaningful
     175                 :            :    if direct_internal_fn_p (FN).  */
     176                 :            : 
     177                 :            : inline const direct_internal_fn_info &
     178                 :     613716 : direct_internal_fn (internal_fn fn)
     179                 :            : {
     180                 :     613716 :   gcc_checking_assert (direct_internal_fn_p (fn));
     181                 :     613716 :   return direct_internal_fn_array[fn];
     182                 :            : }
     183                 :            : 
     184                 :            : extern tree_pair direct_internal_fn_types (internal_fn, tree, tree *);
     185                 :            : extern tree_pair direct_internal_fn_types (internal_fn, gcall *);
     186                 :            : extern bool direct_internal_fn_supported_p (internal_fn, tree_pair,
     187                 :            :                                             optimization_type);
     188                 :            : extern bool direct_internal_fn_supported_p (internal_fn, tree,
     189                 :            :                                             optimization_type);
     190                 :            : extern bool direct_internal_fn_supported_p (gcall *, optimization_type);
     191                 :            : 
     192                 :            : /* Return true if FN is supported for types TYPE0 and TYPE1 when the
     193                 :            :    optimization type is OPT_TYPE.  The types are those associated with
     194                 :            :    the "type0" and "type1" fields of FN's direct_internal_fn_info
     195                 :            :    structure.  */
     196                 :            : 
     197                 :            : inline bool
     198                 :      13695 : direct_internal_fn_supported_p (internal_fn fn, tree type0, tree type1,
     199                 :            :                                 optimization_type opt_type)
     200                 :            : {
     201                 :      13695 :   return direct_internal_fn_supported_p (fn, tree_pair (type0, type1),
     202                 :            :                                          opt_type);
     203                 :            : }
     204                 :            : 
     205                 :            : extern int first_commutative_argument (internal_fn);
     206                 :            : 
     207                 :            : extern bool set_edom_supported_p (void);
     208                 :            : 
     209                 :            : extern internal_fn get_conditional_internal_fn (tree_code);
     210                 :            : extern internal_fn get_conditional_internal_fn (internal_fn);
     211                 :            : extern tree_code conditional_internal_fn_code (internal_fn);
     212                 :            : extern internal_fn get_unconditional_internal_fn (internal_fn);
     213                 :            : extern bool can_interpret_as_conditional_op_p (gimple *, tree *,
     214                 :            :                                                tree_code *, tree (&)[3],
     215                 :            :                                                tree *);
     216                 :            : 
     217                 :            : extern bool internal_load_fn_p (internal_fn);
     218                 :            : extern bool internal_store_fn_p (internal_fn);
     219                 :            : extern bool internal_gather_scatter_fn_p (internal_fn);
     220                 :            : extern int internal_fn_mask_index (internal_fn);
     221                 :            : extern int internal_fn_stored_value_index (internal_fn);
     222                 :            : extern bool internal_gather_scatter_fn_supported_p (internal_fn, tree,
     223                 :            :                                                     tree, tree, int);
     224                 :            : extern bool internal_check_ptrs_fn_supported_p (internal_fn, tree,
     225                 :            :                                                 poly_uint64, unsigned int);
     226                 :            : 
     227                 :            : extern void expand_internal_call (gcall *);
     228                 :            : extern void expand_internal_call (internal_fn, gcall *);
     229                 :            : extern void expand_PHI (internal_fn, gcall *);
     230                 :            : 
     231                 :            : extern bool vectorized_internal_fn_supported_p (internal_fn, tree);
     232                 :            : 
     233                 :            : #endif

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.