Subversion Repositories openrisc

/* Tail merging for gimple.

   Copyright (C) 2011, 2012 Free Software Foundation, Inc.

   Contributed by Tom de Vries (tom@codesourcery.com)

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/>.  */

/* Pass overview.

   MOTIVATIONAL EXAMPLE

   gimple representation of gcc/testsuite/gcc.dg/pr43864.c at

   hprofStartupp (charD.1 * outputFileNameD.2600, charD.1 * ctxD.2601)

   {

     struct FILED.1638 * fpD.2605;

     charD.1 fileNameD.2604[1000];

     intD.0 D.3915;

     const charD.1 * restrict outputFileName.0D.3914;

     # BLOCK 2 freq:10000

     # PRED: ENTRY [100.0%]  (fallthru,exec)

     # PT = nonlocal { D.3926 } (restr)

     outputFileName.0D.3914_3

       = (const charD.1 * restrict) outputFileNameD.2600_2(D);

     # .MEMD.3923_13 = VDEF <.MEMD.3923_12(D)>

     # USE = nonlocal null { fileNameD.2604 D.3926 } (restr)

     # CLB = nonlocal null { fileNameD.2604 D.3926 } (restr)

     sprintfD.759 (&fileNameD.2604, outputFileName.0D.3914_3);

     # .MEMD.3923_14 = VDEF <.MEMD.3923_13>

     # USE = nonlocal null { fileNameD.2604 D.3926 } (restr)

     # CLB = nonlocal null { fileNameD.2604 D.3926 } (restr)

     D.3915_4 = accessD.2606 (&fileNameD.2604, 1);

     if (D.3915_4 == 0)

       goto <bb 3>;

     else

       goto <bb 4>;

     # SUCC: 3 [10.0%]  (true,exec) 4 [90.0%]  (false,exec)

     # BLOCK 3 freq:1000

     # PRED: 2 [10.0%]  (true,exec)

     # .MEMD.3923_15 = VDEF <.MEMD.3923_14>

     # USE = nonlocal null { fileNameD.2604 D.3926 } (restr)

     # CLB = nonlocal null { fileNameD.2604 D.3926 } (restr)

     freeD.898 (ctxD.2601_5(D));

     goto <bb 7>;

     # SUCC: 7 [100.0%]  (fallthru,exec)

     # BLOCK 4 freq:9000

     # PRED: 2 [90.0%]  (false,exec)

     # .MEMD.3923_16 = VDEF <.MEMD.3923_14>

     # PT = nonlocal escaped

     # USE = nonlocal null { fileNameD.2604 D.3926 } (restr)

     # CLB = nonlocal null { fileNameD.2604 D.3926 } (restr)

     fpD.2605_8 = fopenD.1805 (&fileNameD.2604[0], 0B);

     if (fpD.2605_8 == 0B)

       goto <bb 5>;

     else

       goto <bb 6>;

     # SUCC: 5 [1.9%]  (true,exec) 6 [98.1%]  (false,exec)

     # BLOCK 5 freq:173

     # PRED: 4 [1.9%]  (true,exec)

     # .MEMD.3923_17 = VDEF <.MEMD.3923_16>

     # USE = nonlocal null { fileNameD.2604 D.3926 } (restr)

     # CLB = nonlocal null { fileNameD.2604 D.3926 } (restr)

     freeD.898 (ctxD.2601_5(D));

     goto <bb 7>;

     # SUCC: 7 [100.0%]  (fallthru,exec)

     # BLOCK 6 freq:8827

     # PRED: 4 [98.1%]  (false,exec)

     # .MEMD.3923_18 = VDEF <.MEMD.3923_16>

     # USE = nonlocal null { fileNameD.2604 D.3926 } (restr)

     # CLB = nonlocal null { fileNameD.2604 D.3926 } (restr)

     fooD.2599 (outputFileNameD.2600_2(D), fpD.2605_8);

     # SUCC: 7 [100.0%]  (fallthru,exec)

     # BLOCK 7 freq:10000

     # PRED: 3 [100.0%]  (fallthru,exec) 5 [100.0%]  (fallthru,exec)

             6 [100.0%]  (fallthru,exec)

     # PT = nonlocal null

     # ctxD.2601_1 = PHI <0B(3), 0B(5), ctxD.2601_5(D)(6)>

     # .MEMD.3923_11 = PHI <.MEMD.3923_15(3), .MEMD.3923_17(5),

                            .MEMD.3923_18(6)>

     # VUSE <.MEMD.3923_11>

     return ctxD.2601_1;

     # SUCC: EXIT [100.0%]

   }

   bb 3 and bb 5 can be merged.  The blocks have different predecessors, but the

   same successors, and the same operations.

   CONTEXT

   A technique called tail merging (or cross jumping) can fix the example

   above.  For a block, we look for common code at the end (the tail) of the

   predecessor blocks, and insert jumps from one block to the other.

   The example is a special case for tail merging, in that 2 whole blocks

   can be merged, rather than just the end parts of it.

   We currently only focus on whole block merging, so in that sense

   calling this pass tail merge is a bit of a misnomer.

   We distinguish 2 kinds of situations in which blocks can be merged:

   - same operations, same predecessors.  The successor edges coming from one

     block are redirected to come from the other block.

   - same operations, same successors.  The predecessor edges entering one block

     are redirected to enter the other block.  Note that this operation might

     involve introducing phi operations.

   For efficient implementation, we would like to value numbers the blocks, and

   have a comparison operator that tells us whether the blocks are equal.

   Besides being runtime efficient, block value numbering should also abstract

   from irrelevant differences in order of operations, much like normal value

   numbering abstracts from irrelevant order of operations.

   For the first situation (same_operations, same predecessors), normal value

   numbering fits well.  We can calculate a block value number based on the

   value numbers of the defs and vdefs.

   For the second situation (same operations, same successors), this approach

   doesn't work so well.  We can illustrate this using the example.  The calls

   to free use different vdefs: MEMD.3923_16 and MEMD.3923_14, and these will

   remain different in value numbering, since they represent different memory

   states.  So the resulting vdefs of the frees will be different in value

   numbering, so the block value numbers will be different.

   The reason why we call the blocks equal is not because they define the same

   values, but because uses in the blocks use (possibly different) defs in the

   same way.  To be able to detect this efficiently, we need to do some kind of

   reverse value numbering, meaning number the uses rather than the defs, and

   calculate a block value number based on the value number of the uses.

   Ideally, a block comparison operator will also indicate which phis are needed

   to merge the blocks.

   For the moment, we don't do block value numbering, but we do insn-by-insn

   matching, using scc value numbers to match operations with results, and

   structural comparison otherwise, while ignoring vop mismatches.

   IMPLEMENTATION

   1. The pass first determines all groups of blocks with the same successor

      blocks.

   2. Within each group, it tries to determine clusters of equal basic blocks.

   3. The clusters are applied.

   4. The same successor groups are updated.

   5. This process is repeated from 2 onwards, until no more changes.

   LIMITATIONS/TODO

   - block only

   - handles only 'same operations, same successors'.

     It handles same predecessors as a special subcase though.

   - does not implement the reverse value numbering and block value numbering.

   - improve memory allocation: use garbage collected memory, obstacks,

     allocpools where appropriate.

   - no insertion of gimple_reg phis,  We only introduce vop-phis.

   - handle blocks with gimple_reg phi_nodes.

   SWITCHES

   - ftree-tail-merge.  On at -O2.  We may have to enable it only at -Os.  */

