osprey-gcc-4.2.0/gcc/tree-optimize.c

Go to the documentation of this file.

/*
 * Copyright (C) 2007. QLogic Corporation. All Rights Reserved.
 */
/* Top-level control of tree optimizations.
   Copyright 2001, 2002, 2003, 2004, 2005 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 2, 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 COPYING.  If not, write to
the Free Software Foundation, 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.  */

#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "tree.h"
#include "rtl.h"
#include "tm_p.h"
#include "hard-reg-set.h"
#include "basic-block.h"
#include "output.h"
#include "expr.h"
#include "diagnostic.h"
#include "basic-block.h"
#include "flags.h"
#include "tree-flow.h"
#include "tree-dump.h"
#include "timevar.h"
#include "function.h"
#include "langhooks.h"
#include "toplev.h"
#include "flags.h"
#include "cgraph.h"
#include "tree-inline.h"
#include "tree-mudflap.h"
#include "tree-pass.h"
#include "ggc.h"
#include "cgraph.h"
#include "graph.h"
#include "cfgloop.h"
#include "except.h"


/* Gate: execute, or not, all of the non-trivial optimizations.  */

static bool
gate_all_optimizations (void)
{
  return (optimize >= 1
    /* Don't bother doing anything if the program has errors.  */
    && !(errorcount || sorrycount));
}

struct tree_opt_pass pass_all_optimizations =
{
  NULL,         /* name */
  gate_all_optimizations,   /* gate */
  NULL,         /* execute */
  NULL,         /* sub */
  NULL,         /* next */
  0,          /* static_pass_number */
  0,          /* tv_id */
  0,          /* properties_required */
  0,          /* properties_provided */
  0,          /* properties_destroyed */
  0,          /* todo_flags_start */
  0,          /* todo_flags_finish */
  0         /* letter */
};

struct tree_opt_pass pass_early_local_passes =
{
  NULL,         /* name */
  gate_all_optimizations,   /* gate */
  NULL,         /* execute */
  NULL,         /* sub */
  NULL,         /* next */
  0,          /* static_pass_number */
  0,          /* tv_id */
  0,          /* properties_required */
  0,          /* properties_provided */
  0,          /* properties_destroyed */
  0,          /* todo_flags_start */
  0,          /* todo_flags_finish */
  0         /* letter */
};

/* Pass: cleanup the CFG just before expanding trees to RTL.
   This is just a round of label cleanups and case node grouping
   because after the tree optimizers have run such cleanups may
   be necessary.  */

static unsigned int
execute_cleanup_cfg_pre_ipa (void)
{
  cleanup_tree_cfg ();
  return 0;
}

struct tree_opt_pass pass_cleanup_cfg =
{
  "cleanup_cfg",      /* name */
  NULL,         /* gate */
  execute_cleanup_cfg_pre_ipa,    /* execute */
  NULL,         /* sub */
  NULL,         /* next */
  0,          /* static_pass_number */
  0,          /* tv_id */
  PROP_cfg,       /* properties_required */
  0,          /* properties_provided */
  0,          /* properties_destroyed */
  0,          /* todo_flags_start */
  TODO_dump_func,         /* todo_flags_finish */
  0         /* letter */
};


/* Pass: cleanup the CFG just before expanding trees to RTL.
   This is just a round of label cleanups and case node grouping
   because after the tree optimizers have run such cleanups may
   be necessary.  */

static unsigned int
execute_cleanup_cfg_post_optimizing (void)
{
  fold_cond_expr_cond ();
  cleanup_tree_cfg ();
  cleanup_dead_labels ();
  group_case_labels ();
  return 0;
}

struct tree_opt_pass pass_cleanup_cfg_post_optimizing =
{
  "final_cleanup",      /* name */
  NULL,         /* gate */
  execute_cleanup_cfg_post_optimizing,  /* execute */
  NULL,         /* sub */
  NULL,         /* next */
  0,          /* static_pass_number */
  0,          /* tv_id */
  PROP_cfg,       /* properties_required */
  0,          /* properties_provided */
  0,          /* properties_destroyed */
  0,          /* todo_flags_start */
  TODO_dump_func,         /* todo_flags_finish */
  0         /* letter */
};

