#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>
//
extern const TargetData TD;
-static int getConstantValue(const ConstantInt *CPI) {
+static inline int getConstantValue(const ConstantInt *CPI) {
if (const ConstantSInt *CSI = dyn_cast<ConstantSInt>(CPI))
- return CSI->getValue();
- return cast<ConstantUInt>(CPI)->getValue();
+ 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
// 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;
};
// 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