Subversion Repositories openrisc

/* Data flow functions for trees.

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

   Contributed by Diego Novillo <dnovillo@redhat.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/>.  */

#include "config.h"

#include "system.h"

#include "coretypes.h"

#include "tm.h"

#include "hashtab.h"

#include "pointer-set.h"

#include "tree.h"

#include "rtl.h"

#include "tm_p.h"

#include "hard-reg-set.h"

#include "basic-block.h"

#include "output.h"

#include "timevar.h"

#include "expr.h"

#include "ggc.h"

#include "langhooks.h"

#include "flags.h"

#include "function.h"

#include "diagnostic.h"

#include "tree-dump.h"

#include "tree-gimple.h"

#include "tree-flow.h"

#include "tree-inline.h"

#include "tree-pass.h"

#include "convert.h"

#include "params.h"

#include "cgraph.h"

/* Build and maintain data flow information for trees.  */

/* Counters used to display DFA and SSA statistics.  */

struct dfa_stats_d

{

  long num_stmt_anns;

  long num_var_anns;

  long num_defs;

  long num_uses;

  long num_phis;

  long num_phi_args;

  int max_num_phi_args;

  long num_v_may_defs;

  long num_vuses;

  long num_v_must_defs;

};

/* Local functions.  */

static void collect_dfa_stats (struct dfa_stats_d *);

static tree collect_dfa_stats_r (tree *, int *, void *);

static tree find_vars_r (tree *, int *, void *);

/* Global declarations.  */

/* Array of all variables referenced in the function.  */

htab_t referenced_vars;

/* Default definition for this symbols.  If set for symbol, it

   means that the first reference to this variable in the function is a

   USE or a VUSE.  In those cases, the SSA renamer creates an SSA name

   for this variable with an empty defining statement.  */

htab_t default_defs;

/*---------------------------------------------------------------------------

                        Dataflow analysis (DFA) routines

---------------------------------------------------------------------------*/

/* Find all the variables referenced in the function.  This function

   builds the global arrays REFERENCED_VARS and CALL_CLOBBERED_VARS.

   Note that this function does not look for statement operands, it simply

   determines what variables are referenced in the program and detects

   various attributes for each variable used by alias analysis and the

   optimizer.  */

static unsigned int

find_referenced_vars (void)

{

  basic_block bb;

  block_stmt_iterator si;

  FOR_EACH_BB (bb)

    for (si = bsi_start (bb); !bsi_end_p (si); bsi_next (&si))

      {

        tree *stmt_p = bsi_stmt_ptr (si);

        walk_tree (stmt_p, find_vars_r, NULL, NULL);

      }

  return 0;

}

struct tree_opt_pass pass_referenced_vars =

{

  NULL,                                 /* name */

  NULL,                                 /* gate */

  find_referenced_vars,                 /* execute */

  NULL,                                 /* sub */

  NULL,                                 /* next */

  0,                                     /* static_pass_number */

  TV_FIND_REFERENCED_VARS,              /* tv_id */

  PROP_gimple_leh | PROP_cfg,           /* properties_required */

  PROP_referenced_vars,                 /* properties_provided */

  0,                                     /* properties_destroyed */

  0,                                     /* todo_flags_start */

  0,                                    /* todo_flags_finish */

};

/*---------------------------------------------------------------------------

                            Manage annotations

---------------------------------------------------------------------------*/

/* Create a new annotation for a _DECL node T.  */

var_ann_t

create_var_ann (tree t)

{

  var_ann_t ann;

  gcc_assert (t);

  gcc_assert (DECL_P (t));

  gcc_assert (!t->common.ann || t->common.ann->common.type == VAR_ANN);

  ann = GGC_CNEW (struct var_ann_d);

  ann->common.type = VAR_ANN;

  t->common.ann = (tree_ann_t) ann;

  return ann;

}

/* Create a new annotation for a FUNCTION_DECL node T.  */

function_ann_t

create_function_ann (tree t)