/* Pass: do the actions required to finish with tree-ssa optimization
   passes.  */

static unsigned int
execute_free_datastructures (void)
{
  /* ??? This isn't the right place for this.  Worse, it got computed
     more or less at random in various passes.  */
  free_dominance_info (CDI_DOMINATORS);
  free_dominance_info (CDI_POST_DOMINATORS);

  /* Remove the ssa structures.  Do it here since this includes statement
     annotations that need to be intact during disband_implicit_edges.  */
  delete_tree_ssa ();
  return 0;
}

struct tree_opt_pass pass_free_datastructures =
{
  NULL,         /* name */
  NULL,         /* gate */
  execute_free_datastructures,      /* execute */
  NULL,         /* sub */
  NULL,         /* next */
  0,          /* static_pass_number */
  0,          /* tv_id */
  PROP_cfg,       /* properties_required */
  0,          /* properties_provided */
  0,          /* properties_destroyed */
  0,          /* todo_flags_start */
  0,          /* todo_flags_finish */
  0         /* letter */
};
/* Pass: free cfg annotations.  */

static unsigned int
execute_free_cfg_annotations (void)
{
  basic_block bb;
  block_stmt_iterator bsi;

  /* Emit gotos for implicit jumps.  */
  disband_implicit_edges ();

  /* Remove annotations from every tree in the function.  */
  FOR_EACH_BB (bb)
    for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
      {
  tree stmt = bsi_stmt (bsi);
  ggc_free (stmt->common.ann);
  stmt->common.ann = NULL;
      }

  /* And get rid of annotations we no longer need.  */
  delete_tree_cfg_annotations ();

#ifdef ENABLE_CHECKING
  /* Once the statement annotations have been removed, we can verify
     the integrity of statements in the EH throw table.  */
  verify_eh_throw_table_statements ();
#endif
  return 0;
}

struct tree_opt_pass pass_free_cfg_annotations =
{
  NULL,         /* name */
  NULL,         /* gate */
  execute_free_cfg_annotations,   /* execute */
  NULL,         /* sub */
  NULL,         /* next */
  0,          /* static_pass_number */
  0,          /* tv_id */
  PROP_cfg,       /* properties_required */
  0,          /* properties_provided */
  0,          /* properties_destroyed */
  0,          /* todo_flags_start */
  0,          /* todo_flags_finish */
  0         /* letter */
};

/* Return true if BB has at least one abnormal outgoing edge.  */

static inline bool
has_abnormal_outgoing_edge_p (basic_block bb)
{
  edge e;
  edge_iterator ei;

  FOR_EACH_EDGE (e, ei, bb->succs)
    if (e->flags & EDGE_ABNORMAL)
      return true;

  return false;
}

/* Pass: fixup_cfg.  IPA passes, compilation of earlier functions or inlining
   might have changed some properties, such as marked functions nothrow or
   added calls that can potentially go to non-local labels.  Remove redundant
   edges and basic blocks, and create new ones if necessary.  */

static unsigned int
execute_fixup_cfg (void)
{
  basic_block bb;
  block_stmt_iterator bsi;

  if (cfun->eh)
    FOR_EACH_BB (bb)
      {
  for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
    {
      tree stmt = bsi_stmt (bsi);
      tree call = get_call_expr_in (stmt);

      if (call && call_expr_flags (call) & (ECF_CONST | ECF_PURE))
        TREE_SIDE_EFFECTS (call) = 0;
      if (!tree_could_throw_p (stmt) && lookup_stmt_eh_region (stmt))
        remove_stmt_from_eh_region (stmt);
    }
  tree_purge_dead_eh_edges (bb);
      }

  if (current_function_has_nonlocal_label)
    FOR_EACH_BB (bb)
      {
  for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
    {
      tree stmt = bsi_stmt (bsi);
      if (tree_can_make_abnormal_goto (stmt))
        {
    if (stmt == bsi_stmt (bsi_last (bb)))
      {
        if (!has_abnormal_outgoing_edge_p (bb))
          make_abnormal_goto_edges (bb, true);
      }
    else
      {
        edge e = split_block (bb, stmt);
        bb = e->src;
        make_abnormal_goto_edges (bb, true);
      }
    break;
        }
    }
      }

  cleanup_tree_cfg ();

  /* Dump a textual representation of the flowgraph.  */
  if (dump_file)
    dump_tree_cfg (dump_file, dump_flags);

  return 0;
}

