Subversion Repositories openrisc

/* Variable tracking routines for the GNU compiler.

   Copyright (C) 2002, 2003, 2004, 2005, 2007 Free Software Foundation, Inc.

   This file is part of GCC.

   GCC is free software; you can redistribute it and/or modify it

   under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 3, or (at your option)

   any later version.

   GCC is distributed in the hope that it will be useful, but WITHOUT

   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY

   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public

   License for more details.

   You should have received a copy of the GNU General Public License

   along with GCC; see the file COPYING3.  If not see

   <http://www.gnu.org/licenses/>.  */

/* This file contains the variable tracking pass.  It computes where

   variables are located (which registers or where in memory) at each position

   in instruction stream and emits notes describing the locations.

   Debug information (DWARF2 location lists) is finally generated from

   these notes.

   With this debug information, it is possible to show variables

   even when debugging optimized code.

   How does the variable tracking pass work?

   First, it scans RTL code for uses, stores and clobbers (register/memory

   references in instructions), for call insns and for stack adjustments

   separately for each basic block and saves them to an array of micro

   operations.

   The micro operations of one instruction are ordered so that

   pre-modifying stack adjustment < use < use with no var < call insn <

     < set < clobber < post-modifying stack adjustment

   Then, a forward dataflow analysis is performed to find out how locations

   of variables change through code and to propagate the variable locations

   along control flow graph.

   The IN set for basic block BB is computed as a union of OUT sets of BB's

   predecessors, the OUT set for BB is copied from the IN set for BB and

   is changed according to micro operations in BB.

   The IN and OUT sets for basic blocks consist of a current stack adjustment

   (used for adjusting offset of variables addressed using stack pointer),

   the table of structures describing the locations of parts of a variable

   and for each physical register a linked list for each physical register.

   The linked list is a list of variable parts stored in the register,

   i.e. it is a list of triplets (reg, decl, offset) where decl is

   REG_EXPR (reg) and offset is REG_OFFSET (reg).  The linked list is used for

   effective deleting appropriate variable parts when we set or clobber the

   register.

   There may be more than one variable part in a register.  The linked lists

   should be pretty short so it is a good data structure here.

   For example in the following code, register allocator may assign same

   register to variables A and B, and both of them are stored in the same

   register in CODE:

     if (cond)

       set A;

     else

       set B;

     CODE;

     if (cond)

       use A;

     else

       use B;

   Finally, the NOTE_INSN_VAR_LOCATION notes describing the variable locations

   are emitted to appropriate positions in RTL code.  Each such a note describes

   the location of one variable at the point in instruction stream where the

   note is.  There is no need to emit a note for each variable before each

   instruction, we only emit these notes where the location of variable changes

   (this means that we also emit notes for changes between the OUT set of the

   previous block and the IN set of the current block).

   The notes consist of two parts:

   1. the declaration (from REG_EXPR or MEM_EXPR)

   2. the location of a variable - it is either a simple register/memory

      reference (for simple variables, for example int),

      or a parallel of register/memory references (for a large variables

      which consist of several parts, for example long long).

*/

#include "config.h"

#include "system.h"

#include "coretypes.h"

#include "tm.h"

#include "rtl.h"

#include "tree.h"

#include "hard-reg-set.h"

#include "basic-block.h"

#include "flags.h"

#include "output.h"

#include "insn-config.h"

#include "reload.h"

#include "sbitmap.h"

#include "alloc-pool.h"

#include "fibheap.h"

#include "hashtab.h"

#include "regs.h"

#include "expr.h"

#include "timevar.h"

#include "tree-pass.h"

/* Type of micro operation.  */

enum micro_operation_type

{

  MO_USE,       /* Use location (REG or MEM).  */

  MO_USE_NO_VAR,/* Use location which is not associated with a variable

                   or the variable is not trackable.  */

  MO_SET,       /* Set location.  */

  MO_COPY,      /* Copy the same portion of a variable from one

                   location to another.  */

  MO_CLOBBER,   /* Clobber location.  */

  MO_CALL,      /* Call insn.  */

  MO_ADJUST     /* Adjust stack pointer.  */

};

/* Where shall the note be emitted?  BEFORE or AFTER the instruction.  */

enum emit_note_where

{

  EMIT_NOTE_BEFORE_INSN,

  EMIT_NOTE_AFTER_INSN

};

/* Structure holding information about micro operation.  */

typedef struct micro_operation_def

