From: Misha Brukman Date: Tue, 20 May 2003 18:45:36 +0000 (+0000) Subject: s/convertable/convertible/g X-Git-Url: http://demsky.eecs.uci.edu/git/?a=commitdiff_plain;h=f117cc9ee656fa31ea933127757ffc9cd5f21a76;p=oota-llvm.git s/convertable/convertible/g git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@6248 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/include/llvm/Type.h b/include/llvm/Type.h index 3cf08a3bb52..8a420ea805f 100644 --- a/include/llvm/Type.h +++ b/include/llvm/Type.h @@ -157,10 +157,10 @@ public: /// inline bool isRecursive() const { return Recursive; } - /// isLosslesslyConvertableTo - Return true if this type can be converted to + /// isLosslesslyConvertibleTo - Return true if this type can be converted to /// 'Ty' without any reinterpretation of bits. For example, uint to int. /// - bool isLosslesslyConvertableTo(const Type *Ty) const; + bool isLosslesslyConvertibleTo(const Type *Ty) const; /// Here are some useful little methods to query what type derived types are diff --git a/lib/Analysis/DataStructure/DataStructure.cpp b/lib/Analysis/DataStructure/DataStructure.cpp index 1aad8cf69ee..4f774acb0ad 100644 --- a/lib/Analysis/DataStructure/DataStructure.cpp +++ b/lib/Analysis/DataStructure/DataStructure.cpp @@ -336,8 +336,8 @@ bool DSNode::mergeTypeInfo(const Type *NewTy, unsigned Offset, // Check to see if we have a compatible, but different type... if (NewTySize == SubTypeSize) { - // Check to see if this type is obviously convertable... int -> uint f.e. - if (NewTy->isLosslesslyConvertableTo(SubType)) + // Check to see if this type is obviously convertible... int -> uint f.e. + if (NewTy->isLosslesslyConvertibleTo(SubType)) return false; // Check to see if we have a pointer & integer mismatch going on here, diff --git a/lib/Analysis/Expressions.cpp b/lib/Analysis/Expressions.cpp index bfab20c42c8..513efe0ac22 100644 --- a/lib/Analysis/Expressions.cpp +++ b/lib/Analysis/Expressions.cpp @@ -318,7 +318,7 @@ ExprType ClassifyExpression(Value *Expr) { DestTy = Type::ULongTy; // Pointer types are represented as ulong /* - if (!Src.getExprType(0)->isLosslesslyConvertableTo(DestTy)) { + if (!Src.getExprType(0)->isLosslesslyConvertibleTo(DestTy)) { if (Src.ExprTy != ExprType::Constant) return I; // Converting cast, and not a constant value... } diff --git a/lib/Transforms/ExprTypeConvert.cpp b/lib/Transforms/ExprTypeConvert.cpp index b1320185876..044e1ade6a8 100644 --- a/lib/Transforms/ExprTypeConvert.cpp +++ b/lib/Transforms/ExprTypeConvert.cpp @@ -2,7 +2,7 @@ // // This file implements the part of level raising that checks to see if it is // possible to coerce an entire expression tree into a different type. If -// convertable, other routines from this file will do the conversion. +// convertible, other routines from this file will do the conversion. // //===----------------------------------------------------------------------===// @@ -17,7 +17,7 @@ #include using std::cerr; -static bool OperandConvertableToType(User *U, Value *V, const Type *Ty, +static bool OperandConvertibleToType(User *U, Value *V, const Type *Ty, ValueTypeCache &ConvertedTypes, const TargetData &TD); @@ -35,7 +35,7 @@ static void ConvertOperandToType(User *U, Value *OldVal, Value *NewVal, // If these conditions hold, we convert the malloc to allocate an [RTy] // element. TODO: This comment is out of date WRT arrays // -static bool MallocConvertableToType(MallocInst *MI, const Type *Ty, +static bool MallocConvertibleToType(MallocInst *MI, const Type *Ty, ValueTypeCache &CTMap, const TargetData &TD) { if (!isa(Ty)) return false; // Malloc always returns pointers @@ -132,8 +132,8 @@ static Instruction *ConvertMallocToType(MallocInst *MI, const Type *Ty, } -// ExpressionConvertableToType - Return true if it is possible -bool ExpressionConvertableToType(Value *V, const Type *Ty, +// ExpressionConvertibleToType - Return true if it is possible +bool ExpressionConvertibleToType(Value *V, const Type *Ty, ValueTypeCache &CTMap, const TargetData &TD) { // Expression type must be holdable in a register. if (!Ty->isFirstClassType()) @@ -158,8 +158,8 @@ bool ExpressionConvertableToType(Value *V, const Type *Ty, switch (I->getOpcode()) { case Instruction::Cast: // We can convert the expr if the cast destination type is losslessly - // convertable to the requested type. - if (!Ty->isLosslesslyConvertableTo(I->getType())) return false; + // convertible to the requested type. + if (!Ty->isLosslesslyConvertibleTo(I->getType())) return false; // 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 * * @@ -175,8 +175,8 @@ bool ExpressionConvertableToType(Value *V, const Type *Ty, case Instruction::Add: case Instruction::Sub: if (!Ty->isInteger() && !Ty->isFloatingPoint()) return false; - if (!ExpressionConvertableToType(I->getOperand(0), Ty, CTMap, TD) || - !ExpressionConvertableToType(I->getOperand(1), Ty, CTMap, TD)) + if (!ExpressionConvertibleToType(I->getOperand(0), Ty, CTMap, TD) || + !ExpressionConvertibleToType(I->getOperand(1), Ty, CTMap, TD)) return false; break; case Instruction::Shr: @@ -185,13 +185,13 @@ bool ExpressionConvertableToType(Value *V, const Type *Ty, // FALL THROUGH case Instruction::Shl: if (!Ty->isInteger()) return false; - if (!ExpressionConvertableToType(I->getOperand(0), Ty, CTMap, TD)) + if (!ExpressionConvertibleToType(I->getOperand(0), Ty, CTMap, TD)) return false; break; case Instruction::Load: { LoadInst *LI = cast(I); - if (!ExpressionConvertableToType(LI->getPointerOperand(), + if (!ExpressionConvertibleToType(LI->getPointerOperand(), PointerType::get(Ty), CTMap, TD)) return false; break; @@ -199,18 +199,18 @@ bool ExpressionConvertableToType(Value *V, const Type *Ty, case Instruction::PHINode: { PHINode *PN = cast(I); for (unsigned i = 0; i < PN->getNumIncomingValues(); ++i) - if (!ExpressionConvertableToType(PN->getIncomingValue(i), Ty, CTMap, TD)) + if (!ExpressionConvertibleToType(PN->getIncomingValue(i), Ty, CTMap, TD)) return false; break; } case Instruction::Malloc: - if (!MallocConvertableToType(cast(I), Ty, CTMap, TD)) + if (!MallocConvertibleToType(cast(I), Ty, CTMap, TD)) return false; break; case Instruction::GetElementPtr: { - // GetElementPtr's are directly convertable to a pointer type if they have + // GetElementPtr's are directly convertible to a pointer type if they have // a number of zeros at the end. Because removing these values does not // change the logical offset of the GEP, it is okay and fair to remove them. // This can change this: @@ -261,9 +261,9 @@ bool ExpressionConvertableToType(Value *V, const Type *Ty, // the appropriate size... if so, allow it. // std::vector Indices; - const Type *ElTy = ConvertableToGEP(PTy, I->getOperand(1), Indices, TD); + const Type *ElTy = ConvertibleToGEP(PTy, I->getOperand(1), Indices, TD); if (ElTy == PVTy) { - if (!ExpressionConvertableToType(I->getOperand(0), + if (!ExpressionConvertibleToType(I->getOperand(0), PointerType::get(ElTy), CTMap, TD)) return false; // Can't continue, ExConToTy might have polluted set! break; @@ -281,7 +281,7 @@ bool ExpressionConvertableToType(Value *V, const Type *Ty, TD.getTypeSize(PTy->getElementType()) == TD.getTypeSize(GEP->getType()->getElementType())) { const PointerType *NewSrcTy = PointerType::get(PVTy); - if (!ExpressionConvertableToType(I->getOperand(0), NewSrcTy, CTMap, TD)) + if (!ExpressionConvertibleToType(I->getOperand(0), NewSrcTy, CTMap, TD)) return false; break; } @@ -302,7 +302,7 @@ bool ExpressionConvertableToType(Value *V, const Type *Ty, FT->getParamTypes().end()); const FunctionType *NewTy = FunctionType::get(Ty, ArgTys, FT->isVarArg()); - if (!ExpressionConvertableToType(I->getOperand(0), + if (!ExpressionConvertibleToType(I->getOperand(0), PointerType::get(NewTy), CTMap, TD)) return false; break; @@ -311,12 +311,12 @@ bool ExpressionConvertableToType(Value *V, const Type *Ty, return false; } - // Expressions are only convertable if all of the users of the expression can + // Expressions are only convertible if all of the users of the expression can // have this value converted. This makes use of the map to avoid infinite // recursion. // for (Value::use_iterator It = I->use_begin(), E = I->use_end(); It != E; ++It) - if (!OperandConvertableToType(*It, I, Ty, CTMap, TD)) + if (!OperandConvertibleToType(*It, I, Ty, CTMap, TD)) return false; return true; @@ -425,7 +425,7 @@ Value *ConvertExpressionToType(Value *V, const Type *Ty, ValueMapCache &VMC, } case Instruction::GetElementPtr: { - // GetElementPtr's are directly convertable to a pointer type if they have + // GetElementPtr's are directly convertible to a pointer type if they have // a number of zeros at the end. Because removing these values does not // change the logical offset of the GEP, it is okay and fair to remove them. // This can change this: @@ -471,7 +471,7 @@ Value *ConvertExpressionToType(Value *V, const Type *Ty, ValueMapCache &VMC, // the appropriate size... if so, allow it. // std::vector Indices; - const Type *ElTy = ConvertableToGEP(NewSrcTy, I->getOperand(1), + const Type *ElTy = ConvertibleToGEP(NewSrcTy, I->getOperand(1), Indices, TD, &It); if (ElTy) { assert(ElTy == PVTy && "Internal error, setup wrong!"); @@ -527,7 +527,7 @@ Value *ConvertExpressionToType(Value *V, const Type *Ty, ValueMapCache &VMC, break; } default: - assert(0 && "Expression convertable, but don't know how to convert?"); + assert(0 && "Expression convertible, but don't know how to convert?"); return 0; } @@ -538,7 +538,7 @@ Value *ConvertExpressionToType(Value *V, const Type *Ty, ValueMapCache &VMC, // Add the instruction to the expression map VMC.ExprMap[I] = Res; - // Expressions are only convertable if all of the users of the expression can + // Expressions are only convertible if all of the users of the expression can // have this value converted. This makes use of the map to avoid infinite // recursion. // @@ -558,8 +558,8 @@ Value *ConvertExpressionToType(Value *V, const Type *Ty, ValueMapCache &VMC, -// ValueConvertableToType - Return true if it is possible -bool ValueConvertableToType(Value *V, const Type *Ty, +// ValueConvertibleToType - Return true if it is possible +bool ValueConvertibleToType(Value *V, const Type *Ty, ValueTypeCache &ConvertedTypes, const TargetData &TD) { ValueTypeCache::iterator I = ConvertedTypes.find(V); @@ -571,7 +571,7 @@ bool ValueConvertableToType(Value *V, const Type *Ty, // if (V->getType() != Ty) { for (Value::use_iterator I = V->use_begin(), E = V->use_end(); I != E; ++I) - if (!OperandConvertableToType(*I, V, Ty, ConvertedTypes, TD)) + if (!OperandConvertibleToType(*I, V, Ty, ConvertedTypes, TD)) return false; } @@ -582,13 +582,13 @@ bool ValueConvertableToType(Value *V, const Type *Ty, -// OperandConvertableToType - Return true if it is possible to convert operand +// OperandConvertibleToType - Return true if it is possible to convert operand // V of User (instruction) U to the specified type. This is true iff it is // possible to change the specified instruction to accept this. CTMap is a map // of converted types, so that circular definitions will see the future type of // the expression, not the static current type. // -static bool OperandConvertableToType(User *U, Value *V, const Type *Ty, +static bool OperandConvertibleToType(User *U, Value *V, const Type *Ty, ValueTypeCache &CTMap, const TargetData &TD) { // if (V->getType() == Ty) return true; // Operand already the right type? @@ -604,10 +604,10 @@ static bool OperandConvertableToType(User *U, Value *V, const Type *Ty, case Instruction::Cast: assert(I->getOperand(0) == V); // We can convert the expr if the cast destination type is losslessly - // convertable to the requested type. + // convertible to the requested type. // Also, do not change a cast that is a noop cast. For all intents and // purposes it should be eliminated. - if (!Ty->isLosslesslyConvertableTo(I->getOperand(0)->getType()) || + if (!Ty->isLosslesslyConvertibleTo(I->getOperand(0)->getType()) || I->getType() == I->getOperand(0)->getType()) return false; @@ -617,7 +617,7 @@ static bool OperandConvertableToType(User *U, Value *V, const Type *Ty, // signedness doesn't change... or if the current cast is not a lossy // conversion. // - if (!I->getType()->isLosslesslyConvertableTo(I->getOperand(0)->getType()) && + if (!I->getType()->isLosslesslyConvertibleTo(I->getOperand(0)->getType()) && I->getOperand(0)->getType()->isSigned() != Ty->isSigned()) return false; @@ -636,15 +636,15 @@ static bool OperandConvertableToType(User *U, Value *V, const Type *Ty, if (isa(Ty)) { Value *IndexVal = I->getOperand(V == I->getOperand(0) ? 1 : 0); std::vector Indices; - if (const Type *ETy = ConvertableToGEP(Ty, IndexVal, Indices, TD)) { + if (const Type *ETy = ConvertibleToGEP(Ty, IndexVal, Indices, TD)) { const Type *RetTy = PointerType::get(ETy); // Only successful if we can convert this type to the required type - if (ValueConvertableToType(I, RetTy, CTMap, TD)) { + if (ValueConvertibleToType(I, RetTy, CTMap, TD)) { CTMap[I] = RetTy; return true; } - // We have to return failure here because ValueConvertableToType could + // We have to return failure here because ValueConvertibleToType could // have polluted our map return false; } @@ -654,13 +654,13 @@ static bool OperandConvertableToType(User *U, Value *V, const Type *Ty, if (!Ty->isInteger() && !Ty->isFloatingPoint()) return false; Value *OtherOp = I->getOperand((V == I->getOperand(0)) ? 1 : 0); - return ValueConvertableToType(I, Ty, CTMap, TD) && - ExpressionConvertableToType(OtherOp, Ty, CTMap, TD); + return ValueConvertibleToType(I, Ty, CTMap, TD) && + ExpressionConvertibleToType(OtherOp, Ty, CTMap, TD); } case Instruction::SetEQ: case Instruction::SetNE: { Value *OtherOp = I->getOperand((V == I->getOperand(0)) ? 1 : 0); - return ExpressionConvertableToType(OtherOp, Ty, CTMap, TD); + return ExpressionConvertibleToType(OtherOp, Ty, CTMap, TD); } case Instruction::Shr: if (Ty->isSigned() != V->getType()->isSigned()) return false; @@ -668,7 +668,7 @@ static bool OperandConvertableToType(User *U, Value *V, const Type *Ty, case Instruction::Shl: if (I->getOperand(1) == V) return false; // Cannot change shift amount type if (!Ty->isInteger()) return false; - return ValueConvertableToType(I, Ty, CTMap, TD); + return ValueConvertibleToType(I, Ty, CTMap, TD); case Instruction::Free: assert(I->getOperand(0) == V); @@ -697,7 +697,7 @@ static bool OperandConvertableToType(User *U, Value *V, const Type *Ty, if (TD.getTypeSize(LoadedTy) != TD.getTypeSize(LI->getType())) return false; - return ValueConvertableToType(LI, LoadedTy, CTMap, TD); + return ValueConvertibleToType(LI, LoadedTy, CTMap, TD); } return false; @@ -743,7 +743,7 @@ static bool OperandConvertableToType(User *U, Value *V, const Type *Ty, // Can convert the store if we can convert the pointer operand to match // the new value type... - return ExpressionConvertableToType(I->getOperand(1), PointerType::get(Ty), + return ExpressionConvertibleToType(I->getOperand(1), PointerType::get(Ty), CTMap, TD); } else if (const PointerType *PT = dyn_cast(Ty)) { const Type *ElTy = PT->getElementType(); @@ -766,8 +766,8 @@ static bool OperandConvertableToType(User *U, Value *V, const Type *Ty, TD.getTypeSize(ElTy) != TD.getTypeSize(I->getOperand(0)->getType())) return false; - // Can convert store if the incoming value is convertable... - return ExpressionConvertableToType(I->getOperand(0), ElTy, CTMap, TD); + // Can convert store if the incoming value is convertible... + return ExpressionConvertibleToType(I->getOperand(0), ElTy, CTMap, TD); } return false; } @@ -786,7 +786,7 @@ static bool OperandConvertableToType(User *U, Value *V, const Type *Ty, Instruction *TempScale = 0; // If the old data element is not unit sized, we have to create a scale - // instruction so that ConvertableToGEP will know the REAL amount we are + // instruction so that ConvertibleToGEP will know the REAL amount we are // indexing by. Note that this is never inserted into the instruction // stream, so we have to delete it when we're done. // @@ -801,20 +801,20 @@ static bool OperandConvertableToType(User *U, Value *V, const Type *Ty, // be converted to the appropriate size... if so, allow it. // std::vector Indices; - const Type *ElTy = ConvertableToGEP(Ty, Index, Indices, TD); + const Type *ElTy = ConvertibleToGEP(Ty, Index, Indices, TD); delete TempScale; // Free our temporary multiply if we made it if (ElTy == 0) return false; // Cannot make conversion... - return ValueConvertableToType(I, PointerType::get(ElTy), CTMap, TD); + return ValueConvertibleToType(I, PointerType::get(ElTy), CTMap, TD); } return false; case Instruction::PHINode: { PHINode *PN = cast(I); for (unsigned i = 0; i < PN->getNumIncomingValues(); ++i) - if (!ExpressionConvertableToType(PN->getIncomingValue(i), Ty, CTMap, TD)) + if (!ExpressionConvertibleToType(PN->getIncomingValue(i), Ty, CTMap, TD)) return false; - return ValueConvertableToType(PN, Ty, CTMap, TD); + return ValueConvertibleToType(PN, Ty, CTMap, TD); } case Instruction::Call: { @@ -851,21 +851,21 @@ static bool OperandConvertableToType(User *U, Value *V, const Type *Ty, // 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, + // themselves. Note that we do not require operands to be convertible, // we can insert casts if they are convertible but not compatible. The // reason for this is that we prefer to have resolved functions but casted // arguments if possible. // const FunctionType::ParamTypes &PTs = FTy->getParamTypes(); for (unsigned i = 0, NA = PTs.size(); i < NA; ++i) - if (!PTs[i]->isLosslesslyConvertableTo(I->getOperand(i+1)->getType())) + if (!PTs[i]->isLosslesslyConvertibleTo(I->getOperand(i+1)->getType())) return false; // Operands must have compatible types! // Okay, at this point, we know that all of the arguments can be // converted. We succeed if we can change the return type if // neccesary... // - return ValueConvertableToType(I, FTy->getReturnType(), CTMap, TD); + return ValueConvertibleToType(I, FTy->getReturnType(), CTMap, TD); } const PointerType *MPtr = cast(I->getOperand(0)->getType()); @@ -878,7 +878,7 @@ static bool OperandConvertableToType(User *U, Value *V, const Type *Ty, // If we get this far, we know the value is in the varargs section of the // function! We can convert if we don't reinterpret the value... // - return Ty->isLosslesslyConvertableTo(V->getType()); + return Ty->isLosslesslyConvertibleTo(V->getType()); } } return false; @@ -912,7 +912,7 @@ static void ConvertOperandToType(User *U, Value *OldVal, Value *NewVal, return; - Instruction *I = cast(U); // Only Instructions convertable + Instruction *I = cast(U); // Only Instructions convertible BasicBlock *BB = I->getParent(); assert(BB != 0 && "Instruction not embedded in basic block!"); @@ -951,13 +951,13 @@ static void ConvertOperandToType(User *U, Value *OldVal, Value *NewVal, std::vector Indices; BasicBlock::iterator It = I; - if (const Type *ETy = ConvertableToGEP(NewTy, IndexVal, Indices, TD,&It)){ + if (const Type *ETy = ConvertibleToGEP(NewTy, IndexVal, Indices, TD,&It)){ // If successful, convert the add to a GEP //const Type *RetTy = PointerType::get(ETy); // First operand is actually the given pointer... Res = new GetElementPtrInst(NewVal, Indices, Name); assert(cast(Res->getType())->getElementType() == ETy && - "ConvertableToGEP broken!"); + "ConvertibleToGEP broken!"); break; } } @@ -1023,7 +1023,7 @@ static void ConvertOperandToType(User *U, Value *OldVal, Value *NewVal, ValueMapCache::ExprMapTy::iterator VMCI = VMC.ExprMap.find(I->getOperand(1)); if (VMCI != VMC.ExprMap.end()) { - // Comments describing this stuff are in the OperandConvertableToType + // Comments describing this stuff are in the OperandConvertibleToType // switch statement for Store... // const Type *ElTy = @@ -1105,11 +1105,11 @@ static void ConvertOperandToType(User *U, Value *OldVal, Value *NewVal, // Perform the conversion now... // std::vector Indices; - const Type *ElTy = ConvertableToGEP(NewVal->getType(),Index,Indices,TD,&It); + const Type *ElTy = ConvertibleToGEP(NewVal->getType(),Index,Indices,TD,&It); assert(ElTy != 0 && "GEP Conversion Failure!"); Res = new GetElementPtrInst(NewVal, Indices, Name); assert(Res->getType() == PointerType::get(ElTy) && - "ConvertableToGet failed!"); + "ConvertibleToGet failed!"); } #if 0 if (I->getType() == PointerType::get(Type::SByteTy)) { @@ -1122,7 +1122,7 @@ static void ConvertOperandToType(User *U, Value *OldVal, Value *NewVal, // be converted to the appropriate size... if so, allow it. // std::vector Indices; - const Type *ElTy = ConvertableToGEP(NewVal->getType(), I->getOperand(1), + const Type *ElTy = ConvertibleToGEP(NewVal->getType(), I->getOperand(1), Indices, TD, &It); assert(ElTy != 0 && "GEP Conversion Failure!"); @@ -1169,7 +1169,7 @@ static void ConvertOperandToType(User *U, Value *OldVal, Value *NewVal, // 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 + // convertible, we can insert casts if they are convertible but not // compatible. The reason for this is that we prefer to have resolved // functions but casted arguments if possible. // @@ -1200,7 +1200,7 @@ static void ConvertOperandToType(User *U, Value *OldVal, Value *NewVal, break; } default: - assert(0 && "Expression convertable, but don't know how to convert?"); + assert(0 && "Expression convertible, but don't know how to convert?"); return; } diff --git a/lib/Transforms/LevelRaise.cpp b/lib/Transforms/LevelRaise.cpp index 01607e1c97d..b678dffd73e 100644 --- a/lib/Transforms/LevelRaise.cpp +++ b/lib/Transforms/LevelRaise.cpp @@ -90,7 +90,7 @@ Pass *createRaisePointerReferencesPass() { // cast instruction would cause the underlying bits to change. // static inline bool isReinterpretingCast(const CastInst *CI) { - return!CI->getOperand(0)->getType()->isLosslesslyConvertableTo(CI->getType()); + return!CI->getOperand(0)->getType()->isLosslesslyConvertibleTo(CI->getType()); } @@ -127,8 +127,8 @@ static bool HandleCastToPointer(BasicBlock::iterator BI, std::vector Indices; Value *Src = CI.getOperand(0); - const Type *Result = ConvertableToGEP(DestPTy, Src, Indices, TD, &BI); - if (Result == 0) return false; // Not convertable... + const Type *Result = ConvertibleToGEP(DestPTy, Src, Indices, TD, &BI); + if (Result == 0) return false; // Not convertible... // Cannot handle subtracts if there is more than one index required... if (HasSubUse && Indices.size() != 1) return false; @@ -212,8 +212,8 @@ static bool PeepholeOptimizeAddCast(BasicBlock *BB, BasicBlock::iterator &BI, return false; std::vector Indices; - if (!ConvertableToGEP(SrcPtr->getType(), OffsetVal, Indices, TD, &BI)) - return false; // Not convertable... perhaps next time + if (!ConvertibleToGEP(SrcPtr->getType(), OffsetVal, Indices, TD, &BI)) + return false; // Not convertible... perhaps next time if (getPointedToComposite(AddOp1->getType())) { // case 1 PRINT_PEEPHOLE2("add-to-gep1:in", AddOp2, *BI); @@ -271,7 +271,7 @@ bool RPR::PeepholeOptimize(BasicBlock *BB, BasicBlock::iterator &BI) { // destination type of the cast... // ConvertedTypes[CI] = CI->getType(); // Make sure the cast doesn't change - if (ExpressionConvertableToType(Src, DestTy, ConvertedTypes, TD)) { + if (ExpressionConvertibleToType(Src, DestTy, ConvertedTypes, TD)) { PRINT_PEEPHOLE3("CAST-SRC-EXPR-CONV:in ", Src, CI, BB->getParent()); DEBUG(cerr << "\nCONVERTING SRC EXPR TYPE:\n"); @@ -299,7 +299,7 @@ bool RPR::PeepholeOptimize(BasicBlock *BB, BasicBlock::iterator &BI) { ConvertedTypes.clear(); // Make sure the source doesn't change type ConvertedTypes[Src] = Src->getType(); - if (ValueConvertableToType(CI, Src->getType(), ConvertedTypes, TD)) { + if (ValueConvertibleToType(CI, Src->getType(), ConvertedTypes, TD)) { PRINT_PEEPHOLE3("CAST-DEST-EXPR-CONV:in ", Src, CI, BB->getParent()); DEBUG(cerr << "\nCONVERTING EXPR TYPE:\n"); @@ -357,7 +357,7 @@ bool RPR::PeepholeOptimize(BasicBlock *BB, BasicBlock::iterator &BI) { } // If it doesn't have an add use, check to see if the dest type is - // losslessly convertable to one of the types in the start of the struct + // losslessly convertible to one of the types in the start of the struct // type. // if (!HasAddUse) { @@ -386,7 +386,7 @@ bool RPR::PeepholeOptimize(BasicBlock *BB, BasicBlock::iterator &BI) { Indices.push_back(Constant::getNullValue(CurCTy->getIndexType())); // Did we find what we're looking for? - if (ElTy->isLosslesslyConvertableTo(DestPointedTy)) break; + if (ElTy->isLosslesslyConvertibleTo(DestPointedTy)) break; // Nope, go a level deeper. ++Depth; @@ -421,7 +421,7 @@ bool RPR::PeepholeOptimize(BasicBlock *BB, BasicBlock::iterator &BI) { Value *Pointer = SI->getPointerOperand(); // Peephole optimize the following instructions: - // %t = cast * %P to * ;; If T1 is losslessly convertable to T2 + // %t = cast * %P to * ;; If T1 is losslessly convertible to T2 // store %V, * %t // // Into: @@ -436,8 +436,8 @@ bool RPR::PeepholeOptimize(BasicBlock *BB, BasicBlock::iterator &BI) { if (CastInst *CI = dyn_cast(Pointer)) if (Value *CastSrc = CI->getOperand(0)) // CSPT = CastSrcPointerType if (const PointerType *CSPT = dyn_cast(CastSrc->getType())) - // convertable types? - if (Val->getType()->isLosslesslyConvertableTo(CSPT->getElementType())) { + // convertible types? + if (Val->getType()->isLosslesslyConvertibleTo(CSPT->getElementType())) { PRINT_PEEPHOLE3("st-src-cast:in ", Pointer, Val, SI); // Insert the new T cast instruction... stealing old T's name @@ -459,7 +459,7 @@ bool RPR::PeepholeOptimize(BasicBlock *BB, BasicBlock::iterator &BI) { cast(Pointer->getType())->getElementType(); // Peephole optimize the following instructions: - // %Val = cast * to * ;; If T1 is losslessly convertable to T2 + // %Val = cast * to * ;; If T1 is losslessly convertible to T2 // %t = load * %P // // Into: @@ -474,8 +474,8 @@ bool RPR::PeepholeOptimize(BasicBlock *BB, BasicBlock::iterator &BI) { if (CastInst *CI = dyn_cast(Pointer)) if (Value *CastSrc = CI->getOperand(0)) // CSPT = CastSrcPointerType if (const PointerType *CSPT = dyn_cast(CastSrc->getType())) - // convertable types? - if (PtrElType->isLosslesslyConvertableTo(CSPT->getElementType())) { + // convertible types? + if (PtrElType->isLosslesslyConvertibleTo(CSPT->getElementType())) { PRINT_PEEPHOLE2("load-src-cast:in ", Pointer, LI); // Create the new load instruction... loading the pre-casted value diff --git a/lib/Transforms/Scalar/InstructionCombining.cpp b/lib/Transforms/Scalar/InstructionCombining.cpp index d00cefd37d4..d73ee1e40cd 100644 --- a/lib/Transforms/Scalar/InstructionCombining.cpp +++ b/lib/Transforms/Scalar/InstructionCombining.cpp @@ -811,7 +811,7 @@ static inline bool isEliminableCastOfCast(const CastInst &CI, // It is legal to eliminate the instruction if casting A->B->A if the sizes // are identical and the bits don't get reinterpreted (for example // int->float->int would not be allowed) - if (SrcTy == DstTy && SrcTy->isLosslesslyConvertableTo(MidTy)) + if (SrcTy == DstTy && SrcTy->isLosslesslyConvertibleTo(MidTy)) return true; // Allow free casting and conversion of sizes as long as the sign doesn't diff --git a/lib/Transforms/TransformInternals.cpp b/lib/Transforms/TransformInternals.cpp index d3641e6f0df..56c03b991f0 100644 --- a/lib/Transforms/TransformInternals.cpp +++ b/lib/Transforms/TransformInternals.cpp @@ -74,12 +74,12 @@ const Type *getStructOffsetType(const Type *Ty, unsigned &Offset, return LeafTy; } -// ConvertableToGEP - This function returns true if the specified value V is +// ConvertibleToGEP - 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 // -const Type *ConvertableToGEP(const Type *Ty, Value *OffsetVal, +const Type *ConvertibleToGEP(const Type *Ty, Value *OffsetVal, std::vector &Indices, const TargetData &TD, BasicBlock::iterator *BI) { diff --git a/lib/Transforms/TransformInternals.h b/lib/Transforms/TransformInternals.h index 9f6eb7954bc..8cab4293496 100644 --- a/lib/Transforms/TransformInternals.h +++ b/lib/Transforms/TransformInternals.h @@ -30,7 +30,7 @@ static inline const CompositeType *getPointedToComposite(const Type *Ty) { return PT ? dyn_cast(PT->getElementType()) : 0; } -// ConvertableToGEP - This function returns true if the specified value V is +// ConvertibleToGEP - 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 @@ -39,7 +39,7 @@ static inline const CompositeType *getPointedToComposite(const Type *Ty) { // If BI is nonnull, cast instructions are inserted as appropriate for the // arguments of the getelementptr. // -const Type *ConvertableToGEP(const Type *Ty, Value *V, +const Type *ConvertibleToGEP(const Type *Ty, Value *V, std::vector &Indices, const TargetData &TD, BasicBlock::iterator *BI = 0); @@ -105,13 +105,13 @@ struct ValueMapCache { }; -bool ExpressionConvertableToType(Value *V, const Type *Ty, ValueTypeCache &Map, +bool ExpressionConvertibleToType(Value *V, const Type *Ty, ValueTypeCache &Map, const TargetData &TD); Value *ConvertExpressionToType(Value *V, const Type *Ty, ValueMapCache &VMC, const TargetData &TD); -// ValueConvertableToType - Return true if it is possible -bool ValueConvertableToType(Value *V, const Type *Ty, +// ValueConvertibleToType - Return true if it is possible +bool ValueConvertibleToType(Value *V, const Type *Ty, ValueTypeCache &ConvertedTypes, const TargetData &TD); diff --git a/lib/VMCore/Type.cpp b/lib/VMCore/Type.cpp index 398937aa181..237449302c8 100644 --- a/lib/VMCore/Type.cpp +++ b/lib/VMCore/Type.cpp @@ -82,10 +82,10 @@ const Type *Type::getPrimitiveType(PrimitiveID IDNumber) { } } -// isLosslesslyConvertableTo - Return true if this type can be converted to +// isLosslesslyConvertibleTo - Return true if this type can be converted to // 'Ty' without any reinterpretation of bits. For example, uint to int. // -bool Type::isLosslesslyConvertableTo(const Type *Ty) const { +bool Type::isLosslesslyConvertibleTo(const Type *Ty) const { if (this == Ty) return true; if ((!isPrimitiveType() && !isa(this)) || (!isa(Ty) && !Ty->isPrimitiveType())) return false;