X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FTransforms%2FExprTypeConvert.cpp;h=33aa3cb4751d20d8b36185ac0fb05a35c3298eb9;hb=26199059268a05739c84ebf465fcdbf7ded861df;hp=790f68f7a37bb01713d430e09ed94c37a9677da2;hpb=2aac6bf66a4f4486e14ee5bdc96277ec770afdc7;p=oota-llvm.git diff --git a/lib/Transforms/ExprTypeConvert.cpp b/lib/Transforms/ExprTypeConvert.cpp index 790f68f7a37..33aa3cb4751 100644 --- a/lib/Transforms/ExprTypeConvert.cpp +++ b/lib/Transforms/ExprTypeConvert.cpp @@ -7,43 +7,23 @@ //===----------------------------------------------------------------------===// #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/Transforms/Scalar/DCE.h" +#include "llvm/ConstantHandling.h" #include "llvm/Analysis/Expressions.h" #include "Support/STLExtras.h" -#include +#include "Support/StatisticReporter.h" #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, ValueTypeCache &ConvertedTypes); static void ConvertOperandToType(User *U, Value *OldVal, Value *NewVal, ValueMapCache &VMC); -// AllIndicesZero - Return true if all of the indices of the specified memory -// access instruction are zero, indicating an effectively nil offset to the -// pointer value. -// -static bool AllIndicesZero(const MemAccessInst *MAI) { - for (User::const_op_iterator S = MAI->idx_begin(), E = MAI->idx_end(); - S != E; ++S) - if (!isa(*S) || !cast(*S)->isNullValue()) - return false; - return true; -} - - // Peephole Malloc instructions: we take a look at the use chain of the // malloc instruction, and try to find out if the following conditions hold: // 1. The malloc is of the form: 'malloc [sbyte], uint ' @@ -67,7 +47,7 @@ static bool MallocConvertableToType(MallocInst *MI, const Type *Ty, analysis::ExprType Expr = analysis::ClassifyExpression(MI->getArraySize()); // Get information about the base datatype being allocated, before & after - unsigned ReqTypeSize = TD.getTypeSize(Ty); + int ReqTypeSize = TD.getTypeSize(Ty); unsigned OldTypeSize = TD.getTypeSize(MI->getType()->getElementType()); // Must have a scale or offset to analyze it... @@ -76,15 +56,11 @@ static bool MallocConvertableToType(MallocInst *MI, const Type *Ty, // Get the offset and scale of the allocation... int OffsetVal = Expr.Offset ? getConstantValue(Expr.Offset) : 0; int ScaleVal = Expr.Scale ? getConstantValue(Expr.Scale) : (Expr.Var ? 1 : 0); - if (ScaleVal < 0 || OffsetVal < 0) { - cerr << "malloc of a negative number???\n"; - return false; - } // The old type might not be of unit size, take old size into consideration // here... - unsigned Offset = (unsigned)OffsetVal * OldTypeSize; - unsigned Scale = (unsigned)ScaleVal * OldTypeSize; + int Offset = OffsetVal * OldTypeSize; + int Scale = ScaleVal * OldTypeSize; // In order to be successful, both the scale and the offset must be a multiple // of the requested data type's size. @@ -121,7 +97,7 @@ static Instruction *ConvertMallocToType(MallocInst *MI, const Type *Ty, unsigned Scale = (unsigned)ScaleVal * OldTypeSize / DataSize; // Locate the malloc instruction, because we may be inserting instructions - It = find(BB->getInstList().begin(), BB->getInstList().end(), MI); + It = MI; // If we have a scale, apply it first... if (Expr.Var) { @@ -129,7 +105,7 @@ static Instruction *ConvertMallocToType(MallocInst *MI, const Type *Ty, if (Expr.Var->getType() != Type::UIntTy) { Instruction *CI = new CastInst(Expr.Var, Type::UIntTy); if (Expr.Var->hasName()) CI->setName(Expr.Var->getName()+"-uint"); - It = BB->getInstList().insert(It, CI)+1; + It = ++BB->getInstList().insert(It, CI); Expr.Var = CI; } @@ -138,7 +114,7 @@ static Instruction *ConvertMallocToType(MallocInst *MI, const Type *Ty, BinaryOperator::create(Instruction::Mul, Expr.Var, ConstantUInt::get(Type::UIntTy, Scale)); if (Expr.Var->hasName()) ScI->setName(Expr.Var->getName()+"-scl"); - It = BB->getInstList().insert(It, ScI)+1; + It = ++BB->getInstList().insert(It, ScI); Expr.Var = ScI; } @@ -156,7 +132,7 @@ static Instruction *ConvertMallocToType(MallocInst *MI, const Type *Ty, BinaryOperator::create(Instruction::Add, Expr.Var, ConstantUInt::get(Type::UIntTy, Offset)); if (Expr.Var->hasName()) AddI->setName(Expr.Var->getName()+"-off"); - It = BB->getInstList().insert(It, AddI)+1; + It = ++BB->getInstList().insert(It, AddI); Expr.Var = AddI; } @@ -170,8 +146,6 @@ static Instruction *ConvertMallocToType(MallocInst *MI, const Type *Ty, // ExpressionConvertableToType - Return true if it is possible bool ExpressionConvertableToType(Value *V, const Type *Ty, ValueTypeCache &CTMap) { - if (V->getType() == Ty) return true; // Expression already correct type! - // Expression type must be holdable in a register. if (!Ty->isFirstClassType()) return false; @@ -180,6 +154,7 @@ bool ExpressionConvertableToType(Value *V, const Type *Ty, if (CTMI != CTMap.end()) return CTMI->second == Ty; CTMap[V] = Ty; + if (V->getType() == Ty) return true; // Expression already correct type! Instruction *I = dyn_cast(V); if (I == 0) { @@ -200,16 +175,16 @@ bool ExpressionConvertableToType(Value *V, const Type *Ty, // We can convert the expr if the cast destination type is losslessly // convertable to the requested type. if (!Ty->isLosslesslyConvertableTo(I->getType())) return false; -#if 1 + // We also do not allow conversion of a cast that casts from a ptr to array // of X to a *X. For example: cast [4 x %List *] * %val to %List * * // - if (PointerType *SPT = dyn_cast(I->getOperand(0)->getType())) - if (PointerType *DPT = dyn_cast(I->getType())) - if (ArrayType *AT = dyn_cast(SPT->getElementType())) + if (const PointerType *SPT = + dyn_cast(I->getOperand(0)->getType())) + if (const PointerType *DPT = dyn_cast(I->getType())) + if (const ArrayType *AT = dyn_cast(SPT->getElementType())) if (AT->getElementType() == DPT->getElementType()) return false; -#endif break; case Instruction::Add: @@ -228,12 +203,6 @@ bool ExpressionConvertableToType(Value *V, const Type *Ty, case Instruction::Load: { LoadInst *LI = cast(I); - if (LI->hasIndices() && !AllIndicesZero(LI)) { - // We can't convert a load expression if it has indices... unless they are - // all zero. - return false; - } - if (!ExpressionConvertableToType(LI->getPointerOperand(), PointerType::get(Ty), CTMap)) return false; @@ -252,7 +221,6 @@ bool ExpressionConvertableToType(Value *V, const Type *Ty, return false; break; -#if 1 case Instruction::GetElementPtr: { // GetElementPtr's are directly convertable to a pointer type if they have // a number of zeros at the end. Because removing these values does not @@ -272,7 +240,7 @@ bool ExpressionConvertableToType(Value *V, const Type *Ty, // index array. If there are, check to see if removing them causes us to // get to the right type... // - std::vector Indices = GEP->copyIndices(); + std::vector Indices(GEP->idx_begin(), GEP->idx_end()); const Type *BaseType = GEP->getPointerOperand()->getType(); const Type *ElTy = 0; @@ -331,7 +299,6 @@ bool ExpressionConvertableToType(Value *V, const Type *Ty, return false; // No match, maybe next time. } -#endif default: return false; @@ -354,6 +321,8 @@ Value *ConvertExpressionToType(Value *V, const Type *Ty, ValueMapCache &VMC) { ValueMapCache::ExprMapTy::iterator VMCI = VMC.ExprMap.find(V); if (VMCI != VMC.ExprMap.end()) { + const Value *GV = VMCI->second; + const Type *GTy = VMCI->second->getType(); assert(VMCI->second->getType() == Ty); if (Instruction *I = dyn_cast(V)) @@ -362,9 +331,7 @@ Value *ConvertExpressionToType(Value *V, const Type *Ty, ValueMapCache &VMC) { return VMCI->second; } -#ifdef DEBUG_EXPR_CONVERT - cerr << "CETT: " << (void*)V << " " << V; -#endif + DEBUG(cerr << "CETT: " << (void*)V << " " << V); Instruction *I = dyn_cast(V); if (I == 0) @@ -388,11 +355,13 @@ 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: + assert(VMC.NewCasts.count(ValueHandle(VMC, I)) == 0); Res = new CastInst(I->getOperand(0), Ty, Name); + VMC.NewCasts.insert(ValueHandle(VMC, Res)); break; case Instruction::Add: @@ -415,9 +384,8 @@ Value *ConvertExpressionToType(Value *V, const Type *Ty, ValueMapCache &VMC) { case Instruction::Load: { 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)); @@ -465,7 +433,7 @@ Value *ConvertExpressionToType(Value *V, const Type *Ty, ValueMapCache &VMC) { // index array. If there are, check to see if removing them causes us to // get to the right type... // - std::vector Indices = GEP->copyIndices(); + std::vector Indices(GEP->idx_begin(), GEP->idx_end()); const Type *BaseType = GEP->getPointerOperand()->getType(); const Type *PVTy = cast(Ty)->getElementType(); Res = 0; @@ -491,7 +459,7 @@ Value *ConvertExpressionToType(Value *V, const Type *Ty, ValueMapCache &VMC) { // and we could convert this to an appropriate GEP for the new type. // const PointerType *NewSrcTy = PointerType::get(PVTy); - BasicBlock::iterator It = find(BIL.begin(), BIL.end(), I); + BasicBlock::iterator It = I; // Check to see if 'N' is an expression that can be converted to // the appropriate size... if so, allow it. @@ -501,7 +469,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,8 +484,9 @@ Value *ConvertExpressionToType(Value *V, const Type *Ty, ValueMapCache &VMC) { // if (Res == 0) { const PointerType *NewSrcTy = PointerType::get(PVTy); - Res = new GetElementPtrInst(Constant::getNullConstant(NewSrcTy), - GEP->copyIndices(), Name); + std::vector Indices(GEP->idx_begin(), GEP->idx_end()); + Res = new GetElementPtrInst(Constant::getNullValue(NewSrcTy), + Indices, Name); VMC.ExprMap[I] = Res; Res->setOperand(0, ConvertExpressionToType(I->getOperand(0), NewSrcTy, VMC)); @@ -535,9 +504,7 @@ Value *ConvertExpressionToType(Value *V, const Type *Ty, ValueMapCache &VMC) { assert(Res->getType() == Ty && "Didn't convert expr to correct type!"); - BasicBlock::iterator It = find(BIL.begin(), BIL.end(), I); - assert(It != BIL.end() && "Instruction not in own basic block??"); - BIL.insert(It, Res); + BIL.insert(I, Res); // Add the instruction to the expression map VMC.ExprMap[I] = Res; @@ -554,20 +521,8 @@ Value *ConvertExpressionToType(Value *V, const Type *Ty, ValueMapCache &VMC) { if (NumUses == OldSize) ++It; } -#ifdef DEBUG_EXPR_CONVERT - cerr << "ExpIn: " << (void*)I << " " << I - << "ExpOut: " << (void*)Res << " " << Res; -#endif - - if (I->use_empty()) { -#ifdef DEBUG_EXPR_CONVERT - cerr << "EXPR DELETING: " << (void*)I << " " << I; -#endif - BIL.remove(I); - VMC.OperandsMapped.erase(I); - VMC.ExprMap.erase(I); - delete I; - } + DEBUG(cerr << "ExpIn: " << (void*)I << " " << I + << "ExpOut: " << (void*)Res << " " << Res); return Res; } @@ -625,17 +580,25 @@ static bool OperandConvertableToType(User *U, Value *V, const Type *Ty, I->getType() == I->getOperand(0)->getType()) return false; + // Do not allow a 'cast ushort %V to uint' to have it's first operand be + // converted to a 'short' type. Doing so changes the way sign promotion + // happens, and breaks things. Only allow the cast to take place if the + // signedness doesn't change... or if the current cast is not a lossy + // conversion. + // + if (!I->getType()->isLosslesslyConvertableTo(I->getOperand(0)->getType()) && + I->getOperand(0)->getType()->isSigned() != Ty->isSigned()) + return false; -#if 1 // We also do not allow conversion of a cast that casts from a ptr to array // of X to a *X. For example: cast [4 x %List *] * %val to %List * * // - if (PointerType *SPT = dyn_cast(I->getOperand(0)->getType())) - if (PointerType *DPT = dyn_cast(I->getType())) - if (ArrayType *AT = dyn_cast(SPT->getElementType())) + if (const PointerType *SPT = + dyn_cast(I->getOperand(0)->getType())) + if (const PointerType *DPT = dyn_cast(I->getType())) + if (const ArrayType *AT = dyn_cast(SPT->getElementType())) if (AT->getElementType() == DPT->getElementType()) return false; -#endif return true; case Instruction::Add: @@ -684,9 +647,6 @@ static bool OperandConvertableToType(User *U, Value *V, const Type *Ty, if (const PointerType *PT = dyn_cast(Ty)) { LoadInst *LI = cast(I); - if (LI->hasIndices() && !AllIndicesZero(LI)) - return false; - const Type *LoadedTy = PT->getElementType(); // They could be loading the first element of a composite type... @@ -709,7 +669,6 @@ static bool OperandConvertableToType(User *U, Value *V, const Type *Ty, case Instruction::Store: { StoreInst *SI = cast(I); - if (SI->hasIndices()) return false; if (V == I->getOperand(0)) { ValueTypeCache::iterator CTMI = CTMap.find(I->getOperand(1)); @@ -732,7 +691,7 @@ static bool OperandConvertableToType(User *U, Value *V, const Type *Ty, // a whole structure at a time), so the level raiser must be trying to // store into the first field. Check for this and allow it now: // - if (StructType *SElTy = dyn_cast(ElTy)) { + if (const StructType *SElTy = dyn_cast(ElTy)) { unsigned Offset = 0; std::vector Indices; ElTy = getStructOffsetType(ElTy, Offset, Indices, false); @@ -769,7 +728,8 @@ static bool OperandConvertableToType(User *U, Value *V, const Type *Ty, } // Must move the same amount of data... - if (TD.getTypeSize(ElTy) != TD.getTypeSize(I->getOperand(0)->getType())) + if (!ElTy->isSized() || + TD.getTypeSize(ElTy) != TD.getTypeSize(I->getOperand(0)->getType())) return false; // Can convert store if the incoming value is convertable... @@ -828,34 +788,34 @@ 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); + const PointerType *PTy = dyn_cast(Ty); if (PTy == 0) return false; // Can't convert to a non-pointer type... - FunctionType *MTy = dyn_cast(PTy->getElementType()); - if (MTy == 0) return false; // Can't convert to a non ptr to method... + const 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 FunctionType::ParamTypes &PTs = MTy->getParamTypes(); @@ -878,7 +838,7 @@ static bool OperandConvertableToType(User *U, Value *V, const Type *Ty, 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()); } @@ -916,8 +876,10 @@ static void ConvertOperandToType(User *U, Value *OldVal, Value *NewVal, Instruction *I = cast(U); // Only Instructions convertable BasicBlock *BB = I->getParent(); + assert(BB != 0 && "Instruction not embedded in basic block!"); BasicBlock::InstListType &BIL = BB->getInstList(); - std::string Name = I->getName(); if (!Name.empty()) I->setName(""); + std::string Name = I->getName(); + I->setName(""); Instruction *Res; // Result of conversion //cerr << endl << endl << "Type:\t" << Ty << "\nInst: " << I << "BB Before: " << BB << endl; @@ -927,19 +889,29 @@ 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: - assert(I->getOperand(0) == OldVal); - Res = new CastInst(NewVal, I->getType(), Name); + if (VMC.NewCasts.count(ValueHandle(VMC, I))) { + // This cast has already had it's value converted, causing a new cast to + // be created. We don't want to create YET ANOTHER cast instruction + // representing the original one, so just modify the operand of this cast + // instruction, which we know is newly created. + I->setOperand(0, NewVal); + I->setName(Name); // give I its name back + return; + + } else { + Res = new CastInst(NewVal, I->getType(), Name); + } break; case Instruction::Add: if (isa(NewTy)) { Value *IndexVal = I->getOperand(OldVal == I->getOperand(0) ? 1 : 0); std::vector Indices; - BasicBlock::iterator It = find(BIL.begin(), BIL.end(), I); + BasicBlock::iterator It = I; if (const Type *ETy = ConvertableToGEP(NewTy, IndexVal, Indices, &It)) { // If successful, convert the add to a GEP @@ -986,38 +958,91 @@ static void ConvertOperandToType(User *U, Value *OldVal, Value *NewVal, const Type *LoadedTy = cast(NewVal->getType())->getElementType(); - std::vector Indices; - Indices.push_back(ConstantUInt::get(Type::UIntTy, 0)); + Value *Src = NewVal; if (const CompositeType *CT = dyn_cast(LoadedTy)) { + std::vector Indices; + Indices.push_back(ConstantUInt::get(Type::UIntTy, 0)); + unsigned Offset = 0; // No offset, get first leaf. LoadedTy = getStructOffsetType(CT, Offset, Indices, false); - } - assert(LoadedTy->isFirstClassType()); + assert(LoadedTy->isFirstClassType()); - Res = new LoadInst(NewVal, Indices, Name); + if (Indices.size() != 1) { // Do not generate load X, 0 + Src = new GetElementPtrInst(Src, Indices, Name+".idx"); + // Insert the GEP instruction before this load. + BIL.insert(I, cast(Src)); + } + } + + Res = new LoadInst(Src, Name); assert(Res->getType()->isFirstClassType() && "Load of structure or array!"); break; } 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)); - VMC.ExprMap[I] = Res; - Res->setOperand(1, ConvertExpressionToType(I->getOperand(1), NewPT, VMC)); + // Check to see if operand #1 has already been converted... + ValueMapCache::ExprMapTy::iterator VMCI = + VMC.ExprMap.find(I->getOperand(1)); + if (VMCI != VMC.ExprMap.end()) { + // Comments describing this stuff are in the OperandConvertableToType + // switch statement for Store... + // + const Type *ElTy = + cast(VMCI->second->getType())->getElementType(); + + Value *SrcPtr = VMCI->second; + + if (ElTy != NewTy) { + // We check that this is a struct in the initial scan... + const StructType *SElTy = cast(ElTy); + + std::vector Indices; + Indices.push_back(ConstantUInt::get(Type::UIntTy, 0)); + + unsigned Offset = 0; + const Type *Ty = getStructOffsetType(ElTy, Offset, Indices, false); + assert(Offset == 0 && "Offset changed!"); + assert(NewTy == Ty && "Did not convert to correct type!"); + + SrcPtr = new GetElementPtrInst(SrcPtr, Indices, + SrcPtr->getName()+".idx"); + // Insert the GEP instruction before this load. + BIL.insert(I, cast(SrcPtr)); + } + Res = new StoreInst(NewVal, SrcPtr); + + VMC.ExprMap[I] = Res; + } else { + // Otherwise, we haven't converted Operand #1 over yet... + const PointerType *NewPT = PointerType::get(NewTy); + 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 const Type *ValTy = cast(NewTy)->getElementType(); - std::vector Indices; + + Value *SrcPtr = NewVal; if (isa(ValTy)) { - unsigned Offset = 0; + std::vector Indices; Indices.push_back(ConstantUInt::get(Type::UIntTy, 0)); + + unsigned Offset = 0; ValTy = getStructOffsetType(ValTy, Offset, Indices, false); + assert(Offset == 0 && ValTy); + + SrcPtr = new GetElementPtrInst(SrcPtr, Indices, + SrcPtr->getName()+".idx"); + // Insert the GEP instruction before this load. + BIL.insert(I, cast(SrcPtr)); } - Res = new StoreInst(Constant::getNullConstant(ValTy), NewVal, Indices); + Res = new StoreInst(Constant::getNullValue(ValTy), SrcPtr); VMC.ExprMap[I] = Res; Res->setOperand(0, ConvertExpressionToType(I->getOperand(0), ValTy, VMC)); } @@ -1029,7 +1054,7 @@ static void ConvertOperandToType(User *U, Value *OldVal, Value *NewVal, // Convert a one index getelementptr into just about anything that is // desired. // - BasicBlock::iterator It = find(BIL.begin(), BIL.end(), I); + BasicBlock::iterator It = I; const Type *OldElTy = cast(I->getType())->getElementType(); unsigned DataSize = TD.getTypeSize(OldElTy); Value *Index = I->getOperand(1); @@ -1038,7 +1063,7 @@ static void ConvertOperandToType(User *U, Value *OldVal, Value *NewVal, // Insert a multiply of the old element type is not a unit size... Index = BinaryOperator::create(Instruction::Mul, Index, ConstantUInt::get(Type::UIntTy, DataSize)); - It = BIL.insert(It, cast(Index))+1; + It = ++BIL.insert(It, cast(Index)); } // Perform the conversion now... @@ -1055,7 +1080,7 @@ static void ConvertOperandToType(User *U, Value *OldVal, Value *NewVal, // Convert a getelementptr sbyte * %reg111, uint 16 freely back to // anything that is a pointer type... // - BasicBlock::iterator It = find(BIL.begin(), BIL.end(), I); + BasicBlock::iterator It = I; // Check to see if the second argument is an expression that can // be converted to the appropriate size... if so, allow it. @@ -1071,9 +1096,9 @@ static void ConvertOperandToType(User *U, Value *OldVal, Value *NewVal, // to getelementptr long * %reg123, uint %N // ... where the type must simply stay the same size... // - Res = new GetElementPtrInst(NewVal, - cast(I)->copyIndices(), - Name); + GetElementPtrInst *GEP = cast(I); + std::vector Indices(GEP->idx_begin(), GEP->idx_end()); + Res = new GetElementPtrInst(NewVal, Indices, Name); } #endif break; @@ -1098,18 +1123,18 @@ 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? - PointerType *NewPTy = cast(NewVal->getType()); - FunctionType *NewTy = cast(NewPTy->getElementType()); + if (Meth == OldVal) { // Changing the function pointer? + const PointerType *NewPTy = cast(NewVal->getType()); + const 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); + BasicBlock::iterator It = I; // Convert over all of the call operands to their new types... but only // convert over the part that is not in the vararg section of the call. @@ -1120,7 +1145,7 @@ static void ConvertOperandToType(User *U, Value *OldVal, Value *NewVal, // is a lossless cast... // Params[i] = new CastInst(Params[i], PTs[i], "call.resolve.cast"); - It = BIL.insert(It, cast(Params[i]))+1; + It = ++BIL.insert(It, cast(Params[i])); } Meth = NewVal; // Update call destination to new value @@ -1143,14 +1168,13 @@ static void ConvertOperandToType(User *U, Value *OldVal, Value *NewVal, // If the instruction was newly created, insert it into the instruction // stream. // - BasicBlock::iterator It = find(BIL.begin(), BIL.end(), I); + BasicBlock::iterator It = I; assert(It != BIL.end() && "Instruction not in own basic block??"); BIL.insert(It, Res); // Keep It pointing to old instruction -#ifdef DEBUG_EXPR_CONVERT - cerr << "COT CREATED: " << (void*)Res << " " << Res; - cerr << "In: " << (void*)I << " " << I << "Out: " << (void*)Res << " " << Res; -#endif + DEBUG(cerr << "COT CREATED: " << (void*)Res << " " << Res + << "In: " << (void*)I << " " << I << "Out: " << (void*)Res + << " " << Res); // Add the instruction to the expression map VMC.ExprMap[I] = Res; @@ -1166,47 +1190,35 @@ static void ConvertOperandToType(User *U, Value *OldVal, Value *NewVal, Use->replaceUsesOfWith(I, Res); } - if (I->use_empty()) { - // Now we just need to remove the old instruction so we don't get infinite - // loops. Note that we cannot use DCE because DCE won't remove a store - // instruction, for example. - // -#ifdef DEBUG_EXPR_CONVERT - cerr << "DELETING: " << (void*)I << " " << I; -#endif - BIL.remove(I); - VMC.OperandsMapped.erase(I); - VMC.ExprMap.erase(I); - delete I; - } else { - for (Value::use_iterator UI = I->use_begin(), UE = I->use_end(); - UI != UE; ++UI) - assert(isa((Value*)*UI) &&"Uses of Instruction remain!!!"); - } + for (Value::use_iterator UI = I->use_begin(), UE = I->use_end(); + UI != UE; ++UI) + assert(isa((Value*)*UI) &&"Uses of Instruction remain!!!"); } } ValueHandle::ValueHandle(ValueMapCache &VMC, Value *V) : Instruction(Type::VoidTy, UserOp1, ""), Cache(VMC) { -#ifdef DEBUG_EXPR_CONVERT - //cerr << "VH AQUIRING: " << (void*)V << " " << V; -#endif + //DEBUG(cerr << "VH AQUIRING: " << (void*)V << " " << V); Operands.push_back(Use(V, this)); } +ValueHandle::ValueHandle(const ValueHandle &VH) + : Instruction(Type::VoidTy, UserOp1, ""), Cache(VH.Cache) { + //DEBUG(cerr << "VH AQUIRING: " << (void*)V << " " << V); + Operands.push_back(Use((Value*)VH.getOperand(0), this)); +} + static void RecursiveDelete(ValueMapCache &Cache, Instruction *I) { if (!I || !I->use_empty()) return; assert(I->getParent() && "Inst not in basic block!"); -#ifdef DEBUG_EXPR_CONVERT - //cerr << "VH DELETING: " << (void*)I << " " << I; -#endif + //DEBUG(cerr << "VH DELETING: " << (void*)I << " " << I); for (User::op_iterator OI = I->op_begin(), OE = I->op_end(); OI != OE; ++OI) - if (Instruction *U = dyn_cast(*OI)) { + if (Instruction *U = dyn_cast(OI->get())) { *OI = 0; RecursiveDelete(Cache, U); } @@ -1229,8 +1241,7 @@ ValueHandle::~ValueHandle() { // RecursiveDelete(Cache, dyn_cast(V)); } else { -#ifdef DEBUG_EXPR_CONVERT - //cerr << "VH RELEASING: " << (void*)Operands[0].get() << " " << Operands[0]->use_size() << " " << Operands[0]; -#endif + //DEBUG(cerr << "VH RELEASING: " << (void*)Operands[0].get() << " " + // << Operands[0]->use_size() << " " << Operands[0]); } }