---

proceduredb.h

Go to the documentation of this file.

// ----------------------------------------------------------------------
//
//  C-Breeze
//  C Compiler Framework
// 
//  Copyright (c) 2000 University of Texas at Austin
// 
//  Samuel Z. Guyer
//  Daniel A. Jimenez
//  Calvin Lin
// 
//  Permission is hereby granted, free of charge, to any person
//  obtaining a copy of this software and associated documentation
//  files (the "Software"), to deal in the Software without
//  restriction, including without limitation the rights to use, copy,
//  modify, merge, publish, distribute, sublicense, and/or sell copies
//  of the Software, and to permit persons to whom the Software is
//  furnished to do so, subject to the following conditions:
//  
//  The above copyright notice and this permission notice shall be
//  included in all copies or substantial portions of the Software.
//  
//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
//  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
//  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
//  NONINFRINGEMENT.  IN NO EVENT SHALL THE UNIVERSITY OF TEXAS AT
//  AUSTIN BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
//  IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
//  OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
//  THE SOFTWARE.
//
//  We acknowledge the C-to-C Translator from MIT Laboratory for
//  Computer Science for inspiring parts of the C-Breeze design.
//
// ----------------------------------------------------------------------

#ifndef CBZ_PROCEDUREDB_H
#define CBZ_PROCEDUREDB_H

#include "pointers_common.h"
#include "location.h"
#include "dfpreds.h"
#include "memoryaccess.h"
#include "memoryblock.h"
#include "worklist.h"
#include "linker.h"
#include "loops.h"
#include "callgraph.h"

class procedureInfo
{
public:

  typedef map< basicblockNode *, int > worklist_order_map;
  typedef worklist_order_map::iterator worklist_order_map_p;

  // -- This is a map from callsites to the caller

  typedef map< stmtLocation *, procedureInfo *> callsite_map;
  typedef callsite_map::iterator callsite_map_p;
  typedef callsite_map::const_iterator callsite_map_cp;

  typedef map< basicblockLocation *, memoryblock_set > mergepoint_map;
  typedef mergepoint_map::iterator mergepoint_map_p;

  typedef set< procedureInfo * > procedure_set;
  typedef procedure_set::iterator procedure_set_p;
  typedef procedure_set::const_iterator procedure_set_cp;

private:

  procNode * _proc;

  workList _worklist;

  worklist_order_map _forward_worklist_order;

  vector< basicblockNode * > _forward_basicblock_order;

  worklist_order_map _backward_worklist_order;

  vector< basicblockNode * > _backward_basicblock_order;

  mergepoint_map _merge_points;

  DFPreds * _dominance_frontiers;

  loopTree * _loops;

  callsite_map _callsites;

  stmtLocation * _current_callsite;

  bool _context_insensitive;

  TREE procLocation * _only_context;

  memoryblock_set _external_inputs;

  memoryblock_set _external_outputs;

  procedure_set _ancestors;

  procedure_set _calls;

  bool _is_recursive;

public:

  // EDB: Added!
  DFPreds * dominance_frontiers() const { return _dominance_frontiers; }
  
  procedureInfo(procNode * the_proc);

  ~procedureInfo();

  void add_ancestor_set(procedure_set & ancestors);

  void setup_call_at(procedureInfo * caller, stmtLocation * callsite);

  void return_from();

  inline procNode * proc() const { return _proc; }

  inline string & name() { return proc()->decl()->name(); }

  const procedure_set & ancestors() const { return _ancestors; }

  inline const procedure_set & calls() const { return _calls; }

  inline const callsite_map & callsites() const { return _callsites; }

  inline stmtLocation * current_callsite() const { return _current_callsite; }

  procedureInfo * current_caller();

  procedureInfo * caller_at(stmtLocation * callsite);

  bool is_current_call_recursive(procedureInfo * caller);

  procLocation * current_procedure_location();


  void make_context_insensitive();

  inline bool is_context_insensitive() const { return _context_insensitive; }

  procLocation * get_context() const { return _only_context; }

  basicblockLocation * external_inputs_mergepoint();



  void setup_merge_point(memoryBlock * block_to_merge,
                         basicblockLocation * cur);

  memoryblock_set * lookup_merge_point(basicblockLocation * where);



  const memoryblock_set & external_inputs() const { return _external_inputs; }

  const memoryblock_set & external_outputs() const { return _external_outputs; }

  bool add_external_input(memoryBlock * block);

  bool add_external_output(memoryBlock * block);



  basicblockNode * get_next_block(Direction dir);

  void add_block(basicblockNode * block, Direction dir);

  void add_reachable_blocks(basicblockNode * block, Direction dir);

  void add_all_blocks();

  void add_start_block(Direction dir);

  bool is_empty() const;


  void print_call_stack(ostream & out);

  void progress_meter(ostream & out);

  void print(ostream & out);

  void stats(ostream & out);

private:

  void reverse_post_order(Direction dir,
                          basicblockNode * cur,
                          basicblock_set & visited,
                          basicblock_list & order);


  int block_position(basicblockNode * block, Direction dir);

  basicblockNode * block_at(int position, Direction dir);

  void add_reachable_blocks_rec(Direction dir,
                                basicblockNode * cur,
                                worklist_set & temp, bool first); 
};

typedef map< procNode *, procedureInfo *> proc_info_map;
typedef proc_info_map::iterator proc_info_map_p;

typedef list< procedureInfo *> proc_info_list;
typedef proc_info_list::iterator proc_info_list_p;

class procedureDB : public Walker
{
public:

  static bool _debug;

private:

  proc_info_map _procedures;

  callGraph * _callgraph;

  procedureInfo::procedure_set _need_reanalysis;

public:

  procedureDB();

  ~procedureDB();

  void build(procNode * root, Linker & linker);

  void clear();

  void add_procedure(procNode * proc);

  procedureInfo * lookup(procNode * proc);

  void setup_analysis();

  bool is_in_scope(procedureInfo * info,
                   memoryBlock * block);

  void mark_for_reanalysis(procedureInfo * info);

  bool is_reanalysis_required(procedureInfo * info);

  int times_called(procedureInfo * info);

  void stats(ostream & out);

  int size() const { return _procedures.size(); }

};

#endif // CBZ_PROCEDUREDB_H

---