Remove dead code

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

diff --git a/lib/Transforms/TransformInternals.h b/lib/Transforms/TransformInternals.h
index 5c753c506c09adcd169a610c0f401c1557d67f4e..f57ed3ea6ecfab099e7b83e92a0e523a0f9ce4fa 100644 (file)
--- a/lib/Transforms/TransformInternals.h
+++ b/lib/Transforms/TransformInternals.h
@@ -11,6 +11,8 @@
 #include "llvm/BasicBlock.h"
 #include "llvm/Instruction.h"
 #include "llvm/Target/TargetData.h"
+#include "llvm/DerivedTypes.h"
+#include "llvm/Constants.h"
 #include <map>
 #include <set>
 
@@ -22,11 +24,20 @@
 //
 extern const TargetData TD;
 
-// losslessCastableTypes - Return true if the types are bitwise equivalent.
-// This predicate returns true if it is possible to cast from one type to
-// another without gaining or losing precision, or altering the bits in any way.
+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();
+}
+
+
+// getPointedToComposite - If the argument is a pointer type, and the pointed to
+// value is a composite type, return the composite type, else return null.
 //
-bool losslessCastableTypes(const Type *T1, const Type *T2);
+static inline const CompositeType *getPointedToComposite(const Type *Ty) {
+  const PointerType *PT = dyn_cast<PointerType>(Ty);
+  return PT ? dyn_cast<CompositeType>(PT->getElementType()) : 0;
+}
 
 
 // ReplaceInstWithValue - Replace all uses of an instruction (specified by BI)
@@ -42,29 +53,56 @@ void ReplaceInstWithValue(BasicBlock::InstListType &BIL,
 void ReplaceInstWithInst(BasicBlock::InstListType &BIL,
                          BasicBlock::iterator &BI, Instruction *I);
 
+void ReplaceInstWithInst(Instruction *From, Instruction *To);
+
+// InsertInstBeforeInst - Insert 'NewInst' into the basic block that 'Existing'
+// is already in, and put it right before 'Existing'.  This instruction should
+// only be used when there is no iterator to Existing already around.  The 
+// returned iterator points to the new instruction.
+//
+BasicBlock::iterator InsertInstBeforeInst(Instruction *NewInst,
+                                          Instruction *Existing);
+
+// 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
+// instruction.  The type returned is the root type that the GEP would point
+// to if it were synthesized with this operands.
+//
+// If BI is nonnull, cast instructions are inserted as appropriate for the
+// arguments of the getelementptr.
+//
+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<pair<const User*, const Value*> > 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;
 };
 
-// RetValConvertableToType - Return true if it is possible
-bool RetValConvertableToType(Value *V, const Type *Ty,
-                             ValueTypeCache &ConvertedTypes);
 
-void ConvertUsersType(Value *V, Value *NewVal, ValueMapCache &VMC);
+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);
 
 
 //===----------------------------------------------------------------------===//
@@ -74,11 +112,9 @@ void ConvertUsersType(Value *V, Value *NewVal, ValueMapCache &VMC);
 // 
 class ValueHandle : public Instruction {
   ValueHandle(const ValueHandle &); // DO NOT IMPLEMENT
+  ValueMapCache &Cache;
 public:
-  ValueHandle(Value *V) : Instruction(Type::VoidTy, UserOp1, "") {
-    Operands.push_back(Use(V, this));
-  }
-
+  ValueHandle(ValueMapCache &VMC, Value *V);
   ~ValueHandle();
 
   virtual Instruction *clone() const { abort(); return 0; }
@@ -97,4 +133,19 @@ public:
   }
 };
 
+// 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
+// case we update offset to be the offset we actually obtained.  The resultant
+// leaf type is returned.
+//
+// If StopEarly is set to true (the default), the first object with the
+// specified type is returned, even if it is a struct type itself.  In this
+// case, this routine will not drill down to the leaf type.  Set StopEarly to
+// false if you want a leaf
+//
+const Type *getStructOffsetType(const Type *Ty, unsigned &Offset,
+                                std::vector<Value*> &Offsets,
+                                bool StopEarly = true);
+
 #endif