{

  /* Type of micro operation.  */

  enum micro_operation_type type;

  union {

    /* Location.  */

    rtx loc;

    /* Stack adjustment.  */

    HOST_WIDE_INT adjust;

  } u;

  /* The instruction which the micro operation is in, for MO_USE,

     MO_USE_NO_VAR, MO_CALL and MO_ADJUST, or the subsequent

     instruction or note in the original flow (before any var-tracking

     notes are inserted, to simplify emission of notes), for MO_SET

     and MO_CLOBBER.  */

  rtx insn;

} micro_operation;

/* Structure for passing some other parameters to function

   emit_note_insn_var_location.  */

typedef struct emit_note_data_def

{

  /* The instruction which the note will be emitted before/after.  */

  rtx insn;

  /* Where the note will be emitted (before/after insn)?  */

  enum emit_note_where where;

} emit_note_data;

/* Description of location of a part of a variable.  The content of a physical

   register is described by a chain of these structures.

   The chains are pretty short (usually 1 or 2 elements) and thus

   chain is the best data structure.  */

typedef struct attrs_def

{

  /* Pointer to next member of the list.  */

  struct attrs_def *next;

  /* The rtx of register.  */

  rtx loc;

  /* The declaration corresponding to LOC.  */

  tree decl;

  /* Offset from start of DECL.  */

  HOST_WIDE_INT offset;

} *attrs;

/* Structure holding the IN or OUT set for a basic block.  */

typedef struct dataflow_set_def

{

  /* Adjustment of stack offset.  */

  HOST_WIDE_INT stack_adjust;

  /* Attributes for registers (lists of attrs).  */

  attrs regs[FIRST_PSEUDO_REGISTER];

  /* Variable locations.  */

  htab_t vars;

} dataflow_set;

/* The structure (one for each basic block) containing the information

   needed for variable tracking.  */

typedef struct variable_tracking_info_def

{

  /* Number of micro operations stored in the MOS array.  */

  int n_mos;

  /* The array of micro operations.  */

  micro_operation *mos;

  /* The IN and OUT set for dataflow analysis.  */

  dataflow_set in;

  dataflow_set out;

  /* Has the block been visited in DFS?  */

  bool visited;

} *variable_tracking_info;

/* Structure for chaining the locations.  */

typedef struct location_chain_def

{

  /* Next element in the chain.  */

  struct location_chain_def *next;

  /* The location (REG or MEM).  */

  rtx loc;

} *location_chain;

/* Structure describing one part of variable.  */

typedef struct variable_part_def

{

  /* Chain of locations of the part.  */

  location_chain loc_chain;

  /* Location which was last emitted to location list.  */

  rtx cur_loc;

  /* The offset in the variable.  */

  HOST_WIDE_INT offset;

} variable_part;

/* Maximum number of location parts.  */

#define MAX_VAR_PARTS 16

/* Structure describing where the variable is located.  */

typedef struct variable_def

{

  /* The declaration of the variable.  */

  tree decl;

  /* Reference count.  */

  int refcount;

  /* Number of variable parts.  */

  int n_var_parts;

  /* The variable parts.  */

  variable_part var_part[MAX_VAR_PARTS];

} *variable;

/* Hash function for DECL for VARIABLE_HTAB.  */

#define VARIABLE_HASH_VAL(decl) (DECL_UID (decl))

/* Pointer to the BB's information specific to variable tracking pass.  */

#define VTI(BB) ((variable_tracking_info) (BB)->aux)

/* Alloc pool for struct attrs_def.  */

static alloc_pool attrs_pool;

/* Alloc pool for struct variable_def.  */

static alloc_pool var_pool;

/* Alloc pool for struct location_chain_def.  */

static alloc_pool loc_chain_pool;

/* Changed variables, notes will be emitted for them.  */

static htab_t changed_variables;

/* Shall notes be emitted?  */

static bool emit_notes;

/* Local function prototypes.  */

static void stack_adjust_offset_pre_post (rtx, HOST_WIDE_INT *,

                                          HOST_WIDE_INT *);

static void insn_stack_adjust_offset_pre_post (rtx, HOST_WIDE_INT *,

                                               HOST_WIDE_INT *);

static void bb_stack_adjust_offset (basic_block);

static bool vt_stack_adjustments (void);

static rtx adjust_stack_reference (rtx, HOST_WIDE_INT);

static hashval_t variable_htab_hash (const void *);

static int variable_htab_eq (const void *, const void *);

static void variable_htab_free (void *);

