Give the longer name to the instruction that will probably be eliminated later

[oota-llvm.git] / lib / Transforms / TransformInternals.h

diff --git a/lib/Transforms/TransformInternals.h b/lib/Transforms/TransformInternals.h
index 8edeffc82e199f0befa5a1dff4ec9ef3d7f765d6..6680d02b86551e9013a4ab47d0e7502132cd8b9d 100644 (file)
--- a/lib/Transforms/TransformInternals.h
+++ b/lib/Transforms/TransformInternals.h
@@ -12,7 +12,7 @@
 #include "llvm/Instruction.h"
 #include "llvm/Target/TargetData.h"
 #include "llvm/DerivedTypes.h"
-#include "llvm/ConstPoolVals.h"
+#include "llvm/Constants.h"
 #include <map>
 #include <set>
 
@@ -24,43 +24,21 @@
 //
 extern const TargetData TD;
 
-static int getConstantValue(const ConstPoolInt *CPI) {
-  if (const ConstPoolSInt *CSI = dyn_cast<ConstPoolSInt>(CPI))
-    return CSI->getValue();
-  return cast<ConstPoolUInt>(CPI)->getValue();
+static inline int getConstantValue(const ConstantInt *CPI) {
+  if (const ConstantSInt *CSI = dyn_cast<ConstantSInt>(CPI))
+    return (int)CSI->getValue();
+  return (int)cast<ConstantUInt>(CPI)->getValue();
 }
 
 
-// isFirstClassType - Return true if a value of the specified type can be held
-// in a register.
-//
-static inline bool isFirstClassType(const Type *Ty) {
-  return Ty->isPrimitiveType() || Ty->isPointerType();
-}
-
 // getPointedToComposite - If the argument is a pointer type, and the pointed to
 // value is a composite type, return the composite type, else return null.
 //
 static inline const CompositeType *getPointedToComposite(const Type *Ty) {
   const PointerType *PT = dyn_cast<PointerType>(Ty);
-  return PT ? dyn_cast<CompositeType>(PT->getValueType()) : 0;
+  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);
-
-
 // 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,25 +48,26 @@ void ReplaceInstWithInst(BasicBlock::InstListType &BIL,
 // If BI is nonnull, cast instructions are inserted as appropriate for the
 // arguments of the getelementptr.
 //
-const Type *ConvertableToGEP(const Type *Ty, Value *V, vector<Value*> &Indices,
+const Type *ConvertableToGEP(const Type *Ty, Value *V,
+                             std::vector<Value*> &Indices,
                              BasicBlock::iterator *BI = 0);
 
 
 // ------------- Expression Conversion ---------------------
 
-typedef map<const Value*, const Type*>         ValueTypeCache;
+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.
   //
-  set<const User*> OperandsMapped;
+  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.
   //
-  map<const Value *, Value *> ExprMap;
-  typedef map<const Value *, Value *> ExprMapTy;
+  std::map<const Value *, Value *> ExprMap;
+  typedef std::map<const Value *, Value *> ExprMapTy;
 };
 
 
@@ -142,7 +121,7 @@ public:
 // false if you want a leaf
 //
 const Type *getStructOffsetType(const Type *Ty, unsigned &Offset,
-                                vector<Value*> &Offsets,
+                                std::vector<Value*> &Offsets,
                                 bool StopEarly = true);
 
 #endif