X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FTransforms%2FExprTypeConvert.cpp;h=9f75198e1ca1bd3b659e15ebdb7973ea8bd9ede7;hb=c6f3ae5c66c8e0dab6a2bd9601d0e253ef9ba794;hp=3c3e27161b449306baffda66354832202186f794;hpb=8e640f1fc9595cb5500fc9d7d50ee3e34b4d8ca9;p=oota-llvm.git diff --git a/lib/Transforms/ExprTypeConvert.cpp b/lib/Transforms/ExprTypeConvert.cpp index 3c3e27161b4..9f75198e1ca 100644 --- a/lib/Transforms/ExprTypeConvert.cpp +++ b/lib/Transforms/ExprTypeConvert.cpp @@ -7,22 +7,17 @@ //===----------------------------------------------------------------------===// #include "TransformInternals.h" -#include "llvm/Method.h" #include "llvm/iOther.h" #include "llvm/iPHINode.h" #include "llvm/iMemory.h" -#include "llvm/ConstantVals.h" -#include "llvm/Transforms/Scalar/ConstantHandling.h" +#include "llvm/ConstantHandling.h" #include "llvm/Transforms/Scalar/DCE.h" #include "llvm/Analysis/Expressions.h" #include "Support/STLExtras.h" -#include #include #include using std::cerr; -#include "llvm/Assembly/Writer.h" - //#define DEBUG_EXPR_CONVERT 1 static bool OperandConvertableToType(User *U, Value *V, const Type *Ty, @@ -71,7 +66,7 @@ static bool MallocConvertableToType(MallocInst *MI, const Type *Ty, unsigned OldTypeSize = TD.getTypeSize(MI->getType()->getElementType()); // Must have a scale or offset to analyze it... - if (!Expr.Offset && !Expr.Scale) return false; + if (!Expr.Offset && !Expr.Scale && OldTypeSize == 1) return false; // Get the offset and scale of the allocation... int OffsetVal = Expr.Offset ? getConstantValue(Expr.Offset) : 0; @@ -388,7 +383,7 @@ Value *ConvertExpressionToType(Value *V, const Type *Ty, ValueMapCache &VMC) { ValueHandle IHandle(VMC, I); // Prevent I from being removed! - Constant *Dummy = Constant::getNullConstant(Ty); + Constant *Dummy = Constant::getNullValue(Ty); switch (I->getOpcode()) { case Instruction::Cast: @@ -417,7 +412,7 @@ Value *ConvertExpressionToType(Value *V, const Type *Ty, ValueMapCache &VMC) { LoadInst *LI = cast(I); assert(!LI->hasIndices() || AllIndicesZero(LI)); - Res = new LoadInst(Constant::getNullConstant(PointerType::get(Ty)), Name); + Res = new LoadInst(Constant::getNullValue(PointerType::get(Ty)), Name); VMC.ExprMap[I] = Res; Res->setOperand(0, ConvertExpressionToType(LI->getPointerOperand(), PointerType::get(Ty), VMC)); @@ -501,7 +496,7 @@ Value *ConvertExpressionToType(Value *V, const Type *Ty, ValueMapCache &VMC) { Indices, &It); if (ElTy) { assert(ElTy == PVTy && "Internal error, setup wrong!"); - Res = new GetElementPtrInst(Constant::getNullConstant(NewSrcTy), + Res = new GetElementPtrInst(Constant::getNullValue(NewSrcTy), Indices, Name); VMC.ExprMap[I] = Res; Res->setOperand(0, ConvertExpressionToType(I->getOperand(0), @@ -516,7 +511,7 @@ Value *ConvertExpressionToType(Value *V, const Type *Ty, ValueMapCache &VMC) { // if (Res == 0) { const PointerType *NewSrcTy = PointerType::get(PVTy); - Res = new GetElementPtrInst(Constant::getNullConstant(NewSrcTy), + Res = new GetElementPtrInst(Constant::getNullValue(NewSrcTy), GEP->copyIndices(), Name); VMC.ExprMap[I] = Res; Res->setOperand(0, ConvertExpressionToType(I->getOperand(0), @@ -828,37 +823,37 @@ static bool OperandConvertableToType(User *U, Value *V, const Type *Ty, assert (OI != I->op_end() && "Not using value!"); unsigned OpNum = OI - I->op_begin(); - // Are we trying to change the method pointer value to a new type? + // Are we trying to change the function pointer value to a new type? if (OpNum == 0) { PointerType *PTy = dyn_cast(Ty); if (PTy == 0) return false; // Can't convert to a non-pointer type... - MethodType *MTy = dyn_cast(PTy->getElementType()); - if (MTy == 0) return false; // Can't convert to a non ptr to method... + FunctionType *MTy = dyn_cast(PTy->getElementType()); + if (MTy == 0) return false; // Can't convert to a non ptr to function... - // Perform sanity checks to make sure that new method type has the + // Perform sanity checks to make sure that new function type has the // correct number of arguments... // - unsigned NumArgs = I->getNumOperands()-1; // Don't include method ptr + unsigned NumArgs = I->getNumOperands()-1; // Don't include function ptr // Cannot convert to a type that requires more fixed arguments than // the call provides... // if (NumArgs < MTy->getParamTypes().size()) return false; - // Unless this is a vararg method type, we cannot provide more arguments + // Unless this is a vararg function type, we cannot provide more arguments // than are desired... // if (!MTy->isVarArg() && NumArgs > MTy->getParamTypes().size()) return false; - // Okay, at this point, we know that the call and the method type match + // Okay, at this point, we know that the call and the function type match // number of arguments. Now we see if we can convert the arguments // themselves. Note that we do not require operands to be convertable, // we can insert casts if they are convertible but not compatible. The - // reason for this is that we prefer to have resolved methods but casted + // reason for this is that we prefer to have resolved functions but casted // arguments if possible. // - const MethodType::ParamTypes &PTs = MTy->getParamTypes(); + const FunctionType::ParamTypes &PTs = MTy->getParamTypes(); for (unsigned i = 0, NA = PTs.size(); i < NA; ++i) if (!PTs[i]->isLosslesslyConvertableTo(I->getOperand(i+1)->getType())) return false; // Operands must have compatible types! @@ -871,14 +866,14 @@ static bool OperandConvertableToType(User *U, Value *V, const Type *Ty, } const PointerType *MPtr = cast(I->getOperand(0)->getType()); - const MethodType *MTy = cast(MPtr->getElementType()); + const FunctionType *MTy = cast(MPtr->getElementType()); if (!MTy->isVarArg()) return false; if ((OpNum-1) < MTy->getParamTypes().size()) return false; // It's not in the varargs section... // If we get this far, we know the value is in the varargs section of the - // method! We can convert if we don't reinterpret the value... + // function! We can convert if we don't reinterpret the value... // return Ty->isLosslesslyConvertableTo(V->getType()); } @@ -927,7 +922,7 @@ static void ConvertOperandToType(User *U, Value *OldVal, Value *NewVal, const Type *NewTy = NewVal->getType(); Constant *Dummy = (NewTy != Type::VoidTy) ? - Constant::getNullConstant(NewTy) : 0; + Constant::getNullValue(NewTy) : 0; switch (I->getOpcode()) { case Instruction::Cast: @@ -1003,7 +998,7 @@ static void ConvertOperandToType(User *U, Value *OldVal, Value *NewVal, case Instruction::Store: { if (I->getOperand(0) == OldVal) { // Replace the source value const PointerType *NewPT = PointerType::get(NewTy); - Res = new StoreInst(NewVal, Constant::getNullConstant(NewPT)); + Res = new StoreInst(NewVal, Constant::getNullValue(NewPT)); VMC.ExprMap[I] = Res; Res->setOperand(1, ConvertExpressionToType(I->getOperand(1), NewPT, VMC)); } else { // Replace the source pointer @@ -1017,7 +1012,7 @@ static void ConvertOperandToType(User *U, Value *OldVal, Value *NewVal, assert(Offset == 0 && ValTy); } - Res = new StoreInst(Constant::getNullConstant(ValTy), NewVal, Indices); + Res = new StoreInst(Constant::getNullValue(ValTy), NewVal, Indices); VMC.ExprMap[I] = Res; Res->setOperand(0, ConvertExpressionToType(I->getOperand(0), ValTy, VMC)); } @@ -1098,16 +1093,16 @@ static void ConvertOperandToType(User *U, Value *OldVal, Value *NewVal, Value *Meth = I->getOperand(0); std::vector Params(I->op_begin()+1, I->op_end()); - if (Meth == OldVal) { // Changing the method pointer? + if (Meth == OldVal) { // Changing the function pointer? PointerType *NewPTy = cast(NewVal->getType()); - MethodType *NewTy = cast(NewPTy->getElementType()); - const MethodType::ParamTypes &PTs = NewTy->getParamTypes(); + FunctionType *NewTy = cast(NewPTy->getElementType()); + const FunctionType::ParamTypes &PTs = NewTy->getParamTypes(); // Get an iterator to the call instruction so that we can insert casts for // operands if needbe. Note that we do not require operands to be // convertable, we can insert casts if they are convertible but not // compatible. The reason for this is that we prefer to have resolved - // methods but casted arguments if possible. + // functions but casted arguments if possible. // BasicBlock::iterator It = find(BIL.begin(), BIL.end(), I);