static void init_attrs_list_set (attrs *);

static void attrs_list_clear (attrs *);

static attrs attrs_list_member (attrs, tree, HOST_WIDE_INT);

static void attrs_list_insert (attrs *, tree, HOST_WIDE_INT, rtx);

static void attrs_list_copy (attrs *, attrs);

static void attrs_list_union (attrs *, attrs);

static void vars_clear (htab_t);

static variable unshare_variable (dataflow_set *set, variable var);

static int vars_copy_1 (void **, void *);

static void vars_copy (htab_t, htab_t);

static tree var_debug_decl (tree);

static void var_reg_set (dataflow_set *, rtx);

static void var_reg_delete_and_set (dataflow_set *, rtx, bool);

static void var_reg_delete (dataflow_set *, rtx, bool);

static void var_regno_delete (dataflow_set *, int);

static void var_mem_set (dataflow_set *, rtx);

static void var_mem_delete_and_set (dataflow_set *, rtx, bool);

static void var_mem_delete (dataflow_set *, rtx, bool);

static void dataflow_set_init (dataflow_set *, int);

static void dataflow_set_clear (dataflow_set *);

static void dataflow_set_copy (dataflow_set *, dataflow_set *);

static int variable_union_info_cmp_pos (const void *, const void *);

static int variable_union (void **, void *);

static void dataflow_set_union (dataflow_set *, dataflow_set *);

static bool variable_part_different_p (variable_part *, variable_part *);

static bool variable_different_p (variable, variable, bool);

static int dataflow_set_different_1 (void **, void *);

static int dataflow_set_different_2 (void **, void *);

static bool dataflow_set_different (dataflow_set *, dataflow_set *);

static void dataflow_set_destroy (dataflow_set *);

static bool contains_symbol_ref (rtx);

static bool track_expr_p (tree);

static bool same_variable_part_p (rtx, tree, HOST_WIDE_INT);

static int count_uses (rtx *, void *);

static void count_uses_1 (rtx *, void *);

static void count_stores (rtx, rtx, void *);

static int add_uses (rtx *, void *);

static void add_uses_1 (rtx *, void *);

static void add_stores (rtx, rtx, void *);

static bool compute_bb_dataflow (basic_block);

static void vt_find_locations (void);

static void dump_attrs_list (attrs);

static int dump_variable (void **, void *);

static void dump_vars (htab_t);

static void dump_dataflow_set (dataflow_set *);

static void dump_dataflow_sets (void);

static void variable_was_changed (variable, htab_t);

static void set_variable_part (dataflow_set *, rtx, tree, HOST_WIDE_INT);

static void clobber_variable_part (dataflow_set *, rtx, tree, HOST_WIDE_INT);

static void delete_variable_part (dataflow_set *, rtx, tree, HOST_WIDE_INT);

static int emit_note_insn_var_location (void **, void *);

static void emit_notes_for_changes (rtx, enum emit_note_where);

static int emit_notes_for_differences_1 (void **, void *);

static int emit_notes_for_differences_2 (void **, void *);

static void emit_notes_for_differences (rtx, dataflow_set *, dataflow_set *);

static void emit_notes_in_bb (basic_block);

static void vt_emit_notes (void);

static bool vt_get_decl_and_offset (rtx, tree *, HOST_WIDE_INT *);

static void vt_add_function_parameters (void);

static void vt_initialize (void);

static void vt_finalize (void);

/* Given a SET, calculate the amount of stack adjustment it contains

   PRE- and POST-modifying stack pointer.

   This function is similar to stack_adjust_offset.  */

static void

stack_adjust_offset_pre_post (rtx pattern, HOST_WIDE_INT *pre,

                              HOST_WIDE_INT *post)