#include "config.h"

#include "system.h"

#include "coretypes.h"

#include "tm.h"

#include "tree.h"

#include "tm_p.h"

#include "basic-block.h"

#include "output.h"

#include "flags.h"

#include "function.h"

#include "tree-flow.h"

#include "timevar.h"

#include "bitmap.h"

#include "tree-ssa-alias.h"

#include "params.h"

#include "tree-pretty-print.h"

#include "hashtab.h"

#include "gimple-pretty-print.h"

#include "tree-ssa-sccvn.h"

#include "tree-dump.h"

/* Describes a group of bbs with the same successors.  The successor bbs are

   cached in succs, and the successor edge flags are cached in succ_flags.

   If a bb has the EDGE_TRUE/VALSE_VALUE flags swapped compared to succ_flags,

   it's marked in inverse.

   Additionally, the hash value for the struct is cached in hashval, and

   in_worklist indicates whether it's currently part of worklist.  */

struct same_succ_def

{

  /* The bbs that have the same successor bbs.  */

  bitmap bbs;

  /* The successor bbs.  */

  bitmap succs;

  /* Indicates whether the EDGE_TRUE/FALSE_VALUEs of succ_flags are swapped for

     bb.  */

  bitmap inverse;

  /* The edge flags for each of the successor bbs.  */

