Lines Matching refs:CI
28 if (ConstantInt *CI = dyn_cast<ConstantInt>(Val)) {
29 Offset = CI->getZExtValue();
79 Instruction *InstCombiner::PromoteCastOfAllocation(BitCastInst &CI,
84 PointerType *PTy = cast<PointerType>(CI.getType());
146 // things that used it to use the new cast. This will also hack on CI, but it
154 return ReplaceInstUsesWith(CI, New);
235 const CastInst *CI, ///< The first cast instruction
241 Type *SrcTy = CI->getOperand(0)->getType(); // A from above
242 Type *MidTy = CI->getType(); // B from above
245 Instruction::CastOps firstOp = Instruction::CastOps(CI->getOpcode());
277 if (const CastInst *CI = dyn_cast<CastInst>(V))
278 if (isEliminableCastPair(CI, opc, Ty, TD))
291 Instruction *InstCombiner::commonCastTransforms(CastInst &CI) {
292 Value *Src = CI.getOperand(0);
298 isEliminableCastPair(CSrc, CI.getOpcode(), CI.getType(), TD)) {
300 // the second cast (CI). CSrc will then have a good chance of being dead.
301 return CastInst::Create(opc, CSrc->getOperand(0), CI.getType());
307 if (Instruction *NV = FoldOpIntoSelect(CI, SI))
315 !CI.getType()->isIntegerTy() ||
316 ShouldChangeType(CI.getType(), Src->getType()))
317 if (Instruction *NV = FoldOpIntoPhi(CI))
385 if (ConstantInt *CI = dyn_cast<ConstantInt>(I->getOperand(1))) {
387 if (CI->getLimitedValue(BitWidth) < BitWidth)
395 if (ConstantInt *CI = dyn_cast<ConstantInt>(I->getOperand(1))) {
400 CI->getLimitedValue(BitWidth) < BitWidth) {
436 Instruction *InstCombiner::visitTrunc(TruncInst &CI) {
437 if (Instruction *Result = commonCastTransforms(CI))
442 if (SimplifyDemandedInstructionBits(CI))
443 return &CI;
445 Value *Src = CI.getOperand(0);
446 Type *DestTy = CI.getType(), *SrcTy = Src->getType();
458 " to avoid cast: " << CI << '\n');
461 return ReplaceInstUsesWith(CI, Res);
485 return ReplaceInstUsesWith(CI, Constant::getNullValue(CI.getType()));
492 return CastInst::CreateIntegerCast(Shift, CI.getType(), false);
498 ShouldChangeType(Src->getType(), CI.getType()) &&
500 Value *NewTrunc = Builder->CreateTrunc(A, CI.getType(), A->getName()+".tr");
502 ConstantExpr::getTrunc(Cst, CI.getType()));
510 Instruction *InstCombiner::transformZExtICmp(ICmpInst *ICI, Instruction &CI,
528 if (In->getType() != CI.getType())
529 In = Builder->CreateIntCast(In, CI.getType(), false/*ZExt*/);
536 return ReplaceInstUsesWith(CI, In);
563 Constant *Res = ConstantInt::get(Type::getInt1Ty(CI.getContext()),
565 Res = ConstantExpr::getZExt(Res, CI.getType());
566 return ReplaceInstUsesWith(CI, Res);
583 if (CI.getType() == In->getType())
584 return ReplaceInstUsesWith(CI, In);
585 return CastInst::CreateIntegerCast(In, CI.getType(), false/*ZExt*/);
593 if (ICI->isEquality() && CI.getType() == ICI->getOperand(0)->getType()) {
594 if (IntegerType *ITy = dyn_cast<IntegerType>(CI.getType())) {
624 return ReplaceInstUsesWith(CI, Result);
757 Instruction *InstCombiner::visitZExt(ZExtInst &CI) {
760 if (CI.hasOneUse() && isa<TruncInst>(CI.use_back()))
764 if (Instruction *Result = commonCastTransforms(CI))
769 if (SimplifyDemandedInstructionBits(CI))
770 return &CI;
772 Value *Src = CI.getOperand(0);
773 Type *SrcTy = Src->getType(), *DestTy = CI.getType();
787 " to avoid zero extend: " << CI);
798 return ReplaceInstUsesWith(CI, Res);
817 unsigned DstSize = CI.getType()->getScalarSizeInBits();
826 return new ZExtInst(And, CI.getType());
835 Value *Trunc = Builder->CreateTrunc(A, CI.getType());
844 return transformZExtICmp(ICI, CI);
853 (transformZExtICmp(LHS, CI, false) ||
854 transformZExtICmp(RHS, CI, false))) {
855 Value *LCast = Builder->CreateZExt(LHS, CI.getType(), LHS->getName());
856 Value *RCast = Builder->CreateZExt(RHS, CI.getType(), RHS->getName());
866 if (TI0->getType() == CI.getType())
869 ConstantExpr::getZExt(C, CI.getType()));
880 if (TI0->getType() == CI.getType()) {
881 Constant *ZC = ConstantExpr::getZExt(C, CI.getType());
892 Value *New = Builder->CreateZExt(X, CI.getType());
893 return BinaryOperator::CreateXor(New, ConstantInt::get(CI.getType(), 1));
901 Instruction *InstCombiner::transformSExtICmp(ICmpInst *ICI, Instruction &CI) {
914 if (In->getType() != CI.getType())
915 In = Builder->CreateIntCast(In, CI.getType(), true/*SExt*/);
919 return ReplaceInstUsesWith(CI, In);
938 ConstantInt::getAllOnesValue(CI.getType()) :
939 ConstantInt::getNullValue(CI.getType());
940 return ReplaceInstUsesWith(CI, V);
971 if (CI.getType() == In->getType())
972 return ReplaceInstUsesWith(CI, In);
973 return CastInst::CreateIntegerCast(In, CI.getType(), true/*SExt*/);
979 if (VectorType *VTy = dyn_cast<VectorType>(CI.getType())) {
981 Op0->getType() == CI.getType()) {
987 return ReplaceInstUsesWith(CI, In);
1059 Instruction *InstCombiner::visitSExt(SExtInst &CI) {
1062 if (CI.hasOneUse() && isa<TruncInst>(CI.use_back()))
1065 if (Instruction *I = commonCastTransforms(CI))
1070 if (SimplifyDemandedInstructionBits(CI))
1071 return &CI;
1073 Value *Src = CI.getOperand(0);
1074 Type *SrcTy = Src->getType(), *DestTy = CI.getType();
1084 " to avoid sign extend: " << CI);
1094 return ReplaceInstUsesWith(CI, Res);
1116 return transformSExtICmp(ICI, CI);
1136 BA == CA && A->getType() == CI.getType()) {
1138 unsigned SrcDstSize = CI.getType()->getScalarSizeInBits();
1140 Constant *ShAmtV = ConstantInt::get(CI.getType(), ShAmt);
1141 A = Builder->CreateShl(A, ShAmtV, CI.getName());
1189 Instruction *InstCombiner::visitFPTrunc(FPTruncInst &CI) {
1190 if (Instruction *I = commonCastTransforms(CI))
1197 BinaryOperator *OpI = dyn_cast<BinaryOperator>(CI.getOperand(0));
1211 unsigned DstSize = CI.getType()->getScalarSizeInBits();
1216 LHSTrunc = Builder->CreateFPExt(LHSTrunc, CI.getType());
1217 RHSTrunc = Builder->CreateFPExt(RHSTrunc, CI.getType());
1227 CI.getType());
1234 SelectInst *SI = dyn_cast<SelectInst>(CI.getOperand(0));
1239 CI.getType());
1241 CI.getType());
1245 IntrinsicInst *II = dyn_cast<IntrinsicInst>(CI.getOperand(0));
1252 CI.getType());
1253 Type *IntrinsicType[] = { CI.getType() };
1255 Intrinsic::getDeclaration(CI.getParent()->getParent()->getParent(),
1269 CallInst *Call = dyn_cast<CallInst>(CI.getOperand(0));
1277 CI.getType()->isFloatTy() &&
1282 Module *M = CI.getParent()->getParent()->getParent();
1303 Instruction *InstCombiner::visitFPExt(CastInst &CI) {
1304 return commonCastTransforms(CI);
1347 Instruction *InstCombiner::visitUIToFP(CastInst &CI) {
1348 return commonCastTransforms(CI);
1351 Instruction *InstCombiner::visitSIToFP(CastInst &CI) {
1352 return commonCastTransforms(CI);
1355 Instruction *InstCombiner::visitIntToPtr(IntToPtrInst &CI) {
1361 unsigned AS = CI.getAddressSpace();
1362 if (CI.getOperand(0)->getType()->getScalarSizeInBits() !=
1364 Type *Ty = TD->getIntPtrType(CI.getContext(), AS);
1365 if (CI.getType()->isVectorTy()) // Handle vectors of pointers.
1366 Ty = VectorType::get(Ty, CI.getType()->getVectorNumElements());
1368 Value *P = Builder->CreateZExtOrTrunc(CI.getOperand(0), Ty);
1369 return new IntToPtrInst(P, CI.getType());
1373 if (Instruction *I = commonCastTransforms(CI))
1380 Instruction *InstCombiner::commonPointerCastTransforms(CastInst &CI) {
1381 Value *Src = CI.getOperand(0);
1391 CI.setOperand(0, GEP->getOperand(0));
1392 return &CI;
1396 return commonCastTransforms(CI);
1423 if (isa<BitCastInst>(CI))
1424 return new BitCastInst(NGEP, CI.getType());
1425 assert(isa<PtrToIntInst>(CI));
1426 return new PtrToIntInst(NGEP, CI.getType());
1431 return commonCastTransforms(CI);
1434 Instruction *InstCombiner::visitPtrToInt(PtrToIntInst &CI) {
1440 return commonPointerCastTransforms(CI);
1442 Type *Ty = CI.getType();
1443 unsigned AS = CI.getPointerAddressSpace();
1446 return commonPointerCastTransforms(CI);
1448 Type *PtrTy = TD->getIntPtrType(CI.getContext(), AS);
1452 Value *P = Builder->CreatePtrToInt(CI.getOperand(0), PtrTy);
1613 ConstantInt *CI = dyn_cast<ConstantInt>(I->getOperand(1));
1614 if (CI == 0) return false;
1615 Shift += CI->getZExtValue();
1639 static Value *OptimizeIntegerToVectorInsertions(BitCastInst &CI,
1644 VectorType *DestVecTy = cast<VectorType>(CI.getType());
1645 Value *IntInput = CI.getOperand(0);
1655 Value *Result = Constant::getNullValue(CI.getType());
1669 static Instruction *OptimizeIntToFloatBitCast(BitCastInst &CI,InstCombiner &IC){
1673 Value *Src = CI.getOperand(0);
1674 Type *DestTy = CI.getType();
1727 Instruction *InstCombiner::visitBitCast(BitCastInst &CI) {
1730 Value *Src = CI.getOperand(0);
1732 Type *DestTy = CI.getType();
1737 return ReplaceInstUsesWith(CI, Src);
1754 if (Instruction *V = PromoteCastOfAllocation(CI, *AI))
1761 Constant::getNullValue(Type::getInt32Ty(CI.getContext()));
1779 if (Instruction *I = OptimizeIntToFloatBitCast(CI, *this))
1786 Constant::getNullValue(Type::getInt32Ty(CI.getContext())));
1806 if (Value *V = OptimizeIntegerToVectorInsertions(CI, *this))
1807 return ReplaceInstUsesWith(CI, V);
1818 Constant::getNullValue(Type::getInt32Ty(CI.getContext())));
1825 dyn_cast<InsertElementInst>(CI.getOperand(0)))
1839 // If either of the operands is a cast from CI.getType(), then
1856 return commonPointerCastTransforms(CI);
1857 return commonCastTransforms(CI);
1860 Instruction *InstCombiner::visitAddrSpaceCast(AddrSpaceCastInst &CI) {
1861 return commonCastTransforms(CI);