RPCS3/llvm
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm.git synced 2025-04-13 03:21:07 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Remove trailing whitespace.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@173322 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Craig Topper 2013-01-24 05:22:40 +00:00
parent 0ac7e6f293
commit b57c292d29
1 changed files with 134 additions and 134 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

268
lib/Transforms/InstCombine/InstCombineCasts.cpp
View File

@ -30,7 +30,7 @@ static Value *DecomposeSimpleLinearExpr(Value *Val, unsigned &Scale,
Scale = 0; Scale = 0;
return ConstantInt::get(Val->getType(), 0); return ConstantInt::get(Val->getType(), 0);
} }
if (BinaryOperator *I = dyn_cast<BinaryOperator>(Val)) { if (BinaryOperator *I = dyn_cast<BinaryOperator>(Val)) {
// Cannot look past anything that might overflow. // Cannot look past anything that might overflow.
OverflowingBinaryOperator *OBI = dyn_cast<OverflowingBinaryOperator>(Val); OverflowingBinaryOperator *OBI = dyn_cast<OverflowingBinaryOperator>(Val);
@ -47,19 +47,19 @@ static Value *DecomposeSimpleLinearExpr(Value *Val, unsigned &Scale,
Offset = 0; Offset = 0;
return I->getOperand(0); return I->getOperand(0);
} }
if (I->getOpcode() == Instruction::Mul) { if (I->getOpcode() == Instruction::Mul) {
// This value is scaled by 'RHS'. // This value is scaled by 'RHS'.
Scale = RHS->getZExtValue(); Scale = RHS->getZExtValue();
Offset = 0; Offset = 0;
return I->getOperand(0); return I->getOperand(0);
} }
if (I->getOpcode() == Instruction::Add) { if (I->getOpcode() == Instruction::Add) {
// We have X+C. Check to see if we really have (X*C2)+C1, // We have X+C. Check to see if we really have (X*C2)+C1,
// where C1 is divisible by C2. // where C1 is divisible by C2.
unsigned SubScale; unsigned SubScale;
Value *SubVal = Value *SubVal =
DecomposeSimpleLinearExpr(I->getOperand(0), SubScale, Offset); DecomposeSimpleLinearExpr(I->getOperand(0), SubScale, Offset);
Offset += RHS->getZExtValue(); Offset += RHS->getZExtValue();
Scale = SubScale; Scale = SubScale;
@ -82,7 +82,7 @@ Instruction *InstCombiner::PromoteCastOfAllocation(BitCastInst &CI,
if (!TD) return 0; if (!TD) return 0;
PointerType *PTy = cast<PointerType>(CI.getType()); PointerType *PTy = cast<PointerType>(CI.getType());
BuilderTy AllocaBuilder(*Builder); BuilderTy AllocaBuilder(*Builder);
AllocaBuilder.SetInsertPoint(AI.getParent(), &AI); AllocaBuilder.SetInsertPoint(AI.getParent(), &AI);
@ -110,7 +110,7 @@ Instruction *InstCombiner::PromoteCastOfAllocation(BitCastInst &CI,
uint64_t ArrayOffset; uint64_t ArrayOffset;
Value *NumElements = // See if the array size is a decomposable linear expr. Value *NumElements = // See if the array size is a decomposable linear expr.
DecomposeSimpleLinearExpr(AI.getOperand(0), ArraySizeScale, ArrayOffset); DecomposeSimpleLinearExpr(AI.getOperand(0), ArraySizeScale, ArrayOffset);
// If we can now satisfy the modulus, by using a non-1 scale, we really can // If we can now satisfy the modulus, by using a non-1 scale, we really can
// do the xform. // do the xform.
if ((AllocElTySize*ArraySizeScale) % CastElTySize != 0 || if ((AllocElTySize*ArraySizeScale) % CastElTySize != 0 ||
@ -125,17 +125,17 @@ Instruction *InstCombiner::PromoteCastOfAllocation(BitCastInst &CI,
// Insert before the alloca, not before the cast. // Insert before the alloca, not before the cast.
Amt = AllocaBuilder.CreateMul(Amt, NumElements); Amt = AllocaBuilder.CreateMul(Amt, NumElements);
} }
if (uint64_t Offset = (AllocElTySize*ArrayOffset)/CastElTySize) { if (uint64_t Offset = (AllocElTySize*ArrayOffset)/CastElTySize) {
Value *Off = ConstantInt::get(AI.getArraySize()->getType(), Value *Off = ConstantInt::get(AI.getArraySize()->getType(),
Offset, true); Offset, true);
Amt = AllocaBuilder.CreateAdd(Amt, Off); Amt = AllocaBuilder.CreateAdd(Amt, Off);
} }
AllocaInst *New = AllocaBuilder.CreateAlloca(CastElTy, Amt); AllocaInst *New = AllocaBuilder.CreateAlloca(CastElTy, Amt);
New->setAlignment(AI.getAlignment()); New->setAlignment(AI.getAlignment());
New->takeName(&AI); New->takeName(&AI);
// If the allocation has multiple real uses, insert a cast and change all // If the allocation has multiple real uses, insert a cast and change all
// things that used it to use the new cast. This will also hack on CI, but it // things that used it to use the new cast. This will also hack on CI, but it
// will die soon. // will die soon.
@ -148,10 +148,10 @@ Instruction *InstCombiner::PromoteCastOfAllocation(BitCastInst &CI,
return ReplaceInstUsesWith(CI, New); return ReplaceInstUsesWith(CI, New);
} }
/// EvaluateInDifferentType - Given an expression that /// EvaluateInDifferentType - Given an expression that
/// CanEvaluateTruncated or CanEvaluateSExtd returns true for, actually /// CanEvaluateTruncated or CanEvaluateSExtd returns true for, actually
/// insert the code to evaluate the expression. /// insert the code to evaluate the expression.
Value *InstCombiner::EvaluateInDifferentType(Value *V, Type *Ty, Value *InstCombiner::EvaluateInDifferentType(Value *V, Type *Ty,
bool isSigned) { bool isSigned) {
if (Constant *C = dyn_cast<Constant>(V)) { if (Constant *C = dyn_cast<Constant>(V)) {
C = ConstantExpr::getIntegerCast(C, Ty, isSigned /*Sext or ZExt*/); C = ConstantExpr::getIntegerCast(C, Ty, isSigned /*Sext or ZExt*/);
@ -181,7 +181,7 @@ Value *InstCombiner::EvaluateInDifferentType(Value *V, Type *Ty,
Value *RHS = EvaluateInDifferentType(I->getOperand(1), Ty, isSigned); Value *RHS = EvaluateInDifferentType(I->getOperand(1), Ty, isSigned);
Res = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS); Res = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS);
break; break;
} }
case Instruction::Trunc: case Instruction::Trunc:
case Instruction::ZExt: case Instruction::ZExt:
case Instruction::SExt: case Instruction::SExt:
@ -190,7 +190,7 @@ Value *InstCombiner::EvaluateInDifferentType(Value *V, Type *Ty,
// new. // new.
if (I->getOperand(0)->getType() == Ty) if (I->getOperand(0)->getType() == Ty)
return I->getOperand(0); return I->getOperand(0);
// Otherwise, must be the same type of cast, so just reinsert a new one. // Otherwise, must be the same type of cast, so just reinsert a new one.
// This also handles the case of zext(trunc(x)) -> zext(x). // This also handles the case of zext(trunc(x)) -> zext(x).
Res = CastInst::CreateIntegerCast(I->getOperand(0), Ty, Res = CastInst::CreateIntegerCast(I->getOperand(0), Ty,
@ -212,11 +212,11 @@ Value *InstCombiner::EvaluateInDifferentType(Value *V, Type *Ty,
Res = NPN; Res = NPN;
break; break;
} }
default: default:
// TODO: Can handle more cases here. // TODO: Can handle more cases here.
llvm_unreachable("Unreachable!"); llvm_unreachable("Unreachable!");
} }
Res->takeName(I); Res->takeName(I);
return InsertNewInstWith(Res, *I); return InsertNewInstWith(Res, *I);
} }
@ -224,7 +224,7 @@ Value *InstCombiner::EvaluateInDifferentType(Value *V, Type *Ty,
/// This function is a wrapper around CastInst::isEliminableCastPair. It /// This function is a wrapper around CastInst::isEliminableCastPair. It
/// simply extracts arguments and returns what that function returns. /// simply extracts arguments and returns what that function returns.
static Instruction::CastOps static Instruction::CastOps
isEliminableCastPair( isEliminableCastPair(
const CastInst *CI, ///< The first cast instruction const CastInst *CI, ///< The first cast instruction
unsigned opcode, ///< The opcode of the second cast instruction unsigned opcode, ///< The opcode of the second cast instruction
@ -253,7 +253,7 @@ isEliminableCastPair(
if ((Res == Instruction::IntToPtr && SrcTy != DstIntPtrTy) || if ((Res == Instruction::IntToPtr && SrcTy != DstIntPtrTy) ||
(Res == Instruction::PtrToInt && DstTy != SrcIntPtrTy)) (Res == Instruction::PtrToInt && DstTy != SrcIntPtrTy))
Res = 0; Res = 0;
return Instruction::CastOps(Res); return Instruction::CastOps(Res);
} }
@ -265,18 +265,18 @@ bool InstCombiner::ShouldOptimizeCast(Instruction::CastOps opc, const Value *V,
Type *Ty) { Type *Ty) {
// Noop casts and casts of constants should be eliminated trivially. // Noop casts and casts of constants should be eliminated trivially.
if (V->getType() == Ty || isa<Constant>(V)) return false; if (V->getType() == Ty || isa<Constant>(V)) return false;
// If this is another cast that can be eliminated, we prefer to have it // If this is another cast that can be eliminated, we prefer to have it
// eliminated. // eliminated.
if (const CastInst *CI = dyn_cast<CastInst>(V)) if (const CastInst *CI = dyn_cast<CastInst>(V))
if (isEliminableCastPair(CI, opc, Ty, TD)) if (isEliminableCastPair(CI, opc, Ty, TD))
return false; return false;
// If this is a vector sext from a compare, then we don't want to break the // If this is a vector sext from a compare, then we don't want to break the
// idiom where each element of the extended vector is either zero or all ones. // idiom where each element of the extended vector is either zero or all ones.
if (opc == Instruction::SExt && isa<CmpInst>(V) && Ty->isVectorTy()) if (opc == Instruction::SExt && isa<CmpInst>(V) && Ty->isVectorTy())
return false; return false;
return true; return true;
} }
@ -288,7 +288,7 @@ Instruction *InstCombiner::commonCastTransforms(CastInst &CI) {
// Many cases of "cast of a cast" are eliminable. If it's eliminable we just // Many cases of "cast of a cast" are eliminable. If it's eliminable we just
// eliminate it now. // eliminate it now.
if (CastInst *CSrc = dyn_cast<CastInst>(Src)) { // A->B->C cast if (CastInst *CSrc = dyn_cast<CastInst>(Src)) { // A->B->C cast
if (Instruction::CastOps opc = if (Instruction::CastOps opc =
isEliminableCastPair(CSrc, CI.getOpcode(), CI.getType(), TD)) { isEliminableCastPair(CSrc, CI.getOpcode(), CI.getType(), TD)) {
// The first cast (CSrc) is eliminable so we need to fix up or replace // The first cast (CSrc) is eliminable so we need to fix up or replace
// the second cast (CI). CSrc will then have a good chance of being dead. // the second cast (CI). CSrc will then have a good chance of being dead.
@ -311,7 +311,7 @@ Instruction *InstCombiner::commonCastTransforms(CastInst &CI) {
if (Instruction *NV = FoldOpIntoPhi(CI)) if (Instruction *NV = FoldOpIntoPhi(CI))
return NV; return NV;
} }
return 0; return 0;
} }
@ -330,15 +330,15 @@ static bool CanEvaluateTruncated(Value *V, Type *Ty) {
// We can always evaluate constants in another type. // We can always evaluate constants in another type.
if (isa<Constant>(V)) if (isa<Constant>(V))
return true; return true;
Instruction *I = dyn_cast<Instruction>(V); Instruction *I = dyn_cast<Instruction>(V);
if (!I) return false; if (!I) return false;
Type *OrigTy = V->getType(); Type *OrigTy = V->getType();
// If this is an extension from the dest type, we can eliminate it, even if it // If this is an extension from the dest type, we can eliminate it, even if it
// has multiple uses. // has multiple uses.
if ((isa<ZExtInst>(I) || isa<SExtInst>(I)) && if ((isa<ZExtInst>(I) || isa<SExtInst>(I)) &&
I->getOperand(0)->getType() == Ty) I->getOperand(0)->getType() == Ty)
return true; return true;
@ -423,29 +423,29 @@ static bool CanEvaluateTruncated(Value *V, Type *Ty) {
// TODO: Can handle more cases here. // TODO: Can handle more cases here.
break; break;
} }
return false; return false;
} }
Instruction *InstCombiner::visitTrunc(TruncInst &CI) { Instruction *InstCombiner::visitTrunc(TruncInst &CI) {
if (Instruction *Result = commonCastTransforms(CI)) if (Instruction *Result = commonCastTransforms(CI))
return Result; return Result;
// See if we can simplify any instructions used by the input whose sole // See if we can simplify any instructions used by the input whose sole
// purpose is to compute bits we don't care about. // purpose is to compute bits we don't care about.
if (SimplifyDemandedInstructionBits(CI)) if (SimplifyDemandedInstructionBits(CI))
return &CI; return &CI;
Value *Src = CI.getOperand(0); Value *Src = CI.getOperand(0);
Type *DestTy = CI.getType(), *SrcTy = Src->getType(); Type *DestTy = CI.getType(), *SrcTy = Src->getType();
// Attempt to truncate the entire input expression tree to the destination // Attempt to truncate the entire input expression tree to the destination
// type. Only do this if the dest type is a simple type, don't convert the // type. Only do this if the dest type is a simple type, don't convert the
// expression tree to something weird like i93 unless the source is also // expression tree to something weird like i93 unless the source is also
// strange. // strange.
if ((DestTy->isVectorTy() || ShouldChangeType(SrcTy, DestTy)) && if ((DestTy->isVectorTy() || ShouldChangeType(SrcTy, DestTy)) &&
CanEvaluateTruncated(Src, DestTy)) { CanEvaluateTruncated(Src, DestTy)) {
// If this cast is a truncate, evaluting in a different type always // If this cast is a truncate, evaluting in a different type always
// eliminates the cast, so it is always a win. // eliminates the cast, so it is always a win.
DEBUG(dbgs() << "ICE: EvaluateInDifferentType converting expression type" DEBUG(dbgs() << "ICE: EvaluateInDifferentType converting expression type"
@ -462,7 +462,7 @@ Instruction *InstCombiner::visitTrunc(TruncInst &CI) {
Value *Zero = Constant::getNullValue(Src->getType()); Value *Zero = Constant::getNullValue(Src->getType());
return new ICmpInst(ICmpInst::ICMP_NE, Src, Zero); return new ICmpInst(ICmpInst::ICMP_NE, Src, Zero);
} }
// Transform trunc(lshr (zext A), Cst) to eliminate one type conversion. // Transform trunc(lshr (zext A), Cst) to eliminate one type conversion.
Value *A = 0; ConstantInt *Cst = 0; Value *A = 0; ConstantInt *Cst = 0;
if (Src->hasOneUse() && if (Src->hasOneUse() &&
@ -472,7 +472,7 @@ Instruction *InstCombiner::visitTrunc(TruncInst &CI) {
// ASize < MidSize and MidSize > ResultSize, but don't know the relation // ASize < MidSize and MidSize > ResultSize, but don't know the relation
// between ASize and ResultSize. // between ASize and ResultSize.
unsigned ASize = A->getType()->getPrimitiveSizeInBits(); unsigned ASize = A->getType()->getPrimitiveSizeInBits();
// If the shift amount is larger than the size of A, then the result is // If the shift amount is larger than the size of A, then the result is
// known to be zero because all the input bits got shifted out. // known to be zero because all the input bits got shifted out.
if (Cst->getZExtValue() >= ASize) if (Cst->getZExtValue() >= ASize)
@ -485,7 +485,7 @@ Instruction *InstCombiner::visitTrunc(TruncInst &CI) {
Shift->takeName(Src); Shift->takeName(Src);
return CastInst::CreateIntegerCast(Shift, CI.getType(), false); return CastInst::CreateIntegerCast(Shift, CI.getType(), false);
} }
// Transform "trunc (and X, cst)" -> "and (trunc X), cst" so long as the dest // Transform "trunc (and X, cst)" -> "and (trunc X), cst" so long as the dest
// type isn't non-native. // type isn't non-native.
if (Src->hasOneUse() && isa<IntegerType>(Src->getType()) && if (Src->hasOneUse() && isa<IntegerType>(Src->getType()) &&
@ -508,7 +508,7 @@ Instruction *InstCombiner::transformZExtICmp(ICmpInst *ICI, Instruction &CI,
// cast to integer to avoid the comparison. // cast to integer to avoid the comparison.
if (ConstantInt *Op1C = dyn_cast<ConstantInt>(ICI->getOperand(1))) { if (ConstantInt *Op1C = dyn_cast<ConstantInt>(ICI->getOperand(1))) {
const APInt &Op1CV = Op1C->getValue(); const APInt &Op1CV = Op1C->getValue();
// zext (x <s 0) to i32 --> x>>u31 true if signbit set. // zext (x <s 0) to i32 --> x>>u31 true if signbit set.
// zext (x >s -1) to i32 --> (x>>u31)^1 true if signbit clear. // zext (x >s -1) to i32 --> (x>>u31)^1 true if signbit clear.
if ((ICI->getPredicate() == ICmpInst::ICMP_SLT && Op1CV == 0) || if ((ICI->getPredicate() == ICmpInst::ICMP_SLT && Op1CV == 0) ||
@ -538,14 +538,14 @@ Instruction *InstCombiner::transformZExtICmp(ICmpInst *ICI, Instruction &CI,
// zext (X != 0) to i32 --> X>>1 iff X has only the 2nd bit set. // zext (X != 0) to i32 --> X>>1 iff X has only the 2nd bit set.
// zext (X != 1) to i32 --> X^1 iff X has only the low bit set. // zext (X != 1) to i32 --> X^1 iff X has only the low bit set.
// zext (X != 2) to i32 --> (X>>1)^1 iff X has only the 2nd bit set. // zext (X != 2) to i32 --> (X>>1)^1 iff X has only the 2nd bit set.
if ((Op1CV == 0 || Op1CV.isPowerOf2()) && if ((Op1CV == 0 || Op1CV.isPowerOf2()) &&
// This only works for EQ and NE // This only works for EQ and NE
ICI->isEquality()) { ICI->isEquality()) {
// If Op1C some other power of two, convert: // If Op1C some other power of two, convert:
uint32_t BitWidth = Op1C->getType()->getBitWidth(); uint32_t BitWidth = Op1C->getType()->getBitWidth();
APInt KnownZero(BitWidth, 0), KnownOne(BitWidth, 0); APInt KnownZero(BitWidth, 0), KnownOne(BitWidth, 0);
ComputeMaskedBits(ICI->getOperand(0), KnownZero, KnownOne); ComputeMaskedBits(ICI->getOperand(0), KnownZero, KnownOne);
APInt KnownZeroMask(~KnownZero); APInt KnownZeroMask(~KnownZero);
if (KnownZeroMask.isPowerOf2()) { // Exactly 1 possible 1? if (KnownZeroMask.isPowerOf2()) { // Exactly 1 possible 1?
if (!DoXform) return ICI; if (!DoXform) return ICI;
@ -559,7 +559,7 @@ Instruction *InstCombiner::transformZExtICmp(ICmpInst *ICI, Instruction &CI,
Res = ConstantExpr::getZExt(Res, CI.getType()); Res = ConstantExpr::getZExt(Res, CI.getType());
return ReplaceInstUsesWith(CI, Res); return ReplaceInstUsesWith(CI, Res);
} }
uint32_t ShiftAmt = KnownZeroMask.logBase2(); uint32_t ShiftAmt = KnownZeroMask.logBase2();
Value *In = ICI->getOperand(0); Value *In = ICI->getOperand(0);
if (ShiftAmt) { if (ShiftAmt) {
@ -568,12 +568,12 @@ Instruction *InstCombiner::transformZExtICmp(ICmpInst *ICI, Instruction &CI,
In = Builder->CreateLShr(In, ConstantInt::get(In->getType(),ShiftAmt), In = Builder->CreateLShr(In, ConstantInt::get(In->getType(),ShiftAmt),
In->getName()+".lobit"); In->getName()+".lobit");
} }
if ((Op1CV != 0) == isNE) { // Toggle the low bit. if ((Op1CV != 0) == isNE) { // Toggle the low bit.
Constant *One = ConstantInt::get(In->getType(), 1); Constant *One = ConstantInt::get(In->getType(), 1);
In = Builder->CreateXor(In, One); In = Builder->CreateXor(In, One);
} }
if (CI.getType() == In->getType()) if (CI.getType() == In->getType())
return ReplaceInstUsesWith(CI, In); return ReplaceInstUsesWith(CI, In);
return CastInst::CreateIntegerCast(In, CI.getType(), false/*ZExt*/); return CastInst::CreateIntegerCast(In, CI.getType(), false/*ZExt*/);
@ -646,19 +646,19 @@ static bool CanEvaluateZExtd(Value *V, Type *Ty, unsigned &BitsToClear) {
BitsToClear = 0; BitsToClear = 0;
if (isa<Constant>(V)) if (isa<Constant>(V))
return true; return true;
Instruction *I = dyn_cast<Instruction>(V); Instruction *I = dyn_cast<Instruction>(V);
if (!I) return false; if (!I) return false;
// If the input is a truncate from the destination type, we can trivially // If the input is a truncate from the destination type, we can trivially
// eliminate it. // eliminate it.
if (isa<TruncInst>(I) && I->getOperand(0)->getType() == Ty) if (isa<TruncInst>(I) && I->getOperand(0)->getType() == Ty)
return true; return true;
// We can't extend or shrink something that has multiple uses: doing so would // We can't extend or shrink something that has multiple uses: doing so would
// require duplicating the instruction in general, which isn't profitable. // require duplicating the instruction in general, which isn't profitable.
if (!I->hasOneUse()) return false; if (!I->hasOneUse()) return false;
unsigned Opc = I->getOpcode(), Tmp; unsigned Opc = I->getOpcode(), Tmp;
switch (Opc) { switch (Opc) {
case Instruction::ZExt: // zext(zext(x)) -> zext(x). case Instruction::ZExt: // zext(zext(x)) -> zext(x).
@ -678,7 +678,7 @@ static bool CanEvaluateZExtd(Value *V, Type *Ty, unsigned &BitsToClear) {
// These can all be promoted if neither operand has 'bits to clear'. // These can all be promoted if neither operand has 'bits to clear'.
if (BitsToClear == 0 && Tmp == 0) if (BitsToClear == 0 && Tmp == 0)
return true; return true;
// If the operation is an AND/OR/XOR and the bits to clear are zero in the // If the operation is an AND/OR/XOR and the bits to clear are zero in the
// other side, BitsToClear is ok. // other side, BitsToClear is ok.
if (Tmp == 0 && if (Tmp == 0 &&
@ -691,10 +691,10 @@ static bool CanEvaluateZExtd(Value *V, Type *Ty, unsigned &BitsToClear) {
APInt::getHighBitsSet(VSize, BitsToClear))) APInt::getHighBitsSet(VSize, BitsToClear)))
return true; return true;
} }
// Otherwise, we don't know how to analyze this BitsToClear case yet. // Otherwise, we don't know how to analyze this BitsToClear case yet.
return false; return false;
case Instruction::LShr: case Instruction::LShr:
// We can promote lshr(x, cst) if we can promote x. This requires the // We can promote lshr(x, cst) if we can promote x. This requires the
// ultimate 'and' to clear out the high zero bits we're clearing out though. // ultimate 'and' to clear out the high zero bits we're clearing out though.
@ -716,7 +716,7 @@ static bool CanEvaluateZExtd(Value *V, Type *Ty, unsigned &BitsToClear) {
Tmp != BitsToClear) Tmp != BitsToClear)
return false; return false;
return true; return true;
case Instruction::PHI: { case Instruction::PHI: {
// We can change a phi if we can change all operands. Note that we never // We can change a phi if we can change all operands. Note that we never
// get into trouble with cyclic PHIs here because we only consider // get into trouble with cyclic PHIs here because we only consider
@ -743,44 +743,44 @@ Instruction *InstCombiner::visitZExt(ZExtInst &CI) {
// eliminated before we try to optimize this zext. // eliminated before we try to optimize this zext.
if (CI.hasOneUse() && isa<TruncInst>(CI.use_back())) if (CI.hasOneUse() && isa<TruncInst>(CI.use_back()))
return 0; return 0;
// If one of the common conversion will work, do it. // If one of the common conversion will work, do it.
if (Instruction *Result = commonCastTransforms(CI)) if (Instruction *Result = commonCastTransforms(CI))
return Result; return Result;
// See if we can simplify any instructions used by the input whose sole // See if we can simplify any instructions used by the input whose sole
// purpose is to compute bits we don't care about. // purpose is to compute bits we don't care about.
if (SimplifyDemandedInstructionBits(CI)) if (SimplifyDemandedInstructionBits(CI))
return &CI; return &CI;
Value *Src = CI.getOperand(0); Value *Src = CI.getOperand(0);
Type *SrcTy = Src->getType(), *DestTy = CI.getType(); Type *SrcTy = Src->getType(), *DestTy = CI.getType();
// Attempt to extend the entire input expression tree to the destination // Attempt to extend the entire input expression tree to the destination
// type. Only do this if the dest type is a simple type, don't convert the // type. Only do this if the dest type is a simple type, don't convert the
// expression tree to something weird like i93 unless the source is also // expression tree to something weird like i93 unless the source is also
// strange. // strange.
unsigned BitsToClear; unsigned BitsToClear;
if ((DestTy->isVectorTy() || ShouldChangeType(SrcTy, DestTy)) && if ((DestTy->isVectorTy() || ShouldChangeType(SrcTy, DestTy)) &&
CanEvaluateZExtd(Src, DestTy, BitsToClear)) { CanEvaluateZExtd(Src, DestTy, BitsToClear)) {
assert(BitsToClear < SrcTy->getScalarSizeInBits() && assert(BitsToClear < SrcTy->getScalarSizeInBits() &&
"Unreasonable BitsToClear"); "Unreasonable BitsToClear");
// Okay, we can transform this! Insert the new expression now. // Okay, we can transform this! Insert the new expression now.
DEBUG(dbgs() << "ICE: EvaluateInDifferentType converting expression type" DEBUG(dbgs() << "ICE: EvaluateInDifferentType converting expression type"
" to avoid zero extend: " << CI); " to avoid zero extend: " << CI);
Value *Res = EvaluateInDifferentType(Src, DestTy, false); Value *Res = EvaluateInDifferentType(Src, DestTy, false);
assert(Res->getType() == DestTy); assert(Res->getType() == DestTy);
uint32_t SrcBitsKept = SrcTy->getScalarSizeInBits()-BitsToClear; uint32_t SrcBitsKept = SrcTy->getScalarSizeInBits()-BitsToClear;
uint32_t DestBitSize = DestTy->getScalarSizeInBits(); uint32_t DestBitSize = DestTy->getScalarSizeInBits();
// If the high bits are already filled with zeros, just replace this // If the high bits are already filled with zeros, just replace this
// cast with the result. // cast with the result.
if (MaskedValueIsZero(Res, APInt::getHighBitsSet(DestBitSize, if (MaskedValueIsZero(Res, APInt::getHighBitsSet(DestBitSize,
DestBitSize-SrcBitsKept))) DestBitSize-SrcBitsKept)))
return ReplaceInstUsesWith(CI, Res); return ReplaceInstUsesWith(CI, Res);
// We need to emit an AND to clear the high bits. // We need to emit an AND to clear the high bits.
Constant *C = ConstantInt::get(Res->getType(), Constant *C = ConstantInt::get(Res->getType(),
APInt::getLowBitsSet(DestBitSize, SrcBitsKept)); APInt::getLowBitsSet(DestBitSize, SrcBitsKept));
@ -792,7 +792,7 @@ Instruction *InstCombiner::visitZExt(ZExtInst &CI) {
// 'and' which will be much cheaper than the pair of casts. // 'and' which will be much cheaper than the pair of casts.
if (TruncInst *CSrc = dyn_cast<TruncInst>(Src)) { // A->B->C cast if (TruncInst *CSrc = dyn_cast<TruncInst>(Src)) { // A->B->C cast
// TODO: Subsume this into EvaluateInDifferentType. // TODO: Subsume this into EvaluateInDifferentType.
// Get the sizes of the types involved. We know that the intermediate type // Get the sizes of the types involved. We know that the intermediate type
// will be smaller than A or C, but don't know the relation between A and C. // will be smaller than A or C, but don't know the relation between A and C.
Value *A = CSrc->getOperand(0); Value *A = CSrc->getOperand(0);
@ -809,7 +809,7 @@ Instruction *InstCombiner::visitZExt(ZExtInst &CI) {
Value *And = Builder->CreateAnd(A, AndConst, CSrc->getName()+".mask"); Value *And = Builder->CreateAnd(A, AndConst, CSrc->getName()+".mask");
return new ZExtInst(And, CI.getType()); return new ZExtInst(And, CI.getType());
} }
if (SrcSize == DstSize) { if (SrcSize == DstSize) {
APInt AndValue(APInt::getLowBitsSet(SrcSize, MidSize)); APInt AndValue(APInt::getLowBitsSet(SrcSize, MidSize));
return BinaryOperator::CreateAnd(A, ConstantInt::get(A->getType(), return BinaryOperator::CreateAnd(A, ConstantInt::get(A->getType(),
@ -818,7 +818,7 @@ Instruction *InstCombiner::visitZExt(ZExtInst &CI) {
if (SrcSize > DstSize) { if (SrcSize > DstSize) {
Value *Trunc = Builder->CreateTrunc(A, CI.getType()); Value *Trunc = Builder->CreateTrunc(A, CI.getType());
APInt AndValue(APInt::getLowBitsSet(DstSize, MidSize)); APInt AndValue(APInt::getLowBitsSet(DstSize, MidSize));
return BinaryOperator::CreateAnd(Trunc, return BinaryOperator::CreateAnd(Trunc,
ConstantInt::get(Trunc->getType(), ConstantInt::get(Trunc->getType(),
AndValue)); AndValue));
} }
@ -876,7 +876,7 @@ Instruction *InstCombiner::visitZExt(ZExtInst &CI) {
Value *New = Builder->CreateZExt(X, CI.getType()); Value *New = Builder->CreateZExt(X, CI.getType());
return BinaryOperator::CreateXor(New, ConstantInt::get(CI.getType(), 1)); return BinaryOperator::CreateXor(New, ConstantInt::get(CI.getType(), 1));
} }
return 0; return 0;
} }
@ -989,14 +989,14 @@ static bool CanEvaluateSExtd(Value *V, Type *Ty) {
// If this is a constant, it can be trivially promoted. // If this is a constant, it can be trivially promoted.
if (isa<Constant>(V)) if (isa<Constant>(V))
return true; return true;
Instruction *I = dyn_cast<Instruction>(V); Instruction *I = dyn_cast<Instruction>(V);
if (!I) return false; if (!I) return false;
// If this is a truncate from the dest type, we can trivially eliminate it. // If this is a truncate from the dest type, we can trivially eliminate it.
if (isa<TruncInst>(I) && I->getOperand(0)->getType() == Ty) if (isa<TruncInst>(I) && I->getOperand(0)->getType() == Ty)
return true; return true;
// We can't extend or shrink something that has multiple uses: doing so would // We can't extend or shrink something that has multiple uses: doing so would
// require duplicating the instruction in general, which isn't profitable. // require duplicating the instruction in general, which isn't profitable.
if (!I->hasOneUse()) return false; if (!I->hasOneUse()) return false;
@ -1015,14 +1015,14 @@ static bool CanEvaluateSExtd(Value *V, Type *Ty) {
// These operators can all arbitrarily be extended if their inputs can. // These operators can all arbitrarily be extended if their inputs can.
return CanEvaluateSExtd(I->getOperand(0), Ty) && return CanEvaluateSExtd(I->getOperand(0), Ty) &&
CanEvaluateSExtd(I->getOperand(1), Ty); CanEvaluateSExtd(I->getOperand(1), Ty);
//case Instruction::Shl: TODO //case Instruction::Shl: TODO
//case Instruction::LShr: TODO //case Instruction::LShr: TODO
case Instruction::Select: case Instruction::Select:
return CanEvaluateSExtd(I->getOperand(1), Ty) && return CanEvaluateSExtd(I->getOperand(1), Ty) &&
CanEvaluateSExtd(I->getOperand(2), Ty); CanEvaluateSExtd(I->getOperand(2), Ty);
case Instruction::PHI: { case Instruction::PHI: {
// We can change a phi if we can change all operands. Note that we never // We can change a phi if we can change all operands. Note that we never
// get into trouble with cyclic PHIs here because we only consider // get into trouble with cyclic PHIs here because we only consider
@ -1036,7 +1036,7 @@ static bool CanEvaluateSExtd(Value *V, Type *Ty) {
// TODO: Can handle more cases here. // TODO: Can handle more cases here.
break; break;
} }
return false; return false;
} }
@ -1045,15 +1045,15 @@ Instruction *InstCombiner::visitSExt(SExtInst &CI) {
// eliminated before we try to optimize this zext. // eliminated before we try to optimize this zext.
if (CI.hasOneUse() && isa<TruncInst>(CI.use_back())) if (CI.hasOneUse() && isa<TruncInst>(CI.use_back()))
return 0; return 0;
if (Instruction *I = commonCastTransforms(CI)) if (Instruction *I = commonCastTransforms(CI))
return I; return I;
// See if we can simplify any instructions used by the input whose sole // See if we can simplify any instructions used by the input whose sole
// purpose is to compute bits we don't care about. // purpose is to compute bits we don't care about.
if (SimplifyDemandedInstructionBits(CI)) if (SimplifyDemandedInstructionBits(CI))
return &CI; return &CI;
Value *Src = CI.getOperand(0); Value *Src = CI.getOperand(0);
Type *SrcTy = Src->getType(), *DestTy = CI.getType(); Type *SrcTy = Src->getType(), *DestTy = CI.getType();
@ -1076,7 +1076,7 @@ Instruction *InstCombiner::visitSExt(SExtInst &CI) {
// cast with the result. // cast with the result.
if (ComputeNumSignBits(Res) > DestBitSize - SrcBitSize) if (ComputeNumSignBits(Res) > DestBitSize - SrcBitSize)
return ReplaceInstUsesWith(CI, Res); return ReplaceInstUsesWith(CI, Res);
// We need to emit a shl + ashr to do the sign extend. // We need to emit a shl + ashr to do the sign extend.
Value *ShAmt = ConstantInt::get(DestTy, DestBitSize-SrcBitSize); Value *ShAmt = ConstantInt::get(DestTy, DestBitSize-SrcBitSize);
return BinaryOperator::CreateAShr(Builder->CreateShl(Res, ShAmt, "sext"), return BinaryOperator::CreateAShr(Builder->CreateShl(Res, ShAmt, "sext"),
@ -1089,7 +1089,7 @@ Instruction *InstCombiner::visitSExt(SExtInst &CI) {
if (TI->hasOneUse() && TI->getOperand(0)->getType() == DestTy) { if (TI->hasOneUse() && TI->getOperand(0)->getType() == DestTy) {
uint32_t SrcBitSize = SrcTy->getScalarSizeInBits(); uint32_t SrcBitSize = SrcTy->getScalarSizeInBits();
uint32_t DestBitSize = DestTy->getScalarSizeInBits(); uint32_t DestBitSize = DestTy->getScalarSizeInBits();
// We need to emit a shl + ashr to do the sign extend. // We need to emit a shl + ashr to do the sign extend.
Value *ShAmt = ConstantInt::get(DestTy, DestBitSize-SrcBitSize); Value *ShAmt = ConstantInt::get(DestTy, DestBitSize-SrcBitSize);
Value *Res = Builder->CreateShl(TI->getOperand(0), ShAmt, "sext"); Value *Res = Builder->CreateShl(TI->getOperand(0), ShAmt, "sext");
@ -1125,7 +1125,7 @@ Instruction *InstCombiner::visitSExt(SExtInst &CI) {
A = Builder->CreateShl(A, ShAmtV, CI.getName()); A = Builder->CreateShl(A, ShAmtV, CI.getName());
return BinaryOperator::CreateAShr(A, ShAmtV); return BinaryOperator::CreateAShr(A, ShAmtV);
} }
return 0; return 0;
} }
@ -1147,7 +1147,7 @@ static Value *LookThroughFPExtensions(Value *V) {
if (Instruction *I = dyn_cast<Instruction>(V)) if (Instruction *I = dyn_cast<Instruction>(V))
if (I->getOpcode() == Instruction::FPExt) if (I->getOpcode() == Instruction::FPExt)
return LookThroughFPExtensions(I->getOperand(0)); return LookThroughFPExtensions(I->getOperand(0));
// If this value is a constant, return the constant in the smallest FP type // If this value is a constant, return the constant in the smallest FP type
// that can accurately represent it. This allows us to turn // that can accurately represent it. This allows us to turn
// (float)((double)X+2.0) into x+2.0f. // (float)((double)X+2.0) into x+2.0f.
@ -1166,14 +1166,14 @@ static Value *LookThroughFPExtensions(Value *V) {
return V; return V;
// Don't try to shrink to various long double types. // Don't try to shrink to various long double types.
} }
return V; return V;
} }
Instruction *InstCombiner::visitFPTrunc(FPTruncInst &CI) { Instruction *InstCombiner::visitFPTrunc(FPTruncInst &CI) {
if (Instruction *I = commonCastTransforms(CI)) if (Instruction *I = commonCastTransforms(CI))
return I; return I;
// If we have fptrunc(fadd (fpextend x), (fpextend y)), where x and y are // If we have fptrunc(fadd (fpextend x), (fpextend y)), where x and y are
// smaller than the destination type, we can eliminate the truncate by doing // smaller than the destination type, we can eliminate the truncate by doing
// the add as the smaller type. This applies to fadd/fsub/fmul/fdiv as well // the add as the smaller type. This applies to fadd/fsub/fmul/fdiv as well
@ -1190,7 +1190,7 @@ Instruction *InstCombiner::visitFPTrunc(FPTruncInst &CI) {
Type *SrcTy = OpI->getType(); Type *SrcTy = OpI->getType();
Value *LHSTrunc = LookThroughFPExtensions(OpI->getOperand(0)); Value *LHSTrunc = LookThroughFPExtensions(OpI->getOperand(0));
Value *RHSTrunc = LookThroughFPExtensions(OpI->getOperand(1)); Value *RHSTrunc = LookThroughFPExtensions(OpI->getOperand(1));
if (LHSTrunc->getType() != SrcTy && if (LHSTrunc->getType() != SrcTy &&
RHSTrunc->getType() != SrcTy) { RHSTrunc->getType() != SrcTy) {
unsigned DstSize = CI.getType()->getScalarSizeInBits(); unsigned DstSize = CI.getType()->getScalarSizeInBits();
// If the source types were both smaller than the destination type of // If the source types were both smaller than the destination type of
@ -1202,7 +1202,7 @@ Instruction *InstCombiner::visitFPTrunc(FPTruncInst &CI) {
return BinaryOperator::Create(OpI->getOpcode(), LHSTrunc, RHSTrunc); return BinaryOperator::Create(OpI->getOpcode(), LHSTrunc, RHSTrunc);
} }
} }
break; break;
} }
// (fptrunc (fneg x)) -> (fneg (fptrunc x)) // (fptrunc (fneg x)) -> (fneg (fptrunc x))
@ -1246,7 +1246,7 @@ Instruction *InstCombiner::visitFPTrunc(FPTruncInst &CI) {
Arg->getOperand(0)->getType()->isFloatTy()) { Arg->getOperand(0)->getType()->isFloatTy()) {
Function *Callee = Call->getCalledFunction(); Function *Callee = Call->getCalledFunction();
Module *M = CI.getParent()->getParent()->getParent(); Module *M = CI.getParent()->getParent()->getParent();
Constant *SqrtfFunc = M->getOrInsertFunction("sqrtf", Constant *SqrtfFunc = M->getOrInsertFunction("sqrtf",
Callee->getAttributes(), Callee->getAttributes(),
Builder->getFloatTy(), Builder->getFloatTy(),
Builder->getFloatTy(), Builder->getFloatTy(),
@ -1254,15 +1254,15 @@ Instruction *InstCombiner::visitFPTrunc(FPTruncInst &CI) {
CallInst *ret = CallInst::Create(SqrtfFunc, Arg->getOperand(0), CallInst *ret = CallInst::Create(SqrtfFunc, Arg->getOperand(0),
"sqrtfcall"); "sqrtfcall");
ret->setAttributes(Callee->getAttributes()); ret->setAttributes(Callee->getAttributes());
// Remove the old Call. With -fmath-errno, it won't get marked readnone. // Remove the old Call. With -fmath-errno, it won't get marked readnone.
ReplaceInstUsesWith(*Call, UndefValue::get(Call->getType())); ReplaceInstUsesWith(*Call, UndefValue::get(Call->getType()));
EraseInstFromFunction(*Call); EraseInstFromFunction(*Call);
return ret; return ret;
} }
} }
return 0; return 0;
} }
@ -1280,7 +1280,7 @@ Instruction *InstCombiner::visitFPToUI(FPToUIInst &FI) {
// This is safe if the intermediate type has enough bits in its mantissa to // This is safe if the intermediate type has enough bits in its mantissa to
// accurately represent all values of X. For example, do not do this with // accurately represent all values of X. For example, do not do this with
// i64->float->i64. This is also safe for sitofp case, because any negative // i64->float->i64. This is also safe for sitofp case, because any negative
// 'X' value would cause an undefined result for the fptoui. // 'X' value would cause an undefined result for the fptoui.
if ((isa<UIToFPInst>(OpI) || isa<SIToFPInst>(OpI)) && if ((isa<UIToFPInst>(OpI) || isa<SIToFPInst>(OpI)) &&
OpI->getOperand(0)->getType() == FI.getType() && OpI->getOperand(0)->getType() == FI.getType() &&
(int)FI.getType()->getScalarSizeInBits() < /*extra bit for sign */ (int)FI.getType()->getScalarSizeInBits() < /*extra bit for sign */
@ -1294,19 +1294,19 @@ Instruction *InstCombiner::visitFPToSI(FPToSIInst &FI) {
Instruction *OpI = dyn_cast<Instruction>(FI.getOperand(0)); Instruction *OpI = dyn_cast<Instruction>(FI.getOperand(0));
if (OpI == 0) if (OpI == 0)
return commonCastTransforms(FI); return commonCastTransforms(FI);
// fptosi(sitofp(X)) --> X // fptosi(sitofp(X)) --> X
// fptosi(uitofp(X)) --> X // fptosi(uitofp(X)) --> X
// This is safe if the intermediate type has enough bits in its mantissa to // This is safe if the intermediate type has enough bits in its mantissa to
// accurately represent all values of X. For example, do not do this with // accurately represent all values of X. For example, do not do this with
// i64->float->i64. This is also safe for sitofp case, because any negative // i64->float->i64. This is also safe for sitofp case, because any negative
// 'X' value would cause an undefined result for the fptoui. // 'X' value would cause an undefined result for the fptoui.
if ((isa<UIToFPInst>(OpI) || isa<SIToFPInst>(OpI)) && if ((isa<UIToFPInst>(OpI) || isa<SIToFPInst>(OpI)) &&
OpI->getOperand(0)->getType() == FI.getType() && OpI->getOperand(0)->getType() == FI.getType() &&
(int)FI.getType()->getScalarSizeInBits() <= (int)FI.getType()->getScalarSizeInBits() <=
OpI->getType()->getFPMantissaWidth()) OpI->getType()->getFPMantissaWidth())
return ReplaceInstUsesWith(FI, OpI->getOperand(0)); return ReplaceInstUsesWith(FI, OpI->getOperand(0));
return commonCastTransforms(FI); return commonCastTransforms(FI);
} }
@ -1336,7 +1336,7 @@ Instruction *InstCombiner::visitIntToPtr(IntToPtrInst &CI) {
return new IntToPtrInst(P, CI.getType()); return new IntToPtrInst(P, CI.getType());
} }
} }
if (Instruction *I = commonCastTransforms(CI)) if (Instruction *I = commonCastTransforms(CI))
return I; return I;
@ -1346,19 +1346,19 @@ Instruction *InstCombiner::visitIntToPtr(IntToPtrInst &CI) {
/// @brief Implement the transforms for cast of pointer (bitcast/ptrtoint) /// @brief Implement the transforms for cast of pointer (bitcast/ptrtoint)
Instruction *InstCombiner::commonPointerCastTransforms(CastInst &CI) { Instruction *InstCombiner::commonPointerCastTransforms(CastInst &CI) {
Value *Src = CI.getOperand(0); Value *Src = CI.getOperand(0);
if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(Src)) { if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(Src)) {
// If casting the result of a getelementptr instruction with no offset, turn // If casting the result of a getelementptr instruction with no offset, turn
// this into a cast of the original pointer! // this into a cast of the original pointer!
if (GEP->hasAllZeroIndices()) { if (GEP->hasAllZeroIndices()) {
// Changing the cast operand is usually not a good idea but it is safe // Changing the cast operand is usually not a good idea but it is safe
// here because the pointer operand is being replaced with another // here because the pointer operand is being replaced with another
// pointer operand so the opcode doesn't need to change. // pointer operand so the opcode doesn't need to change.
Worklist.Add(GEP); Worklist.Add(GEP);
CI.setOperand(0, GEP->getOperand(0)); CI.setOperand(0, GEP->getOperand(0));
return &CI; return &CI;
} }
// If the GEP has a single use, and the base pointer is a bitcast, and the // If the GEP has a single use, and the base pointer is a bitcast, and the
// GEP computes a constant offset, see if we can convert these three // GEP computes a constant offset, see if we can convert these three
// instructions into fewer. This typically happens with unions and other // instructions into fewer. This typically happens with unions and other
@ -1379,15 +1379,15 @@ Instruction *InstCombiner::commonPointerCastTransforms(CastInst &CI) {
Builder->CreateInBoundsGEP(OrigBase, NewIndices) : Builder->CreateInBoundsGEP(OrigBase, NewIndices) :
Builder->CreateGEP(OrigBase, NewIndices); Builder->CreateGEP(OrigBase, NewIndices);
NGEP->takeName(GEP); NGEP->takeName(GEP);
if (isa<BitCastInst>(CI)) if (isa<BitCastInst>(CI))
return new BitCastInst(NGEP, CI.getType()); return new BitCastInst(NGEP, CI.getType());
assert(isa<PtrToIntInst>(CI)); assert(isa<PtrToIntInst>(CI));
return new PtrToIntInst(NGEP, CI.getType()); return new PtrToIntInst(NGEP, CI.getType());
} }
} }
} }
return commonCastTransforms(CI); return commonCastTransforms(CI);
} }
@ -1407,7 +1407,7 @@ Instruction *InstCombiner::visitPtrToInt(PtrToIntInst &CI) {
return new ZExtInst(P, CI.getType()); return new ZExtInst(P, CI.getType());
} }
} }
return commonPointerCastTransforms(CI); return commonPointerCastTransforms(CI);
} }
@ -1422,33 +1422,33 @@ static Instruction *OptimizeVectorResize(Value *InVal, VectorType *DestTy,
// element size, or the input is a multiple of the output element size. // element size, or the input is a multiple of the output element size.
// Convert the input type to have the same element type as the output. // Convert the input type to have the same element type as the output.
VectorType *SrcTy = cast<VectorType>(InVal->getType()); VectorType *SrcTy = cast<VectorType>(InVal->getType());
if (SrcTy->getElementType() != DestTy->getElementType()) { if (SrcTy->getElementType() != DestTy->getElementType()) {
// The input types don't need to be identical, but for now they must be the // The input types don't need to be identical, but for now they must be the
// same size. There is no specific reason we couldn't handle things like // same size. There is no specific reason we couldn't handle things like
// <4 x i16> -> <4 x i32> by bitcasting to <2 x i32> but haven't gotten // <4 x i16> -> <4 x i32> by bitcasting to <2 x i32> but haven't gotten
// there yet. // there yet.
if (SrcTy->getElementType()->getPrimitiveSizeInBits() != if (SrcTy->getElementType()->getPrimitiveSizeInBits() !=
DestTy->getElementType()->getPrimitiveSizeInBits()) DestTy->getElementType()->getPrimitiveSizeInBits())
return 0; return 0;
SrcTy = VectorType::get(DestTy->getElementType(), SrcTy->getNumElements()); SrcTy = VectorType::get(DestTy->getElementType(), SrcTy->getNumElements());
InVal = IC.Builder->CreateBitCast(InVal, SrcTy); InVal = IC.Builder->CreateBitCast(InVal, SrcTy);
} }
// Now that the element types match, get the shuffle mask and RHS of the // Now that the element types match, get the shuffle mask and RHS of the
// shuffle to use, which depends on whether we're increasing or decreasing the // shuffle to use, which depends on whether we're increasing or decreasing the
// size of the input. // size of the input.
SmallVector<uint32_t, 16> ShuffleMask; SmallVector<uint32_t, 16> ShuffleMask;
Value *V2; Value *V2;
if (SrcTy->getNumElements() > DestTy->getNumElements()) { if (SrcTy->getNumElements() > DestTy->getNumElements()) {
// If we're shrinking the number of elements, just shuffle in the low // If we're shrinking the number of elements, just shuffle in the low
// elements from the input and use undef as the second shuffle input. // elements from the input and use undef as the second shuffle input.
V2 = UndefValue::get(SrcTy); V2 = UndefValue::get(SrcTy);
for (unsigned i = 0, e = DestTy->getNumElements(); i != e; ++i) for (unsigned i = 0, e = DestTy->getNumElements(); i != e; ++i)
ShuffleMask.push_back(i); ShuffleMask.push_back(i);
} else { } else {
// If we're increasing the number of elements, shuffle in all of the // If we're increasing the number of elements, shuffle in all of the
// elements from InVal and fill the rest of the result elements with zeros // elements from InVal and fill the rest of the result elements with zeros
@ -1462,7 +1462,7 @@ static Instruction *OptimizeVectorResize(Value *InVal, VectorType *DestTy,
for (unsigned i = 0, e = DestTy->getNumElements()-SrcElts; i != e; ++i) for (unsigned i = 0, e = DestTy->getNumElements()-SrcElts; i != e; ++i)
ShuffleMask.push_back(SrcElts); ShuffleMask.push_back(SrcElts);
} }
return new ShuffleVectorInst(InVal, V2, return new ShuffleVectorInst(InVal, V2,
ConstantDataVector::get(V2->getContext(), ConstantDataVector::get(V2->getContext(),
ShuffleMask)); ShuffleMask));
@ -1489,7 +1489,7 @@ static bool CollectInsertionElements(Value *V, unsigned ElementIndex,
Type *VecEltTy) { Type *VecEltTy) {
// Undef values never contribute useful bits to the result. // Undef values never contribute useful bits to the result.
if (isa<UndefValue>(V)) return true; if (isa<UndefValue>(V)) return true;
// If we got down to a value of the right type, we win, try inserting into the // If we got down to a value of the right type, we win, try inserting into the
// right element. // right element.
if (V->getType() == VecEltTy) { if (V->getType() == VecEltTy) {
@ -1497,15 +1497,15 @@ static bool CollectInsertionElements(Value *V, unsigned ElementIndex,
if (Constant *C = dyn_cast<Constant>(V)) if (Constant *C = dyn_cast<Constant>(V))
if (C->isNullValue()) if (C->isNullValue())
return true; return true;
// Fail if multiple elements are inserted into this slot. // Fail if multiple elements are inserted into this slot.
if (ElementIndex >= Elements.size() || Elements[ElementIndex] != 0) if (ElementIndex >= Elements.size() || Elements[ElementIndex] != 0)
return false; return false;
Elements[ElementIndex] = V; Elements[ElementIndex] = V;
return true; return true;
} }
if (Constant *C = dyn_cast<Constant>(V)) { if (Constant *C = dyn_cast<Constant>(V)) {
// Figure out the # elements this provides, and bitcast it or slice it up // Figure out the # elements this provides, and bitcast it or slice it up
// as required. // as required.
@ -1516,7 +1516,7 @@ static bool CollectInsertionElements(Value *V, unsigned ElementIndex,
if (NumElts == 1) if (NumElts == 1)
return CollectInsertionElements(ConstantExpr::getBitCast(C, VecEltTy), return CollectInsertionElements(ConstantExpr::getBitCast(C, VecEltTy),
ElementIndex, Elements, VecEltTy); ElementIndex, Elements, VecEltTy);
// Okay, this is a constant that covers multiple elements. Slice it up into // Okay, this is a constant that covers multiple elements. Slice it up into
// pieces and insert each element-sized piece into the vector. // pieces and insert each element-sized piece into the vector.
if (!isa<IntegerType>(C->getType())) if (!isa<IntegerType>(C->getType()))
@ -1524,7 +1524,7 @@ static bool CollectInsertionElements(Value *V, unsigned ElementIndex,
C->getType()->getPrimitiveSizeInBits())); C->getType()->getPrimitiveSizeInBits()));
unsigned ElementSize = VecEltTy->getPrimitiveSizeInBits(); unsigned ElementSize = VecEltTy->getPrimitiveSizeInBits();
Type *ElementIntTy = IntegerType::get(C->getContext(), ElementSize); Type *ElementIntTy = IntegerType::get(C->getContext(), ElementSize);
for (unsigned i = 0; i != NumElts; ++i) { for (unsigned i = 0; i != NumElts; ++i) {
Constant *Piece = ConstantExpr::getLShr(C, ConstantInt::get(C->getType(), Constant *Piece = ConstantExpr::getLShr(C, ConstantInt::get(C->getType(),
i*ElementSize)); i*ElementSize));
@ -1534,23 +1534,23 @@ static bool CollectInsertionElements(Value *V, unsigned ElementIndex,
} }
return true; return true;
} }
if (!V->hasOneUse()) return false; if (!V->hasOneUse()) return false;
Instruction *I = dyn_cast<Instruction>(V); Instruction *I = dyn_cast<Instruction>(V);
if (I == 0) return false; if (I == 0) return false;
switch (I->getOpcode()) { switch (I->getOpcode()) {
default: return false; // Unhandled case. default: return false; // Unhandled case.
case Instruction::BitCast: case Instruction::BitCast:
return CollectInsertionElements(I->getOperand(0), ElementIndex, return CollectInsertionElements(I->getOperand(0), ElementIndex,
Elements, VecEltTy); Elements, VecEltTy);
case Instruction::ZExt: case Instruction::ZExt:
if (!isMultipleOfTypeSize( if (!isMultipleOfTypeSize(
I->getOperand(0)->getType()->getPrimitiveSizeInBits(), I->getOperand(0)->getType()->getPrimitiveSizeInBits(),
VecEltTy)) VecEltTy))
return false; return false;
return CollectInsertionElements(I->getOperand(0), ElementIndex, return CollectInsertionElements(I->getOperand(0), ElementIndex,
Elements, VecEltTy); Elements, VecEltTy);
case Instruction::Or: case Instruction::Or:
return CollectInsertionElements(I->getOperand(0), ElementIndex, return CollectInsertionElements(I->getOperand(0), ElementIndex,
Elements, VecEltTy) && Elements, VecEltTy) &&
@ -1562,11 +1562,11 @@ static bool CollectInsertionElements(Value *V, unsigned ElementIndex,
if (CI == 0) return false; if (CI == 0) return false;
if (!isMultipleOfTypeSize(CI->getZExtValue(), VecEltTy)) return false; if (!isMultipleOfTypeSize(CI->getZExtValue(), VecEltTy)) return false;
unsigned IndexShift = getTypeSizeIndex(CI->getZExtValue(), VecEltTy); unsigned IndexShift = getTypeSizeIndex(CI->getZExtValue(), VecEltTy);
return CollectInsertionElements(I->getOperand(0), ElementIndex+IndexShift, return CollectInsertionElements(I->getOperand(0), ElementIndex+IndexShift,
Elements, VecEltTy); Elements, VecEltTy);
} }
} }
} }
@ -1601,11 +1601,11 @@ static Value *OptimizeIntegerToVectorInsertions(BitCastInst &CI,
Value *Result = Constant::getNullValue(CI.getType()); Value *Result = Constant::getNullValue(CI.getType());
for (unsigned i = 0, e = Elements.size(); i != e; ++i) { for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
if (Elements[i] == 0) continue; // Unset element. if (Elements[i] == 0) continue; // Unset element.
Result = IC.Builder->CreateInsertElement(Result, Elements[i], Result = IC.Builder->CreateInsertElement(Result, Elements[i],
IC.Builder->getInt32(i)); IC.Builder->getInt32(i));
} }
return Result; return Result;
} }
@ -1633,11 +1633,11 @@ static Instruction *OptimizeIntToFloatBitCast(BitCastInst &CI,InstCombiner &IC){
VecTy->getPrimitiveSizeInBits() / DestWidth); VecTy->getPrimitiveSizeInBits() / DestWidth);
VecInput = IC.Builder->CreateBitCast(VecInput, VecTy); VecInput = IC.Builder->CreateBitCast(VecInput, VecTy);
} }
return ExtractElementInst::Create(VecInput, IC.Builder->getInt32(0)); return ExtractElementInst::Create(VecInput, IC.Builder->getInt32(0));
} }
} }
// bitcast(trunc(lshr(bitcast(somevector), cst)) // bitcast(trunc(lshr(bitcast(somevector), cst))
ConstantInt *ShAmt = 0; ConstantInt *ShAmt = 0;
if (match(Src, m_Trunc(m_LShr(m_BitCast(m_Value(VecInput)), if (match(Src, m_Trunc(m_LShr(m_BitCast(m_Value(VecInput)),
@ -1654,7 +1654,7 @@ static Instruction *OptimizeIntToFloatBitCast(BitCastInst &CI,InstCombiner &IC){
VecTy->getPrimitiveSizeInBits() / DestWidth); VecTy->getPrimitiveSizeInBits() / DestWidth);
VecInput = IC.Builder->CreateBitCast(VecInput, VecTy); VecInput = IC.Builder->CreateBitCast(VecInput, VecTy);
} }
unsigned Elt = ShAmt->getZExtValue() / DestWidth; unsigned Elt = ShAmt->getZExtValue() / DestWidth;
return ExtractElementInst::Create(VecInput, IC.Builder->getInt32(Elt)); return ExtractElementInst::Create(VecInput, IC.Builder->getInt32(Elt));
} }
@ -1678,12 +1678,12 @@ Instruction *InstCombiner::visitBitCast(BitCastInst &CI) {
PointerType *SrcPTy = cast<PointerType>(SrcTy); PointerType *SrcPTy = cast<PointerType>(SrcTy);
Type *DstElTy = DstPTy->getElementType(); Type *DstElTy = DstPTy->getElementType();
Type *SrcElTy = SrcPTy->getElementType(); Type *SrcElTy = SrcPTy->getElementType();
// If the address spaces don't match, don't eliminate the bitcast, which is // If the address spaces don't match, don't eliminate the bitcast, which is
// required for changing types. // required for changing types.
if (SrcPTy->getAddressSpace() != DstPTy->getAddressSpace()) if (SrcPTy->getAddressSpace() != DstPTy->getAddressSpace())
return 0; return 0;
// If we are casting a alloca to a pointer to a type of the same // If we are casting a alloca to a pointer to a type of the same
// size, rewrite the allocation instruction to allocate the "right" type. // size, rewrite the allocation instruction to allocate the "right" type.
// There is no need to modify malloc calls because it is their bitcast that // There is no need to modify malloc calls because it is their bitcast that
@ -1691,14 +1691,14 @@ Instruction *InstCombiner::visitBitCast(BitCastInst &CI) {
if (AllocaInst *AI = dyn_cast<AllocaInst>(Src)) if (AllocaInst *AI = dyn_cast<AllocaInst>(Src))
if (Instruction *V = PromoteCastOfAllocation(CI, *AI)) if (Instruction *V = PromoteCastOfAllocation(CI, *AI))
return V; return V;
// If the source and destination are pointers, and this cast is equivalent // If the source and destination are pointers, and this cast is equivalent
// to a getelementptr X, 0, 0, 0... turn it into the appropriate gep. // to a getelementptr X, 0, 0, 0... turn it into the appropriate gep.
// This can enhance SROA and other transforms that want type-safe pointers. // This can enhance SROA and other transforms that want type-safe pointers.
Constant *ZeroUInt = Constant *ZeroUInt =
Constant::getNullValue(Type::getInt32Ty(CI.getContext())); Constant::getNullValue(Type::getInt32Ty(CI.getContext()));
unsigned NumZeros = 0; unsigned NumZeros = 0;
while (SrcElTy != DstElTy && while (SrcElTy != DstElTy &&
isa<CompositeType>(SrcElTy) && !SrcElTy->isPointerTy() && isa<CompositeType>(SrcElTy) && !SrcElTy->isPointerTy() &&
SrcElTy->getNumContainedTypes() /* not "{}" */) { SrcElTy->getNumContainedTypes() /* not "{}" */) {
SrcElTy = cast<CompositeType>(SrcElTy)->getTypeAtIndex(ZeroUInt); SrcElTy = cast<CompositeType>(SrcElTy)->getTypeAtIndex(ZeroUInt);
@ -1711,7 +1711,7 @@ Instruction *InstCombiner::visitBitCast(BitCastInst &CI) {
return GetElementPtrInst::CreateInBounds(Src, Idxs); return GetElementPtrInst::CreateInBounds(Src, Idxs);
} }
} }
// Try to optimize int -> float bitcasts. // Try to optimize int -> float bitcasts.
if ((DestTy->isFloatTy() || DestTy->isDoubleTy()) && isa<IntegerType>(SrcTy)) if ((DestTy->isFloatTy() || DestTy->isDoubleTy()) && isa<IntegerType>(SrcTy))
if (Instruction *I = OptimizeIntToFloatBitCast(CI, *this)) if (Instruction *I = OptimizeIntToFloatBitCast(CI, *this))
@ -1724,7 +1724,7 @@ Instruction *InstCombiner::visitBitCast(BitCastInst &CI) {
Constant::getNullValue(Type::getInt32Ty(CI.getContext()))); Constant::getNullValue(Type::getInt32Ty(CI.getContext())));
// FIXME: Canonicalize bitcast(insertelement) -> insertelement(bitcast) // FIXME: Canonicalize bitcast(insertelement) -> insertelement(bitcast)
} }
if (isa<IntegerType>(SrcTy)) { if (isa<IntegerType>(SrcTy)) {
// If this is a cast from an integer to vector, check to see if the input // If this is a cast from an integer to vector, check to see if the input
// is a trunc or zext of a bitcast from vector. If so, we can replace all // is a trunc or zext of a bitcast from vector. If so, we can replace all
@ -1737,7 +1737,7 @@ Instruction *InstCombiner::visitBitCast(BitCastInst &CI) {
cast<VectorType>(DestTy), *this)) cast<VectorType>(DestTy), *this))
return I; return I;
} }
// If the input is an 'or' instruction, we may be doing shifts and ors to // If the input is an 'or' instruction, we may be doing shifts and ors to
// assemble the elements of the vector manually. Try to rip the code out // assemble the elements of the vector manually. Try to rip the code out
// and replace it with insertelements. // and replace it with insertelements.
@ -1748,7 +1748,7 @@ Instruction *InstCombiner::visitBitCast(BitCastInst &CI) {
if (VectorType *SrcVTy = dyn_cast<VectorType>(SrcTy)) { if (VectorType *SrcVTy = dyn_cast<VectorType>(SrcTy)) {
if (SrcVTy->getNumElements() == 1 && !DestTy->isVectorTy()) { if (SrcVTy->getNumElements() == 1 && !DestTy->isVectorTy()) {
Value *Elem = Value *Elem =
Builder->CreateExtractElement(Src, Builder->CreateExtractElement(Src,
Constant::getNullValue(Type::getInt32Ty(CI.getContext()))); Constant::getNullValue(Type::getInt32Ty(CI.getContext())));
return CastInst::Create(Instruction::BitCast, Elem, DestTy); return CastInst::Create(Instruction::BitCast, Elem, DestTy);
@ -1758,7 +1758,7 @@ Instruction *InstCombiner::visitBitCast(BitCastInst &CI) {
if (ShuffleVectorInst *SVI = dyn_cast<ShuffleVectorInst>(Src)) { if (ShuffleVectorInst *SVI = dyn_cast<ShuffleVectorInst>(Src)) {
// Okay, we have (bitcast (shuffle ..)). Check to see if this is // Okay, we have (bitcast (shuffle ..)). Check to see if this is
// a bitcast to a vector with the same # elts. // a bitcast to a vector with the same # elts.
if (SVI->hasOneUse() && DestTy->isVectorTy() && if (SVI->hasOneUse() && DestTy->isVectorTy() &&
cast<VectorType>(DestTy)->getNumElements() == cast<VectorType>(DestTy)->getNumElements() ==
SVI->getType()->getNumElements() && SVI->getType()->getNumElements() &&
SVI->getType()->getNumElements() == SVI->getType()->getNumElements() ==
@ -1767,9 +1767,9 @@ Instruction *InstCombiner::visitBitCast(BitCastInst &CI) {
// If either of the operands is a cast from CI.getType(), then // If either of the operands is a cast from CI.getType(), then
// evaluating the shuffle in the casted destination's type will allow // evaluating the shuffle in the casted destination's type will allow
// us to eliminate at least one cast. // us to eliminate at least one cast.
if (((Tmp = dyn_cast<BitCastInst>(SVI->getOperand(0))) && if (((Tmp = dyn_cast<BitCastInst>(SVI->getOperand(0))) &&
Tmp->getOperand(0)->getType() == DestTy) || Tmp->getOperand(0)->getType() == DestTy) ||
((Tmp = dyn_cast<BitCastInst>(SVI->getOperand(1))) && ((Tmp = dyn_cast<BitCastInst>(SVI->getOperand(1))) &&
Tmp->getOperand(0)->getType() == DestTy)) { Tmp->getOperand(0)->getType() == DestTy)) {
Value *LHS = Builder->CreateBitCast(SVI->getOperand(0), DestTy); Value *LHS = Builder->CreateBitCast(SVI->getOperand(0), DestTy);
Value *RHS = Builder->CreateBitCast(SVI->getOperand(1), DestTy); Value *RHS = Builder->CreateBitCast(SVI->getOperand(1), DestTy);
@ -1779,7 +1779,7 @@ Instruction *InstCombiner::visitBitCast(BitCastInst &CI) {
} }
} }
} }
if (SrcTy->isPointerTy()) if (SrcTy->isPointerTy())
return commonPointerCastTransforms(CI); return commonPointerCastTransforms(CI);
return commonCastTransforms(CI); return commonCastTransforms(CI);