6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-03-15 22:32:35 +00:00
Code Issues Projects Releases Wiki Activity

s/convertable/convertible/g

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@6248 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Misha Brukman 2003-05-20 18:45:36 +00:00
parent d5bd008265
commit f117cc9ee6
9 changed files with 91 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/llvm/Type.h
View File

@ -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

4
lib/Analysis/DataStructure/DataStructure.cpp
View File

@ -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,

2
lib/Analysis/Expressions.cpp
View File

@ -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...
}

122
lib/Transforms/ExprTypeConvert.cpp
View File

@ -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 <algorithm>
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<PointerType>(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<LoadInst>(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<PHINode>(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<MallocInst>(I), Ty, CTMap, TD))
if (!MallocConvertibleToType(cast<MallocInst>(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<Value*> 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<Value*> 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<PointerType>(Ty)) {
Value *IndexVal = I->getOperand(V == I->getOperand(0) ? 1 : 0);
std::vector<Value*> 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<PointerType>(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<Value*> 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<PHINode>(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<PointerType>(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<Instruction>(U); // Only Instructions convertable
Instruction *I = cast<Instruction>(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<Value*> 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<PointerType>(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<Value*> 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<Value*> 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;
}

30
lib/Transforms/LevelRaise.cpp
View File

@ -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<Value*> 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<Value*> 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 <T1>* %P to <T2> * ;; If T1 is losslessly convertable to T2
// %t = cast <T1>* %P to <T2> * ;; If T1 is losslessly convertible to T2
// store <T2> %V, <T2>* %t
//
// Into:
@ -436,8 +436,8 @@ bool RPR::PeepholeOptimize(BasicBlock *BB, BasicBlock::iterator &BI) {
if (CastInst *CI = dyn_cast<CastInst>(Pointer))
if (Value *CastSrc = CI->getOperand(0)) // CSPT = CastSrcPointerType
if (const PointerType *CSPT = dyn_cast<PointerType>(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<PointerType>(Pointer->getType())->getElementType();
// Peephole optimize the following instructions:
// %Val = cast <T1>* to <T2>* ;; If T1 is losslessly convertable to T2
// %Val = cast <T1>* to <T2>* ;; If T1 is losslessly convertible to T2
// %t = load <T2>* %P
//
// Into:
@ -474,8 +474,8 @@ bool RPR::PeepholeOptimize(BasicBlock *BB, BasicBlock::iterator &BI) {
if (CastInst *CI = dyn_cast<CastInst>(Pointer))
if (Value *CastSrc = CI->getOperand(0)) // CSPT = CastSrcPointerType
if (const PointerType *CSPT = dyn_cast<PointerType>(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

2
lib/Transforms/Scalar/InstructionCombining.cpp
View File

@ -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

4
lib/Transforms/TransformInternals.cpp
View File

@ -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<Value*> &Indices,
const TargetData &TD,
BasicBlock::iterator *BI) {

10
lib/Transforms/TransformInternals.h
View File

@ -30,7 +30,7 @@ static inline const CompositeType *getPointedToComposite(const Type *Ty) {
return PT ? dyn_cast<CompositeType>(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<Value*> &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);

4
lib/VMCore/Type.cpp
View File

@ -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<PointerType>(this)) ||
(!isa<PointerType>(Ty) && !Ty->isPrimitiveType())) return false;