{

  function_ann_t ann;

  gcc_assert (t);

  gcc_assert (TREE_CODE (t) == FUNCTION_DECL);

  gcc_assert (!t->common.ann || t->common.ann->common.type == FUNCTION_ANN);

  ann = ggc_alloc (sizeof (*ann));

  memset ((void *) ann, 0, sizeof (*ann));

  ann->common.type = FUNCTION_ANN;

  t->common.ann = (tree_ann_t) ann;

  return ann;

}

/* Create a new annotation for a statement node T.  */

stmt_ann_t

create_stmt_ann (tree t)

{

  stmt_ann_t ann;

  gcc_assert (is_gimple_stmt (t));

  gcc_assert (!t->common.ann || t->common.ann->common.type == STMT_ANN);

  ann = GGC_CNEW (struct stmt_ann_d);

  ann->common.type = STMT_ANN;

  /* Since we just created the annotation, mark the statement modified.  */

  ann->modified = true;

  t->common.ann = (tree_ann_t) ann;

  return ann;

}

/* Create a new annotation for a tree T.  */

tree_ann_common_t

create_tree_common_ann (tree t)

{

  tree_ann_common_t ann;

  gcc_assert (t);

  gcc_assert (!t->common.ann || t->common.ann->common.type == TREE_ANN_COMMON);

  ann = GGC_CNEW (struct tree_ann_common_d);

  ann->type = TREE_ANN_COMMON;

  t->common.ann = (tree_ann_t) ann;

  return ann;

}

/* Build a temporary.  Make sure and register it to be renamed.  */

tree

make_rename_temp (tree type, const char *prefix)

{

  tree t = create_tmp_var (type, prefix);

  if (TREE_CODE (type) == COMPLEX_TYPE)

    DECL_COMPLEX_GIMPLE_REG_P (t) = 1;

  if (referenced_vars)

    {

      add_referenced_var (t);

      mark_sym_for_renaming (t);

    }

  return t;

}

/*---------------------------------------------------------------------------

                              Debugging functions

---------------------------------------------------------------------------*/

/* Dump the list of all the referenced variables in the current function to

   FILE.  */

void

dump_referenced_vars (FILE *file)

{

  tree var;

  referenced_var_iterator rvi;

  fprintf (file, "\nReferenced variables in %s: %u\n\n",

           get_name (current_function_decl), (unsigned) num_referenced_vars);

  FOR_EACH_REFERENCED_VAR (var, rvi)

    {

      fprintf (file, "Variable: ");

      dump_variable (file, var);

      fprintf (file, "\n");

    }

}

/* Dump the list of all the referenced variables to stderr.  */

void

debug_referenced_vars (void)

{

  dump_referenced_vars (stderr);

}

/* Dump sub-variables for VAR to FILE.  */

void

dump_subvars_for (FILE *file, tree var)

{

  subvar_t sv = get_subvars_for_var (var);

  if (!sv)

    return;

  fprintf (file, "{ ");

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

    {

      print_generic_expr (file, sv->var, dump_flags);

      fprintf (file, " ");

    }

  fprintf (file, "}");

}

/* Dumb sub-variables for VAR to stderr.  */

void

debug_subvars_for (tree var)

{

  dump_subvars_for (stderr, var);

}

/* Dump variable VAR and its may-aliases to FILE.  */

void

dump_variable (FILE *file, tree var)

