gcc/integrate.h

   1 /* Function integration definitions for GNU C-Compiler
   2    Copyright (C) 1990, 1995, 1998, 1999, 2000 Free Software Foundation, Inc.
   3
   4 This file is part of GNU CC.
   5
   6 GNU CC is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU CC is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU CC; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 59 Temple Place - Suite 330,
  19 Boston, MA 02111-1307, USA.  */
  20
  21 #include "varray.h"
  22
  23 /* This structure is used to remap objects in the function being inlined to
  24    those belonging to the calling function.  It is passed by
  25    expand_inline_function to its children.
  26
  27    This structure is also used when unrolling loops and otherwise
  28    replicating code, although not all fields are needed in this case;
  29    only those fields needed by copy_rtx_and_substitute() and its children
  30    are used.
  31
  32    This structure is used instead of static variables because
  33    expand_inline_function may be called recursively via expand_expr.  */
  34
  35 struct inline_remap
  36 {
  37   /* True if we are doing function integration, false otherwise.
  38      Used to control whether RTX_UNCHANGING bits are copied by
  39      copy_rtx_and_substitute. */
  40   int integrating;
  41   /* Definition of function be inlined.  */
  42   union tree_node *fndecl;
  43   /* Place to put insns needed at start of function.  */
  44   rtx insns_at_start;
  45   /* Mapping from old BLOCKs to new BLOCKs.  */
  46   varray_type block_map;
  47   /* Mapping from old registers to new registers.
  48      It is allocated and deallocated in `expand_inline_function' */
  49   rtx *reg_map;
  50   /* Mapping from old code-labels to new code-labels.
  51      The first element of this map is label_map[min_labelno].  */
  52   rtx *label_map;
  53   /* Mapping from old insn uid's to copied insns.  The first element
  54    of this map is insn_map[min_insnno]; the last element is
  55    insn_map[max_insnno].  We keep the bounds here for when the map
  56    only covers a partial range of insns (such as loop unrolling or
  57    code replication).  */
  58   rtx *insn_map;
  59   int min_insnno, max_insnno;
  60
  61   /* Map pseudo reg number in calling function to equivalent constant.  We
  62      cannot in general substitute constants into parameter pseudo registers,
  63      since some machine descriptions (many RISCs) won't always handle
  64      the resulting insns.  So if an incoming parameter has a constant
  65      equivalent, we record it here, and if the resulting insn is
  66      recognizable, we go with it.
  67
  68      We also use this mechanism to convert references to incoming arguments
  69      and stacked variables.  copy_rtx_and_substitute will replace the virtual
  70      incoming argument and virtual stacked variables registers with new
  71      pseudos that contain pointers into the replacement area allocated for
  72      this inline instance.  These pseudos are then marked as being equivalent
  73      to the appropriate address and substituted if valid.  */
  74   varray_type const_equiv_varray;
  75   /* This is incremented for each new basic block.
  76      It is used to store in the age field to record the domain of validity
  77      of each entry in const_equiv_varray.
  78      A value of -1 indicates an entry for a reg which is a parm.
  79      All other values are "positive".  */
  80 #define CONST_AGE_PARM (-1)
  81   unsigned int const_age;
  82
  83   /* Target of the inline function being expanded, or NULL if none.  */
  84   rtx inline_target;
  85   /* When an insn is being copied by copy_rtx_and_substitute,
  86      this is nonzero if we have copied an ASM_OPERANDS.
  87      In that case, it is the original input-operand vector.  */
  88   rtvec orig_asm_operands_vector;
  89   /* When an insn is being copied by copy_rtx_and_substitute,
  90      this is nonzero if we have copied an ASM_OPERANDS.
  91      In that case, it is the copied input-operand vector.  */
  92   rtvec copy_asm_operands_vector;
  93   /* Likewise, this is the copied constraints vector.  */
  94   rtvec copy_asm_constraints_vector;
  95
  96   /* Target of a return insn, if needed and inlining.  */
  97   rtx local_return_label;
  98
  99   /* Indications for regs being pointers and their alignment.  */
 100   unsigned char *regno_pointer_align;
 101   rtx *x_regno_reg_rtx;
 102
 103   /* The next few fields are used for subst_constants to record the SETs
 104      that it saw.  */
 105   int num_sets;
 106   struct equiv_table
 107     {
 108       rtx dest;
 109       rtx equiv;
 110     }  equiv_sets[MAX_RECOG_OPERANDS];
 111   /* Record the last thing assigned to pc.  This is used for folded
 112      conditional branch insns.  */
 113   rtx last_pc_value;
 114 #ifdef HAVE_cc0
 115   /* Record the last thing assigned to cc0.  */
 116   rtx last_cc0_value;
 117 #endif
 118   /* Note mode of COMPARE if the mode would be otherwise lost (comparing of
 119      two VOIDmode constants.  */
 120   rtx compare_src;
 121   enum machine_mode compare_mode;
 122 };
 123
 124 /* Return a copy of an rtx (as needed), substituting pseudo-register,
 125    labels, and frame-pointer offsets as necessary.  */
 126 extern rtx copy_rtx_and_substitute PARAMS ((rtx, struct inline_remap *, int));
 127
 128 /* Copy a declaration when one function is substituted inline into
 129    another.  */
 130 extern union tree_node *copy_decl_for_inlining PARAMS ((union tree_node *,
 131                                                       union tree_node *,
 132                                                       union tree_node *));
 133
 134 extern void try_constants PARAMS ((rtx, struct inline_remap *));
 135
 136 /* Return the label indicated.  */
 137 extern rtx get_label_from_map PARAMS ((struct inline_remap *, int));
 138
 139 /* Set the label indicated.  */
 140 #define set_label_in_map(MAP, I, X) ((MAP)->label_map[I] = (X))
 141
 142 /* Unfortunately, we need a global copy of const_equiv varray for
 143    communication with a function called from note_stores.  Be *very*
 144    careful that this is used properly in the presence of recursion.  */
 145
 146 extern varray_type global_const_equiv_varray;
 147
 148 #define MAYBE_EXTEND_CONST_EQUIV_VARRAY(MAP,MAX)                        \
 149   {                                                                     \
 150     if ((size_t)(MAX) >= VARRAY_SIZE ((MAP)->const_equiv_varray))       \
 151       {                                                                 \
 152         int is_global = (global_const_equiv_varray                      \
 153                          == (MAP)->const_equiv_varray);                 \
 154         VARRAY_GROW ((MAP)->const_equiv_varray, (MAX)+1);               \
 155         if (is_global)                                                  \
 156            global_const_equiv_varray = (MAP)->const_equiv_varray;       \
 157       }                                                                 \
 158   }
 159
 160 #define SET_CONST_EQUIV_DATA(MAP,REG,RTX,AGE)                           \
 161   {                                                                     \
 162     struct const_equiv_data *p;                                         \
 163     MAYBE_EXTEND_CONST_EQUIV_VARRAY ((MAP), REGNO (REG));               \
 164     p = &VARRAY_CONST_EQUIV ((MAP)->const_equiv_varray, REGNO (REG));   \
 165     p->rtx = (RTX);                                                     \
 166     p->age = (AGE);                                                     \
 167   }