Use the expression map correctly.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@1140 91177308-0d34-0410-b5e6-96231b3b80d8

1 files changed, 46 insertions, 2 deletions

diff --git a/lib/Transforms/TransformInternals.h b/lib/Transforms/TransformInternals.h
index e6e65efd03..5c753c506c 100644
--- a/lib/Transforms/TransformInternals.h
+++ b/lib/Transforms/TransformInternals.h
@@ -9,8 +9,10 @@
 #define TRANSFORM_INTERNALS_H
 
 #include "llvm/BasicBlock.h"
+#include "llvm/Instruction.h"
 #include "llvm/Target/TargetData.h"
 #include <map>
+#include <set>
 
 // TargetData Hack: Eventually we will have annotations given to us by the
 // backend so that we know stuff about type size and alignments.  For now
@@ -43,8 +45,20 @@ void ReplaceInstWithInst(BasicBlock::InstListType &BIL,
 
 // ------------- Expression Conversion ---------------------
 
-typedef map<const Value*, const Type*> ValueTypeCache;
-typedef map<const Value*, Value*>      ValueMapCache;
+typedef map<const Value*, const Type*>         ValueTypeCache;
+
+struct ValueMapCache {
+  // Operands mapped - Contains an entry if the first value (the user) has had
+  // the second value (the operand) mapped already.
+  //
+  set<pair<const User*, const Value*> > OperandsMapped;
+
+  // Expression Map - Contains an entry from the old value to the new value of
+  // an expression that has been converted over.
+  //
+  map<const Value *, Value *> ExprMap;
+  typedef map<const Value *, Value *> ExprMapTy;
+};
 
 // RetValConvertableToType - Return true if it is possible
 bool RetValConvertableToType(Value *V, const Type *Ty,
@@ -53,4 +67,34 @@ bool RetValConvertableToType(Value *V, const Type *Ty,
 void ConvertUsersType(Value *V, Value *NewVal, ValueMapCache &VMC);
 
 
+//===----------------------------------------------------------------------===//
+//  ValueHandle Class - Smart pointer that occupies a slot on the users USE list
+//  that prevents it from being destroyed.  This "looks" like an Instruction
+//  with Opcode UserOp1.
+// 
+class ValueHandle : public Instruction {
+  ValueHandle(const ValueHandle &); // DO NOT IMPLEMENT
+public:
+  ValueHandle(Value *V) : Instruction(Type::VoidTy, UserOp1, "") {
+    Operands.push_back(Use(V, this));
+  }
+
+  ~ValueHandle();
+
+  virtual Instruction *clone() const { abort(); return 0; }
+
+  virtual const char *getOpcodeName() const {
+    return "ValueHandle";
+  }
+
+  // Methods for support type inquiry through isa, cast, and dyn_cast:
+  static inline bool classof(const ValueHandle *) { return true; }
+  static inline bool classof(const Instruction *I) {
+    return (I->getOpcode() == Instruction::UserOp1);
+  }
+  static inline bool classof(const Value *V) {
+    return isa<Instruction>(V) && classof(cast<Instruction>(V));
+  }
+};
+
 #endif