X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FTransforms%2FTransformInternals.h;h=867dd5d4abea7a293017d215690bc0c42f474cef;hb=93d545e691ef8c7c802a0c83dfb046e81d38e5d8;hp=7bc3df4fc37654b523bcae9b32fd0eaf3dfe9774;hpb=697954c15da58bd8b186dbafdedd8b06db770201;p=oota-llvm.git

diff --git a/lib/Transforms/TransformInternals.h b/lib/Transforms/TransformInternals.h
index 7bc3df4fc37..867dd5d4abe 100644
--- a/lib/Transforms/TransformInternals.h
+++ b/lib/Transforms/TransformInternals.h
@@ -9,10 +9,9 @@
 #define TRANSFORM_INTERNALS_H
 
 #include "llvm/BasicBlock.h"
-#include "llvm/Instruction.h"
 #include "llvm/Target/TargetData.h"
 #include "llvm/DerivedTypes.h"
-#include "llvm/ConstantVals.h"
+#include "llvm/Constants.h"
 #include <map>
 #include <set>
 
@@ -24,10 +23,10 @@
 //
 extern const TargetData TD;
 
-static inline int getConstantValue(const ConstantInt *CPI) {
+static inline int64_t getConstantValue(const ConstantInt *CPI) {
   if (const ConstantSInt *CSI = dyn_cast<ConstantSInt>(CPI))
     return CSI->getValue();
-  return cast<ConstantUInt>(CPI)->getValue();
+  return (int64_t)cast<ConstantUInt>(CPI)->getValue();
 }
 
 
@@ -39,23 +38,6 @@ static inline const CompositeType *getPointedToComposite(const Type *Ty) {
   return PT ? dyn_cast<CompositeType>(PT->getElementType()) : 0;
 }
 
-
-// ReplaceInstWithValue - Replace all uses of an instruction (specified by BI)
-// with a value, then remove and delete the original instruction.
-//
-void ReplaceInstWithValue(BasicBlock::InstListType &BIL,
-                          BasicBlock::iterator &BI, Value *V);
-
-// ReplaceInstWithInst - Replace the instruction specified by BI with the
-// instruction specified by I.  The original instruction is deleted and BI is
-// updated to point to the new instruction.
-//
-void ReplaceInstWithInst(BasicBlock::InstListType &BIL,
-                         BasicBlock::iterator &BI, Instruction *I);
-
-void ReplaceInstWithInst(Instruction *From, Instruction *To);
-
-
 // ConvertableToGEP - This function returns true if the specified value V is
 // a valid index into a pointer of type Ty.  If it is valid, Idx is filled in
 // with the values that would be appropriate to make this a getelementptr
@@ -70,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; }
@@ -116,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) {
@@ -126,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