-//===- llvm/Analysis/InstForest.h - Partition Method into forest -*- C++ -*--=//
+//===- llvm/Analysis/InstForest.h - Partition Func into forest ---*- C++ -*--=//
//
// This interface is used to partition a method into a forest of instruction
// trees, where the following invariants hold:
#ifndef LLVM_ANALYSIS_INSTFOREST_H
#define LLVM_ANALYSIS_INSTFOREST_H
-#include "llvm/Support/Tree.h"
#include "llvm/Instruction.h"
+#include "llvm/BasicBlock.h"
+#include "Support/Tree.h"
#include <map>
namespace analysis {
//
template<class Payload>
class InstTreeNode :
- public Tree<InstTreeNode<Payload>, pair<pair<Value*, char>, Payload> > {
+ public Tree<InstTreeNode<Payload>,
+ std::pair<std::pair<Value*, char>, Payload> > {
friend class InstForest<Payload>;
- typedef Tree<InstTreeNode<Payload>, pair<pair<Value*, char>, Payload> > super;
+ typedef Tree<InstTreeNode<Payload>,
+ std::pair<std::pair<Value*, char>, Payload> > super;
// Constants used for the node type value
enum NodeTypeTy {
inline bool isTemporary() const { return getNodeType() == TemporaryNode; }
// Accessors for different node types...
- inline ConstPoolVal *getConstant() {
- return cast<ConstPoolVal>(getValue());
+ inline Constant *getConstant() {
+ return cast<Constant>(getValue());
}
- inline const ConstPoolVal *getConstant() const {
- return cast<const ConstPoolVal>(getValue());
+ inline const Constant *getConstant() const {
+ return cast<const Constant>(getValue());
}
inline BasicBlock *getBasicBlock() {
return cast<BasicBlock>(getValue());
public:
// print - Called by operator<< below...
- void print(ostream &o, unsigned Indent) const {
- o << string(Indent*2, ' ');
+ void print(std::ostream &o, unsigned Indent) const {
+ o << std::string(Indent*2, ' ');
switch (getNodeType()) {
case ConstNode : o << "Constant : "; break;
- case BasicBlockNode : o << "BasicBlock : " << getValue()->getName() << endl;
+ case BasicBlockNode : o << "BasicBlock : " << getValue()->getName() << "\n";
return;
case InstructionNode: o << "Instruction: "; break;
case TemporaryNode : o << "Temporary : "; break;
- default: o << "UNKNOWN NODE TYPE: " << getNodeType() << endl; abort();
+ default: o << "UNKNOWN NODE TYPE: " << getNodeType() << "\n"; abort();
}
o << getValue();
};
template<class Payload>
-inline ostream &operator<<(ostream &o, const InstTreeNode<Payload> *N) {
+inline std::ostream &operator<<(std::ostream &o,
+ const InstTreeNode<Payload> *N) {
N->print(o, 0); return o;
}
// guaranteed to be an instruction node. The constructor builds the forest.
//
template<class Payload>
-class InstForest : public vector<InstTreeNode<Payload> *> {
+class InstForest : public
std::vector<InstTreeNode<Payload> *> {
friend class InstTreeNode<Payload>;
// InstMap - Map contains entries for ALL instructions in the method and the
// InstTreeNode that they correspond to.
//
- map<Instruction*, InstTreeNode<Payload> *> InstMap;
+
std::map<Instruction*, InstTreeNode<Payload> *> InstMap;
void addInstMapping(Instruction *I, InstTreeNode<Payload> *IN) {
- InstMap.insert(make_pair(I, IN));
+ InstMap.insert(std::make_pair(I, IN));
}
void removeInstFromRootList(Instruction *I) {
public:
// ctor - Create an instruction forest for the specified method...
- InstForest(Method *M) {
- for (Method::inst_iterator I = M->inst_begin(), E = M->inst_end();
- I != E; ++I) {
- Instruction *Inst = *I;
- if (!getInstNode(Inst)) // Do we already have a tree for this inst?
- push_back(new InstTreeNode<Payload>(*this, Inst, 0)); // No create one!
- // InstTreeNode ctor automatically adds the created node into our InstMap
+ InstForest(Function *F) {
+ for (Function::iterator MI = F->begin(), ME = F->end(); MI != ME; ++MI) {
+ BasicBlock *BB = *MI;
+ for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) {
+ Instruction *Inst = *I;
+ if (!getInstNode(Inst)) { // Do we already have a tree for this inst?
+ // No, create one! InstTreeNode ctor automatically adds the
+ // created node into our InstMap
+ push_back(new InstTreeNode<Payload>(*this, Inst, 0));
+ }
+ }
}
}
// the parent pointer can be used to find the root of the tree.
//
inline InstTreeNode<Payload> *getInstNode(Instruction *Inst) {
- map<Instruction*, InstTreeNode<Payload> *>::iterator I = InstMap.find(Inst);
+ std::map<Instruction*, InstTreeNode<Payload> *>::iterator I =
+ InstMap.find(Inst);
if (I != InstMap.end()) return I->second;
return 0;
}
inline const InstTreeNode<Payload> *getInstNode(const Instruction *Inst)const{
- map<Instruction*, InstTreeNode<Payload>*>::const_iterator I =
+
std::map<Instruction*, InstTreeNode<Payload>*>::const_iterator I =
InstMap.find(Inst);
if (I != InstMap.end()) return I->second;
return 0;
}
// print - Called by operator<< below...
- void print(ostream &out) const {
+ void print(std::ostream &out) const {
for (const_iterator I = begin(), E = end(); I != E; ++I)
out << *I;
}
};
template<class Payload>
-inline ostream &operator<<(ostream &o, const InstForest<Payload> &IF) {
+inline std::ostream &operator<<(std::ostream &o, const InstForest<Payload> &IF){
IF.print(o); return o;
}
getTreeData().first.first = V; // Save tree node
if (!isa<Instruction>(V)) {
- assert((isa<ConstPoolVal>(V) || isa<BasicBlock>(V) ||
- isa<MethodArgument>(V) || isa<GlobalVariable>(V)) &&
+ assert((isa<Constant>(V) || isa<BasicBlock>(V) ||
+ isa<Argument>(V) || isa<GlobalValue>(V)) &&
"Unrecognized value type for InstForest Partition!");
- if (isa<ConstPoolVal>(V))
+ if (isa<Constant>(V))
getTreeData().first.second = ConstNode;
else if (isa<BasicBlock>(V))
getTreeData().first.second = BasicBlockNode;
// Otherwise, we are an internal instruction node. We must process our
// uses and add them as children of this node.
//
- vector<InstTreeNode*> Children;
+ std::vector<InstTreeNode*> Children;
// Make sure that the forest knows about us!
IF.addInstMapping(I, this);
projects / oota-llvm.git / blobdiff