1 files changed, 43 insertions, 30 deletions

diff --git a/lib/Transforms/TransformInternals.h b/lib/Transforms/TransformInternals.h
index 6680d02b86..7a2dbf1b69 100644
--- a/lib/Transforms/TransformInternals.h
+++ b/lib/Transforms/TransformInternals.h
@@ -9,7 +9,6 @@
 #define TRANSFORM_INTERNALS_H
 
 #include "llvm/BasicBlock.h"
-#include "llvm/Instruction.h"
 #include "llvm/Target/TargetData.h"
 #include "llvm/DerivedTypes.h"
 #include "llvm/Constants.h"
@@ -53,44 +52,17 @@ const Type *ConvertableToGEP(const Type *Ty, Value *V,
                              BasicBlock::iterator *BI = 0);
 
 
-// ------------- Expression Conversion ---------------------
-
-typedef std::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.
-  //
-  std::set<const User*> OperandsMapped;
-
-  // Expression Map - Contains an entry from the old value to the new value of
-  // an expression that has been converted over.
-  //
-  std::map<const Value *, Value *> ExprMap;
-  typedef std::map<const Value *, Value *> ExprMapTy;
-};
-
-
-bool ExpressionConvertableToType(Value *V, const Type *Ty, ValueTypeCache &Map);
-Value *ConvertExpressionToType(Value *V, const Type *Ty, ValueMapCache &VMC);
-
-// ValueConvertableToType - Return true if it is possible
-bool ValueConvertableToType(Value *V, const Type *Ty,
-                            ValueTypeCache &ConvertedTypes);
-
-void ConvertValueToNewType(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 ValueMapCache;
 class ValueHandle : public Instruction {
-  ValueHandle(const ValueHandle &); // DO NOT IMPLEMENT
   ValueMapCache &Cache;
 public:
   ValueHandle(ValueMapCache &VMC, Value *V);
+  ValueHandle(const ValueHandle &);
   ~ValueHandle();
 
   virtual Instruction *clone() const { abort(); return 0; }
@@ -99,6 +71,10 @@ public:
     return "ValueHandle";
   }
 
+  inline bool operator<(const ValueHandle &VH) const {
+    return getOperand(0) < VH.getOperand(0);
+  }
+
   // 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) {
@@ -109,6 +85,43 @@ public:
   }
 };
 
+
+// ------------- Expression Conversion ---------------------
+
+typedef std::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.
+  //
+  std::set<const User*> OperandsMapped;
+
+  // Expression Map - Contains an entry from the old value to the new value of
+  // an expression that has been converted over.
+  //
+  std::map<const Value *, Value *> ExprMap;
+  typedef std::map<const Value *, Value *> ExprMapTy;
+
+  // Cast Map - Cast instructions can have their source and destination values
+  // changed independantly for each part.  Because of this, our old naive
+  // implementation would create a TWO new cast instructions, which would cause
+  // all kinds of problems.  Here we keep track of the newly allocated casts, so
+  // that we only create one for a particular instruction.
+  //
+  std::set<ValueHandle> NewCasts;
+};
+
+
+bool ExpressionConvertableToType(Value *V, const Type *Ty, ValueTypeCache &Map);
+Value *ConvertExpressionToType(Value *V, const Type *Ty, ValueMapCache &VMC);
+
+// ValueConvertableToType - Return true if it is possible
+bool ValueConvertableToType(Value *V, const Type *Ty,
+                            ValueTypeCache &ConvertedTypes);
+
+void ConvertValueToNewType(Value *V, Value *NewVal, ValueMapCache &VMC);
+
+
 // getStructOffsetType - Return a vector of offsets that are to be used to index
 // into the specified struct type to get as close as possible to index as we
 // can.  Note that it is possible that we cannot get exactly to Offset, in which