LCOV - code coverage report
Current view: top level - gcc - expr.h (source / functions) Hit Total Coverage
Test: gcc.info Lines: 12 16 75.0 %
Date: 2020-04-04 11:58:09 Functions: 3 4 75.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Definitions for code generation pass of GNU compiler.
       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                 :            : #ifndef GCC_EXPR_H
      21                 :            : #define GCC_EXPR_H
      22                 :            : 
      23                 :            : /* This is the 4th arg to `expand_expr'.
      24                 :            :    EXPAND_STACK_PARM means we are possibly expanding a call param onto
      25                 :            :    the stack.
      26                 :            :    EXPAND_SUM means it is ok to return a PLUS rtx or MULT rtx.
      27                 :            :    EXPAND_INITIALIZER is similar but also record any labels on forced_labels.
      28                 :            :    EXPAND_CONST_ADDRESS means it is ok to return a MEM whose address
      29                 :            :     is a constant that is not a legitimate address.
      30                 :            :    EXPAND_WRITE means we are only going to write to the resulting rtx.
      31                 :            :    EXPAND_MEMORY means we are interested in a memory result, even if
      32                 :            :     the memory is constant and we could have propagated a constant value,
      33                 :            :     or the memory is unaligned on a STRICT_ALIGNMENT target.  */
      34                 :            : enum expand_modifier {EXPAND_NORMAL = 0, EXPAND_STACK_PARM, EXPAND_SUM,
      35                 :            :                       EXPAND_CONST_ADDRESS, EXPAND_INITIALIZER, EXPAND_WRITE,
      36                 :            :                       EXPAND_MEMORY};
      37                 :            : 
      38                 :            : /* Prevent the compiler from deferring stack pops.  See
      39                 :            :    inhibit_defer_pop for more information.  */
      40                 :            : #define NO_DEFER_POP (inhibit_defer_pop += 1)
      41                 :            : 
      42                 :            : /* Allow the compiler to defer stack pops.  See inhibit_defer_pop for
      43                 :            :    more information.  */
      44                 :            : #define OK_DEFER_POP (inhibit_defer_pop -= 1)
      45                 :            : 
      46                 :            : /* This structure is used to pass around information about exploded
      47                 :            :    unary, binary and trinary expressions between expand_expr_real_1 and
      48                 :            :    friends.  */
      49                 :            : typedef struct separate_ops
      50                 :            : {
      51                 :            :   enum tree_code code;
      52                 :            :   location_t location;
      53                 :            :   tree type;
      54                 :            :   tree op0, op1, op2;
      55                 :            : } *sepops;
      56                 :            : 
      57                 :            : /* This is run during target initialization to set up which modes can be
      58                 :            :    used directly in memory and to initialize the block move optab.  */
      59                 :            : extern void init_expr_target (void);
      60                 :            : 
      61                 :            : /* This is run at the start of compiling a function.  */
      62                 :            : extern void init_expr (void);
      63                 :            : 
      64                 :            : /* Emit some rtl insns to move data between rtx's, converting machine modes.
      65                 :            :    Both modes must be floating or both fixed.  */
      66                 :            : extern void convert_move (rtx, rtx, int);
      67                 :            : 
      68                 :            : /* Convert an rtx to specified machine mode and return the result.  */
      69                 :            : extern rtx convert_to_mode (machine_mode, rtx, int);
      70                 :            : 
      71                 :            : /* Convert an rtx to MODE from OLDMODE and return the result.  */
      72                 :            : extern rtx convert_modes (machine_mode, machine_mode, rtx, int);
      73                 :            : 
      74                 :            : /* Expand a call to memcpy or memmove or memcmp, and return the result.  */
      75                 :            : extern rtx emit_block_op_via_libcall (enum built_in_function, rtx, rtx, rtx,
      76                 :            :                                       bool);
      77                 :            : 
      78                 :            : static inline rtx
      79                 :      16874 : emit_block_copy_via_libcall (rtx dst, rtx src, rtx size, bool tailcall = false)
      80                 :            : {
      81                 :      16874 :   return emit_block_op_via_libcall (BUILT_IN_MEMCPY, dst, src, size, tailcall);
      82                 :            : }
      83                 :            : 
      84                 :            : static inline rtx
      85                 :          0 : emit_block_move_via_libcall (rtx dst, rtx src, rtx size, bool tailcall = false)
      86                 :            : {
      87                 :          0 :   return emit_block_op_via_libcall (BUILT_IN_MEMMOVE, dst, src, size, tailcall);
      88                 :            : }
      89                 :            : 
      90                 :            : static inline rtx
      91                 :          0 : emit_block_comp_via_libcall (rtx dst, rtx src, rtx size, bool tailcall = false)
      92                 :            : {
      93                 :          0 :   return emit_block_op_via_libcall (BUILT_IN_MEMCMP, dst, src, size, tailcall);
      94                 :            : }
      95                 :            : 
      96                 :            : /* Emit code to move a block Y to a block X.  */
      97                 :            : enum block_op_methods
      98                 :            : {
      99                 :            :   BLOCK_OP_NORMAL,
     100                 :            :   BLOCK_OP_NO_LIBCALL,
     101                 :            :   BLOCK_OP_CALL_PARM,
     102                 :            :   /* Like BLOCK_OP_NORMAL, but the libcall can be tail call optimized.  */
     103                 :            :   BLOCK_OP_TAILCALL,
     104                 :            :   /* Like BLOCK_OP_NO_LIBCALL, but instead of emitting a libcall return
     105                 :            :      pc_rtx to indicate nothing has been emitted and let the caller handle
     106                 :            :      it.  */
     107                 :            :   BLOCK_OP_NO_LIBCALL_RET
     108                 :            : };
     109                 :            : 
     110                 :            : typedef rtx (*by_pieces_constfn) (void *, HOST_WIDE_INT, scalar_int_mode);
     111                 :            : 
     112                 :            : extern rtx emit_block_move (rtx, rtx, rtx, enum block_op_methods);
     113                 :            : extern rtx emit_block_move_hints (rtx, rtx, rtx, enum block_op_methods,
     114                 :            :                                   unsigned int, HOST_WIDE_INT,
     115                 :            :                                   unsigned HOST_WIDE_INT,
     116                 :            :                                   unsigned HOST_WIDE_INT,
     117                 :            :                                   unsigned HOST_WIDE_INT,
     118                 :            :                                   bool bail_out_libcall = false,
     119                 :            :                                   bool *is_move_done = NULL,
     120                 :            :                                   bool might_overlap = false);
     121                 :            : extern rtx emit_block_cmp_hints (rtx, rtx, rtx, tree, rtx, bool,
     122                 :            :                                  by_pieces_constfn, void *);
     123                 :            : extern bool emit_storent_insn (rtx to, rtx from);
     124                 :            : 
     125                 :            : /* Copy all or part of a value X into registers starting at REGNO.
     126                 :            :    The number of registers to be filled is NREGS.  */
     127                 :            : extern void move_block_to_reg (int, rtx, int, machine_mode);
     128                 :            : 
     129                 :            : /* Copy all or part of a BLKmode value X out of registers starting at REGNO.
     130                 :            :    The number of registers to be filled is NREGS.  */
     131                 :            : extern void move_block_from_reg (int, rtx, int);
     132                 :            : 
     133                 :            : /* Generate a non-consecutive group of registers represented by a PARALLEL.  */
     134                 :            : extern rtx gen_group_rtx (rtx);
     135                 :            : 
     136                 :            : /* Load a BLKmode value into non-consecutive registers represented by a
     137                 :            :    PARALLEL.  */
     138                 :            : extern void emit_group_load (rtx, rtx, tree, poly_int64);
     139                 :            : 
     140                 :            : /* Similarly, but load into new temporaries.  */
     141                 :            : extern rtx emit_group_load_into_temps (rtx, rtx, tree, poly_int64);
     142                 :            : 
     143                 :            : /* Move a non-consecutive group of registers represented by a PARALLEL into
     144                 :            :    a non-consecutive group of registers represented by a PARALLEL.  */
     145                 :            : extern void emit_group_move (rtx, rtx);
     146                 :            : 
     147                 :            : /* Move a group of registers represented by a PARALLEL into pseudos.  */
     148                 :            : extern rtx emit_group_move_into_temps (rtx);
     149                 :            : 
     150                 :            : /* Store a BLKmode value from non-consecutive registers represented by a
     151                 :            :    PARALLEL.  */
     152                 :            : extern void emit_group_store (rtx, rtx, tree, poly_int64);
     153                 :            : 
     154                 :            : extern rtx maybe_emit_group_store (rtx, tree);
     155                 :            : 
     156                 :            : /* Mark REG as holding a parameter for the next CALL_INSN.
     157                 :            :    Mode is TYPE_MODE of the non-promoted parameter, or VOIDmode.  */
     158                 :            : extern void use_reg_mode (rtx *, rtx, machine_mode);
     159                 :            : extern void clobber_reg_mode (rtx *, rtx, machine_mode);
     160                 :            : 
     161                 :            : extern rtx copy_blkmode_to_reg (machine_mode, tree);
     162                 :            : 
     163                 :            : /* Mark REG as holding a parameter for the next CALL_INSN.  */
     164                 :            : static inline void
     165                 :    1038268 : use_reg (rtx *fusage, rtx reg)
     166                 :            : {
     167                 :    1038268 :   use_reg_mode (fusage, reg, VOIDmode);
     168                 :     861422 : }
     169                 :            : 
     170                 :            : /* Mark REG as clobbered by the call with FUSAGE as CALL_INSN_FUNCTION_USAGE.  */
     171                 :            : static inline void
     172                 :     170637 : clobber_reg (rtx *fusage, rtx reg)
     173                 :            : {
     174                 :     170637 :   clobber_reg_mode (fusage, reg, VOIDmode);
     175                 :       1305 : }
     176                 :            : 
     177                 :            : /* Mark NREGS consecutive regs, starting at REGNO, as holding parameters
     178                 :            :    for the next CALL_INSN.  */
     179                 :            : extern void use_regs (rtx *, int, int);
     180                 :            : 
     181                 :            : /* Mark a PARALLEL as holding a parameter for the next CALL_INSN.  */
     182                 :            : extern void use_group_regs (rtx *, rtx);
     183                 :            : 
     184                 :            : #ifdef GCC_INSN_CODES_H
     185                 :            : extern rtx expand_cmpstrn_or_cmpmem (insn_code, rtx, rtx, rtx, tree, rtx,
     186                 :            :                                      HOST_WIDE_INT);
     187                 :            : #endif
     188                 :            : 
     189                 :            : /* Write zeros through the storage of OBJECT.
     190                 :            :    If OBJECT has BLKmode, SIZE is its length in bytes.  */
     191                 :            : extern rtx clear_storage (rtx, rtx, enum block_op_methods);
     192                 :            : extern rtx clear_storage_hints (rtx, rtx, enum block_op_methods,
     193                 :            :                                 unsigned int, HOST_WIDE_INT,
     194                 :            :                                 unsigned HOST_WIDE_INT,
     195                 :            :                                 unsigned HOST_WIDE_INT,
     196                 :            :                                 unsigned HOST_WIDE_INT);
     197                 :            : /* The same, but always output an library call.  */
     198                 :            : extern rtx set_storage_via_libcall (rtx, rtx, rtx, bool = false);
     199                 :            : 
     200                 :            : /* Expand a setmem pattern; return true if successful.  */
     201                 :            : extern bool set_storage_via_setmem (rtx, rtx, rtx, unsigned int,
     202                 :            :                                     unsigned int, HOST_WIDE_INT,
     203                 :            :                                     unsigned HOST_WIDE_INT,
     204                 :            :                                     unsigned HOST_WIDE_INT,
     205                 :            :                                     unsigned HOST_WIDE_INT);
     206                 :            : 
     207                 :            : /* Return nonzero if it is desirable to store LEN bytes generated by
     208                 :            :    CONSTFUN with several move instructions by store_by_pieces
     209                 :            :    function.  CONSTFUNDATA is a pointer which will be passed as argument
     210                 :            :    in every CONSTFUN call.
     211                 :            :    ALIGN is maximum alignment we can assume.
     212                 :            :    MEMSETP is true if this is a real memset/bzero, not a copy
     213                 :            :    of a const string.  */
     214                 :            : extern int can_store_by_pieces (unsigned HOST_WIDE_INT,
     215                 :            :                                 by_pieces_constfn,
     216                 :            :                                 void *, unsigned int, bool);
     217                 :            : 
     218                 :            : /* Generate several move instructions to store LEN bytes generated by
     219                 :            :    CONSTFUN to block TO.  (A MEM rtx with BLKmode).  CONSTFUNDATA is a
     220                 :            :    pointer which will be passed as argument in every CONSTFUN call.
     221                 :            :    ALIGN is maximum alignment we can assume.
     222                 :            :    MEMSETP is true if this is a real memset/bzero, not a copy.
     223                 :            :    Returns TO + LEN.  */
     224                 :            : extern rtx store_by_pieces (rtx, unsigned HOST_WIDE_INT, by_pieces_constfn,
     225                 :            :                             void *, unsigned int, bool, memop_ret);
     226                 :            : 
     227                 :            : /* Emit insns to set X from Y.  */
     228                 :            : extern rtx_insn *emit_move_insn (rtx, rtx);
     229                 :            : extern rtx_insn *gen_move_insn (rtx, rtx);
     230                 :            : 
     231                 :            : /* Emit insns to set X from Y, with no frills.  */
     232                 :            : extern rtx_insn *emit_move_insn_1 (rtx, rtx);
     233                 :            : 
     234                 :            : extern rtx_insn *emit_move_complex_push (machine_mode, rtx, rtx);
     235                 :            : extern rtx_insn *emit_move_complex_parts (rtx, rtx);
     236                 :            : extern rtx read_complex_part (rtx, bool);
     237                 :            : extern void write_complex_part (rtx, rtx, bool);
     238                 :            : extern rtx read_complex_part (rtx, bool);
     239                 :            : extern rtx emit_move_resolve_push (machine_mode, rtx);
     240                 :            : 
     241                 :            : /* Push a block of length SIZE (perhaps variable)
     242                 :            :    and return an rtx to address the beginning of the block.  */
     243                 :            : extern rtx push_block (rtx, poly_int64, int);
     244                 :            : 
     245                 :            : /* Generate code to push something onto the stack, given its mode and type.  */
     246                 :            : extern bool emit_push_insn (rtx, machine_mode, tree, rtx, unsigned int,
     247                 :            :                             int, rtx, poly_int64, rtx, rtx, int, rtx, bool);
     248                 :            : 
     249                 :            : /* Extract the accessible bit-range from a COMPONENT_REF.  */
     250                 :            : extern void get_bit_range (poly_uint64_pod *, poly_uint64_pod *, tree,
     251                 :            :                            poly_int64_pod *, tree *);
     252                 :            : 
     253                 :            : /* Expand an assignment that stores the value of FROM into TO.  */
     254                 :            : extern void expand_assignment (tree, tree, bool);
     255                 :            : 
     256                 :            : /* Generate code for computing expression EXP,
     257                 :            :    and storing the value into TARGET.
     258                 :            :    If SUGGEST_REG is nonzero, copy the value through a register
     259                 :            :    and return that register, if that is possible.  */
     260                 :            : extern rtx store_expr (tree, rtx, int, bool, bool);
     261                 :            : 
     262                 :            : /* Given an rtx that may include add and multiply operations,
     263                 :            :    generate them as insns and return a pseudo-reg containing the value.
     264                 :            :    Useful after calling expand_expr with 1 as sum_ok.  */
     265                 :            : extern rtx force_operand (rtx, rtx);
     266                 :            : 
     267                 :            : /* Work horses for expand_expr.  */
     268                 :            : extern rtx expand_expr_real (tree, rtx, machine_mode,
     269                 :            :                              enum expand_modifier, rtx *, bool);
     270                 :            : extern rtx expand_expr_real_1 (tree, rtx, machine_mode,
     271                 :            :                                enum expand_modifier, rtx *, bool);
     272                 :            : extern rtx expand_expr_real_2 (sepops, rtx, machine_mode,
     273                 :            :                                enum expand_modifier);
     274                 :            : 
     275                 :            : /* Generate code for computing expression EXP.
     276                 :            :    An rtx for the computed value is returned.  The value is never null.
     277                 :            :    In the case of a void EXP, const0_rtx is returned.  */
     278                 :            : static inline rtx
     279                 :   69276057 : expand_expr (tree exp, rtx target, machine_mode mode,
     280                 :            :              enum expand_modifier modifier)
     281                 :            : {
     282                 :   64925780 :   return expand_expr_real (exp, target, mode, modifier, NULL, false);
     283                 :            : }
     284                 :            : 
     285                 :            : static inline rtx
     286                 :   13866743 : expand_normal (tree exp)
     287                 :            : {
     288                 :   13776619 :   return expand_expr_real (exp, NULL_RTX, VOIDmode, EXPAND_NORMAL, NULL, false);
     289                 :            : }
     290                 :            : 
     291                 :            : 
     292                 :            : /* Return the tree node and offset if a given argument corresponds to
     293                 :            :    a string constant.  */
     294                 :            : extern tree string_constant (tree, tree *, tree *, tree *);
     295                 :            : 
     296                 :            : extern enum tree_code maybe_optimize_mod_cmp (enum tree_code, tree *, tree *);
     297                 :            : 
     298                 :            : /* Two different ways of generating switch statements.  */
     299                 :            : extern int try_casesi (tree, tree, tree, tree, rtx, rtx, rtx, profile_probability);
     300                 :            : extern int try_tablejump (tree, tree, tree, tree, rtx, rtx, profile_probability);
     301                 :            : 
     302                 :            : extern int safe_from_p (const_rtx, tree, int);
     303                 :            : 
     304                 :            : /* Get the personality libfunc for a function decl.  */
     305                 :            : rtx get_personality_function (tree);
     306                 :            : 
     307                 :            : /* Determine whether the LEN bytes can be moved by using several move
     308                 :            :    instructions.  Return nonzero if a call to move_by_pieces should
     309                 :            :    succeed.  */
     310                 :            : extern bool can_move_by_pieces (unsigned HOST_WIDE_INT, unsigned int);
     311                 :            : 
     312                 :            : extern unsigned HOST_WIDE_INT highest_pow2_factor (const_tree);
     313                 :            : 
     314                 :            : extern bool categorize_ctor_elements (const_tree, HOST_WIDE_INT *,
     315                 :            :                                       HOST_WIDE_INT *, HOST_WIDE_INT *,
     316                 :            :                                       bool *);
     317                 :            : 
     318                 :            : extern void expand_operands (tree, tree, rtx, rtx*, rtx*,
     319                 :            :                              enum expand_modifier);
     320                 :            : 
     321                 :            : /* rtl.h and tree.h were included.  */
     322                 :            : /* Return an rtx for the size in bytes of the value of an expr.  */
     323                 :            : extern rtx expr_size (tree);
     324                 :            : 
     325                 :            : #endif /* GCC_EXPR_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.