{

  var_ann_t ann;

  if (TREE_CODE (var) == SSA_NAME)

    {

      if (POINTER_TYPE_P (TREE_TYPE (var)))

        dump_points_to_info_for (file, var);

      var = SSA_NAME_VAR (var);

    }

  if (var == NULL_TREE)

    {

      fprintf (file, "<nil>");

      return;

    }

  print_generic_expr (file, var, dump_flags);

  ann = var_ann (var);

  fprintf (file, ", UID %u", (unsigned) DECL_UID (var));

  fprintf (file, ", ");

  print_generic_expr (file, TREE_TYPE (var), dump_flags);

  if (ann && ann->symbol_mem_tag)

    {

      fprintf (file, ", symbol memory tag: ");

      print_generic_expr (file, ann->symbol_mem_tag, dump_flags);

    }

  if (ann && ann->is_aliased)

    fprintf (file, ", is aliased");

  if (TREE_ADDRESSABLE (var))

    fprintf (file, ", is addressable");

  if (is_global_var (var))

    fprintf (file, ", is global");

  if (TREE_THIS_VOLATILE (var))

    fprintf (file, ", is volatile");

  if (is_call_clobbered (var))

    {

      fprintf (file, ", call clobbered");

      if (dump_flags & TDF_DETAILS)

        {

          var_ann_t va = var_ann (var);

          unsigned int escape_mask = va->escape_mask;

          fprintf (file, " (");

          if (escape_mask & ESCAPE_STORED_IN_GLOBAL)

            fprintf (file, ", stored in global");

          if (escape_mask & ESCAPE_TO_ASM)

            fprintf (file, ", goes through ASM");

          if (escape_mask & ESCAPE_TO_CALL)

            fprintf (file, ", passed to call");

          if (escape_mask & ESCAPE_BAD_CAST)

            fprintf (file, ", bad cast");

          if (escape_mask & ESCAPE_TO_RETURN)

            fprintf (file, ", returned from func");

          if (escape_mask & ESCAPE_TO_PURE_CONST)

            fprintf (file, ", passed to pure/const");

          if (escape_mask & ESCAPE_IS_GLOBAL)

            fprintf (file, ", is global var");

          if (escape_mask & ESCAPE_IS_PARM)

            fprintf (file, ", is incoming pointer");

          if (escape_mask & ESCAPE_UNKNOWN)

            fprintf (file, ", unknown escape");

          fprintf (file, " )");

        }

    }

  if (default_def (var))

    {

      fprintf (file, ", default def: ");

      print_generic_expr (file, default_def (var), dump_flags);

    }

  if (may_aliases (var))

    {

      fprintf (file, ", may aliases: ");

      dump_may_aliases_for (file, var);

    }

  if (get_subvars_for_var (var))

    {

      fprintf (file, ", sub-vars: ");

      dump_subvars_for (file, var);

    }

  fprintf (file, "\n");

}

/* Dump variable VAR and its may-aliases to stderr.  */

void

debug_variable (tree var)

{

  dump_variable (stderr, var);

}

/* Dump various DFA statistics to FILE.  */

void

dump_dfa_stats (FILE *file)

