set_property.h

Go to the documentation of this file.

#ifndef BDWY_SET_PROPERTY_H
#define BDWY_SET_PROPERTY_H

typedef std::map< std::string, setPropertyAnn *> set_property_map;
typedef set_property_map::iterator set_property_map_p;
typedef set_property_map::const_iterator set_property_map_cp;

// -- NOTE: By choosing 1024 here, we are fixing the maximum size of sets
// and equivalence classes.

typedef std::bitset< 1024 > memoryblock_bitset;

class setPropertyAnn : public propertyAnn
{
public:

  typedef enum { Set, Equivalence } SetPropertyKind;

  typedef enum { Union, Intersect } MeetFunction;

  // -- Manage the mapping from memoryblocks to bit positions

#ifdef __FOO
  typedef std::map< memoryBlock *, int > memoryblock_position_map;
  typedef memoryblock_position_map::iterator memoryblock_position_map_p;

  // -- Store the memoryBlocks in a vector to create the reverse mapping

  typedef vector< memoryBlock * > memoryblock_vector;
  typedef memoryblock_vector::iterator memoryblock_vector_p;

  // -- Set representation: map from program points to sets of blocks

  typedef std::map< memoryAccess *, memoryblock_bitset > set_property_map;
  typedef set_property_map::iterator set_property_map_p;

  // -- Equivalence representation: map from program points to lists of
  // sets of blocks. Each set of blocks in the list represents an
  // equivalence class.

  typedef list< memoryblock_bitset > memoryblock_bitset_list;
  typedef memoryblock_bitset_list::iterator memoryblock_bitset_list_p;
  typedef memoryblock_bitset_list::const_iterator memoryblock_bitset_list_cp;

  typedef std::map< memoryAccess *, memoryblock_bitset_list> equiv_property_map;
  typedef equiv_property_map::iterator equiv_property_map_p;
#endif  
private:

  SetPropertyKind _kind;

  MeetFunction _meet_function;

  annVariable * _property_variable;

#ifdef __FOO
  memoryBlock * _block;

  set_property_map _set;

  equiv_property_map _equivalence;

  memoryblock_position_map _position_of_memoryblock;

  memoryblock_vector _memoryblock_at_position;

  bool _change;
#endif
public:

  setPropertyAnn(const parserID * name,
                 Direction direction,
                 SetPropertyKind kind,
                 MeetFunction meet);

  void clear();

  inline SetPropertyKind kind() const { return _kind; }

  inline MeetFunction meet_function() const { return _meet_function; }

  inline void set_property_variable(annVariable * var)
  { _property_variable = var; }

  inline annVariable * property_variable() const { return _property_variable; }

#ifdef __FOO
  void set_property_variable_block(memoryBlock * block)
  { _block = block; }

  memoryBlock * property_variable_block() const { return _block; }

  //{

  void to_top(memoryblock_bitset & bits);

  void to_bottom(memoryblock_bitset & bits);

  void meet(memoryblock_bitset & dest,
            memoryblock_bitset & src);

  void lookup_set_value(memoryAccess * def_or_use,
                        memoryblock_bitset & bits);

  bool update_set_value(memoryAccess * def_or_use,
                        memoryblock_bitset & new_set);

  void current_set_value(memoryblock_bitset & bits,
                         bool & found_reaching_value);

  bool update_current_set_value(memoryblock_bitset & new_set);

  bool is_element_of(pointerValue & var);

  bool is_emptyset();

  void add_elements(pointerValue & var);

  void apply_set_merge(memoryuse_list & phi_uses,
                       memoryblock_set & changes);  
  //}

  //{

  void to_top(memoryblock_bitset_list & bits);

  void to_bottom(memoryblock_bitset_list & bits);

  void meet(memoryblock_bitset_list & dest,
            const memoryblock_bitset_list & src);

  void lookup_equivalence_classes(memoryAccess * def_or_use,
                                  memoryblock_bitset_list & bits);

  bool update_equivalence_classes(memoryAccess * def_or_use,
                                  memoryblock_bitset_list & classes);
  
  void current_equivalence_classes(memoryblock_bitset_list & bits,
                                   bool & found_reaching_value);

  bool update_current_equivalence_classes(memoryblock_bitset_list & new_set);

  bool is_equivalent(pointerValue & left,
                     pointerValue & right);

  void add_equivalence(pointerValue & left,
                       pointerValue & right);

  void apply_equivalence_merge(memoryuse_list & phi_uses,
                               memoryblock_set & changes);

  //}

  void apply_next(memoryblock_set & changes);

  void apply_merge(memoryuse_list & phi_uses,
                   memoryblock_set & changes);

  void self_assignment(memoryblock_set & changes);

  void report(std::ostream & out);
#endif /* __FOO */

  friend std::ostream& operator<<(std::ostream & o, const setPropertyAnn & anns) {
    anns.print(o);
    return o;
  }

  void print(std::ostream & o) const;

private:

#ifdef __FOO
  void build_memoryblock_bitset(pointerValue & variables,
                                memoryblock_bitset & bits);

  void add_equivalence_class(memoryblock_bitset_list & equiv,
                             const memoryblock_bitset & new_class);

  bool is_same_equivalence(memoryblock_bitset_list & equiv1,
                           memoryblock_bitset_list & equiv2);

  void print_memoryblock_bitset(const std::string & label,
                                memoryblock_bitset & bits,
                                std::ostream & out);
  void print_memoryblock_bitset_list(const std::string & label,
                                     memoryblock_bitset_list & bits,
                                     std::ostream & out);
#endif /* __FOO */
};

#endif