{

  rtx src = SET_SRC (pattern);

  rtx dest = SET_DEST (pattern);

  enum rtx_code code;

  if (dest == stack_pointer_rtx)

    {

      /* (set (reg sp) (plus (reg sp) (const_int))) */

      code = GET_CODE (src);

      if (! (code == PLUS || code == MINUS)

          || XEXP (src, 0) != stack_pointer_rtx

          || GET_CODE (XEXP (src, 1)) != CONST_INT)

        return;

      if (code == MINUS)

        *post += INTVAL (XEXP (src, 1));

      else

        *post -= INTVAL (XEXP (src, 1));

    }

  else if (MEM_P (dest))

    {

      /* (set (mem (pre_dec (reg sp))) (foo)) */

      src = XEXP (dest, 0);

      code = GET_CODE (src);

      switch (code)

        {

        case PRE_MODIFY:

        case POST_MODIFY:

          if (XEXP (src, 0) == stack_pointer_rtx)

            {

              rtx val = XEXP (XEXP (src, 1), 1);

              /* We handle only adjustments by constant amount.  */

              gcc_assert (GET_CODE (XEXP (src, 1)) == PLUS &&

                          GET_CODE (val) == CONST_INT);

              if (code == PRE_MODIFY)

                *pre -= INTVAL (val);

              else

                *post -= INTVAL (val);

              break;

            }

          return;

        case PRE_DEC:

          if (XEXP (src, 0) == stack_pointer_rtx)

            {

              *pre += GET_MODE_SIZE (GET_MODE (dest));

              break;

            }

          return;

        case POST_DEC:

          if (XEXP (src, 0) == stack_pointer_rtx)

            {

              *post += GET_MODE_SIZE (GET_MODE (dest));

              break;

            }

          return;

        case PRE_INC:

          if (XEXP (src, 0) == stack_pointer_rtx)

            {

              *pre -= GET_MODE_SIZE (GET_MODE (dest));

              break;

            }

          return;

        case POST_INC:

          if (XEXP (src, 0) == stack_pointer_rtx)

            {

              *post -= GET_MODE_SIZE (GET_MODE (dest));

              break;

            }

          return;

        default:

          return;

        }

    }

}

/* Given an INSN, calculate the amount of stack adjustment it contains

   PRE- and POST-modifying stack pointer.  */

static void

insn_stack_adjust_offset_pre_post (rtx insn, HOST_WIDE_INT *pre,

                                   HOST_WIDE_INT *post)

{

  *pre = 0;

  *post = 0;

  if (GET_CODE (PATTERN (insn)) == SET)

    stack_adjust_offset_pre_post (PATTERN (insn), pre, post);

  else if (GET_CODE (PATTERN (insn)) == PARALLEL

           || GET_CODE (PATTERN (insn)) == SEQUENCE)

    {

      int i;

      /* There may be stack adjustments inside compound insns.  Search

         for them.  */

      for ( i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)

        if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)

          stack_adjust_offset_pre_post (XVECEXP (PATTERN (insn), 0, i),

                                        pre, post);

    }

}

/* Compute stack adjustment in basic block BB.  */

static void

bb_stack_adjust_offset (basic_block bb)

{

  HOST_WIDE_INT offset;

  int i;

  offset = VTI (bb)->in.stack_adjust;

  for (i = 0; i < VTI (bb)->n_mos; i++)

    {

      if (VTI (bb)->mos[i].type == MO_ADJUST)

        offset += VTI (bb)->mos[i].u.adjust;

      else if (VTI (bb)->mos[i].type != MO_CALL)

        {

          if (MEM_P (VTI (bb)->mos[i].u.loc))

            {

              VTI (bb)->mos[i].u.loc

                = adjust_stack_reference (VTI (bb)->mos[i].u.loc, -offset);

            }

        }

    }

  VTI (bb)->out.stack_adjust = offset;

}

/* Compute stack adjustments for all blocks by traversing DFS tree.

   Return true when the adjustments on all incoming edges are consistent.

   Heavily borrowed from pre_and_rev_post_order_compute.  */

static bool

vt_stack_adjustments (void)

{

  edge_iterator *stack;

  int sp;

  /* Initialize entry block.  */

  VTI (ENTRY_BLOCK_PTR)->visited = true;

  VTI (ENTRY_BLOCK_PTR)->out.stack_adjust = INCOMING_FRAME_SP_OFFSET;

  /* Allocate stack for back-tracking up CFG.  */

  stack = XNEWVEC (edge_iterator, n_basic_blocks + 1);

  sp = 0;

  /* Push the first edge on to the stack.  */

  stack[sp++] = ei_start (ENTRY_BLOCK_PTR->succs);

  while (sp)

    {

      edge_iterator ei;

      basic_block src;

      basic_block dest;

      /* Look at the edge on the top of the stack.  */

      ei = stack[sp - 1];

      src = ei_edge (ei)->src;

      dest = ei_edge (ei)->dest;

      /* Check if the edge destination has been visited yet.  */

      if (!VTI (dest)->visited)

        {

          VTI (dest)->visited = true;

          VTI (dest)->in.stack_adjust = VTI (src)->out.stack_adjust;

          bb_stack_adjust_offset (dest);

          if (EDGE_COUNT (dest->succs) > 0)

            /* Since the DEST node has been visited for the first

               time, check its successors.  */

            stack[sp++] = ei_start (dest->succs);

        }

      else

        {

          /* Check whether the adjustments on the edges are the same.  */

          if (VTI (dest)->in.stack_adjust != VTI (src)->out.stack_adjust)

            {

              free (stack);

              return false;

            }

          if (! ei_one_before_end_p (ei))

            /* Go to the next edge.  */

            ei_next (&stack[sp - 1]);

          else

            /* Return to previous level if there are no more edges.  */

            sp--;

        }

    }

  free (stack);

  return true;

}