{

  struct dfa_stats_d dfa_stats;

  unsigned long size, total = 0;

  const char * const fmt_str   = "%-30s%-13s%12s\n";

  const char * const fmt_str_1 = "%-30s%13lu%11lu%c\n";

  const char * const fmt_str_3 = "%-43s%11lu%c\n";

  const char *funcname

    = lang_hooks.decl_printable_name (current_function_decl, 2);

  collect_dfa_stats (&dfa_stats);

  fprintf (file, "\nDFA Statistics for %s\n\n", funcname);

  fprintf (file, "---------------------------------------------------------\n");

  fprintf (file, fmt_str, "", "  Number of  ", "Memory");

  fprintf (file, fmt_str, "", "  instances  ", "used ");

  fprintf (file, "---------------------------------------------------------\n");

  size = num_referenced_vars * sizeof (tree);

  total += size;

  fprintf (file, fmt_str_1, "Referenced variables", (unsigned long)num_referenced_vars,

           SCALE (size), LABEL (size));

  size = dfa_stats.num_stmt_anns * sizeof (struct stmt_ann_d);

  total += size;

  fprintf (file, fmt_str_1, "Statements annotated", dfa_stats.num_stmt_anns,

           SCALE (size), LABEL (size));

  size = dfa_stats.num_var_anns * sizeof (struct var_ann_d);

  total += size;

  fprintf (file, fmt_str_1, "Variables annotated", dfa_stats.num_var_anns,

           SCALE (size), LABEL (size));

  size = dfa_stats.num_uses * sizeof (tree *);

  total += size;

  fprintf (file, fmt_str_1, "USE operands", dfa_stats.num_uses,

           SCALE (size), LABEL (size));

  size = dfa_stats.num_defs * sizeof (tree *);

  total += size;

  fprintf (file, fmt_str_1, "DEF operands", dfa_stats.num_defs,

           SCALE (size), LABEL (size));

  size = dfa_stats.num_vuses * sizeof (tree *);

  total += size;

  fprintf (file, fmt_str_1, "VUSE operands", dfa_stats.num_vuses,

           SCALE (size), LABEL (size));

  size = dfa_stats.num_v_may_defs * sizeof (tree *);

  total += size;

  fprintf (file, fmt_str_1, "V_MAY_DEF operands", dfa_stats.num_v_may_defs,

           SCALE (size), LABEL (size));

  size = dfa_stats.num_v_must_defs * sizeof (tree *);

  total += size;

  fprintf (file, fmt_str_1, "V_MUST_DEF operands", dfa_stats.num_v_must_defs,

           SCALE (size), LABEL (size));

  size = dfa_stats.num_phis * sizeof (struct tree_phi_node);

  total += size;

  fprintf (file, fmt_str_1, "PHI nodes", dfa_stats.num_phis,

           SCALE (size), LABEL (size));

  size = dfa_stats.num_phi_args * sizeof (struct phi_arg_d);

  total += size;

  fprintf (file, fmt_str_1, "PHI arguments", dfa_stats.num_phi_args,

           SCALE (size), LABEL (size));

  fprintf (file, "---------------------------------------------------------\n");

  fprintf (file, fmt_str_3, "Total memory used by DFA/SSA data", SCALE (total),

           LABEL (total));

  fprintf (file, "---------------------------------------------------------\n");

  fprintf (file, "\n");

  if (dfa_stats.num_phis)

    fprintf (file, "Average number of arguments per PHI node: %.1f (max: %d)\n",

             (float) dfa_stats.num_phi_args / (float) dfa_stats.num_phis,

             dfa_stats.max_num_phi_args);

  fprintf (file, "\n");

}

/* Dump DFA statistics on stderr.  */

void

debug_dfa_stats (void)

{

  dump_dfa_stats (stderr);

}

/* Collect DFA statistics and store them in the structure pointed to by

   DFA_STATS_P.  */

static void

collect_dfa_stats (struct dfa_stats_d *dfa_stats_p)

{

  struct pointer_set_t *pset;

  basic_block bb;

  block_stmt_iterator i;

  gcc_assert (dfa_stats_p);

  memset ((void *)dfa_stats_p, 0, sizeof (struct dfa_stats_d));

  /* Walk all the trees in the function counting references.  Start at

     basic block NUM_FIXED_BLOCKS, but don't stop at block boundaries.  */

  pset = pointer_set_create ();

  for (i = bsi_start (BASIC_BLOCK (NUM_FIXED_BLOCKS));

       !bsi_end_p (i); bsi_next (&i))

    walk_tree (bsi_stmt_ptr (i), collect_dfa_stats_r, (void *) dfa_stats_p,

               pset);

  pointer_set_destroy (pset);

  FOR_EACH_BB (bb)

    {

      tree phi;

      for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))

        {

          dfa_stats_p->num_phis++;

          dfa_stats_p->num_phi_args += PHI_NUM_ARGS (phi);

          if (PHI_NUM_ARGS (phi) > dfa_stats_p->max_num_phi_args)

            dfa_stats_p->max_num_phi_args = PHI_NUM_ARGS (phi);

        }

    }

}

/* Callback for walk_tree to collect DFA statistics for a tree and its

   children.  */

static tree

collect_dfa_stats_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,

                     void *data)

