LCOV - code coverage report
Current view: top level - gcc - calls.h (source / functions) Coverage Total Hit
Test: gcc.info Lines: 100.0 % 19 19
Test Date: 2024-03-23 14:05:01 Functions: 100.0 % 5 5
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: - 0 0

             Branch data     Line data    Source code
       1                 :             : /* Declarations and data types for RTL call insn generation.
       2                 :             :    Copyright (C) 2013-2024 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_CALLS_H
      21                 :             : #define GCC_CALLS_H
      22                 :             : 
      23                 :             : /* Describes a function argument.
      24                 :             : 
      25                 :             :    Each argument conceptually has a gimple-level type.  Usually this type
      26                 :             :    is available directly as a tree via the TYPE field, but when calling
      27                 :             :    libgcc support functions it might instead be inferred from a mode,
      28                 :             :    in which case the type isn't available directly.
      29                 :             : 
      30                 :             :    This gimple-level type might go through promotion before being passed to
      31                 :             :    the target function.  Depending on the context, the MODE field is either
      32                 :             :    the mode of the gimple-level type (whether explicitly given or not)
      33                 :             :    or the mode after promotion has been performed.  */
      34                 :             : class function_arg_info
      35                 :             : {
      36                 :             : public:
      37                 :    17042013 :   function_arg_info ()
      38                 :     8520981 :     : type (NULL_TREE), mode (VOIDmode), named (false),
      39                 :     8521032 :       pass_by_reference (false)
      40                 :             :   {}
      41                 :             : 
      42                 :             :   /* Initialize an argument of mode MODE, either before or after promotion.  */
      43                 :      280708 :   function_arg_info (machine_mode mode, bool named)
      44                 :      280708 :     : type (NULL_TREE), mode (mode), named (named), pass_by_reference (false)
      45                 :      280705 :   {}
      46                 :             : 
      47                 :             :   /* Initialize an unpromoted argument of type TYPE.  */
      48                 :    17191039 :   function_arg_info (tree type, bool named)
      49                 :    17191039 :     : type (type), mode (TYPE_MODE (type)), named (named),
      50                 :    17191039 :       pass_by_reference (false)
      51                 :    17191039 :   {}
      52                 :             : 
      53                 :             :   /* Initialize an argument with explicit properties.  */
      54                 :   323608582 :   function_arg_info (tree type, machine_mode mode, bool named)
      55                 :   323608582 :     : type (type), mode (mode), named (named), pass_by_reference (false)
      56                 :   323608582 :   {}
      57                 :             : 
      58                 :             :   /* Return true if the gimple-level type is an aggregate.  */
      59                 :             :   bool aggregate_type_p () const { return type && AGGREGATE_TYPE_P (type); }
      60                 :             : 
      61                 :             :   /* Return the size of the gimple-level type, or -1 if the size is
      62                 :             :      variable or otherwise not representable as a poly_int64.
      63                 :             : 
      64                 :             :      Use this function when MODE is the mode of the type before promotion,
      65                 :             :      or in any context if the target never promotes function arguments.  */
      66                 :             :   poly_int64 type_size_in_bytes () const
      67                 :             :   {
      68                 :             :     if (type)
      69                 :             :       return int_size_in_bytes (type);
      70                 :             :     return GET_MODE_SIZE (mode);
      71                 :             :   }
      72                 :             : 
      73                 :             :   /* Return the size of the argument after promotion, or -1 if the size
      74                 :             :      is variable or otherwise not representable as a poly_int64.
      75                 :             : 
      76                 :             :      Use this function when MODE is the mode of the type after promotion.  */
      77                 :    40771383 :   poly_int64 promoted_size_in_bytes () const
      78                 :             :   {
      79                 :    40771383 :     if (mode == BLKmode)
      80                 :      784458 :       return int_size_in_bytes (type);
      81                 :    79973850 :     return GET_MODE_SIZE (mode);
      82                 :             :   }
      83                 :             : 
      84                 :             :   /* True if the argument represents the end of the argument list,
      85                 :             :      as returned by end_marker ().  */
      86                 :             :   bool end_marker_p () const { return mode == VOIDmode; }
      87                 :             : 
      88                 :             :   /* Return a function_arg_info that represents the end of the
      89                 :             :      argument list.  */
      90                 :     5663473 :   static function_arg_info end_marker ()
      91                 :             :   {
      92                 :     5663473 :     return function_arg_info (void_type_node, /*named=*/true);
      93                 :             :   }
      94                 :             : 
      95                 :             :   /* The type of the argument, or null if not known (which is true for
      96                 :             :      libgcc support functions).  */
      97                 :             :   tree type;
      98                 :             : 
      99                 :             :   /* The mode of the argument.  Depending on context, this might be
     100                 :             :      the mode of the argument type or the mode after promotion.  */
     101                 :             :   machine_mode mode;
     102                 :             : 
     103                 :             :   /* True if the argument is treated as a named argument, false if it is
     104                 :             :      treated as an unnamed variadic argument (i.e. one passed through
     105                 :             :      "...").  See also TARGET_STRICT_ARGUMENT_NAMING.  */
     106                 :             :   unsigned int named : 1;
     107                 :             : 
     108                 :             :   /* True if we have decided to pass the argument by reference, in which case
     109                 :             :      the function_arg_info describes a pointer to the original argument.  */
     110                 :             :   unsigned int pass_by_reference : 1;
     111                 :             : };
     112                 :             : 
     113                 :             : extern int flags_from_decl_or_type (const_tree);
     114                 :             : extern int call_expr_flags (const_tree);
     115                 :             : extern bool setjmp_call_p (const_tree);
     116                 :             : extern bool gimple_maybe_alloca_call_p (const gimple *);
     117                 :             : extern bool gimple_alloca_call_p (const gimple *);
     118                 :             : extern bool alloca_call_p (const_tree);
     119                 :             : extern bool must_pass_in_stack_var_size (const function_arg_info &);
     120                 :             : extern bool must_pass_in_stack_var_size_or_pad (const function_arg_info &);
     121                 :             : extern bool must_pass_va_arg_in_stack (tree);
     122                 :             : extern rtx prepare_call_address (tree, rtx, rtx, rtx *, int, int);
     123                 :             : extern bool shift_return_value (machine_mode, bool, rtx);
     124                 :             : extern rtx expand_call (tree, rtx, int);
     125                 :             : extern void fixup_tail_calls (void);
     126                 :             : 
     127                 :             : extern bool pass_by_reference (CUMULATIVE_ARGS *, function_arg_info);
     128                 :             : extern bool pass_va_arg_by_reference (tree);
     129                 :             : extern bool apply_pass_by_reference_rules (CUMULATIVE_ARGS *,
     130                 :             :                                            function_arg_info &);
     131                 :             : extern bool reference_callee_copied (CUMULATIVE_ARGS *,
     132                 :             :                                      const function_arg_info &);
     133                 :             : extern void maybe_complain_about_tail_call (tree, const char *);
     134                 :             : 
     135                 :             : extern rtx rtx_for_static_chain (const_tree, bool);
     136                 :             : extern bool cxx17_empty_base_field_p (const_tree);
     137                 :             : 
     138                 :             : #endif // GCC_CALLS_H
        

Generated by: LCOV version 2.0-1

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,rust,m2 --enable-host-shared. GCC test suite is run with the built compiler.