---

memoryblock.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_MEMORYBLOCK_H
#define CBZ_MEMORYBLOCK_H

#include "pointers_common.h"
#include "location.h"
#include "memoryaccess.h"

#include <set>

// ------------------------------------------------------------
//  Memory block

// Each object in memory that may be a pointer, or pointed to is
// represented by a memoryBlock. 

class memoryBlock;

typedef list< memoryBlock * > memoryblock_list;
typedef memoryblock_list::iterator memoryblock_list_p;

typedef map< int, memoryBlock *, less< int > > component_map;
typedef component_map::iterator component_map_p;
typedef component_map::const_iterator component_map_cp;

class memoryBlock : public PerClassHeap< PointersHeap >
{
private:

  REF const memoryBlock * _container;


  TREE orderedDefs Defs;
  TREE orderedUses Uses;


  REF memoryUse * _current_use;

  REF memoryDef * _current_def;

  component_map  _components;

  declNode * _decl;

  bool _synthetic_decl;

  procNode * _local_to;

  bool _multiplicity;

  bool _write_protected;

  bool _is_array;

  memoryDef * _initializer_def;

private:

  friend class memoryModel;

  memoryBlock(declNode * decl, bool synthetic,
              memoryBlock * container,
              procNode * local_to = 0);

  ~memoryBlock();

public:

  void clear();

  // --- Data members

  declNode * decl() const { return _decl; }
  procNode * local_to() const { return _local_to; }

  bool multiplicity() const { return _multiplicity; }
  void set_multiplicity() { _multiplicity = true; }

  bool write_protected() const { return _write_protected; }
  void set_write_protected() { _write_protected = true; }

  memoryUse * current_use() const { return _current_use; }
  memoryDef * current_def() const { return _current_def; }

  void reset_current_def_use(Location * unused);
  void set_current_def_use(Location * where);

  // --- Manage uses and defs

  memoryDef * def_at(Location * where, bool & is_new);
  memoryDef * nearest_def_at(Location * where);
  memoryUse * use_at(Location * where);
  memoryDef * last_def_at(basicblockLocation * block);
  memoryDef * find_def_at(Location * where);

  void set_current_to_nearest_def_at(Location * where);

  void setup_merge_uses_at(basicblockLocation * merge_location,
                           memoryDef * reaching_def,
                           basicblock_set & predecessors);

  void merge_uses_at(basicblockLocation * where,
                     memoryuse_list & uses,
                     bool computePointers);

  // --- Conservative 

  void reachable_blocks(Location * where,
                        memoryblock_list & worklist,
                        memoryblock_set & already_seen,
                        memoryBlock * null);

  // --- Prune out unneeded uses and defs

  void prune_defs_uses();

  // --- Manage structure fields

  void dot(const string & field_name,
           declNode * field_decl,
           memoryModel & Memory,
           memoryblock_set & results);

  // --- Handle special array objects

  bool is_array() const { return _is_array; }

  void set_array_element(memoryBlock * element);

  memoryBlock * get_array_element();

  memoryDef * setup_array_def();

  // --- Scoping

  bool in_scope(basicblockLocation * where) const;

  // --- Output

  friend ostream& operator<<(ostream & o, const memoryBlock & mb) {
    // mb.print(o, Path::always());
    return o;
  }

  // --- Pass after = true to see the points-to information after the
  // given statement has been executed.

  typedef enum { NAME_ONLY, CURRENT_VALUE, AFTER_ASSIGNMENT, ALL_VALUES } Output_mode;

  void print(ostream & o, Location * path, Output_mode mode = CURRENT_VALUE) const;
  string name() const;

  void print_def_use(ostream & o) const;

  // --- Update the def-use chains (only performed once at the end of
  // analysis by the memoryModel).

  void update_def_use_chains();

  // --- Statistics

  static void stats();
  int num_defs() const { return Defs.size(); }
  
private:

  //  Structure field-name database

  // Since the number of possible field names is small, we keep them in
  // a database and then refer to them by number in the memoryBlock class.

  class FieldNameDB
  {
  private:

    typedef map< string, int, less< string > > field_name_map;
    typedef field_name_map::iterator field_name_map_p;

    field_name_map _fields;
    int _count;

  public:

    static int ArrayField;

    FieldNameDB()
      : _fields(),
        _count(0)
    {}

    // --- Get the index for a field name, create if needed

    int get_field(const string & name);

    // --- Reverse search: find the name for a particular index

    string field_name(int index);
  };

  static FieldNameDB FieldNames;
};


#endif // CBZ_MEMORYBLOCK_H

---