LCOV - code coverage report
Current view: top level - gcc - calls.h (source / functions) Hit Total Coverage
Test: gcc.info Lines: 17 17 100.0 %
Date: 2020-04-04 11:58:09 Functions: 2 2 100.0 %
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-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_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                 :   11583300 :   function_arg_info ()
      38                 :    5791660 :     : type (NULL_TREE), mode (VOIDmode), named (false),
      39                 :    5791660 :       pass_by_reference (false)
      40                 :            :   {}
      41                 :            : 
      42                 :            :   /* Initialize an argument of mode MODE, either before or after promotion.  */
      43                 :     211673 :   function_arg_info (machine_mode mode, bool named)
      44                 :     211673 :     : type (NULL_TREE), mode (mode), named (named), pass_by_reference (false)
      45                 :            :   {}
      46                 :            : 
      47                 :            :   /* Initialize an unpromoted argument of type TYPE.  */
      48                 :   11474277 :   function_arg_info (tree type, bool named)
      49                 :   11474277 :     : type (type), mode (TYPE_MODE (type)), named (named),
      50                 :   11474277 :       pass_by_reference (false)
      51                 :   11474277 :   {}
      52                 :            : 
      53                 :            :   /* Initialize an argument with explicit properties.  */
      54                 :  160431000 :   function_arg_info (tree type, machine_mode mode, bool named)
      55                 :  160431000 :     : type (type), mode (mode), named (named), pass_by_reference (false)
      56                 :            :   {}
      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                 :   27156700 :   poly_int64 promoted_size_in_bytes () const
      78                 :            :   {
      79                 :   27156700 :     if (mode == BLKmode)
      80                 :     612029 :       return int_size_in_bytes (type);
      81                 :   53089300 :     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                 :    3962660 :   static function_arg_info end_marker ()
      91                 :            :   {
      92                 :    3962660 :     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 int 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_warn_alloc_args_overflow (tree, tree, tree[2], int[2]);
     134                 :            : extern tree get_attr_nonstring_decl (tree, tree * = NULL);
     135                 :            : extern void maybe_warn_nonstring_arg (tree, tree);
     136                 :            : extern bool get_size_range (tree, tree[2], bool = false);
     137                 :            : extern rtx rtx_for_static_chain (const_tree, bool);
     138                 :            : 
     139                 :            : #endif // GCC_CALLS_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.