  VEC (int, heap) *succ_flags;

  /* Indicates whether the struct is currently in the worklist.  */

  bool in_worklist;

  /* The hash value of the struct.  */

  hashval_t hashval;

};

typedef struct same_succ_def *same_succ;

typedef const struct same_succ_def *const_same_succ;

/* A group of bbs where 1 bb from bbs can replace the other bbs.  */

struct bb_cluster_def

{

  /* The bbs in the cluster.  */

  bitmap bbs;

  /* The preds of the bbs in the cluster.  */

  bitmap preds;

  /* Index in all_clusters vector.  */

  int index;

  /* The bb to replace the cluster with.  */

  basic_block rep_bb;

};

typedef struct bb_cluster_def *bb_cluster;

typedef const struct bb_cluster_def *const_bb_cluster;

/* Per bb-info.  */

struct aux_bb_info

{

  /* The number of non-debug statements in the bb.  */

  int size;

  /* The same_succ that this bb is a member of.  */

  same_succ bb_same_succ;

  /* The cluster that this bb is a member of.  */

  bb_cluster cluster;

  /* The vop state at the exit of a bb.  This is shortlived data, used to

     communicate data between update_block_by and update_vuses.  */

  tree vop_at_exit;

  /* The bb that either contains or is dominated by the dependencies of the

     bb.  */

  basic_block dep_bb;

};

/* Macros to access the fields of struct aux_bb_info.  */

#define BB_SIZE(bb) (((struct aux_bb_info *)bb->aux)->size)

#define BB_SAME_SUCC(bb) (((struct aux_bb_info *)bb->aux)->bb_same_succ)

#define BB_CLUSTER(bb) (((struct aux_bb_info *)bb->aux)->cluster)

#define BB_VOP_AT_EXIT(bb) (((struct aux_bb_info *)bb->aux)->vop_at_exit)

#define BB_DEP_BB(bb) (((struct aux_bb_info *)bb->aux)->dep_bb)

/* VAL1 and VAL2 are either:

   - uses in BB1 and BB2, or

   - phi alternatives for BB1 and BB2.

   Return true if the uses have the same gvn value.  */

static bool

gvn_uses_equal (tree val1, tree val2)

{

  gcc_checking_assert (val1 != NULL_TREE && val2 != NULL_TREE);

  if (val1 == val2)

    return true;

  if (vn_valueize (val1) != vn_valueize (val2))

    return false;

  return ((TREE_CODE (val1) == SSA_NAME || CONSTANT_CLASS_P (val1))

          && (TREE_CODE (val2) == SSA_NAME || CONSTANT_CLASS_P (val2)));

}

/* Prints E to FILE.  */

static void

same_succ_print (FILE *file, const same_succ e)

{

  unsigned int i;

  bitmap_print (file, e->bbs, "bbs:", "\n");

  bitmap_print (file, e->succs, "succs:", "\n");

  bitmap_print (file, e->inverse, "inverse:", "\n");

  fprintf (file, "flags:");

  for (i = 0; i < VEC_length (int, e->succ_flags); ++i)

    fprintf (file, " %x", VEC_index (int, e->succ_flags, i));

  fprintf (file, "\n");

}

/* Prints same_succ VE to VFILE.  */

static int

same_succ_print_traverse (void **ve, void *vfile)

{

  const same_succ e = *((const same_succ *)ve);

  FILE *file = ((FILE*)vfile);

  same_succ_print (file, e);

  return 1;

}

/* Update BB_DEP_BB (USE_BB), given a use of VAL in USE_BB.  */

static void

update_dep_bb (basic_block use_bb, tree val)