struct tree_opt_pass pass_fixup_cfg =
{
  "fixupcfg",       /* name */
  NULL,         /* gate */
  execute_fixup_cfg,      /* execute */
  NULL,         /* sub */
  NULL,         /* next */
  0,          /* static_pass_number */
  0,          /* tv_id */
  PROP_cfg,       /* properties_required */
  0,          /* properties_provided */
  0,          /* properties_destroyed */
  0,          /* todo_flags_start */
  0,          /* todo_flags_finish */
  0         /* letter */
};

/* Do the actions required to initialize internal data structures used
   in tree-ssa optimization passes.  */

static unsigned int
execute_init_datastructures (void)
{
  /* Allocate hash tables, arrays and other structures.  */
  init_tree_ssa ();
  return 0;
}

struct tree_opt_pass pass_init_datastructures =
{
  NULL,         /* name */
  NULL,         /* gate */
  execute_init_datastructures,    /* execute */
  NULL,         /* sub */
  NULL,         /* next */
  0,          /* static_pass_number */
  0,          /* tv_id */
  PROP_cfg,       /* properties_required */
  0,          /* properties_provided */
  0,          /* properties_destroyed */
  0,          /* todo_flags_start */
  0,          /* todo_flags_finish */
  0         /* letter */
};

void
tree_lowering_passes (tree fn)
{
  tree saved_current_function_decl = current_function_decl;

  current_function_decl = fn;
  push_cfun (DECL_STRUCT_FUNCTION (fn));

#ifdef KEY
  // This is the *only* point where we fully translate a FUNCTION_DECL for C++.
  // Exception: C++ thunk functions are fully translated from use_thunk().
  if (!strcmp("GNU C++", lang_hooks.name) &&
      flag_spin_file &&
      lang_hooks.cp_genericize /* C++ ? */) {
    gs_x_func_decl(fn);
    // gimplify
    lang_hooks.cp_genericize(fn);
    // simplify AGGR_INIT_EXPR into CALL_EXPR.
    walk_tree_without_duplicates (&DECL_SAVED_TREE (fn),
                                  lang_hooks.simplify_aggr_init_exprs_r,
                                  NULL);
  }
#endif

  tree_register_cfg_hooks ();
  bitmap_obstack_initialize (NULL);
  execute_pass_list (all_lowering_passes);
  free_dominance_info (CDI_POST_DOMINATORS);
  compact_blocks ();
  current_function_decl = saved_current_function_decl;
  bitmap_obstack_release (NULL);
  pop_cfun ();
}

/* Update recursively all inlined_to pointers of functions
   inlined into NODE to INLINED_TO.  */
static void
update_inlined_to_pointers (struct cgraph_node *node,
          struct cgraph_node *inlined_to)
{
  struct cgraph_edge *e;
  for (e = node->callees; e; e = e->next_callee)
    {
      if (e->callee->global.inlined_to)
  {
    e->callee->global.inlined_to = inlined_to;
    update_inlined_to_pointers (e->callee, inlined_to);
  }
    }
}


/* For functions-as-trees languages, this performs all optimization and
   compilation for FNDECL.  */

