gcc/integrate.h

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