{

  basic_block dep_bb;

  /* Not a dep.  */

  if (TREE_CODE (val) != SSA_NAME)

    return;

  /* Skip use of global def.  */

  if (SSA_NAME_IS_DEFAULT_DEF (val))

    return;

  /* Skip use of local def.  */

  dep_bb = gimple_bb (SSA_NAME_DEF_STMT (val));

  if (dep_bb == use_bb)

    return;

  if (BB_DEP_BB (use_bb) == NULL

      || dominated_by_p (CDI_DOMINATORS, dep_bb, BB_DEP_BB (use_bb)))

    BB_DEP_BB (use_bb) = dep_bb;

}

/* Update BB_DEP_BB, given the dependencies in STMT.  */

static void

stmt_update_dep_bb (gimple stmt)

{

  ssa_op_iter iter;

  use_operand_p use;

  FOR_EACH_SSA_USE_OPERAND (use, stmt, iter, SSA_OP_USE)

    update_dep_bb (gimple_bb (stmt), USE_FROM_PTR (use));

}

/* Returns whether VAL is used in the same bb as in which it is defined, or

   in the phi of a successor bb.  */

static bool

local_def (tree val)

{

  gimple stmt, def_stmt;

  basic_block bb, def_bb;

  imm_use_iterator iter;

  bool res;

  if (TREE_CODE (val) != SSA_NAME)

    return false;

  def_stmt = SSA_NAME_DEF_STMT (val);

  def_bb = gimple_bb (def_stmt);

  res = true;

  FOR_EACH_IMM_USE_STMT (stmt, iter, val)

    {

      if (is_gimple_debug (stmt))

        continue;

      bb = gimple_bb (stmt);

      if (bb == def_bb)

        continue;

      if (gimple_code (stmt) == GIMPLE_PHI

          && find_edge (def_bb, bb))

        continue;

      res = false;

      BREAK_FROM_IMM_USE_STMT (iter);

    }

  return res;

}

/* Calculates hash value for same_succ VE.  */

static hashval_t

same_succ_hash (const void *ve)

{

  const_same_succ e = (const_same_succ)ve;

  hashval_t hashval = bitmap_hash (e->succs);

  int flags;

  unsigned int i;

  unsigned int first = bitmap_first_set_bit (e->bbs);

  basic_block bb = BASIC_BLOCK (first);

  int size = 0;

  gimple_stmt_iterator gsi;

  gimple stmt;

  tree arg;

  unsigned int s;

  bitmap_iterator bs;

  for (gsi = gsi_start_nondebug_bb (bb);

       !gsi_end_p (gsi); gsi_next_nondebug (&gsi))

    {

      stmt = gsi_stmt (gsi);

      stmt_update_dep_bb (stmt);

      if (is_gimple_assign (stmt) && local_def (gimple_get_lhs (stmt))

          && !gimple_has_side_effects (stmt))

        continue;

      size++;

      hashval = iterative_hash_hashval_t (gimple_code (stmt), hashval);

      if (is_gimple_assign (stmt))

        hashval = iterative_hash_hashval_t (gimple_assign_rhs_code (stmt),

                                            hashval);

      if (!is_gimple_call (stmt))

        continue;

      if (gimple_call_internal_p (stmt))

        hashval = iterative_hash_hashval_t

          ((hashval_t) gimple_call_internal_fn (stmt), hashval);

      else

        hashval = iterative_hash_expr (gimple_call_fn (stmt), hashval);

      for (i = 0; i < gimple_call_num_args (stmt); i++)

        {

          arg = gimple_call_arg (stmt, i);

          arg = vn_valueize (arg);

          hashval = iterative_hash_expr (arg, hashval);

        }

    }

  hashval = iterative_hash_hashval_t (size, hashval);

  BB_SIZE (bb) = size;

  for (i = 0; i < VEC_length (int, e->succ_flags); ++i)

    {

      flags = VEC_index (int, e->succ_flags, i);

      flags = flags & ~(EDGE_TRUE_VALUE | EDGE_FALSE_VALUE);

      hashval = iterative_hash_hashval_t (flags, hashval);

    }

  EXECUTE_IF_SET_IN_BITMAP (e->succs, 0, s, bs)

    {

      int n = find_edge (bb, BASIC_BLOCK (s))->dest_idx;

      for (gsi = gsi_start_phis (BASIC_BLOCK (s)); !gsi_end_p (gsi);

           gsi_next (&gsi))

        {

          gimple phi = gsi_stmt (gsi);

          tree lhs = gimple_phi_result (phi);

          tree val = gimple_phi_arg_def (phi, n);

          if (!is_gimple_reg (lhs))

            continue;

          update_dep_bb (bb, val);

        }

    }

  return hashval;

}

