LCOV - code coverage report
Current view: top level - gcc - function-abi.h (source / functions) Hit Total Coverage
Test: gcc.info Lines: 42 44 95.5 %
Date: 2020-05-30 12:51:24 Functions: 3 5 60.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Information about fuunction binary interfaces.
       2                 :            :    Copyright (C) 2019-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_FUNCTION_ABI_H
      21                 :            : #define GCC_FUNCTION_ABI_H
      22                 :            : 
      23                 :            : /* Most targets use the same ABI for all functions in a translation
      24                 :            :    unit, but some targets support interoperability between several ABIs.
      25                 :            :    Each such ABI has a unique 0-based identifier, with 0 always being
      26                 :            :    the default choice of ABI.
      27                 :            : 
      28                 :            :    NUM_ABI_IDS is the maximum number of such ABIs that GCC can handle at once.
      29                 :            :    A bitfield with this number of bits can represent any combinaion of the
      30                 :            :    supported ABIs.  */
      31                 :            : const size_t NUM_ABI_IDS = 8;
      32                 :            : 
      33                 :            : /* Information about one of the target's predefined ABIs.  */
      34                 :            : class predefined_function_abi
      35                 :            : {
      36                 :            : public:
      37                 :            :   /* A target-specific identifier for this ABI.  The value must be in
      38                 :            :      the range [0, NUM_ABI_IDS - 1].  */
      39                 :   51137036 :   unsigned int id () const { return m_id; }
      40                 :            : 
      41                 :            :   /* True if this ABI has been initialized.  */
      42                 :            :   bool initialized_p () const { return m_initialized; }
      43                 :            : 
      44                 :            :   /* Return true if a function call is allowed to alter every bit of
      45                 :            :      register REGNO, so that the register contains an arbitrary value
      46                 :            :      on return.  If so, the register cannot hold any part of a value
      47                 :            :      that is live across a call.  */
      48                 :            :   bool
      49                 : 3846387434 :   clobbers_full_reg_p (unsigned int regno) const
      50                 :            :   {
      51                 :  550650434 :     return TEST_HARD_REG_BIT (m_full_reg_clobbers, regno);
      52                 :            :   }
      53                 :            : 
      54                 :            :   /* Return true if a function call is allowed to alter some or all bits
      55                 :            :      of register REGNO.
      56                 :            : 
      57                 :            :      This is true whenever clobbers_full_reg_p (REGNO) is true.  It is
      58                 :            :      also true if, for example, the ABI says that a call must preserve the
      59                 :            :      low 32 or 64 bits of REGNO, but can clobber the upper bits of REGNO.
      60                 :            :      In the latter case, it is possible for REGNO to hold values that
      61                 :            :      are live across a call, provided that the value occupies only the
      62                 :            :      call-preserved part of the register.  */
      63                 :            :   bool
      64                 :  272242700 :   clobbers_at_least_part_of_reg_p (unsigned int regno) const
      65                 :            :   {
      66                 :  272242700 :     return TEST_HARD_REG_BIT (m_full_and_partial_reg_clobbers, regno);
      67                 :            :   }
      68                 :            : 
      69                 :            :   /* Return true if a function call is allowed to clobber at least part
      70                 :            :      of (reg:MODE REGNO).  If so, it is not possible for the register
      71                 :            :      as a whole to be live across a call.  */
      72                 :            :   bool
      73                 :          0 :   clobbers_reg_p (machine_mode mode, unsigned int regno) const
      74                 :            :   {
      75                 :          0 :     return overlaps_hard_reg_set_p (m_mode_clobbers[mode], mode, regno);
      76                 :            :   }
      77                 :            : 
      78                 :            :   /* Return the set of registers that a function call is allowed to
      79                 :            :      alter completely, so that the registers contain arbitrary values
      80                 :            :      on return.  This doesn't include registers that a call can only
      81                 :            :      partly clobber (as per TARGET_HARD_REGNO_CALL_PART_CLOBBERED).
      82                 :            : 
      83                 :            :      These registers cannot hold any part of a value that is live across
      84                 :            :      a call.  */
      85                 :   85735310 :   HARD_REG_SET full_reg_clobbers () const { return m_full_reg_clobbers; }
      86                 :            : 
      87                 :            :   /* Return the set of registers that a function call is allowed to alter
      88                 :            :      to some degree.  For example, if an ABI says that a call must preserve
      89                 :            :      the low 32 or 64 bits of a register R, but can clobber the upper bits
      90                 :            :      of R, R would be in this set but not in full_reg_clobbers ().
      91                 :            : 
      92                 :            :      This set is a superset of full_reg_clobbers ().  It is possible for a
      93                 :            :      register in full_and_partial_reg_clobbers () & ~full_reg_clobbers ()
      94                 :            :      to contain values that are live across a call, provided that the live
      95                 :            :      value only occupies the call-preserved part of the register.  */
      96                 :            :   HARD_REG_SET
      97                 :  267830856 :   full_and_partial_reg_clobbers () const
      98                 :            :   {
      99                 :  267268756 :     return m_full_and_partial_reg_clobbers;
     100                 :            :   }
     101                 :            : 
     102                 :            :   /* Return the set of registers that cannot be used to hold a value of
     103                 :            :      mode MODE across a function call.  That is:
     104                 :            : 
     105                 :            :        (reg:REGNO MODE)
     106                 :            : 
     107                 :            :      might be clobbered by a call whenever:
     108                 :            : 
     109                 :            :        overlaps_hard_reg_set (mode_clobbers (MODE), MODE, REGNO)
     110                 :            : 
     111                 :            :      In allocation terms, the registers in the returned set conflict
     112                 :            :      with any value of mode MODE that is live across a call.  */
     113                 :            :   HARD_REG_SET
     114                 :  184714993 :   mode_clobbers (machine_mode mode) const
     115                 :            :   {
     116                 :  184714993 :     return m_mode_clobbers[mode];
     117                 :            :   }
     118                 :            : 
     119                 :            :   void initialize (unsigned int, const_hard_reg_set);
     120                 :            :   void add_full_reg_clobber (unsigned int);
     121                 :            : 
     122                 :            : private:
     123                 :            :   unsigned int m_id : NUM_ABI_IDS;
     124                 :            :   unsigned int m_initialized : 1;
     125                 :            :   HARD_REG_SET m_full_reg_clobbers;
     126                 :            :   HARD_REG_SET m_full_and_partial_reg_clobbers;
     127                 :            :   HARD_REG_SET m_mode_clobbers[NUM_MACHINE_MODES];
     128                 :            : };
     129                 :            : 
     130                 :            : /* Describes either a predefined ABI or the ABI of a particular function.
     131                 :            :    In the latter case, the ABI might make use of extra function-specific
     132                 :            :    information, such as for -fipa-ra.  */
     133                 :            : class function_abi
     134                 :            : {
     135                 :            : public:
     136                 :            :   /* Initialize the structure for a general function with the given ABI.  */
     137                 :  192697931 :   function_abi (const predefined_function_abi &base_abi)
     138                 :  192697931 :     : m_base_abi (&base_abi),
     139                 :  192697931 :       m_mask (base_abi.full_and_partial_reg_clobbers ()) {}
     140                 :            : 
     141                 :            :   /* Initialize the structure for a function that has the given ABI and
     142                 :            :      that is known not to clobber registers outside MASK.  */
     143                 :   17611900 :   function_abi (const predefined_function_abi &base_abi,
     144                 :            :                 const_hard_reg_set mask)
     145                 :   17611900 :     : m_base_abi (&base_abi), m_mask (mask) {}
     146                 :            : 
     147                 :            :   /* The predefined ABI from which this ABI is derived.  */
     148                 :     965920 :   const predefined_function_abi &base_abi () const { return *m_base_abi; }
     149                 :            : 
     150                 :            :   /* The target-specific identifier of the predefined ABI.  */
     151                 :   51136428 :   unsigned int id () const { return m_base_abi->id (); }
     152                 :            : 
     153                 :            :   /* See the corresponding predefined_function_abi functions for
     154                 :            :      details about the following functions.  */
     155                 :            : 
     156                 :            :   HARD_REG_SET
     157                 :   10097653 :   full_reg_clobbers () const
     158                 :            :   {
     159                 :   20195316 :     return m_mask & m_base_abi->full_reg_clobbers ();
     160                 :            :   }
     161                 :            : 
     162                 :            :   HARD_REG_SET
     163                 :   63364836 :   full_and_partial_reg_clobbers () const
     164                 :            :   {
     165                 :  126729592 :     return m_mask & m_base_abi->full_and_partial_reg_clobbers ();
     166                 :            :   }
     167                 :            : 
     168                 :            :   HARD_REG_SET
     169                 :  147888593 :   mode_clobbers (machine_mode mode) const
     170                 :            :   {
     171                 :  295776490 :     return m_mask & m_base_abi->mode_clobbers (mode);
     172                 :            :   }
     173                 :            : 
     174                 :            :   bool
     175                 : 3295740000 :   clobbers_full_reg_p (unsigned int regno) const
     176                 :            :   {
     177                 : 3295740000 :     return (TEST_HARD_REG_BIT (m_mask, regno)
     178                 : 3295740000 :             & m_base_abi->clobbers_full_reg_p (regno));
     179                 :            :   }
     180                 :            : 
     181                 :            :   bool
     182                 :  231978000 :   clobbers_at_least_part_of_reg_p (unsigned int regno) const
     183                 :            :   {
     184                 :  231978000 :     return (TEST_HARD_REG_BIT (m_mask, regno)
     185                 :  231978000 :             & m_base_abi->clobbers_at_least_part_of_reg_p (regno));
     186                 :            :   }
     187                 :            : 
     188                 :            :   bool
     189                 :  106260046 :   clobbers_reg_p (machine_mode mode, unsigned int regno) const
     190                 :            :   {
     191                 :  212519496 :     return overlaps_hard_reg_set_p (mode_clobbers (mode), mode, regno);
     192                 :            :   }
     193                 :            : 
     194                 :            :   bool
     195                 :   11625660 :   operator== (const function_abi &other) const
     196                 :            :   {
     197                 :   34877000 :     return m_base_abi == other.m_base_abi && m_mask == other.m_mask;
     198                 :            :   }
     199                 :            : 
     200                 :            :   bool
     201                 :   11625660 :   operator!= (const function_abi &other) const
     202                 :            :   {
     203                 :   23251310 :     return !operator== (other);
     204                 :            :   }
     205                 :            : 
     206                 :            : protected:
     207                 :            :   const predefined_function_abi *m_base_abi;
     208                 :            :   HARD_REG_SET m_mask;
     209                 :            : };
     210                 :            : 
     211                 :            : /* This class collects information about the ABIs of functions that are
     212                 :            :    called in a particular region of code.  It is mostly intended to be
     213                 :            :    used as a local variable during an IR walk.  */
     214                 :            : class function_abi_aggregator
     215                 :            : {
     216                 :            : public:
     217                 :    8642080 :   function_abi_aggregator () : m_abi_clobbers () {}
     218                 :            : 
     219                 :            :   /* Record that the code region calls a function with the given ABI.  */
     220                 :            :   void
     221                 :    4017240 :   note_callee_abi (const function_abi &abi)
     222                 :            :   {
     223                 :    8034480 :     m_abi_clobbers[abi.id ()] |= abi.full_and_partial_reg_clobbers ();
     224                 :    4017240 :   }
     225                 :            : 
     226                 :            :   HARD_REG_SET caller_save_regs (const function_abi &) const;
     227                 :            : 
     228                 :            : private:
     229                 :            :   HARD_REG_SET m_abi_clobbers[NUM_ABI_IDS];
     230                 :            : };
     231                 :            : 
     232                 :            : struct target_function_abi_info
     233                 :            : {
     234                 :            :   /* An array of all the target ABIs that are available in this
     235                 :            :      translation unit.  Not all entries are used for all targets,
     236                 :            :      but the structures are relatively small, and using a fixed-size
     237                 :            :      array avoids extra indirection.
     238                 :            : 
     239                 :            :      There are various ways of getting an ABI descriptor:
     240                 :            : 
     241                 :            :      * fndecl_abi (FNDECL) is the ABI of function FNDECL.
     242                 :            : 
     243                 :            :      * fntype_abi (FNTYPE) is the ABI of a function with type FNTYPE.
     244                 :            : 
     245                 :            :      * crtl->abi is the ABI of the function that we are currently
     246                 :            :        compiling to rtl.
     247                 :            : 
     248                 :            :      * insn_callee_abi (INSN) is the ABI used by the target of call insn INSN.
     249                 :            : 
     250                 :            :      * eh_edge_abi is the "ABI" used when taking an EH edge from an
     251                 :            :        exception-throwing statement to an exception handler.  Catching
     252                 :            :        exceptions from calls can be treated as an abnormal return from
     253                 :            :        those calls, and this ABI therefore describes the ABI of functions
     254                 :            :        on such an abnormal return.  Statements that throw non-call
     255                 :            :        exceptions can be treated as being implicitly wrapped in a call
     256                 :            :        that has such an abnormal return.
     257                 :            : 
     258                 :            :        At present, no target needs to support more than one EH ABI.
     259                 :            : 
     260                 :            :      * function_abis[N] is the ABI with identifier N.  This can be useful
     261                 :            :        when referring back to ABIs that have been collected by number in
     262                 :            :        a bitmask, such as after walking function calls in a particular
     263                 :            :        region of code.
     264                 :            : 
     265                 :            :      * default_function_abi refers specifically to the target's default
     266                 :            :        choice of ABI, regardless of which (if any) functions actually
     267                 :            :        use it.  This ABI and data derived from it do *not* provide
     268                 :            :        globally conservatively-correct information, so it is only
     269                 :            :        useful in very specific circumstances.  */
     270                 :            :   predefined_function_abi x_function_abis[NUM_ABI_IDS];
     271                 :            : };
     272                 :            : 
     273                 :            : extern target_function_abi_info default_target_function_abi_info;
     274                 :            : #if SWITCHABLE_TARGET
     275                 :            : extern target_function_abi_info *this_target_function_abi_info;
     276                 :            : #else
     277                 :            : #define this_target_function_abi_info (&default_target_function_abi_info)
     278                 :            : #endif
     279                 :            : 
     280                 :            : /* See the comment above x_function_abis for when these macros should be used.
     281                 :            :    At present, eh_edge_abi is always the default ABI, but that could change
     282                 :            :    in future if a target needs it to.  */
     283                 :            : #define function_abis \
     284                 :            :   (this_target_function_abi_info->x_function_abis)
     285                 :            : #define default_function_abi \
     286                 :            :   (this_target_function_abi_info->x_function_abis[0])
     287                 :            : #define eh_edge_abi default_function_abi
     288                 :            : 
     289                 :            : extern HARD_REG_SET call_clobbers_in_region (unsigned int, const_hard_reg_set,
     290                 :            :                                              machine_mode mode);
     291                 :            : 
     292                 :            : /* Return true if (reg:MODE REGNO) might be clobbered by one of the
     293                 :            :    calls in a region described by ABIS and MASK, where:
     294                 :            : 
     295                 :            :    * Bit ID of ABIS is set if the region contains a call with
     296                 :            :      function_abi identifier ID.
     297                 :            : 
     298                 :            :    * MASK contains all the registers that are fully or partially
     299                 :            :      clobbered by calls in the region.
     300                 :            : 
     301                 :            :    This is not quite as accurate as testing each individual call,
     302                 :            :    but it's a close and conservatively-correct approximation.
     303                 :            :    It's much better for some targets than:
     304                 :            : 
     305                 :            :      overlaps_hard_reg_set_p (MASK, MODE, REGNO).  */
     306                 :            : 
     307                 :            : inline bool
     308                 :   50890290 : call_clobbered_in_region_p (unsigned int abis, const_hard_reg_set mask,
     309                 :            :                             machine_mode mode, unsigned int regno)
     310                 :            : {
     311                 :   50890290 :   HARD_REG_SET clobbers = call_clobbers_in_region (abis, mask, mode);
     312                 :   50890290 :   return overlaps_hard_reg_set_p (clobbers, mode, regno);
     313                 :            : }
     314                 :            : 
     315                 :            : extern const predefined_function_abi &fntype_abi (const_tree);
     316                 :            : extern function_abi fndecl_abi (const_tree);
     317                 :            : extern function_abi insn_callee_abi (const rtx_insn *);
     318                 :            : extern function_abi expr_callee_abi (const_tree);
     319                 :            : 
     320                 :            : #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.