/* Adjust stack reference MEM by ADJUSTMENT bytes and make it relative

   to the argument pointer.  Return the new rtx.  */

static rtx

adjust_stack_reference (rtx mem, HOST_WIDE_INT adjustment)

{

  rtx addr, cfa, tmp;

#ifdef FRAME_POINTER_CFA_OFFSET

  adjustment -= FRAME_POINTER_CFA_OFFSET (current_function_decl);

  cfa = plus_constant (frame_pointer_rtx, adjustment);

#else

  adjustment -= ARG_POINTER_CFA_OFFSET (current_function_decl);

  cfa = plus_constant (arg_pointer_rtx, adjustment);

#endif

  addr = replace_rtx (copy_rtx (XEXP (mem, 0)), stack_pointer_rtx, cfa);

  tmp = simplify_rtx (addr);

  if (tmp)

    addr = tmp;

  return replace_equiv_address_nv (mem, addr);

}

/* The hash function for variable_htab, computes the hash value

   from the declaration of variable X.  */

static hashval_t

variable_htab_hash (const void *x)

{

  const variable v = (const variable) x;

  return (VARIABLE_HASH_VAL (v->decl));

}

/* Compare the declaration of variable X with declaration Y.  */

static int

variable_htab_eq (const void *x, const void *y)

{

  const variable v = (const variable) x;

  const tree decl = (const tree) y;

  return (VARIABLE_HASH_VAL (v->decl) == VARIABLE_HASH_VAL (decl));

}

/* Free the element of VARIABLE_HTAB (its type is struct variable_def).  */

static void

variable_htab_free (void *elem)

{

  int i;

  variable var = (variable) elem;

  location_chain node, next;

  gcc_assert (var->refcount > 0);

  var->refcount--;

  if (var->refcount > 0)

    return;

  for (i = 0; i < var->n_var_parts; i++)

    {

      for (node = var->var_part[i].loc_chain; node; node = next)

        {

          next = node->next;

          pool_free (loc_chain_pool, node);

        }

      var->var_part[i].loc_chain = NULL;

    }

  pool_free (var_pool, var);

}

/* Initialize the set (array) SET of attrs to empty lists.  */

static void

init_attrs_list_set (attrs *set)

{

  int i;

  for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)

    set[i] = NULL;

}

/* Make the list *LISTP empty.  */

static void

attrs_list_clear (attrs *listp)

{

  attrs list, next;

  for (list = *listp; list; list = next)

    {

      next = list->next;

      pool_free (attrs_pool, list);

    }

  *listp = NULL;

}

/* Return true if the pair of DECL and OFFSET is the member of the LIST.  */

static attrs

attrs_list_member (attrs list, tree decl, HOST_WIDE_INT offset)

{

  for (; list; list = list->next)

    if (list->decl == decl && list->offset == offset)

      return list;

  return NULL;

}

/* Insert the triplet DECL, OFFSET, LOC to the list *LISTP.  */

static void

attrs_list_insert (attrs *listp, tree decl, HOST_WIDE_INT offset, rtx loc)

{

  attrs list;

  list = pool_alloc (attrs_pool);

  list->loc = loc;

  list->decl = decl;

  list->offset = offset;

  list->next = *listp;

  *listp = list;

}

/* Copy all nodes from SRC and create a list *DSTP of the copies.  */

static void

attrs_list_copy (attrs *dstp, attrs src)

{

  attrs n;

  attrs_list_clear (dstp);

  for (; src; src = src->next)

    {

      n = pool_alloc (attrs_pool);

      n->loc = src->loc;

      n->decl = src->decl;

      n->offset = src->offset;

      n->next = *dstp;

      *dstp = n;

    }

}

/* Add all nodes from SRC which are not in *DSTP to *DSTP.  */