/* Returns true if E1 and E2 have 2 successors, and if the successor flags

   are inverse for the EDGE_TRUE_VALUE and EDGE_FALSE_VALUE flags, and equal for

   the other edge flags.  */

static bool

inverse_flags (const_same_succ e1, const_same_succ e2)

{

  int f1a, f1b, f2a, f2b;

  int mask = ~(EDGE_TRUE_VALUE | EDGE_FALSE_VALUE);

  if (VEC_length (int, e1->succ_flags) != 2)

    return false;

  f1a = VEC_index (int, e1->succ_flags, 0);

  f1b = VEC_index (int, e1->succ_flags, 1);

  f2a = VEC_index (int, e2->succ_flags, 0);

  f2b = VEC_index (int, e2->succ_flags, 1);

  if (f1a == f2a && f1b == f2b)

    return false;

  return (f1a & mask) == (f2a & mask) && (f1b & mask) == (f2b & mask);

}

/* Compares SAME_SUCCs VE1 and VE2.  */

static int

same_succ_equal (const void *ve1, const void *ve2)

{

  const_same_succ e1 = (const_same_succ)ve1;

  const_same_succ e2 = (const_same_succ)ve2;

  unsigned int i, first1, first2;

  gimple_stmt_iterator gsi1, gsi2;

  gimple s1, s2;

  basic_block bb1, bb2;

  if (e1->hashval != e2->hashval)

    return 0;

  if (VEC_length (int, e1->succ_flags) != VEC_length (int, e2->succ_flags))

    return 0;

  if (!bitmap_equal_p (e1->succs, e2->succs))

    return 0;

  if (!inverse_flags (e1, e2))

    {

      for (i = 0; i < VEC_length (int, e1->succ_flags); ++i)

        if (VEC_index (int, e1->succ_flags, i)

            != VEC_index (int, e1->succ_flags, i))

          return 0;

    }

  first1 = bitmap_first_set_bit (e1->bbs);

  first2 = bitmap_first_set_bit (e2->bbs);

  bb1 = BASIC_BLOCK (first1);

  bb2 = BASIC_BLOCK (first2);

  if (BB_SIZE (bb1) != BB_SIZE (bb2))

    return 0;

  gsi1 = gsi_start_nondebug_bb (bb1);

  gsi2 = gsi_start_nondebug_bb (bb2);

  while (!(gsi_end_p (gsi1) || gsi_end_p (gsi2)))

    {

      s1 = gsi_stmt (gsi1);

      s2 = gsi_stmt (gsi2);

      if (gimple_code (s1) != gimple_code (s2))

        return 0;

      if (is_gimple_call (s1) && !gimple_call_same_target_p (s1, s2))

        return 0;

      gsi_next_nondebug (&gsi1);

      gsi_next_nondebug (&gsi2);

    }

  return 1;

}

/* Alloc and init a new SAME_SUCC.  */

static same_succ

same_succ_alloc (void)

{

  same_succ same = XNEW (struct same_succ_def);

  same->bbs = BITMAP_ALLOC (NULL);

  same->succs = BITMAP_ALLOC (NULL);

  same->inverse = BITMAP_ALLOC (NULL);

  same->succ_flags = VEC_alloc (int, heap, 10);

  same->in_worklist = false;

  return same;

}

/* Delete same_succ VE.  */

static void

same_succ_delete (void *ve)

{

  same_succ e = (same_succ)ve;

  BITMAP_FREE (e->bbs);

  BITMAP_FREE (e->succs);

  BITMAP_FREE (e->inverse);

  VEC_free (int, heap, e->succ_flags);

  XDELETE (ve);

}

/* Reset same_succ SAME.  */

static void

same_succ_reset (same_succ same)