void
tree_rest_of_compilation (tree fndecl)
{
  location_t saved_loc;
  struct cgraph_node *node;

  timevar_push (TV_EXPAND);

  gcc_assert (!flag_unit_at_a_time || cgraph_global_info_ready);

  node = cgraph_node (fndecl);

  /* We might need the body of this function so that we can expand
     it inline somewhere else.  */
  if (cgraph_preserve_function_body_p (fndecl))
    save_inline_function_body (node);

  /* Initialize the RTL code for the function.  */
  current_function_decl = fndecl;
  saved_loc = input_location;
  input_location = DECL_SOURCE_LOCATION (fndecl);
  init_function_start (fndecl);

  /* Even though we're inside a function body, we still don't want to
     call expand_expr to calculate the size of a variable-sized array.
     We haven't necessarily assigned RTL to all variables yet, so it's
     not safe to try to expand expressions involving them.  */
  cfun->x_dont_save_pending_sizes_p = 1;
  cfun->after_inlining = true;

  if (flag_inline_trees)
    {
      struct cgraph_edge *e;
      for (e = node->callees; e; e = e->next_callee)
  if (!e->inline_failed || warn_inline)
    break;
      if (e)
  {
    timevar_push (TV_INTEGRATION);
    optimize_inline_calls (fndecl);
    timevar_pop (TV_INTEGRATION);
  }
    }
  /* In non-unit-at-a-time we must mark all referenced functions as needed.
     */
  if (!flag_unit_at_a_time)
    {
      struct cgraph_edge *e;
      for (e = node->callees; e; e = e->next_callee)
  if (e->callee->analyzed)
          cgraph_mark_needed_node (e->callee);
    }

  /* We are not going to maintain the cgraph edges up to date.
     Kill it so it won't confuse us.  */
  cgraph_node_remove_callees (node);


  /* Initialize the default bitmap obstack.  */
  bitmap_obstack_initialize (NULL);
  bitmap_obstack_initialize (&reg_obstack); /* FIXME, only at RTL generation*/
  
  tree_register_cfg_hooks ();
  /* Perform all tree transforms and optimizations.  */
  execute_pass_list (all_passes);
  
  bitmap_obstack_release (&reg_obstack);

  /* Release the default bitmap obstack.  */
  bitmap_obstack_release (NULL);
  
  DECL_SAVED_TREE (fndecl) = NULL;
  cfun = 0;

  /* If requested, warn about function definitions where the function will
     return a value (usually of some struct or union type) which itself will
     take up a lot of stack space.  */
  if (warn_larger_than && !DECL_EXTERNAL (fndecl) && TREE_TYPE (fndecl))
    {
      tree ret_type = TREE_TYPE (TREE_TYPE (fndecl));

      if (ret_type && TYPE_SIZE_UNIT (ret_type)
    && TREE_CODE (TYPE_SIZE_UNIT (ret_type)) == INTEGER_CST
    && 0 < compare_tree_int (TYPE_SIZE_UNIT (ret_type),
           larger_than_size))
  {
    unsigned int size_as_int
      = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (ret_type));

    if (compare_tree_int (TYPE_SIZE_UNIT (ret_type), size_as_int) == 0)
      warning (0, "size of return value of %q+D is %u bytes",
                     fndecl, size_as_int);
    else
      warning (0, "size of return value of %q+D is larger than %wd bytes",
                     fndecl, larger_than_size);
  }
    }

  if (!flag_inline_trees)
    {
      DECL_SAVED_TREE (fndecl) = NULL;
      if (DECL_STRUCT_FUNCTION (fndecl) == 0
    && !cgraph_node (fndecl)->origin)
  {
    /* Stop pointing to the local nodes about to be freed.
       But DECL_INITIAL must remain nonzero so we know this
       was an actual function definition.
       For a nested function, this is done in c_pop_function_context.
       If rest_of_compilation set this to 0, leave it 0.  */
    if (DECL_INITIAL (fndecl) != 0)
      DECL_INITIAL (fndecl) = error_mark_node;
  }
    }

  input_location = saved_loc;

  ggc_collect ();
  timevar_pop (TV_EXPAND);
}

---