---

location.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_LOCATION_H
#define CBZ_LOCATION_H

#include "allocation.h"
#include "dominators.h"

// ------------------------------------------------------------
// Location
// ------------------------------------------------------------

// Dominance testing : Dominance is tested in much the same way it was
// in the previous version: we have a chain of path components, so we
// move up until the two arguments have a common immediate
// parent. Then we call the type-specific dominance test. The only
// complication is when the two paths turn out to be in a direct
// ancestor/descendant relationship. In this case, we allow each type
// to determine what it does in that situation. The cases are based on
// the following rationale:

// 1. Assignments to the formal parameters are associated with the
// procLocation, and thus must dominate all other statements inside
// the procedure.
//       => ancestor procLocation always dominates descendant

// 2. Control-flow merges are associated with the basicblockLocation,
// and thus must dominate all other statements within that block.
//       => ancestor basicblockLocation always dominates descendant

// 3. The assignment of the return value at a callsite, which is
// associated with the stmtLocation, should be dominated by all
// assignments inside the procedure.
//       => ancestor stmtLocation never dominates descendant

// The rules for descendants are the mirrors of the above rules for
// ancestors.

//       => descendant stmtLocation only dominates ancestor stmtLocations
//       => descendant basicblockLocation only dominates ancestor stmtLocations
//       => descendant procLocation only dominates ancestor stmtLocations

// This divides locations into two categories: stmtLocations and
// non-stmtLocation. So we implement all of this logic with a boolean:
// is_stmt.

class procLocation;
class basicblockLocation;
class stmtLocation;

class Location : public PerClassHeap< PointersHeap >
{
public:

  typedef enum { Statement, BasicBlock, Procedure } LocationKind;

  static unsigned int stmt_count;
  static unsigned int block_count;
  static unsigned int proc_count;
  static unsigned int dom_calls;

private:

  Location & operator=(const Location & other)
  {
    cerr << "ERROR: Cannot assign Location objects" << endl;
    return *this;
  }

protected:

  Location * _parent;

  int _depth:16;
  int _kind:4;
  int _dominates_exit:1;
  int _not_basicblock:1;
  int _not_procedure:1;

public:

  Location(Location * parent, LocationKind kind);

  // Fields

  inline int depth() const { return _depth; }
  inline LocationKind kind() const { return (LocationKind)_kind; }
  inline Location * parent() const { return _parent; }

  inline int dominates_exit() const { return _dominates_exit; }

  static bool dominates(const Location * dom, const Location * cur);

  static bool strictly_dominates(const Location * dom, const Location * cur);

  static Location * common_parent(Location * one,
                                  Location * two);

  static procLocation * procedure(Location * where);

  static bool is_prefix(const Location * prefix, const Location * longer);

  virtual void adjust_depth() = 0;
 
  // Output

  virtual void print(ostream & o) const = 0;
  virtual void print_path(ostream & o) const = 0;

  friend ostream & operator<<(ostream & o, const Location & loc) {
    loc.print_path(o);
    return o;
  }

  // Destructor

  virtual ~Location();

  // Stats

  static void stats();
};

// ------------------------------------------------------------
// stmtLocation
// ------------------------------------------------------------

class stmtLocation : public Location
{
  friend class basicblockLocation;
  friend class procLocation;

private:

  int _stmt_num;
  stmtNode * _stmt;
  procLocation * _calls;

  inline void stmt_num(int num) { _stmt_num = num; }
  inline void stmt(stmtNode * s) { _stmt = s; }

public:

  stmtLocation(basicblockLocation * parent);

  void setup_call(procNode * proc, bool is_context_insensitive);

  procLocation * remove_call();

  // Fields

  inline basicblockLocation * block_location() const
  { return (basicblockLocation *) _parent; }

  inline int stmt_num() const { return _stmt_num; }

  inline stmtNode * stmt() const { return _stmt; }

  inline procLocation * calls() const { return _calls; }

  // Check for the presence of a function call

  bool is_present(const procNode * proc) const;

  virtual void adjust_depth();

  // Output

  virtual void print(ostream & o) const;
  virtual void print_path(ostream & o) const;

  // Destructor

  virtual ~stmtLocation();
};

typedef vector< stmtLocation > stmt_location_vec;
typedef stmt_location_vec::iterator stmt_location_vec_p;

// ------------------------------------------------------------
// basicblockLocation
// ------------------------------------------------------------

class basicblockLocation : public Location
{
  friend class procLocation;

private:

  basicblockNode * const _block;
  stmt_location_vec _statements;

public:

  basicblockLocation(procLocation * parent,
                     basicblockNode * block);

  // Fields

  inline procLocation * proc_location() const { return (procLocation *) _parent; }
  inline basicblockNode * block() const { return _block; }
  inline stmt_location_vec & statements() { return _statements; }

  stmtLocation * last() { return & _statements.back(); }

  virtual void adjust_depth();

  // Output

  virtual void print(ostream & o) const;
  virtual void print_path(ostream & o) const;

  // Destructor

  virtual ~basicblockLocation();
};

typedef map< basicblockNode *, basicblockLocation *,
              less< basicblockNode * >, basicblock_alloc > basicblock_location_map;
typedef basicblock_location_map::iterator basicblock_location_map_p;
typedef basicblock_location_map::const_iterator basicblock_location_map_cp;

// ------------------------------------------------------------
// procLocation
// ------------------------------------------------------------

class procLocation : public Location
{
private:

  procNode * const _proc;
  basicblock_location_map _basicblocks;

  static procLocation * Main;

public:

  procLocation(stmtLocation * parent,
               procNode * proc,
               bool is_context_insensitive = false);

  // Fields

  inline stmtLocation * stmt_location() const { return (stmtLocation *) _parent; }
  inline procNode * proc() const { return _proc; }
  basicblockLocation * lookup_block(basicblockNode * block) const;
  procLocation * parent_proc() const;

  static inline procLocation * main() { return Main; }

  // -- Get the last statement in the procedure

  stmtLocation * last();

  void remove_from_tree();

  virtual void adjust_depth();

  // Output

  virtual void print(ostream & o) const;
  virtual void print_path(ostream & o) const;

  // Destructor

  virtual ~procLocation();
};

#endif // CBZ_LOCATION_H

---