00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028 #ifndef __MANAGED_H__
00029 #define __MANAGED_H__
00030
00031 #include <list>
00032 #include <set>
00033 #include <vector>
00034
00035 #include "exphelp.h"
00036
00037 class Statement;
00038 class Assign;
00039 class Exp;
00040 class RefExp;
00041 class Cfg;
00042 class LocationSet;
00043
00044
00045 class StatementSet {
00046 std::set<Statement*> sset;
00047
00048 public:
00049 typedef std::set<Statement*>::iterator iterator;
00050
00051 ~StatementSet() {}
00052 void makeUnion(StatementSet& other);
00053 void makeDiff (StatementSet& other);
00054 void makeIsect(StatementSet& other);
00055 bool isSubSetOf(StatementSet& other);
00056
00057 unsigned size() {return sset.size();}
00058 iterator begin() {return sset.begin();}
00059 iterator end() {return sset.end();}
00060
00061 void insert(Statement* s) {sset.insert(s);}
00062 bool remove(Statement* s);
00063 bool removeIfDefines(Exp* given);
00064 bool removeIfDefines(StatementSet& given);
00065 bool exists(Statement* s);
00066 bool definesLoc(Exp* loc);
00067
00068 void clear() {sset.clear();}
00069 bool operator==(const StatementSet& o) const
00070 { return sset == o.sset;}
00071 bool operator<(const StatementSet& o) const;
00072 void print(std::ostream& os);
00073 void printNums(std::ostream& os);
00074 char* prints();
00075 void dump();
00076 };
00077
00078
00079 class AssignSet {
00080 std::set<Assign*, lessAssign> aset;
00081
00082 public:
00083 typedef std::set<Assign*, lessAssign>::iterator iterator;
00084 typedef std::set<Assign*, lessAssign>::const_iterator const_iterator;
00085
00086 ~AssignSet() {}
00087 void makeUnion(AssignSet& other);
00088 void makeDiff (AssignSet& other);
00089 void makeIsect(AssignSet& other);
00090 bool isSubSetOf(AssignSet& other);
00091
00092 unsigned size() {return aset.size();}
00093
00094
00095 iterator begin() {return aset.begin();}
00096 iterator end() {return aset.end();}
00097
00098 void insert(Assign* a) {aset.insert(a);}
00099 bool remove(Assign* a);
00100 bool removeIfDefines(Exp* given);
00101 bool removeIfDefines(AssignSet& given);
00102 bool exists(Assign* s);
00103 bool definesLoc(Exp* loc);
00104 Assign* lookupLoc(Exp* loc);
00105
00106 void clear() {aset.clear();}
00107 bool operator==(const AssignSet& o) const
00108 { return aset == o.aset;}
00109 bool operator<(const AssignSet& o) const;
00110 void print(std::ostream& os);
00111 void printNums(std::ostream& os);
00112 char* prints();
00113 void dump();
00114
00115 };
00116
00117 class StatementList {
00118 std::list<Statement*> slist;
00119
00120 public:
00121 typedef std::list<Statement*>::iterator iterator;
00122 typedef std::list<Statement*>::reverse_iterator reverse_iterator;
00123 ~StatementList() {}
00124 unsigned size() {return slist.size();}
00125 iterator begin() {return slist.begin();}
00126 iterator end() {return slist.end();}
00127 reverse_iterator rbegin() {return slist.rbegin();}
00128 reverse_iterator rend() {return slist.rend();}
00129
00130
00131
00132
00133 void makeIsect(StatementList& a, LocationSet& b);
00134
00135 void append(Statement* s) {slist.push_back(s);}
00136 void append(StatementList& sl);
00137 void append(StatementSet& sl);
00138 bool remove(Statement* s);
00139 void removeDefOf(Exp* loc);
00140
00141
00142 iterator erase(iterator it) {return slist.erase(it);}
00143 iterator erase(iterator first, iterator last) {return slist.erase(first, last);}
00144 iterator insert(iterator it, Statement* s) {return slist.insert(it, s);}
00145 bool exists(Statement* s);
00146 char* prints();
00147 void dump();
00148 void clear() { slist.clear(); }
00149 void makeCloneOf(StatementList& o);
00150 bool existsOnLeft(Exp* loc);
00151 Assignment* findOnLeft(Exp* loc);
00152 };
00153
00154 class StatementVec {
00155 std::vector<Statement*> svec;
00156
00157 public:
00158 typedef std::vector<Statement*>::iterator iterator;
00159 typedef std::vector<Statement*>::reverse_iterator reverse_iterator;
00160 unsigned size() {return svec.size();}
00161 iterator begin() { return svec.begin();}
00162 iterator end() { return svec.end();}
00163 reverse_iterator rbegin() { return svec.rbegin();}
00164 reverse_iterator rend() { return svec.rend();}
00165
00166 Statement* operator[](int idx) {return svec[idx];}
00167 void putAt(int idx, Statement* s);
00168 iterator remove(iterator it);
00169 char* prints();
00170 void dump();
00171 void printNums(std::ostream& os);
00172 void clear() { svec.clear(); }
00173 bool operator==(const StatementVec& o) const
00174 { return svec == o.svec;}
00175 bool operator<(const StatementVec& o) const
00176 { return svec < o.svec;}
00177 void append(Statement* s) {svec.push_back(s);}
00178 void erase(iterator it) {svec.erase(it);}
00179 };
00180
00181
00182 class LocationSet {
00183
00184
00185
00186
00187 std::set<Exp*, lessExpStar> lset;
00188 public:
00189 typedef std::set<Exp*, lessExpStar>::iterator iterator;
00190 LocationSet() {}
00191 ~LocationSet() {}
00192 LocationSet(const LocationSet& o);
00193 LocationSet& operator=(const LocationSet& o);
00194 void makeUnion(LocationSet& other);
00195 void makeDiff (LocationSet& other);
00196 void clear() {lset.clear();}
00197 iterator begin() {return lset.begin();}
00198 iterator end() {return lset.end();}
00199 void insert(Exp* loc) {lset.insert(loc);}
00200 void remove(Exp* loc);
00201 void remove(iterator ll) {lset.erase(ll);}
00202 void removeIfDefines(StatementSet& given);
00203 unsigned size() const {return lset.size();}
00204 bool operator==(const LocationSet& o) const;
00205 void substitute(Assign& a);
00206 void print(std::ostream& os);
00207 char* prints();
00208 void dump();
00209 void diff(LocationSet* o);
00210 bool exists(Exp* e);
00211 Exp* findNS(Exp* e);
00212 bool existsImplicit(Exp* e);
00213
00214 iterator find(Exp* e) {return lset.find(e); }
00215
00216
00217 bool findDifferentRef(RefExp* e, Exp *&dr);
00218 void addSubscript(Statement* def );
00219 };
00220
00221 class Range {
00222 protected:
00223 int stride, lowerBound, upperBound;
00224 Exp *base;
00225
00226 public:
00227 Range();
00228 Range(int stride, int lowerBound, int upperBound, Exp *base);
00229
00230 Exp *getBase() { return base; }
00231 int getStride() { return stride; }
00232 int getLowerBound() { return lowerBound; }
00233 int getUpperBound() { return upperBound; }
00234 void unionWith(Range &r);
00235 void widenWith(Range &r);
00236 void print(std::ostream &os);
00237 bool operator==(Range &other);
00238
00239 static const int MAX = 2147483647;
00240 static const int MIN = -2147483647;
00241 };
00242
00243 class RangeMap {
00244 protected:
00245 std::map<Exp*, Range, lessExpStar> ranges;
00246
00247 public:
00248 RangeMap() { }
00249 void addRange(Exp *loc, Range &r) { ranges[loc] = r; }
00250 bool hasRange(Exp *loc) { return ranges.find(loc) != ranges.end(); }
00251 Range &getRange(Exp *loc);
00252 void unionwith(RangeMap &other);
00253 void widenwith(RangeMap &other);
00254 void print(std::ostream &os);
00255 Exp * substInto(Exp *e, std::set<Exp*, lessExpStar> *only = NULL);
00256 void killAllMemOfs();
00257 void clear() { ranges.clear(); }
00258 bool isSubset(RangeMap &other);
00259 bool empty() { return ranges.empty(); }
00260 };
00261
00262
00263
00264
00265
00266
00267
00268 class ConnectionGraph {
00269 std::multimap<Exp*, Exp*, lessExpStar> emap;
00270 public:
00271 typedef std::multimap<Exp*, Exp*, lessExpStar>::iterator iterator;
00272 ConnectionGraph() {}
00273
00274 void add(Exp* a, Exp* b);
00275 void connect(Exp* a, Exp* b);
00276 iterator begin() {return emap.begin();}
00277 iterator end() {return emap.end();}
00278 int count(Exp* a);
00279 bool isConnected(Exp* a, Exp* b);
00280
00281 void update(Exp* a, Exp* b, Exp* c);
00282 iterator remove(iterator aa);
00283 void dump();
00284 };
00285
00286 #endif // #ifdef __MANAGED_H__