{

  tree t = *tp;

  struct dfa_stats_d *dfa_stats_p = (struct dfa_stats_d *)data;

  if (t->common.ann)

    {

      switch (ann_type (t->common.ann))

        {

        case STMT_ANN:

          {

            dfa_stats_p->num_stmt_anns++;

            dfa_stats_p->num_defs += NUM_SSA_OPERANDS (t, SSA_OP_DEF);

            dfa_stats_p->num_uses += NUM_SSA_OPERANDS (t, SSA_OP_USE);

            dfa_stats_p->num_v_may_defs += NUM_SSA_OPERANDS (t, SSA_OP_VMAYDEF);

            dfa_stats_p->num_vuses += NUM_SSA_OPERANDS (t, SSA_OP_VUSE);

            dfa_stats_p->num_v_must_defs +=

                                  NUM_SSA_OPERANDS (t, SSA_OP_VMUSTDEF);

            break;

          }

        case VAR_ANN:

          dfa_stats_p->num_var_anns++;

          break;

        default:

          break;

        }

    }

  return NULL;

}

/*---------------------------------------------------------------------------

                             Miscellaneous helpers

---------------------------------------------------------------------------*/

/* Callback for walk_tree.  Used to collect variables referenced in

   the function.  */

static tree

find_vars_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)

{

  /* If T is a regular variable that the optimizers are interested

     in, add it to the list of variables.  */

  if (SSA_VAR_P (*tp))

    add_referenced_var (*tp);

  /* Type, _DECL and constant nodes have no interesting children.

     Ignore them.  */

  else if (IS_TYPE_OR_DECL_P (*tp) || CONSTANT_CLASS_P (*tp))

    *walk_subtrees = 0;

  return NULL_TREE;

}

/* Lookup UID in the referenced_vars hashtable and return the associated

   variable.  */

tree

referenced_var_lookup (unsigned int uid)

{

  struct int_tree_map *h, in;

  in.uid = uid;

  h = (struct int_tree_map *) htab_find_with_hash (referenced_vars, &in, uid);

  gcc_assert (h || uid == 0);

  if (h)

    return h->to;

  return NULL_TREE;

}

/* Check if TO is in the referenced_vars hash table and insert it if not.

   Return true if it required insertion.  */

bool

referenced_var_check_and_insert (tree to)

{

  struct int_tree_map *h, in;

  void **loc;

  unsigned int uid = DECL_UID (to);

  in.uid = uid;

  in.to = to;

  h = (struct int_tree_map *) htab_find_with_hash (referenced_vars, &in, uid);

  if (h)

    {

      /* DECL_UID has already been entered in the table.  Verify that it is

         the same entry as TO.  See PR 27793.  */

      gcc_assert (h->to == to);

      return false;

    }

  h = GGC_NEW (struct int_tree_map);

  h->uid = uid;

  h->to = to;

  loc = htab_find_slot_with_hash (referenced_vars, h, uid, INSERT);

  *(struct int_tree_map **)  loc = h;

  return true;

}

/* Lookup VAR UID in the default_defs hashtable and return the associated

   variable.  */

tree

default_def (tree var)

{

  struct int_tree_map *h, in;

  gcc_assert (SSA_VAR_P (var));

  in.uid = DECL_UID (var);

  h = (struct int_tree_map *) htab_find_with_hash (default_defs, &in,

                                                   DECL_UID (var));

  if (h)

    return h->to;

  return NULL_TREE;

}

/* Insert the pair VAR's UID, DEF into the default_defs hashtable.  */

void

set_default_def (tree var, tree def)

{

  struct int_tree_map in;

  struct int_tree_map *h;

  void **loc;

  gcc_assert (SSA_VAR_P (var));

  in.uid = DECL_UID (var);

  if (!def && default_def (var))

    {

      loc = htab_find_slot_with_hash (default_defs, &in, DECL_UID (var), INSERT);

      htab_remove_elt (default_defs, *loc);

      return;

    }

  gcc_assert (TREE_CODE (def) == SSA_NAME);

  loc = htab_find_slot_with_hash (default_defs, &in, DECL_UID (var), INSERT);

  /* Default definition might be changed by tail call optimization.  */

  if (!*loc)

    {

      h = GGC_NEW (struct int_tree_map);

      h->uid = DECL_UID (var);

      h->to = def;

      *(struct int_tree_map **)  loc = h;

    }

   else

    {