{

  bitmap_clear (same->bbs);

  bitmap_clear (same->succs);

  bitmap_clear (same->inverse);

  VEC_truncate (int, same->succ_flags, 0);

}

/* Hash table with all same_succ entries.  */

static htab_t same_succ_htab;

/* Array that is used to store the edge flags for a successor.  */

static int *same_succ_edge_flags;

/* Bitmap that is used to mark bbs that are recently deleted.  */

static bitmap deleted_bbs;

/* Bitmap that is used to mark predecessors of bbs that are

   deleted.  */

static bitmap deleted_bb_preds;

/* Prints same_succ_htab to stderr.  */

extern void debug_same_succ (void);

DEBUG_FUNCTION void

debug_same_succ ( void)

{

  htab_traverse (same_succ_htab, same_succ_print_traverse, stderr);

}

DEF_VEC_P (same_succ);

DEF_VEC_ALLOC_P (same_succ, heap);

/* Vector of bbs to process.  */

static VEC (same_succ, heap) *worklist;

/* Prints worklist to FILE.  */

static void

print_worklist (FILE *file)

{

  unsigned int i;

  for (i = 0; i < VEC_length (same_succ, worklist); ++i)

    same_succ_print (file, VEC_index (same_succ, worklist, i));

}

/* Adds SAME to worklist.  */

static void

add_to_worklist (same_succ same)

{

  if (same->in_worklist)

    return;

  if (bitmap_count_bits (same->bbs) < 2)

    return;

  same->in_worklist = true;

  VEC_safe_push (same_succ, heap, worklist, same);

}

/* Add BB to same_succ_htab.  */

static void

find_same_succ_bb (basic_block bb, same_succ *same_p)

{

  unsigned int j;

  bitmap_iterator bj;

  same_succ same = *same_p;

  same_succ *slot;

  edge_iterator ei;

  edge e;

  if (bb == NULL)

    return;

  bitmap_set_bit (same->bbs, bb->index);

  FOR_EACH_EDGE (e, ei, bb->succs)

    {

      int index = e->dest->index;

      bitmap_set_bit (same->succs, index);

      same_succ_edge_flags[index] = e->flags;

    }

  EXECUTE_IF_SET_IN_BITMAP (same->succs, 0, j, bj)

    VEC_safe_push (int, heap, same->succ_flags, same_succ_edge_flags[j]);

  same->hashval = same_succ_hash (same);

  slot = (same_succ *) htab_find_slot_with_hash (same_succ_htab, same,

                                                   same->hashval, INSERT);

  if (*slot == NULL)

    {

      *slot = same;

      BB_SAME_SUCC (bb) = same;

      add_to_worklist (same);

      *same_p = NULL;

    }

  else

    {

      bitmap_set_bit ((*slot)->bbs, bb->index);

      BB_SAME_SUCC (bb) = *slot;

      add_to_worklist (*slot);

      if (inverse_flags (same, *slot))

        bitmap_set_bit ((*slot)->inverse, bb->index);

      same_succ_reset (same);

    }

}

/* Find bbs with same successors.  */

static void

find_same_succ (void)

{

  same_succ same = same_succ_alloc ();

  basic_block bb;

  FOR_EACH_BB (bb)

    {

      find_same_succ_bb (bb, &same);

      if (same == NULL)

        same = same_succ_alloc ();

    }

  same_succ_delete (same);

}

/* Initializes worklist administration.  */

static void

init_worklist (void)

{

  alloc_aux_for_blocks (sizeof (struct aux_bb_info));

  same_succ_htab

    = htab_create (n_basic_blocks, same_succ_hash, same_succ_equal,

                   same_succ_delete);

  same_succ_edge_flags = XCNEWVEC (int, last_basic_block);

  deleted_bbs = BITMAP_ALLOC (NULL);

  deleted_bb_preds = BITMAP_ALLOC (NULL);

  worklist = VEC_alloc (same_succ, heap, n_basic_blocks);

  find_same_succ ();

  if (dump_file && (dump_flags & TDF_DETAILS))

    {

      fprintf (dump_file, "initial worklist:\n");

      print_worklist (dump_file);

    }

}

/* Deletes worklist administration.  */