InstructionCombining.cpp revision b8a5cecd6bc74d6c1c256263f857f79f383e53bd
1//===- InstructionCombining.cpp - Combine multiple instructions -----------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// InstructionCombining - Combine instructions to form fewer, simple 11// instructions. This pass does not modify the CFG. This pass is where 12// algebraic simplification happens. 13// 14// This pass combines things like: 15// %Y = add i32 %X, 1 16// %Z = add i32 %Y, 1 17// into: 18// %Z = add i32 %X, 2 19// 20// This is a simple worklist driven algorithm. 21// 22// This pass guarantees that the following canonicalizations are performed on 23// the program: 24// 1. If a binary operator has a constant operand, it is moved to the RHS 25// 2. Bitwise operators with constant operands are always grouped so that 26// shifts are performed first, then or's, then and's, then xor's. 27// 3. Compare instructions are converted from <,>,<=,>= to ==,!= if possible 28// 4. All cmp instructions on boolean values are replaced with logical ops 29// 5. add X, X is represented as (X*2) => (X << 1) 30// 6. Multiplies with a power-of-two constant argument are transformed into 31// shifts. 32// ... etc. 33// 34//===----------------------------------------------------------------------===// 35 36#define DEBUG_TYPE "instcombine" 37#include "llvm/Transforms/Scalar.h" 38#include "InstCombine.h" 39#include "llvm/IntrinsicInst.h" 40#include "llvm/LLVMContext.h" 41#include "llvm/DerivedTypes.h" 42#include "llvm/GlobalVariable.h" 43#include "llvm/Operator.h" 44#include "llvm/Analysis/ConstantFolding.h" 45#include "llvm/Analysis/InstructionSimplify.h" 46#include "llvm/Analysis/MemoryBuiltins.h" 47#include "llvm/Target/TargetData.h" 48#include "llvm/Transforms/Utils/BasicBlockUtils.h" 49#include "llvm/Transforms/Utils/Local.h" 50#include "llvm/Support/CallSite.h" 51#include "llvm/Support/Debug.h" 52#include "llvm/Support/ErrorHandling.h" 53#include "llvm/Support/GetElementPtrTypeIterator.h" 54#include "llvm/Support/MathExtras.h" 55#include "llvm/Support/PatternMatch.h" 56#include "llvm/ADT/SmallPtrSet.h" 57#include "llvm/ADT/Statistic.h" 58#include "llvm/ADT/STLExtras.h" 59#include <algorithm> 60#include <climits> 61using namespace llvm; 62using namespace llvm::PatternMatch; 63 64STATISTIC(NumCombined , "Number of insts combined"); 65STATISTIC(NumConstProp, "Number of constant folds"); 66STATISTIC(NumDeadInst , "Number of dead inst eliminated"); 67STATISTIC(NumDeadStore, "Number of dead stores eliminated"); 68STATISTIC(NumSunkInst , "Number of instructions sunk"); 69 70 71char InstCombiner::ID = 0; 72static RegisterPass<InstCombiner> 73X("instcombine", "Combine redundant instructions"); 74 75void InstCombiner::getAnalysisUsage(AnalysisUsage &AU) const { 76 AU.addPreservedID(LCSSAID); 77 AU.setPreservesCFG(); 78} 79 80 81// isOnlyUse - Return true if this instruction will be deleted if we stop using 82// it. 83static bool isOnlyUse(Value *V) { 84 return V->hasOneUse() || isa<Constant>(V); 85} 86 87// getPromotedType - Return the specified type promoted as it would be to pass 88// though a va_arg area... 89static const Type *getPromotedType(const Type *Ty) { 90 if (const IntegerType* ITy = dyn_cast<IntegerType>(Ty)) { 91 if (ITy->getBitWidth() < 32) 92 return Type::getInt32Ty(Ty->getContext()); 93 } 94 return Ty; 95} 96 97/// ShouldChangeType - Return true if it is desirable to convert a computation 98/// from 'From' to 'To'. We don't want to convert from a legal to an illegal 99/// type for example, or from a smaller to a larger illegal type. 100bool InstCombiner::ShouldChangeType(const Type *From, const Type *To) const { 101 assert(isa<IntegerType>(From) && isa<IntegerType>(To)); 102 103 // If we don't have TD, we don't know if the source/dest are legal. 104 if (!TD) return false; 105 106 unsigned FromWidth = From->getPrimitiveSizeInBits(); 107 unsigned ToWidth = To->getPrimitiveSizeInBits(); 108 bool FromLegal = TD->isLegalInteger(FromWidth); 109 bool ToLegal = TD->isLegalInteger(ToWidth); 110 111 // If this is a legal integer from type, and the result would be an illegal 112 // type, don't do the transformation. 113 if (FromLegal && !ToLegal) 114 return false; 115 116 // Otherwise, if both are illegal, do not increase the size of the result. We 117 // do allow things like i160 -> i64, but not i64 -> i160. 118 if (!FromLegal && !ToLegal && ToWidth > FromWidth) 119 return false; 120 121 return true; 122} 123 124/// getBitCastOperand - If the specified operand is a CastInst, a constant 125/// expression bitcast, or a GetElementPtrInst with all zero indices, return the 126/// operand value, otherwise return null. 127static Value *getBitCastOperand(Value *V) { 128 if (Operator *O = dyn_cast<Operator>(V)) { 129 if (O->getOpcode() == Instruction::BitCast) 130 return O->getOperand(0); 131 if (GEPOperator *GEP = dyn_cast<GEPOperator>(V)) 132 if (GEP->hasAllZeroIndices()) 133 return GEP->getPointerOperand(); 134 } 135 return 0; 136} 137 138 139 140// SimplifyCommutative - This performs a few simplifications for commutative 141// operators: 142// 143// 1. Order operands such that they are listed from right (least complex) to 144// left (most complex). This puts constants before unary operators before 145// binary operators. 146// 147// 2. Transform: (op (op V, C1), C2) ==> (op V, (op C1, C2)) 148// 3. Transform: (op (op V1, C1), (op V2, C2)) ==> (op (op V1, V2), (op C1,C2)) 149// 150bool InstCombiner::SimplifyCommutative(BinaryOperator &I) { 151 bool Changed = false; 152 if (getComplexity(I.getOperand(0)) < getComplexity(I.getOperand(1))) 153 Changed = !I.swapOperands(); 154 155 if (!I.isAssociative()) return Changed; 156 Instruction::BinaryOps Opcode = I.getOpcode(); 157 if (BinaryOperator *Op = dyn_cast<BinaryOperator>(I.getOperand(0))) 158 if (Op->getOpcode() == Opcode && isa<Constant>(Op->getOperand(1))) { 159 if (isa<Constant>(I.getOperand(1))) { 160 Constant *Folded = ConstantExpr::get(I.getOpcode(), 161 cast<Constant>(I.getOperand(1)), 162 cast<Constant>(Op->getOperand(1))); 163 I.setOperand(0, Op->getOperand(0)); 164 I.setOperand(1, Folded); 165 return true; 166 } else if (BinaryOperator *Op1=dyn_cast<BinaryOperator>(I.getOperand(1))) 167 if (Op1->getOpcode() == Opcode && isa<Constant>(Op1->getOperand(1)) && 168 isOnlyUse(Op) && isOnlyUse(Op1)) { 169 Constant *C1 = cast<Constant>(Op->getOperand(1)); 170 Constant *C2 = cast<Constant>(Op1->getOperand(1)); 171 172 // Fold (op (op V1, C1), (op V2, C2)) ==> (op (op V1, V2), (op C1,C2)) 173 Constant *Folded = ConstantExpr::get(I.getOpcode(), C1, C2); 174 Instruction *New = BinaryOperator::Create(Opcode, Op->getOperand(0), 175 Op1->getOperand(0), 176 Op1->getName(), &I); 177 Worklist.Add(New); 178 I.setOperand(0, New); 179 I.setOperand(1, Folded); 180 return true; 181 } 182 } 183 return Changed; 184} 185 186// dyn_castNegVal - Given a 'sub' instruction, return the RHS of the instruction 187// if the LHS is a constant zero (which is the 'negate' form). 188// 189Value *InstCombiner::dyn_castNegVal(Value *V) const { 190 if (BinaryOperator::isNeg(V)) 191 return BinaryOperator::getNegArgument(V); 192 193 // Constants can be considered to be negated values if they can be folded. 194 if (ConstantInt *C = dyn_cast<ConstantInt>(V)) 195 return ConstantExpr::getNeg(C); 196 197 if (ConstantVector *C = dyn_cast<ConstantVector>(V)) 198 if (C->getType()->getElementType()->isInteger()) 199 return ConstantExpr::getNeg(C); 200 201 return 0; 202} 203 204// dyn_castFNegVal - Given a 'fsub' instruction, return the RHS of the 205// instruction if the LHS is a constant negative zero (which is the 'negate' 206// form). 207// 208static inline Value *dyn_castFNegVal(Value *V) { 209 if (BinaryOperator::isFNeg(V)) 210 return BinaryOperator::getFNegArgument(V); 211 212 // Constants can be considered to be negated values if they can be folded. 213 if (ConstantFP *C = dyn_cast<ConstantFP>(V)) 214 return ConstantExpr::getFNeg(C); 215 216 if (ConstantVector *C = dyn_cast<ConstantVector>(V)) 217 if (C->getType()->getElementType()->isFloatingPoint()) 218 return ConstantExpr::getFNeg(C); 219 220 return 0; 221} 222 223/// MatchSelectPattern - Pattern match integer [SU]MIN, [SU]MAX, and ABS idioms, 224/// returning the kind and providing the out parameter results if we 225/// successfully match. 226static SelectPatternFlavor 227MatchSelectPattern(Value *V, Value *&LHS, Value *&RHS) { 228 SelectInst *SI = dyn_cast<SelectInst>(V); 229 if (SI == 0) return SPF_UNKNOWN; 230 231 ICmpInst *ICI = dyn_cast<ICmpInst>(SI->getCondition()); 232 if (ICI == 0) return SPF_UNKNOWN; 233 234 LHS = ICI->getOperand(0); 235 RHS = ICI->getOperand(1); 236 237 // (icmp X, Y) ? X : Y 238 if (SI->getTrueValue() == ICI->getOperand(0) && 239 SI->getFalseValue() == ICI->getOperand(1)) { 240 switch (ICI->getPredicate()) { 241 default: return SPF_UNKNOWN; // Equality. 242 case ICmpInst::ICMP_UGT: 243 case ICmpInst::ICMP_UGE: return SPF_UMAX; 244 case ICmpInst::ICMP_SGT: 245 case ICmpInst::ICMP_SGE: return SPF_SMAX; 246 case ICmpInst::ICMP_ULT: 247 case ICmpInst::ICMP_ULE: return SPF_UMIN; 248 case ICmpInst::ICMP_SLT: 249 case ICmpInst::ICMP_SLE: return SPF_SMIN; 250 } 251 } 252 253 // (icmp X, Y) ? Y : X 254 if (SI->getTrueValue() == ICI->getOperand(1) && 255 SI->getFalseValue() == ICI->getOperand(0)) { 256 switch (ICI->getPredicate()) { 257 default: return SPF_UNKNOWN; // Equality. 258 case ICmpInst::ICMP_UGT: 259 case ICmpInst::ICMP_UGE: return SPF_UMIN; 260 case ICmpInst::ICMP_SGT: 261 case ICmpInst::ICMP_SGE: return SPF_SMIN; 262 case ICmpInst::ICMP_ULT: 263 case ICmpInst::ICMP_ULE: return SPF_UMAX; 264 case ICmpInst::ICMP_SLT: 265 case ICmpInst::ICMP_SLE: return SPF_SMAX; 266 } 267 } 268 269 // TODO: (X > 4) ? X : 5 --> (X >= 5) ? X : 5 --> MAX(X, 5) 270 271 return SPF_UNKNOWN; 272} 273 274/// isFreeToInvert - Return true if the specified value is free to invert (apply 275/// ~ to). This happens in cases where the ~ can be eliminated. 276static inline bool isFreeToInvert(Value *V) { 277 // ~(~(X)) -> X. 278 if (BinaryOperator::isNot(V)) 279 return true; 280 281 // Constants can be considered to be not'ed values. 282 if (isa<ConstantInt>(V)) 283 return true; 284 285 // Compares can be inverted if they have a single use. 286 if (CmpInst *CI = dyn_cast<CmpInst>(V)) 287 return CI->hasOneUse(); 288 289 return false; 290} 291 292static inline Value *dyn_castNotVal(Value *V) { 293 // If this is not(not(x)) don't return that this is a not: we want the two 294 // not's to be folded first. 295 if (BinaryOperator::isNot(V)) { 296 Value *Operand = BinaryOperator::getNotArgument(V); 297 if (!isFreeToInvert(Operand)) 298 return Operand; 299 } 300 301 // Constants can be considered to be not'ed values... 302 if (ConstantInt *C = dyn_cast<ConstantInt>(V)) 303 return ConstantInt::get(C->getType(), ~C->getValue()); 304 return 0; 305} 306 307 308 309// dyn_castFoldableMul - If this value is a multiply that can be folded into 310// other computations (because it has a constant operand), return the 311// non-constant operand of the multiply, and set CST to point to the multiplier. 312// Otherwise, return null. 313// 314static inline Value *dyn_castFoldableMul(Value *V, ConstantInt *&CST) { 315 if (V->hasOneUse() && V->getType()->isInteger()) 316 if (Instruction *I = dyn_cast<Instruction>(V)) { 317 if (I->getOpcode() == Instruction::Mul) 318 if ((CST = dyn_cast<ConstantInt>(I->getOperand(1)))) 319 return I->getOperand(0); 320 if (I->getOpcode() == Instruction::Shl) 321 if ((CST = dyn_cast<ConstantInt>(I->getOperand(1)))) { 322 // The multiplier is really 1 << CST. 323 uint32_t BitWidth = cast<IntegerType>(V->getType())->getBitWidth(); 324 uint32_t CSTVal = CST->getLimitedValue(BitWidth); 325 CST = ConstantInt::get(V->getType()->getContext(), 326 APInt(BitWidth, 1).shl(CSTVal)); 327 return I->getOperand(0); 328 } 329 } 330 return 0; 331} 332 333/// AddOne - Add one to a ConstantInt 334static Constant *AddOne(Constant *C) { 335 return ConstantExpr::getAdd(C, ConstantInt::get(C->getType(), 1)); 336} 337/// SubOne - Subtract one from a ConstantInt 338static Constant *SubOne(ConstantInt *C) { 339 return ConstantExpr::getSub(C, ConstantInt::get(C->getType(), 1)); 340} 341/// MultiplyOverflows - True if the multiply can not be expressed in an int 342/// this size. 343static bool MultiplyOverflows(ConstantInt *C1, ConstantInt *C2, bool sign) { 344 uint32_t W = C1->getBitWidth(); 345 APInt LHSExt = C1->getValue(), RHSExt = C2->getValue(); 346 if (sign) { 347 LHSExt.sext(W * 2); 348 RHSExt.sext(W * 2); 349 } else { 350 LHSExt.zext(W * 2); 351 RHSExt.zext(W * 2); 352 } 353 354 APInt MulExt = LHSExt * RHSExt; 355 356 if (!sign) 357 return MulExt.ugt(APInt::getLowBitsSet(W * 2, W)); 358 359 APInt Min = APInt::getSignedMinValue(W).sext(W * 2); 360 APInt Max = APInt::getSignedMaxValue(W).sext(W * 2); 361 return MulExt.slt(Min) || MulExt.sgt(Max); 362} 363 364 365 366/// AssociativeOpt - Perform an optimization on an associative operator. This 367/// function is designed to check a chain of associative operators for a 368/// potential to apply a certain optimization. Since the optimization may be 369/// applicable if the expression was reassociated, this checks the chain, then 370/// reassociates the expression as necessary to expose the optimization 371/// opportunity. This makes use of a special Functor, which must define 372/// 'shouldApply' and 'apply' methods. 373/// 374template<typename Functor> 375static Instruction *AssociativeOpt(BinaryOperator &Root, const Functor &F) { 376 unsigned Opcode = Root.getOpcode(); 377 Value *LHS = Root.getOperand(0); 378 379 // Quick check, see if the immediate LHS matches... 380 if (F.shouldApply(LHS)) 381 return F.apply(Root); 382 383 // Otherwise, if the LHS is not of the same opcode as the root, return. 384 Instruction *LHSI = dyn_cast<Instruction>(LHS); 385 while (LHSI && LHSI->getOpcode() == Opcode && LHSI->hasOneUse()) { 386 // Should we apply this transform to the RHS? 387 bool ShouldApply = F.shouldApply(LHSI->getOperand(1)); 388 389 // If not to the RHS, check to see if we should apply to the LHS... 390 if (!ShouldApply && F.shouldApply(LHSI->getOperand(0))) { 391 cast<BinaryOperator>(LHSI)->swapOperands(); // Make the LHS the RHS 392 ShouldApply = true; 393 } 394 395 // If the functor wants to apply the optimization to the RHS of LHSI, 396 // reassociate the expression from ((? op A) op B) to (? op (A op B)) 397 if (ShouldApply) { 398 // Now all of the instructions are in the current basic block, go ahead 399 // and perform the reassociation. 400 Instruction *TmpLHSI = cast<Instruction>(Root.getOperand(0)); 401 402 // First move the selected RHS to the LHS of the root... 403 Root.setOperand(0, LHSI->getOperand(1)); 404 405 // Make what used to be the LHS of the root be the user of the root... 406 Value *ExtraOperand = TmpLHSI->getOperand(1); 407 if (&Root == TmpLHSI) { 408 Root.replaceAllUsesWith(Constant::getNullValue(TmpLHSI->getType())); 409 return 0; 410 } 411 Root.replaceAllUsesWith(TmpLHSI); // Users now use TmpLHSI 412 TmpLHSI->setOperand(1, &Root); // TmpLHSI now uses the root 413 BasicBlock::iterator ARI = &Root; ++ARI; 414 TmpLHSI->moveBefore(ARI); // Move TmpLHSI to after Root 415 ARI = Root; 416 417 // Now propagate the ExtraOperand down the chain of instructions until we 418 // get to LHSI. 419 while (TmpLHSI != LHSI) { 420 Instruction *NextLHSI = cast<Instruction>(TmpLHSI->getOperand(0)); 421 // Move the instruction to immediately before the chain we are 422 // constructing to avoid breaking dominance properties. 423 NextLHSI->moveBefore(ARI); 424 ARI = NextLHSI; 425 426 Value *NextOp = NextLHSI->getOperand(1); 427 NextLHSI->setOperand(1, ExtraOperand); 428 TmpLHSI = NextLHSI; 429 ExtraOperand = NextOp; 430 } 431 432 // Now that the instructions are reassociated, have the functor perform 433 // the transformation... 434 return F.apply(Root); 435 } 436 437 LHSI = dyn_cast<Instruction>(LHSI->getOperand(0)); 438 } 439 return 0; 440} 441 442namespace { 443 444// AddRHS - Implements: X + X --> X << 1 445struct AddRHS { 446 Value *RHS; 447 explicit AddRHS(Value *rhs) : RHS(rhs) {} 448 bool shouldApply(Value *LHS) const { return LHS == RHS; } 449 Instruction *apply(BinaryOperator &Add) const { 450 return BinaryOperator::CreateShl(Add.getOperand(0), 451 ConstantInt::get(Add.getType(), 1)); 452 } 453}; 454 455// AddMaskingAnd - Implements (A & C1)+(B & C2) --> (A & C1)|(B & C2) 456// iff C1&C2 == 0 457struct AddMaskingAnd { 458 Constant *C2; 459 explicit AddMaskingAnd(Constant *c) : C2(c) {} 460 bool shouldApply(Value *LHS) const { 461 ConstantInt *C1; 462 return match(LHS, m_And(m_Value(), m_ConstantInt(C1))) && 463 ConstantExpr::getAnd(C1, C2)->isNullValue(); 464 } 465 Instruction *apply(BinaryOperator &Add) const { 466 return BinaryOperator::CreateOr(Add.getOperand(0), Add.getOperand(1)); 467 } 468}; 469 470} 471 472static Value *FoldOperationIntoSelectOperand(Instruction &I, Value *SO, 473 InstCombiner *IC) { 474 if (CastInst *CI = dyn_cast<CastInst>(&I)) 475 return IC->Builder->CreateCast(CI->getOpcode(), SO, I.getType()); 476 477 // Figure out if the constant is the left or the right argument. 478 bool ConstIsRHS = isa<Constant>(I.getOperand(1)); 479 Constant *ConstOperand = cast<Constant>(I.getOperand(ConstIsRHS)); 480 481 if (Constant *SOC = dyn_cast<Constant>(SO)) { 482 if (ConstIsRHS) 483 return ConstantExpr::get(I.getOpcode(), SOC, ConstOperand); 484 return ConstantExpr::get(I.getOpcode(), ConstOperand, SOC); 485 } 486 487 Value *Op0 = SO, *Op1 = ConstOperand; 488 if (!ConstIsRHS) 489 std::swap(Op0, Op1); 490 491 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(&I)) 492 return IC->Builder->CreateBinOp(BO->getOpcode(), Op0, Op1, 493 SO->getName()+".op"); 494 if (ICmpInst *CI = dyn_cast<ICmpInst>(&I)) 495 return IC->Builder->CreateICmp(CI->getPredicate(), Op0, Op1, 496 SO->getName()+".cmp"); 497 if (FCmpInst *CI = dyn_cast<FCmpInst>(&I)) 498 return IC->Builder->CreateICmp(CI->getPredicate(), Op0, Op1, 499 SO->getName()+".cmp"); 500 llvm_unreachable("Unknown binary instruction type!"); 501} 502 503// FoldOpIntoSelect - Given an instruction with a select as one operand and a 504// constant as the other operand, try to fold the binary operator into the 505// select arguments. This also works for Cast instructions, which obviously do 506// not have a second operand. 507Instruction *InstCombiner::FoldOpIntoSelect(Instruction &Op, SelectInst *SI) { 508 // Don't modify shared select instructions 509 if (!SI->hasOneUse()) return 0; 510 Value *TV = SI->getOperand(1); 511 Value *FV = SI->getOperand(2); 512 513 if (isa<Constant>(TV) || isa<Constant>(FV)) { 514 // Bool selects with constant operands can be folded to logical ops. 515 if (SI->getType() == Type::getInt1Ty(SI->getContext())) return 0; 516 517 Value *SelectTrueVal = FoldOperationIntoSelectOperand(Op, TV, this); 518 Value *SelectFalseVal = FoldOperationIntoSelectOperand(Op, FV, this); 519 520 return SelectInst::Create(SI->getCondition(), SelectTrueVal, 521 SelectFalseVal); 522 } 523 return 0; 524} 525 526 527/// FoldOpIntoPhi - Given a binary operator, cast instruction, or select which 528/// has a PHI node as operand #0, see if we can fold the instruction into the 529/// PHI (which is only possible if all operands to the PHI are constants). 530/// 531/// If AllowAggressive is true, FoldOpIntoPhi will allow certain transforms 532/// that would normally be unprofitable because they strongly encourage jump 533/// threading. 534Instruction *InstCombiner::FoldOpIntoPhi(Instruction &I, 535 bool AllowAggressive) { 536 AllowAggressive = false; 537 PHINode *PN = cast<PHINode>(I.getOperand(0)); 538 unsigned NumPHIValues = PN->getNumIncomingValues(); 539 if (NumPHIValues == 0 || 540 // We normally only transform phis with a single use, unless we're trying 541 // hard to make jump threading happen. 542 (!PN->hasOneUse() && !AllowAggressive)) 543 return 0; 544 545 546 // Check to see if all of the operands of the PHI are simple constants 547 // (constantint/constantfp/undef). If there is one non-constant value, 548 // remember the BB it is in. If there is more than one or if *it* is a PHI, 549 // bail out. We don't do arbitrary constant expressions here because moving 550 // their computation can be expensive without a cost model. 551 BasicBlock *NonConstBB = 0; 552 for (unsigned i = 0; i != NumPHIValues; ++i) 553 if (!isa<Constant>(PN->getIncomingValue(i)) || 554 isa<ConstantExpr>(PN->getIncomingValue(i))) { 555 if (NonConstBB) return 0; // More than one non-const value. 556 if (isa<PHINode>(PN->getIncomingValue(i))) return 0; // Itself a phi. 557 NonConstBB = PN->getIncomingBlock(i); 558 559 // If the incoming non-constant value is in I's block, we have an infinite 560 // loop. 561 if (NonConstBB == I.getParent()) 562 return 0; 563 } 564 565 // If there is exactly one non-constant value, we can insert a copy of the 566 // operation in that block. However, if this is a critical edge, we would be 567 // inserting the computation one some other paths (e.g. inside a loop). Only 568 // do this if the pred block is unconditionally branching into the phi block. 569 if (NonConstBB != 0 && !AllowAggressive) { 570 BranchInst *BI = dyn_cast<BranchInst>(NonConstBB->getTerminator()); 571 if (!BI || !BI->isUnconditional()) return 0; 572 } 573 574 // Okay, we can do the transformation: create the new PHI node. 575 PHINode *NewPN = PHINode::Create(I.getType(), ""); 576 NewPN->reserveOperandSpace(PN->getNumOperands()/2); 577 InsertNewInstBefore(NewPN, *PN); 578 NewPN->takeName(PN); 579 580 // Next, add all of the operands to the PHI. 581 if (SelectInst *SI = dyn_cast<SelectInst>(&I)) { 582 // We only currently try to fold the condition of a select when it is a phi, 583 // not the true/false values. 584 Value *TrueV = SI->getTrueValue(); 585 Value *FalseV = SI->getFalseValue(); 586 BasicBlock *PhiTransBB = PN->getParent(); 587 for (unsigned i = 0; i != NumPHIValues; ++i) { 588 BasicBlock *ThisBB = PN->getIncomingBlock(i); 589 Value *TrueVInPred = TrueV->DoPHITranslation(PhiTransBB, ThisBB); 590 Value *FalseVInPred = FalseV->DoPHITranslation(PhiTransBB, ThisBB); 591 Value *InV = 0; 592 if (Constant *InC = dyn_cast<Constant>(PN->getIncomingValue(i))) { 593 InV = InC->isNullValue() ? FalseVInPred : TrueVInPred; 594 } else { 595 assert(PN->getIncomingBlock(i) == NonConstBB); 596 InV = SelectInst::Create(PN->getIncomingValue(i), TrueVInPred, 597 FalseVInPred, 598 "phitmp", NonConstBB->getTerminator()); 599 Worklist.Add(cast<Instruction>(InV)); 600 } 601 NewPN->addIncoming(InV, ThisBB); 602 } 603 } else if (I.getNumOperands() == 2) { 604 Constant *C = cast<Constant>(I.getOperand(1)); 605 for (unsigned i = 0; i != NumPHIValues; ++i) { 606 Value *InV = 0; 607 if (Constant *InC = dyn_cast<Constant>(PN->getIncomingValue(i))) { 608 if (CmpInst *CI = dyn_cast<CmpInst>(&I)) 609 InV = ConstantExpr::getCompare(CI->getPredicate(), InC, C); 610 else 611 InV = ConstantExpr::get(I.getOpcode(), InC, C); 612 } else { 613 assert(PN->getIncomingBlock(i) == NonConstBB); 614 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(&I)) 615 InV = BinaryOperator::Create(BO->getOpcode(), 616 PN->getIncomingValue(i), C, "phitmp", 617 NonConstBB->getTerminator()); 618 else if (CmpInst *CI = dyn_cast<CmpInst>(&I)) 619 InV = CmpInst::Create(CI->getOpcode(), 620 CI->getPredicate(), 621 PN->getIncomingValue(i), C, "phitmp", 622 NonConstBB->getTerminator()); 623 else 624 llvm_unreachable("Unknown binop!"); 625 626 Worklist.Add(cast<Instruction>(InV)); 627 } 628 NewPN->addIncoming(InV, PN->getIncomingBlock(i)); 629 } 630 } else { 631 CastInst *CI = cast<CastInst>(&I); 632 const Type *RetTy = CI->getType(); 633 for (unsigned i = 0; i != NumPHIValues; ++i) { 634 Value *InV; 635 if (Constant *InC = dyn_cast<Constant>(PN->getIncomingValue(i))) { 636 InV = ConstantExpr::getCast(CI->getOpcode(), InC, RetTy); 637 } else { 638 assert(PN->getIncomingBlock(i) == NonConstBB); 639 InV = CastInst::Create(CI->getOpcode(), PN->getIncomingValue(i), 640 I.getType(), "phitmp", 641 NonConstBB->getTerminator()); 642 Worklist.Add(cast<Instruction>(InV)); 643 } 644 NewPN->addIncoming(InV, PN->getIncomingBlock(i)); 645 } 646 } 647 return ReplaceInstUsesWith(I, NewPN); 648} 649 650 651/// WillNotOverflowSignedAdd - Return true if we can prove that: 652/// (sext (add LHS, RHS)) === (add (sext LHS), (sext RHS)) 653/// This basically requires proving that the add in the original type would not 654/// overflow to change the sign bit or have a carry out. 655bool InstCombiner::WillNotOverflowSignedAdd(Value *LHS, Value *RHS) { 656 // There are different heuristics we can use for this. Here are some simple 657 // ones. 658 659 // Add has the property that adding any two 2's complement numbers can only 660 // have one carry bit which can change a sign. As such, if LHS and RHS each 661 // have at least two sign bits, we know that the addition of the two values 662 // will sign extend fine. 663 if (ComputeNumSignBits(LHS) > 1 && ComputeNumSignBits(RHS) > 1) 664 return true; 665 666 667 // If one of the operands only has one non-zero bit, and if the other operand 668 // has a known-zero bit in a more significant place than it (not including the 669 // sign bit) the ripple may go up to and fill the zero, but won't change the 670 // sign. For example, (X & ~4) + 1. 671 672 // TODO: Implement. 673 674 return false; 675} 676 677 678Instruction *InstCombiner::visitAdd(BinaryOperator &I) { 679 bool Changed = SimplifyCommutative(I); 680 Value *LHS = I.getOperand(0), *RHS = I.getOperand(1); 681 682 if (Value *V = SimplifyAddInst(LHS, RHS, I.hasNoSignedWrap(), 683 I.hasNoUnsignedWrap(), TD)) 684 return ReplaceInstUsesWith(I, V); 685 686 687 if (Constant *RHSC = dyn_cast<Constant>(RHS)) { 688 if (ConstantInt *CI = dyn_cast<ConstantInt>(RHSC)) { 689 // X + (signbit) --> X ^ signbit 690 const APInt& Val = CI->getValue(); 691 uint32_t BitWidth = Val.getBitWidth(); 692 if (Val == APInt::getSignBit(BitWidth)) 693 return BinaryOperator::CreateXor(LHS, RHS); 694 695 // See if SimplifyDemandedBits can simplify this. This handles stuff like 696 // (X & 254)+1 -> (X&254)|1 697 if (SimplifyDemandedInstructionBits(I)) 698 return &I; 699 700 // zext(bool) + C -> bool ? C + 1 : C 701 if (ZExtInst *ZI = dyn_cast<ZExtInst>(LHS)) 702 if (ZI->getSrcTy() == Type::getInt1Ty(I.getContext())) 703 return SelectInst::Create(ZI->getOperand(0), AddOne(CI), CI); 704 } 705 706 if (isa<PHINode>(LHS)) 707 if (Instruction *NV = FoldOpIntoPhi(I)) 708 return NV; 709 710 ConstantInt *XorRHS = 0; 711 Value *XorLHS = 0; 712 if (isa<ConstantInt>(RHSC) && 713 match(LHS, m_Xor(m_Value(XorLHS), m_ConstantInt(XorRHS)))) { 714 uint32_t TySizeBits = I.getType()->getScalarSizeInBits(); 715 const APInt& RHSVal = cast<ConstantInt>(RHSC)->getValue(); 716 717 uint32_t Size = TySizeBits / 2; 718 APInt C0080Val(APInt(TySizeBits, 1ULL).shl(Size - 1)); 719 APInt CFF80Val(-C0080Val); 720 do { 721 if (TySizeBits > Size) { 722 // If we have ADD(XOR(AND(X, 0xFF), 0x80), 0xF..F80), it's a sext. 723 // If we have ADD(XOR(AND(X, 0xFF), 0xF..F80), 0x80), it's a sext. 724 if ((RHSVal == CFF80Val && XorRHS->getValue() == C0080Val) || 725 (RHSVal == C0080Val && XorRHS->getValue() == CFF80Val)) { 726 // This is a sign extend if the top bits are known zero. 727 if (!MaskedValueIsZero(XorLHS, 728 APInt::getHighBitsSet(TySizeBits, TySizeBits - Size))) 729 Size = 0; // Not a sign ext, but can't be any others either. 730 break; 731 } 732 } 733 Size >>= 1; 734 C0080Val = APIntOps::lshr(C0080Val, Size); 735 CFF80Val = APIntOps::ashr(CFF80Val, Size); 736 } while (Size >= 1); 737 738 // FIXME: This shouldn't be necessary. When the backends can handle types 739 // with funny bit widths then this switch statement should be removed. It 740 // is just here to get the size of the "middle" type back up to something 741 // that the back ends can handle. 742 const Type *MiddleType = 0; 743 switch (Size) { 744 default: break; 745 case 32: 746 case 16: 747 case 8: MiddleType = IntegerType::get(I.getContext(), Size); break; 748 } 749 if (MiddleType) { 750 Value *NewTrunc = Builder->CreateTrunc(XorLHS, MiddleType, "sext"); 751 return new SExtInst(NewTrunc, I.getType(), I.getName()); 752 } 753 } 754 } 755 756 if (I.getType() == Type::getInt1Ty(I.getContext())) 757 return BinaryOperator::CreateXor(LHS, RHS); 758 759 // X + X --> X << 1 760 if (I.getType()->isInteger()) { 761 if (Instruction *Result = AssociativeOpt(I, AddRHS(RHS))) 762 return Result; 763 764 if (Instruction *RHSI = dyn_cast<Instruction>(RHS)) { 765 if (RHSI->getOpcode() == Instruction::Sub) 766 if (LHS == RHSI->getOperand(1)) // A + (B - A) --> B 767 return ReplaceInstUsesWith(I, RHSI->getOperand(0)); 768 } 769 if (Instruction *LHSI = dyn_cast<Instruction>(LHS)) { 770 if (LHSI->getOpcode() == Instruction::Sub) 771 if (RHS == LHSI->getOperand(1)) // (B - A) + A --> B 772 return ReplaceInstUsesWith(I, LHSI->getOperand(0)); 773 } 774 } 775 776 // -A + B --> B - A 777 // -A + -B --> -(A + B) 778 if (Value *LHSV = dyn_castNegVal(LHS)) { 779 if (LHS->getType()->isIntOrIntVector()) { 780 if (Value *RHSV = dyn_castNegVal(RHS)) { 781 Value *NewAdd = Builder->CreateAdd(LHSV, RHSV, "sum"); 782 return BinaryOperator::CreateNeg(NewAdd); 783 } 784 } 785 786 return BinaryOperator::CreateSub(RHS, LHSV); 787 } 788 789 // A + -B --> A - B 790 if (!isa<Constant>(RHS)) 791 if (Value *V = dyn_castNegVal(RHS)) 792 return BinaryOperator::CreateSub(LHS, V); 793 794 795 ConstantInt *C2; 796 if (Value *X = dyn_castFoldableMul(LHS, C2)) { 797 if (X == RHS) // X*C + X --> X * (C+1) 798 return BinaryOperator::CreateMul(RHS, AddOne(C2)); 799 800 // X*C1 + X*C2 --> X * (C1+C2) 801 ConstantInt *C1; 802 if (X == dyn_castFoldableMul(RHS, C1)) 803 return BinaryOperator::CreateMul(X, ConstantExpr::getAdd(C1, C2)); 804 } 805 806 // X + X*C --> X * (C+1) 807 if (dyn_castFoldableMul(RHS, C2) == LHS) 808 return BinaryOperator::CreateMul(LHS, AddOne(C2)); 809 810 // X + ~X --> -1 since ~X = -X-1 811 if (dyn_castNotVal(LHS) == RHS || 812 dyn_castNotVal(RHS) == LHS) 813 return ReplaceInstUsesWith(I, Constant::getAllOnesValue(I.getType())); 814 815 816 // (A & C1)+(B & C2) --> (A & C1)|(B & C2) iff C1&C2 == 0 817 if (match(RHS, m_And(m_Value(), m_ConstantInt(C2)))) 818 if (Instruction *R = AssociativeOpt(I, AddMaskingAnd(C2))) 819 return R; 820 821 // A+B --> A|B iff A and B have no bits set in common. 822 if (const IntegerType *IT = dyn_cast<IntegerType>(I.getType())) { 823 APInt Mask = APInt::getAllOnesValue(IT->getBitWidth()); 824 APInt LHSKnownOne(IT->getBitWidth(), 0); 825 APInt LHSKnownZero(IT->getBitWidth(), 0); 826 ComputeMaskedBits(LHS, Mask, LHSKnownZero, LHSKnownOne); 827 if (LHSKnownZero != 0) { 828 APInt RHSKnownOne(IT->getBitWidth(), 0); 829 APInt RHSKnownZero(IT->getBitWidth(), 0); 830 ComputeMaskedBits(RHS, Mask, RHSKnownZero, RHSKnownOne); 831 832 // No bits in common -> bitwise or. 833 if ((LHSKnownZero|RHSKnownZero).isAllOnesValue()) 834 return BinaryOperator::CreateOr(LHS, RHS); 835 } 836 } 837 838 // W*X + Y*Z --> W * (X+Z) iff W == Y 839 if (I.getType()->isIntOrIntVector()) { 840 Value *W, *X, *Y, *Z; 841 if (match(LHS, m_Mul(m_Value(W), m_Value(X))) && 842 match(RHS, m_Mul(m_Value(Y), m_Value(Z)))) { 843 if (W != Y) { 844 if (W == Z) { 845 std::swap(Y, Z); 846 } else if (Y == X) { 847 std::swap(W, X); 848 } else if (X == Z) { 849 std::swap(Y, Z); 850 std::swap(W, X); 851 } 852 } 853 854 if (W == Y) { 855 Value *NewAdd = Builder->CreateAdd(X, Z, LHS->getName()); 856 return BinaryOperator::CreateMul(W, NewAdd); 857 } 858 } 859 } 860 861 if (ConstantInt *CRHS = dyn_cast<ConstantInt>(RHS)) { 862 Value *X = 0; 863 if (match(LHS, m_Not(m_Value(X)))) // ~X + C --> (C-1) - X 864 return BinaryOperator::CreateSub(SubOne(CRHS), X); 865 866 // (X & FF00) + xx00 -> (X+xx00) & FF00 867 if (LHS->hasOneUse() && 868 match(LHS, m_And(m_Value(X), m_ConstantInt(C2)))) { 869 Constant *Anded = ConstantExpr::getAnd(CRHS, C2); 870 if (Anded == CRHS) { 871 // See if all bits from the first bit set in the Add RHS up are included 872 // in the mask. First, get the rightmost bit. 873 const APInt& AddRHSV = CRHS->getValue(); 874 875 // Form a mask of all bits from the lowest bit added through the top. 876 APInt AddRHSHighBits(~((AddRHSV & -AddRHSV)-1)); 877 878 // See if the and mask includes all of these bits. 879 APInt AddRHSHighBitsAnd(AddRHSHighBits & C2->getValue()); 880 881 if (AddRHSHighBits == AddRHSHighBitsAnd) { 882 // Okay, the xform is safe. Insert the new add pronto. 883 Value *NewAdd = Builder->CreateAdd(X, CRHS, LHS->getName()); 884 return BinaryOperator::CreateAnd(NewAdd, C2); 885 } 886 } 887 } 888 889 // Try to fold constant add into select arguments. 890 if (SelectInst *SI = dyn_cast<SelectInst>(LHS)) 891 if (Instruction *R = FoldOpIntoSelect(I, SI)) 892 return R; 893 } 894 895 // add (select X 0 (sub n A)) A --> select X A n 896 { 897 SelectInst *SI = dyn_cast<SelectInst>(LHS); 898 Value *A = RHS; 899 if (!SI) { 900 SI = dyn_cast<SelectInst>(RHS); 901 A = LHS; 902 } 903 if (SI && SI->hasOneUse()) { 904 Value *TV = SI->getTrueValue(); 905 Value *FV = SI->getFalseValue(); 906 Value *N; 907 908 // Can we fold the add into the argument of the select? 909 // We check both true and false select arguments for a matching subtract. 910 if (match(FV, m_Zero()) && 911 match(TV, m_Sub(m_Value(N), m_Specific(A)))) 912 // Fold the add into the true select value. 913 return SelectInst::Create(SI->getCondition(), N, A); 914 if (match(TV, m_Zero()) && 915 match(FV, m_Sub(m_Value(N), m_Specific(A)))) 916 // Fold the add into the false select value. 917 return SelectInst::Create(SI->getCondition(), A, N); 918 } 919 } 920 921 // Check for (add (sext x), y), see if we can merge this into an 922 // integer add followed by a sext. 923 if (SExtInst *LHSConv = dyn_cast<SExtInst>(LHS)) { 924 // (add (sext x), cst) --> (sext (add x, cst')) 925 if (ConstantInt *RHSC = dyn_cast<ConstantInt>(RHS)) { 926 Constant *CI = 927 ConstantExpr::getTrunc(RHSC, LHSConv->getOperand(0)->getType()); 928 if (LHSConv->hasOneUse() && 929 ConstantExpr::getSExt(CI, I.getType()) == RHSC && 930 WillNotOverflowSignedAdd(LHSConv->getOperand(0), CI)) { 931 // Insert the new, smaller add. 932 Value *NewAdd = Builder->CreateNSWAdd(LHSConv->getOperand(0), 933 CI, "addconv"); 934 return new SExtInst(NewAdd, I.getType()); 935 } 936 } 937 938 // (add (sext x), (sext y)) --> (sext (add int x, y)) 939 if (SExtInst *RHSConv = dyn_cast<SExtInst>(RHS)) { 940 // Only do this if x/y have the same type, if at last one of them has a 941 // single use (so we don't increase the number of sexts), and if the 942 // integer add will not overflow. 943 if (LHSConv->getOperand(0)->getType()==RHSConv->getOperand(0)->getType()&& 944 (LHSConv->hasOneUse() || RHSConv->hasOneUse()) && 945 WillNotOverflowSignedAdd(LHSConv->getOperand(0), 946 RHSConv->getOperand(0))) { 947 // Insert the new integer add. 948 Value *NewAdd = Builder->CreateNSWAdd(LHSConv->getOperand(0), 949 RHSConv->getOperand(0), "addconv"); 950 return new SExtInst(NewAdd, I.getType()); 951 } 952 } 953 } 954 955 return Changed ? &I : 0; 956} 957 958Instruction *InstCombiner::visitFAdd(BinaryOperator &I) { 959 bool Changed = SimplifyCommutative(I); 960 Value *LHS = I.getOperand(0), *RHS = I.getOperand(1); 961 962 if (Constant *RHSC = dyn_cast<Constant>(RHS)) { 963 // X + 0 --> X 964 if (ConstantFP *CFP = dyn_cast<ConstantFP>(RHSC)) { 965 if (CFP->isExactlyValue(ConstantFP::getNegativeZero 966 (I.getType())->getValueAPF())) 967 return ReplaceInstUsesWith(I, LHS); 968 } 969 970 if (isa<PHINode>(LHS)) 971 if (Instruction *NV = FoldOpIntoPhi(I)) 972 return NV; 973 } 974 975 // -A + B --> B - A 976 // -A + -B --> -(A + B) 977 if (Value *LHSV = dyn_castFNegVal(LHS)) 978 return BinaryOperator::CreateFSub(RHS, LHSV); 979 980 // A + -B --> A - B 981 if (!isa<Constant>(RHS)) 982 if (Value *V = dyn_castFNegVal(RHS)) 983 return BinaryOperator::CreateFSub(LHS, V); 984 985 // Check for X+0.0. Simplify it to X if we know X is not -0.0. 986 if (ConstantFP *CFP = dyn_cast<ConstantFP>(RHS)) 987 if (CFP->getValueAPF().isPosZero() && CannotBeNegativeZero(LHS)) 988 return ReplaceInstUsesWith(I, LHS); 989 990 // Check for (add double (sitofp x), y), see if we can merge this into an 991 // integer add followed by a promotion. 992 if (SIToFPInst *LHSConv = dyn_cast<SIToFPInst>(LHS)) { 993 // (add double (sitofp x), fpcst) --> (sitofp (add int x, intcst)) 994 // ... if the constant fits in the integer value. This is useful for things 995 // like (double)(x & 1234) + 4.0 -> (double)((X & 1234)+4) which no longer 996 // requires a constant pool load, and generally allows the add to be better 997 // instcombined. 998 if (ConstantFP *CFP = dyn_cast<ConstantFP>(RHS)) { 999 Constant *CI = 1000 ConstantExpr::getFPToSI(CFP, LHSConv->getOperand(0)->getType()); 1001 if (LHSConv->hasOneUse() && 1002 ConstantExpr::getSIToFP(CI, I.getType()) == CFP && 1003 WillNotOverflowSignedAdd(LHSConv->getOperand(0), CI)) { 1004 // Insert the new integer add. 1005 Value *NewAdd = Builder->CreateNSWAdd(LHSConv->getOperand(0), 1006 CI, "addconv"); 1007 return new SIToFPInst(NewAdd, I.getType()); 1008 } 1009 } 1010 1011 // (add double (sitofp x), (sitofp y)) --> (sitofp (add int x, y)) 1012 if (SIToFPInst *RHSConv = dyn_cast<SIToFPInst>(RHS)) { 1013 // Only do this if x/y have the same type, if at last one of them has a 1014 // single use (so we don't increase the number of int->fp conversions), 1015 // and if the integer add will not overflow. 1016 if (LHSConv->getOperand(0)->getType()==RHSConv->getOperand(0)->getType()&& 1017 (LHSConv->hasOneUse() || RHSConv->hasOneUse()) && 1018 WillNotOverflowSignedAdd(LHSConv->getOperand(0), 1019 RHSConv->getOperand(0))) { 1020 // Insert the new integer add. 1021 Value *NewAdd = Builder->CreateNSWAdd(LHSConv->getOperand(0), 1022 RHSConv->getOperand(0),"addconv"); 1023 return new SIToFPInst(NewAdd, I.getType()); 1024 } 1025 } 1026 } 1027 1028 return Changed ? &I : 0; 1029} 1030 1031 1032/// EmitGEPOffset - Given a getelementptr instruction/constantexpr, emit the 1033/// code necessary to compute the offset from the base pointer (without adding 1034/// in the base pointer). Return the result as a signed integer of intptr size. 1035Value *InstCombiner::EmitGEPOffset(User *GEP) { 1036 TargetData &TD = *getTargetData(); 1037 gep_type_iterator GTI = gep_type_begin(GEP); 1038 const Type *IntPtrTy = TD.getIntPtrType(GEP->getContext()); 1039 Value *Result = Constant::getNullValue(IntPtrTy); 1040 1041 // Build a mask for high order bits. 1042 unsigned IntPtrWidth = TD.getPointerSizeInBits(); 1043 uint64_t PtrSizeMask = ~0ULL >> (64-IntPtrWidth); 1044 1045 for (User::op_iterator i = GEP->op_begin() + 1, e = GEP->op_end(); i != e; 1046 ++i, ++GTI) { 1047 Value *Op = *i; 1048 uint64_t Size = TD.getTypeAllocSize(GTI.getIndexedType()) & PtrSizeMask; 1049 if (ConstantInt *OpC = dyn_cast<ConstantInt>(Op)) { 1050 if (OpC->isZero()) continue; 1051 1052 // Handle a struct index, which adds its field offset to the pointer. 1053 if (const StructType *STy = dyn_cast<StructType>(*GTI)) { 1054 Size = TD.getStructLayout(STy)->getElementOffset(OpC->getZExtValue()); 1055 1056 Result = Builder->CreateAdd(Result, 1057 ConstantInt::get(IntPtrTy, Size), 1058 GEP->getName()+".offs"); 1059 continue; 1060 } 1061 1062 Constant *Scale = ConstantInt::get(IntPtrTy, Size); 1063 Constant *OC = 1064 ConstantExpr::getIntegerCast(OpC, IntPtrTy, true /*SExt*/); 1065 Scale = ConstantExpr::getMul(OC, Scale); 1066 // Emit an add instruction. 1067 Result = Builder->CreateAdd(Result, Scale, GEP->getName()+".offs"); 1068 continue; 1069 } 1070 // Convert to correct type. 1071 if (Op->getType() != IntPtrTy) 1072 Op = Builder->CreateIntCast(Op, IntPtrTy, true, Op->getName()+".c"); 1073 if (Size != 1) { 1074 Constant *Scale = ConstantInt::get(IntPtrTy, Size); 1075 // We'll let instcombine(mul) convert this to a shl if possible. 1076 Op = Builder->CreateMul(Op, Scale, GEP->getName()+".idx"); 1077 } 1078 1079 // Emit an add instruction. 1080 Result = Builder->CreateAdd(Op, Result, GEP->getName()+".offs"); 1081 } 1082 return Result; 1083} 1084 1085 1086 1087 1088/// Optimize pointer differences into the same array into a size. Consider: 1089/// &A[10] - &A[0]: we should compile this to "10". LHS/RHS are the pointer 1090/// operands to the ptrtoint instructions for the LHS/RHS of the subtract. 1091/// 1092Value *InstCombiner::OptimizePointerDifference(Value *LHS, Value *RHS, 1093 const Type *Ty) { 1094 assert(TD && "Must have target data info for this"); 1095 1096 // If LHS is a gep based on RHS or RHS is a gep based on LHS, we can optimize 1097 // this. 1098 bool Swapped = false; 1099 GetElementPtrInst *GEP = 0; 1100 ConstantExpr *CstGEP = 0; 1101 1102 // TODO: Could also optimize &A[i] - &A[j] -> "i-j", and "&A.foo[i] - &A.foo". 1103 // For now we require one side to be the base pointer "A" or a constant 1104 // expression derived from it. 1105 if (GetElementPtrInst *LHSGEP = dyn_cast<GetElementPtrInst>(LHS)) { 1106 // (gep X, ...) - X 1107 if (LHSGEP->getOperand(0) == RHS) { 1108 GEP = LHSGEP; 1109 Swapped = false; 1110 } else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(RHS)) { 1111 // (gep X, ...) - (ce_gep X, ...) 1112 if (CE->getOpcode() == Instruction::GetElementPtr && 1113 LHSGEP->getOperand(0) == CE->getOperand(0)) { 1114 CstGEP = CE; 1115 GEP = LHSGEP; 1116 Swapped = false; 1117 } 1118 } 1119 } 1120 1121 if (GetElementPtrInst *RHSGEP = dyn_cast<GetElementPtrInst>(RHS)) { 1122 // X - (gep X, ...) 1123 if (RHSGEP->getOperand(0) == LHS) { 1124 GEP = RHSGEP; 1125 Swapped = true; 1126 } else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(LHS)) { 1127 // (ce_gep X, ...) - (gep X, ...) 1128 if (CE->getOpcode() == Instruction::GetElementPtr && 1129 RHSGEP->getOperand(0) == CE->getOperand(0)) { 1130 CstGEP = CE; 1131 GEP = RHSGEP; 1132 Swapped = true; 1133 } 1134 } 1135 } 1136 1137 if (GEP == 0) 1138 return 0; 1139 1140 // Emit the offset of the GEP and an intptr_t. 1141 Value *Result = EmitGEPOffset(GEP); 1142 1143 // If we had a constant expression GEP on the other side offsetting the 1144 // pointer, subtract it from the offset we have. 1145 if (CstGEP) { 1146 Value *CstOffset = EmitGEPOffset(CstGEP); 1147 Result = Builder->CreateSub(Result, CstOffset); 1148 } 1149 1150 1151 // If we have p - gep(p, ...) then we have to negate the result. 1152 if (Swapped) 1153 Result = Builder->CreateNeg(Result, "diff.neg"); 1154 1155 return Builder->CreateIntCast(Result, Ty, true); 1156} 1157 1158 1159Instruction *InstCombiner::visitSub(BinaryOperator &I) { 1160 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1); 1161 1162 if (Op0 == Op1) // sub X, X -> 0 1163 return ReplaceInstUsesWith(I, Constant::getNullValue(I.getType())); 1164 1165 // If this is a 'B = x-(-A)', change to B = x+A. This preserves NSW/NUW. 1166 if (Value *V = dyn_castNegVal(Op1)) { 1167 BinaryOperator *Res = BinaryOperator::CreateAdd(Op0, V); 1168 Res->setHasNoSignedWrap(I.hasNoSignedWrap()); 1169 Res->setHasNoUnsignedWrap(I.hasNoUnsignedWrap()); 1170 return Res; 1171 } 1172 1173 if (isa<UndefValue>(Op0)) 1174 return ReplaceInstUsesWith(I, Op0); // undef - X -> undef 1175 if (isa<UndefValue>(Op1)) 1176 return ReplaceInstUsesWith(I, Op1); // X - undef -> undef 1177 if (I.getType() == Type::getInt1Ty(I.getContext())) 1178 return BinaryOperator::CreateXor(Op0, Op1); 1179 1180 if (ConstantInt *C = dyn_cast<ConstantInt>(Op0)) { 1181 // Replace (-1 - A) with (~A). 1182 if (C->isAllOnesValue()) 1183 return BinaryOperator::CreateNot(Op1); 1184 1185 // C - ~X == X + (1+C) 1186 Value *X = 0; 1187 if (match(Op1, m_Not(m_Value(X)))) 1188 return BinaryOperator::CreateAdd(X, AddOne(C)); 1189 1190 // -(X >>u 31) -> (X >>s 31) 1191 // -(X >>s 31) -> (X >>u 31) 1192 if (C->isZero()) { 1193 if (BinaryOperator *SI = dyn_cast<BinaryOperator>(Op1)) { 1194 if (SI->getOpcode() == Instruction::LShr) { 1195 if (ConstantInt *CU = dyn_cast<ConstantInt>(SI->getOperand(1))) { 1196 // Check to see if we are shifting out everything but the sign bit. 1197 if (CU->getLimitedValue(SI->getType()->getPrimitiveSizeInBits()) == 1198 SI->getType()->getPrimitiveSizeInBits()-1) { 1199 // Ok, the transformation is safe. Insert AShr. 1200 return BinaryOperator::Create(Instruction::AShr, 1201 SI->getOperand(0), CU, SI->getName()); 1202 } 1203 } 1204 } else if (SI->getOpcode() == Instruction::AShr) { 1205 if (ConstantInt *CU = dyn_cast<ConstantInt>(SI->getOperand(1))) { 1206 // Check to see if we are shifting out everything but the sign bit. 1207 if (CU->getLimitedValue(SI->getType()->getPrimitiveSizeInBits()) == 1208 SI->getType()->getPrimitiveSizeInBits()-1) { 1209 // Ok, the transformation is safe. Insert LShr. 1210 return BinaryOperator::CreateLShr( 1211 SI->getOperand(0), CU, SI->getName()); 1212 } 1213 } 1214 } 1215 } 1216 } 1217 1218 // Try to fold constant sub into select arguments. 1219 if (SelectInst *SI = dyn_cast<SelectInst>(Op1)) 1220 if (Instruction *R = FoldOpIntoSelect(I, SI)) 1221 return R; 1222 1223 // C - zext(bool) -> bool ? C - 1 : C 1224 if (ZExtInst *ZI = dyn_cast<ZExtInst>(Op1)) 1225 if (ZI->getSrcTy() == Type::getInt1Ty(I.getContext())) 1226 return SelectInst::Create(ZI->getOperand(0), SubOne(C), C); 1227 } 1228 1229 if (BinaryOperator *Op1I = dyn_cast<BinaryOperator>(Op1)) { 1230 if (Op1I->getOpcode() == Instruction::Add) { 1231 if (Op1I->getOperand(0) == Op0) // X-(X+Y) == -Y 1232 return BinaryOperator::CreateNeg(Op1I->getOperand(1), 1233 I.getName()); 1234 else if (Op1I->getOperand(1) == Op0) // X-(Y+X) == -Y 1235 return BinaryOperator::CreateNeg(Op1I->getOperand(0), 1236 I.getName()); 1237 else if (ConstantInt *CI1 = dyn_cast<ConstantInt>(I.getOperand(0))) { 1238 if (ConstantInt *CI2 = dyn_cast<ConstantInt>(Op1I->getOperand(1))) 1239 // C1-(X+C2) --> (C1-C2)-X 1240 return BinaryOperator::CreateSub( 1241 ConstantExpr::getSub(CI1, CI2), Op1I->getOperand(0)); 1242 } 1243 } 1244 1245 if (Op1I->hasOneUse()) { 1246 // Replace (x - (y - z)) with (x + (z - y)) if the (y - z) subexpression 1247 // is not used by anyone else... 1248 // 1249 if (Op1I->getOpcode() == Instruction::Sub) { 1250 // Swap the two operands of the subexpr... 1251 Value *IIOp0 = Op1I->getOperand(0), *IIOp1 = Op1I->getOperand(1); 1252 Op1I->setOperand(0, IIOp1); 1253 Op1I->setOperand(1, IIOp0); 1254 1255 // Create the new top level add instruction... 1256 return BinaryOperator::CreateAdd(Op0, Op1); 1257 } 1258 1259 // Replace (A - (A & B)) with (A & ~B) if this is the only use of (A&B)... 1260 // 1261 if (Op1I->getOpcode() == Instruction::And && 1262 (Op1I->getOperand(0) == Op0 || Op1I->getOperand(1) == Op0)) { 1263 Value *OtherOp = Op1I->getOperand(Op1I->getOperand(0) == Op0); 1264 1265 Value *NewNot = Builder->CreateNot(OtherOp, "B.not"); 1266 return BinaryOperator::CreateAnd(Op0, NewNot); 1267 } 1268 1269 // 0 - (X sdiv C) -> (X sdiv -C) 1270 if (Op1I->getOpcode() == Instruction::SDiv) 1271 if (ConstantInt *CSI = dyn_cast<ConstantInt>(Op0)) 1272 if (CSI->isZero()) 1273 if (Constant *DivRHS = dyn_cast<Constant>(Op1I->getOperand(1))) 1274 return BinaryOperator::CreateSDiv(Op1I->getOperand(0), 1275 ConstantExpr::getNeg(DivRHS)); 1276 1277 // X - X*C --> X * (1-C) 1278 ConstantInt *C2 = 0; 1279 if (dyn_castFoldableMul(Op1I, C2) == Op0) { 1280 Constant *CP1 = 1281 ConstantExpr::getSub(ConstantInt::get(I.getType(), 1), 1282 C2); 1283 return BinaryOperator::CreateMul(Op0, CP1); 1284 } 1285 } 1286 } 1287 1288 if (BinaryOperator *Op0I = dyn_cast<BinaryOperator>(Op0)) { 1289 if (Op0I->getOpcode() == Instruction::Add) { 1290 if (Op0I->getOperand(0) == Op1) // (Y+X)-Y == X 1291 return ReplaceInstUsesWith(I, Op0I->getOperand(1)); 1292 else if (Op0I->getOperand(1) == Op1) // (X+Y)-Y == X 1293 return ReplaceInstUsesWith(I, Op0I->getOperand(0)); 1294 } else if (Op0I->getOpcode() == Instruction::Sub) { 1295 if (Op0I->getOperand(0) == Op1) // (X-Y)-X == -Y 1296 return BinaryOperator::CreateNeg(Op0I->getOperand(1), 1297 I.getName()); 1298 } 1299 } 1300 1301 ConstantInt *C1; 1302 if (Value *X = dyn_castFoldableMul(Op0, C1)) { 1303 if (X == Op1) // X*C - X --> X * (C-1) 1304 return BinaryOperator::CreateMul(Op1, SubOne(C1)); 1305 1306 ConstantInt *C2; // X*C1 - X*C2 -> X * (C1-C2) 1307 if (X == dyn_castFoldableMul(Op1, C2)) 1308 return BinaryOperator::CreateMul(X, ConstantExpr::getSub(C1, C2)); 1309 } 1310 1311 // Optimize pointer differences into the same array into a size. Consider: 1312 // &A[10] - &A[0]: we should compile this to "10". 1313 if (TD) { 1314 Value *LHSOp, *RHSOp; 1315 if (match(Op0, m_PtrToInt(m_Value(LHSOp))) && 1316 match(Op1, m_PtrToInt(m_Value(RHSOp)))) 1317 if (Value *Res = OptimizePointerDifference(LHSOp, RHSOp, I.getType())) 1318 return ReplaceInstUsesWith(I, Res); 1319 1320 // trunc(p)-trunc(q) -> trunc(p-q) 1321 if (match(Op0, m_Trunc(m_PtrToInt(m_Value(LHSOp)))) && 1322 match(Op1, m_Trunc(m_PtrToInt(m_Value(RHSOp))))) 1323 if (Value *Res = OptimizePointerDifference(LHSOp, RHSOp, I.getType())) 1324 return ReplaceInstUsesWith(I, Res); 1325 } 1326 1327 return 0; 1328} 1329 1330Instruction *InstCombiner::visitFSub(BinaryOperator &I) { 1331 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1); 1332 1333 // If this is a 'B = x-(-A)', change to B = x+A... 1334 if (Value *V = dyn_castFNegVal(Op1)) 1335 return BinaryOperator::CreateFAdd(Op0, V); 1336 1337 if (BinaryOperator *Op1I = dyn_cast<BinaryOperator>(Op1)) { 1338 if (Op1I->getOpcode() == Instruction::FAdd) { 1339 if (Op1I->getOperand(0) == Op0) // X-(X+Y) == -Y 1340 return BinaryOperator::CreateFNeg(Op1I->getOperand(1), 1341 I.getName()); 1342 else if (Op1I->getOperand(1) == Op0) // X-(Y+X) == -Y 1343 return BinaryOperator::CreateFNeg(Op1I->getOperand(0), 1344 I.getName()); 1345 } 1346 } 1347 1348 return 0; 1349} 1350 1351Instruction *InstCombiner::visitMul(BinaryOperator &I) { 1352 bool Changed = SimplifyCommutative(I); 1353 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1); 1354 1355 if (isa<UndefValue>(Op1)) // undef * X -> 0 1356 return ReplaceInstUsesWith(I, Constant::getNullValue(I.getType())); 1357 1358 // Simplify mul instructions with a constant RHS. 1359 if (Constant *Op1C = dyn_cast<Constant>(Op1)) { 1360 if (ConstantInt *CI = dyn_cast<ConstantInt>(Op1C)) { 1361 1362 // ((X << C1)*C2) == (X * (C2 << C1)) 1363 if (BinaryOperator *SI = dyn_cast<BinaryOperator>(Op0)) 1364 if (SI->getOpcode() == Instruction::Shl) 1365 if (Constant *ShOp = dyn_cast<Constant>(SI->getOperand(1))) 1366 return BinaryOperator::CreateMul(SI->getOperand(0), 1367 ConstantExpr::getShl(CI, ShOp)); 1368 1369 if (CI->isZero()) 1370 return ReplaceInstUsesWith(I, Op1C); // X * 0 == 0 1371 if (CI->equalsInt(1)) // X * 1 == X 1372 return ReplaceInstUsesWith(I, Op0); 1373 if (CI->isAllOnesValue()) // X * -1 == 0 - X 1374 return BinaryOperator::CreateNeg(Op0, I.getName()); 1375 1376 const APInt& Val = cast<ConstantInt>(CI)->getValue(); 1377 if (Val.isPowerOf2()) { // Replace X*(2^C) with X << C 1378 return BinaryOperator::CreateShl(Op0, 1379 ConstantInt::get(Op0->getType(), Val.logBase2())); 1380 } 1381 } else if (isa<VectorType>(Op1C->getType())) { 1382 if (Op1C->isNullValue()) 1383 return ReplaceInstUsesWith(I, Op1C); 1384 1385 if (ConstantVector *Op1V = dyn_cast<ConstantVector>(Op1C)) { 1386 if (Op1V->isAllOnesValue()) // X * -1 == 0 - X 1387 return BinaryOperator::CreateNeg(Op0, I.getName()); 1388 1389 // As above, vector X*splat(1.0) -> X in all defined cases. 1390 if (Constant *Splat = Op1V->getSplatValue()) { 1391 if (ConstantInt *CI = dyn_cast<ConstantInt>(Splat)) 1392 if (CI->equalsInt(1)) 1393 return ReplaceInstUsesWith(I, Op0); 1394 } 1395 } 1396 } 1397 1398 if (BinaryOperator *Op0I = dyn_cast<BinaryOperator>(Op0)) 1399 if (Op0I->getOpcode() == Instruction::Add && Op0I->hasOneUse() && 1400 isa<ConstantInt>(Op0I->getOperand(1)) && isa<ConstantInt>(Op1C)) { 1401 // Canonicalize (X+C1)*C2 -> X*C2+C1*C2. 1402 Value *Add = Builder->CreateMul(Op0I->getOperand(0), Op1C, "tmp"); 1403 Value *C1C2 = Builder->CreateMul(Op1C, Op0I->getOperand(1)); 1404 return BinaryOperator::CreateAdd(Add, C1C2); 1405 1406 } 1407 1408 // Try to fold constant mul into select arguments. 1409 if (SelectInst *SI = dyn_cast<SelectInst>(Op0)) 1410 if (Instruction *R = FoldOpIntoSelect(I, SI)) 1411 return R; 1412 1413 if (isa<PHINode>(Op0)) 1414 if (Instruction *NV = FoldOpIntoPhi(I)) 1415 return NV; 1416 } 1417 1418 if (Value *Op0v = dyn_castNegVal(Op0)) // -X * -Y = X*Y 1419 if (Value *Op1v = dyn_castNegVal(Op1)) 1420 return BinaryOperator::CreateMul(Op0v, Op1v); 1421 1422 // (X / Y) * Y = X - (X % Y) 1423 // (X / Y) * -Y = (X % Y) - X 1424 { 1425 Value *Op1C = Op1; 1426 BinaryOperator *BO = dyn_cast<BinaryOperator>(Op0); 1427 if (!BO || 1428 (BO->getOpcode() != Instruction::UDiv && 1429 BO->getOpcode() != Instruction::SDiv)) { 1430 Op1C = Op0; 1431 BO = dyn_cast<BinaryOperator>(Op1); 1432 } 1433 Value *Neg = dyn_castNegVal(Op1C); 1434 if (BO && BO->hasOneUse() && 1435 (BO->getOperand(1) == Op1C || BO->getOperand(1) == Neg) && 1436 (BO->getOpcode() == Instruction::UDiv || 1437 BO->getOpcode() == Instruction::SDiv)) { 1438 Value *Op0BO = BO->getOperand(0), *Op1BO = BO->getOperand(1); 1439 1440 // If the division is exact, X % Y is zero. 1441 if (SDivOperator *SDiv = dyn_cast<SDivOperator>(BO)) 1442 if (SDiv->isExact()) { 1443 if (Op1BO == Op1C) 1444 return ReplaceInstUsesWith(I, Op0BO); 1445 return BinaryOperator::CreateNeg(Op0BO); 1446 } 1447 1448 Value *Rem; 1449 if (BO->getOpcode() == Instruction::UDiv) 1450 Rem = Builder->CreateURem(Op0BO, Op1BO); 1451 else 1452 Rem = Builder->CreateSRem(Op0BO, Op1BO); 1453 Rem->takeName(BO); 1454 1455 if (Op1BO == Op1C) 1456 return BinaryOperator::CreateSub(Op0BO, Rem); 1457 return BinaryOperator::CreateSub(Rem, Op0BO); 1458 } 1459 } 1460 1461 /// i1 mul -> i1 and. 1462 if (I.getType() == Type::getInt1Ty(I.getContext())) 1463 return BinaryOperator::CreateAnd(Op0, Op1); 1464 1465 // X*(1 << Y) --> X << Y 1466 // (1 << Y)*X --> X << Y 1467 { 1468 Value *Y; 1469 if (match(Op0, m_Shl(m_One(), m_Value(Y)))) 1470 return BinaryOperator::CreateShl(Op1, Y); 1471 if (match(Op1, m_Shl(m_One(), m_Value(Y)))) 1472 return BinaryOperator::CreateShl(Op0, Y); 1473 } 1474 1475 // If one of the operands of the multiply is a cast from a boolean value, then 1476 // we know the bool is either zero or one, so this is a 'masking' multiply. 1477 // X * Y (where Y is 0 or 1) -> X & (0-Y) 1478 if (!isa<VectorType>(I.getType())) { 1479 // -2 is "-1 << 1" so it is all bits set except the low one. 1480 APInt Negative2(I.getType()->getPrimitiveSizeInBits(), (uint64_t)-2, true); 1481 1482 Value *BoolCast = 0, *OtherOp = 0; 1483 if (MaskedValueIsZero(Op0, Negative2)) 1484 BoolCast = Op0, OtherOp = Op1; 1485 else if (MaskedValueIsZero(Op1, Negative2)) 1486 BoolCast = Op1, OtherOp = Op0; 1487 1488 if (BoolCast) { 1489 Value *V = Builder->CreateSub(Constant::getNullValue(I.getType()), 1490 BoolCast, "tmp"); 1491 return BinaryOperator::CreateAnd(V, OtherOp); 1492 } 1493 } 1494 1495 return Changed ? &I : 0; 1496} 1497 1498Instruction *InstCombiner::visitFMul(BinaryOperator &I) { 1499 bool Changed = SimplifyCommutative(I); 1500 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1); 1501 1502 // Simplify mul instructions with a constant RHS... 1503 if (Constant *Op1C = dyn_cast<Constant>(Op1)) { 1504 if (ConstantFP *Op1F = dyn_cast<ConstantFP>(Op1C)) { 1505 // "In IEEE floating point, x*1 is not equivalent to x for nans. However, 1506 // ANSI says we can drop signals, so we can do this anyway." (from GCC) 1507 if (Op1F->isExactlyValue(1.0)) 1508 return ReplaceInstUsesWith(I, Op0); // Eliminate 'mul double %X, 1.0' 1509 } else if (isa<VectorType>(Op1C->getType())) { 1510 if (ConstantVector *Op1V = dyn_cast<ConstantVector>(Op1C)) { 1511 // As above, vector X*splat(1.0) -> X in all defined cases. 1512 if (Constant *Splat = Op1V->getSplatValue()) { 1513 if (ConstantFP *F = dyn_cast<ConstantFP>(Splat)) 1514 if (F->isExactlyValue(1.0)) 1515 return ReplaceInstUsesWith(I, Op0); 1516 } 1517 } 1518 } 1519 1520 // Try to fold constant mul into select arguments. 1521 if (SelectInst *SI = dyn_cast<SelectInst>(Op0)) 1522 if (Instruction *R = FoldOpIntoSelect(I, SI)) 1523 return R; 1524 1525 if (isa<PHINode>(Op0)) 1526 if (Instruction *NV = FoldOpIntoPhi(I)) 1527 return NV; 1528 } 1529 1530 if (Value *Op0v = dyn_castFNegVal(Op0)) // -X * -Y = X*Y 1531 if (Value *Op1v = dyn_castFNegVal(Op1)) 1532 return BinaryOperator::CreateFMul(Op0v, Op1v); 1533 1534 return Changed ? &I : 0; 1535} 1536 1537/// SimplifyDivRemOfSelect - Try to fold a divide or remainder of a select 1538/// instruction. 1539bool InstCombiner::SimplifyDivRemOfSelect(BinaryOperator &I) { 1540 SelectInst *SI = cast<SelectInst>(I.getOperand(1)); 1541 1542 // div/rem X, (Cond ? 0 : Y) -> div/rem X, Y 1543 int NonNullOperand = -1; 1544 if (Constant *ST = dyn_cast<Constant>(SI->getOperand(1))) 1545 if (ST->isNullValue()) 1546 NonNullOperand = 2; 1547 // div/rem X, (Cond ? Y : 0) -> div/rem X, Y 1548 if (Constant *ST = dyn_cast<Constant>(SI->getOperand(2))) 1549 if (ST->isNullValue()) 1550 NonNullOperand = 1; 1551 1552 if (NonNullOperand == -1) 1553 return false; 1554 1555 Value *SelectCond = SI->getOperand(0); 1556 1557 // Change the div/rem to use 'Y' instead of the select. 1558 I.setOperand(1, SI->getOperand(NonNullOperand)); 1559 1560 // Okay, we know we replace the operand of the div/rem with 'Y' with no 1561 // problem. However, the select, or the condition of the select may have 1562 // multiple uses. Based on our knowledge that the operand must be non-zero, 1563 // propagate the known value for the select into other uses of it, and 1564 // propagate a known value of the condition into its other users. 1565 1566 // If the select and condition only have a single use, don't bother with this, 1567 // early exit. 1568 if (SI->use_empty() && SelectCond->hasOneUse()) 1569 return true; 1570 1571 // Scan the current block backward, looking for other uses of SI. 1572 BasicBlock::iterator BBI = &I, BBFront = I.getParent()->begin(); 1573 1574 while (BBI != BBFront) { 1575 --BBI; 1576 // If we found a call to a function, we can't assume it will return, so 1577 // information from below it cannot be propagated above it. 1578 if (isa<CallInst>(BBI) && !isa<IntrinsicInst>(BBI)) 1579 break; 1580 1581 // Replace uses of the select or its condition with the known values. 1582 for (Instruction::op_iterator I = BBI->op_begin(), E = BBI->op_end(); 1583 I != E; ++I) { 1584 if (*I == SI) { 1585 *I = SI->getOperand(NonNullOperand); 1586 Worklist.Add(BBI); 1587 } else if (*I == SelectCond) { 1588 *I = NonNullOperand == 1 ? ConstantInt::getTrue(BBI->getContext()) : 1589 ConstantInt::getFalse(BBI->getContext()); 1590 Worklist.Add(BBI); 1591 } 1592 } 1593 1594 // If we past the instruction, quit looking for it. 1595 if (&*BBI == SI) 1596 SI = 0; 1597 if (&*BBI == SelectCond) 1598 SelectCond = 0; 1599 1600 // If we ran out of things to eliminate, break out of the loop. 1601 if (SelectCond == 0 && SI == 0) 1602 break; 1603 1604 } 1605 return true; 1606} 1607 1608 1609/// This function implements the transforms on div instructions that work 1610/// regardless of the kind of div instruction it is (udiv, sdiv, or fdiv). It is 1611/// used by the visitors to those instructions. 1612/// @brief Transforms common to all three div instructions 1613Instruction *InstCombiner::commonDivTransforms(BinaryOperator &I) { 1614 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1); 1615 1616 // undef / X -> 0 for integer. 1617 // undef / X -> undef for FP (the undef could be a snan). 1618 if (isa<UndefValue>(Op0)) { 1619 if (Op0->getType()->isFPOrFPVector()) 1620 return ReplaceInstUsesWith(I, Op0); 1621 return ReplaceInstUsesWith(I, Constant::getNullValue(I.getType())); 1622 } 1623 1624 // X / undef -> undef 1625 if (isa<UndefValue>(Op1)) 1626 return ReplaceInstUsesWith(I, Op1); 1627 1628 return 0; 1629} 1630 1631/// This function implements the transforms common to both integer division 1632/// instructions (udiv and sdiv). It is called by the visitors to those integer 1633/// division instructions. 1634/// @brief Common integer divide transforms 1635Instruction *InstCombiner::commonIDivTransforms(BinaryOperator &I) { 1636 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1); 1637 1638 // (sdiv X, X) --> 1 (udiv X, X) --> 1 1639 if (Op0 == Op1) { 1640 if (const VectorType *Ty = dyn_cast<VectorType>(I.getType())) { 1641 Constant *CI = ConstantInt::get(Ty->getElementType(), 1); 1642 std::vector<Constant*> Elts(Ty->getNumElements(), CI); 1643 return ReplaceInstUsesWith(I, ConstantVector::get(Elts)); 1644 } 1645 1646 Constant *CI = ConstantInt::get(I.getType(), 1); 1647 return ReplaceInstUsesWith(I, CI); 1648 } 1649 1650 if (Instruction *Common = commonDivTransforms(I)) 1651 return Common; 1652 1653 // Handle cases involving: [su]div X, (select Cond, Y, Z) 1654 // This does not apply for fdiv. 1655 if (isa<SelectInst>(Op1) && SimplifyDivRemOfSelect(I)) 1656 return &I; 1657 1658 if (ConstantInt *RHS = dyn_cast<ConstantInt>(Op1)) { 1659 // div X, 1 == X 1660 if (RHS->equalsInt(1)) 1661 return ReplaceInstUsesWith(I, Op0); 1662 1663 // (X / C1) / C2 -> X / (C1*C2) 1664 if (Instruction *LHS = dyn_cast<Instruction>(Op0)) 1665 if (Instruction::BinaryOps(LHS->getOpcode()) == I.getOpcode()) 1666 if (ConstantInt *LHSRHS = dyn_cast<ConstantInt>(LHS->getOperand(1))) { 1667 if (MultiplyOverflows(RHS, LHSRHS, 1668 I.getOpcode()==Instruction::SDiv)) 1669 return ReplaceInstUsesWith(I, Constant::getNullValue(I.getType())); 1670 else 1671 return BinaryOperator::Create(I.getOpcode(), LHS->getOperand(0), 1672 ConstantExpr::getMul(RHS, LHSRHS)); 1673 } 1674 1675 if (!RHS->isZero()) { // avoid X udiv 0 1676 if (SelectInst *SI = dyn_cast<SelectInst>(Op0)) 1677 if (Instruction *R = FoldOpIntoSelect(I, SI)) 1678 return R; 1679 if (isa<PHINode>(Op0)) 1680 if (Instruction *NV = FoldOpIntoPhi(I)) 1681 return NV; 1682 } 1683 } 1684 1685 // 0 / X == 0, we don't need to preserve faults! 1686 if (ConstantInt *LHS = dyn_cast<ConstantInt>(Op0)) 1687 if (LHS->equalsInt(0)) 1688 return ReplaceInstUsesWith(I, Constant::getNullValue(I.getType())); 1689 1690 // It can't be division by zero, hence it must be division by one. 1691 if (I.getType() == Type::getInt1Ty(I.getContext())) 1692 return ReplaceInstUsesWith(I, Op0); 1693 1694 if (ConstantVector *Op1V = dyn_cast<ConstantVector>(Op1)) { 1695 if (ConstantInt *X = cast_or_null<ConstantInt>(Op1V->getSplatValue())) 1696 // div X, 1 == X 1697 if (X->isOne()) 1698 return ReplaceInstUsesWith(I, Op0); 1699 } 1700 1701 return 0; 1702} 1703 1704Instruction *InstCombiner::visitUDiv(BinaryOperator &I) { 1705 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1); 1706 1707 // Handle the integer div common cases 1708 if (Instruction *Common = commonIDivTransforms(I)) 1709 return Common; 1710 1711 if (ConstantInt *C = dyn_cast<ConstantInt>(Op1)) { 1712 // X udiv C^2 -> X >> C 1713 // Check to see if this is an unsigned division with an exact power of 2, 1714 // if so, convert to a right shift. 1715 if (C->getValue().isPowerOf2()) // 0 not included in isPowerOf2 1716 return BinaryOperator::CreateLShr(Op0, 1717 ConstantInt::get(Op0->getType(), C->getValue().logBase2())); 1718 1719 // X udiv C, where C >= signbit 1720 if (C->getValue().isNegative()) { 1721 Value *IC = Builder->CreateICmpULT( Op0, C); 1722 return SelectInst::Create(IC, Constant::getNullValue(I.getType()), 1723 ConstantInt::get(I.getType(), 1)); 1724 } 1725 } 1726 1727 // X udiv (C1 << N), where C1 is "1<<C2" --> X >> (N+C2) 1728 if (BinaryOperator *RHSI = dyn_cast<BinaryOperator>(I.getOperand(1))) { 1729 if (RHSI->getOpcode() == Instruction::Shl && 1730 isa<ConstantInt>(RHSI->getOperand(0))) { 1731 const APInt& C1 = cast<ConstantInt>(RHSI->getOperand(0))->getValue(); 1732 if (C1.isPowerOf2()) { 1733 Value *N = RHSI->getOperand(1); 1734 const Type *NTy = N->getType(); 1735 if (uint32_t C2 = C1.logBase2()) 1736 N = Builder->CreateAdd(N, ConstantInt::get(NTy, C2), "tmp"); 1737 return BinaryOperator::CreateLShr(Op0, N); 1738 } 1739 } 1740 } 1741 1742 // udiv X, (Select Cond, C1, C2) --> Select Cond, (shr X, C1), (shr X, C2) 1743 // where C1&C2 are powers of two. 1744 if (SelectInst *SI = dyn_cast<SelectInst>(Op1)) 1745 if (ConstantInt *STO = dyn_cast<ConstantInt>(SI->getOperand(1))) 1746 if (ConstantInt *SFO = dyn_cast<ConstantInt>(SI->getOperand(2))) { 1747 const APInt &TVA = STO->getValue(), &FVA = SFO->getValue(); 1748 if (TVA.isPowerOf2() && FVA.isPowerOf2()) { 1749 // Compute the shift amounts 1750 uint32_t TSA = TVA.logBase2(), FSA = FVA.logBase2(); 1751 // Construct the "on true" case of the select 1752 Constant *TC = ConstantInt::get(Op0->getType(), TSA); 1753 Value *TSI = Builder->CreateLShr(Op0, TC, SI->getName()+".t"); 1754 1755 // Construct the "on false" case of the select 1756 Constant *FC = ConstantInt::get(Op0->getType(), FSA); 1757 Value *FSI = Builder->CreateLShr(Op0, FC, SI->getName()+".f"); 1758 1759 // construct the select instruction and return it. 1760 return SelectInst::Create(SI->getOperand(0), TSI, FSI, SI->getName()); 1761 } 1762 } 1763 return 0; 1764} 1765 1766Instruction *InstCombiner::visitSDiv(BinaryOperator &I) { 1767 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1); 1768 1769 // Handle the integer div common cases 1770 if (Instruction *Common = commonIDivTransforms(I)) 1771 return Common; 1772 1773 if (ConstantInt *RHS = dyn_cast<ConstantInt>(Op1)) { 1774 // sdiv X, -1 == -X 1775 if (RHS->isAllOnesValue()) 1776 return BinaryOperator::CreateNeg(Op0); 1777 1778 // sdiv X, C --> ashr X, log2(C) 1779 if (cast<SDivOperator>(&I)->isExact() && 1780 RHS->getValue().isNonNegative() && 1781 RHS->getValue().isPowerOf2()) { 1782 Value *ShAmt = llvm::ConstantInt::get(RHS->getType(), 1783 RHS->getValue().exactLogBase2()); 1784 return BinaryOperator::CreateAShr(Op0, ShAmt, I.getName()); 1785 } 1786 1787 // -X/C --> X/-C provided the negation doesn't overflow. 1788 if (SubOperator *Sub = dyn_cast<SubOperator>(Op0)) 1789 if (isa<Constant>(Sub->getOperand(0)) && 1790 cast<Constant>(Sub->getOperand(0))->isNullValue() && 1791 Sub->hasNoSignedWrap()) 1792 return BinaryOperator::CreateSDiv(Sub->getOperand(1), 1793 ConstantExpr::getNeg(RHS)); 1794 } 1795 1796 // If the sign bits of both operands are zero (i.e. we can prove they are 1797 // unsigned inputs), turn this into a udiv. 1798 if (I.getType()->isInteger()) { 1799 APInt Mask(APInt::getSignBit(I.getType()->getPrimitiveSizeInBits())); 1800 if (MaskedValueIsZero(Op0, Mask)) { 1801 if (MaskedValueIsZero(Op1, Mask)) { 1802 // X sdiv Y -> X udiv Y, iff X and Y don't have sign bit set 1803 return BinaryOperator::CreateUDiv(Op0, Op1, I.getName()); 1804 } 1805 ConstantInt *ShiftedInt; 1806 if (match(Op1, m_Shl(m_ConstantInt(ShiftedInt), m_Value())) && 1807 ShiftedInt->getValue().isPowerOf2()) { 1808 // X sdiv (1 << Y) -> X udiv (1 << Y) ( -> X u>> Y) 1809 // Safe because the only negative value (1 << Y) can take on is 1810 // INT_MIN, and X sdiv INT_MIN == X udiv INT_MIN == 0 if X doesn't have 1811 // the sign bit set. 1812 return BinaryOperator::CreateUDiv(Op0, Op1, I.getName()); 1813 } 1814 } 1815 } 1816 1817 return 0; 1818} 1819 1820Instruction *InstCombiner::visitFDiv(BinaryOperator &I) { 1821 return commonDivTransforms(I); 1822} 1823 1824/// This function implements the transforms on rem instructions that work 1825/// regardless of the kind of rem instruction it is (urem, srem, or frem). It 1826/// is used by the visitors to those instructions. 1827/// @brief Transforms common to all three rem instructions 1828Instruction *InstCombiner::commonRemTransforms(BinaryOperator &I) { 1829 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1); 1830 1831 if (isa<UndefValue>(Op0)) { // undef % X -> 0 1832 if (I.getType()->isFPOrFPVector()) 1833 return ReplaceInstUsesWith(I, Op0); // X % undef -> undef (could be SNaN) 1834 return ReplaceInstUsesWith(I, Constant::getNullValue(I.getType())); 1835 } 1836 if (isa<UndefValue>(Op1)) 1837 return ReplaceInstUsesWith(I, Op1); // X % undef -> undef 1838 1839 // Handle cases involving: rem X, (select Cond, Y, Z) 1840 if (isa<SelectInst>(Op1) && SimplifyDivRemOfSelect(I)) 1841 return &I; 1842 1843 return 0; 1844} 1845 1846/// This function implements the transforms common to both integer remainder 1847/// instructions (urem and srem). It is called by the visitors to those integer 1848/// remainder instructions. 1849/// @brief Common integer remainder transforms 1850Instruction *InstCombiner::commonIRemTransforms(BinaryOperator &I) { 1851 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1); 1852 1853 if (Instruction *common = commonRemTransforms(I)) 1854 return common; 1855 1856 // 0 % X == 0 for integer, we don't need to preserve faults! 1857 if (Constant *LHS = dyn_cast<Constant>(Op0)) 1858 if (LHS->isNullValue()) 1859 return ReplaceInstUsesWith(I, Constant::getNullValue(I.getType())); 1860 1861 if (ConstantInt *RHS = dyn_cast<ConstantInt>(Op1)) { 1862 // X % 0 == undef, we don't need to preserve faults! 1863 if (RHS->equalsInt(0)) 1864 return ReplaceInstUsesWith(I, UndefValue::get(I.getType())); 1865 1866 if (RHS->equalsInt(1)) // X % 1 == 0 1867 return ReplaceInstUsesWith(I, Constant::getNullValue(I.getType())); 1868 1869 if (Instruction *Op0I = dyn_cast<Instruction>(Op0)) { 1870 if (SelectInst *SI = dyn_cast<SelectInst>(Op0I)) { 1871 if (Instruction *R = FoldOpIntoSelect(I, SI)) 1872 return R; 1873 } else if (isa<PHINode>(Op0I)) { 1874 if (Instruction *NV = FoldOpIntoPhi(I)) 1875 return NV; 1876 } 1877 1878 // See if we can fold away this rem instruction. 1879 if (SimplifyDemandedInstructionBits(I)) 1880 return &I; 1881 } 1882 } 1883 1884 return 0; 1885} 1886 1887Instruction *InstCombiner::visitURem(BinaryOperator &I) { 1888 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1); 1889 1890 if (Instruction *common = commonIRemTransforms(I)) 1891 return common; 1892 1893 if (ConstantInt *RHS = dyn_cast<ConstantInt>(Op1)) { 1894 // X urem C^2 -> X and C 1895 // Check to see if this is an unsigned remainder with an exact power of 2, 1896 // if so, convert to a bitwise and. 1897 if (ConstantInt *C = dyn_cast<ConstantInt>(RHS)) 1898 if (C->getValue().isPowerOf2()) 1899 return BinaryOperator::CreateAnd(Op0, SubOne(C)); 1900 } 1901 1902 if (Instruction *RHSI = dyn_cast<Instruction>(I.getOperand(1))) { 1903 // Turn A % (C << N), where C is 2^k, into A & ((C << N)-1) 1904 if (RHSI->getOpcode() == Instruction::Shl && 1905 isa<ConstantInt>(RHSI->getOperand(0))) { 1906 if (cast<ConstantInt>(RHSI->getOperand(0))->getValue().isPowerOf2()) { 1907 Constant *N1 = Constant::getAllOnesValue(I.getType()); 1908 Value *Add = Builder->CreateAdd(RHSI, N1, "tmp"); 1909 return BinaryOperator::CreateAnd(Op0, Add); 1910 } 1911 } 1912 } 1913 1914 // urem X, (select Cond, 2^C1, 2^C2) --> select Cond, (and X, C1), (and X, C2) 1915 // where C1&C2 are powers of two. 1916 if (SelectInst *SI = dyn_cast<SelectInst>(Op1)) { 1917 if (ConstantInt *STO = dyn_cast<ConstantInt>(SI->getOperand(1))) 1918 if (ConstantInt *SFO = dyn_cast<ConstantInt>(SI->getOperand(2))) { 1919 // STO == 0 and SFO == 0 handled above. 1920 if ((STO->getValue().isPowerOf2()) && 1921 (SFO->getValue().isPowerOf2())) { 1922 Value *TrueAnd = Builder->CreateAnd(Op0, SubOne(STO), 1923 SI->getName()+".t"); 1924 Value *FalseAnd = Builder->CreateAnd(Op0, SubOne(SFO), 1925 SI->getName()+".f"); 1926 return SelectInst::Create(SI->getOperand(0), TrueAnd, FalseAnd); 1927 } 1928 } 1929 } 1930 1931 return 0; 1932} 1933 1934Instruction *InstCombiner::visitSRem(BinaryOperator &I) { 1935 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1); 1936 1937 // Handle the integer rem common cases 1938 if (Instruction *Common = commonIRemTransforms(I)) 1939 return Common; 1940 1941 if (Value *RHSNeg = dyn_castNegVal(Op1)) 1942 if (!isa<Constant>(RHSNeg) || 1943 (isa<ConstantInt>(RHSNeg) && 1944 cast<ConstantInt>(RHSNeg)->getValue().isStrictlyPositive())) { 1945 // X % -Y -> X % Y 1946 Worklist.AddValue(I.getOperand(1)); 1947 I.setOperand(1, RHSNeg); 1948 return &I; 1949 } 1950 1951 // If the sign bits of both operands are zero (i.e. we can prove they are 1952 // unsigned inputs), turn this into a urem. 1953 if (I.getType()->isInteger()) { 1954 APInt Mask(APInt::getSignBit(I.getType()->getPrimitiveSizeInBits())); 1955 if (MaskedValueIsZero(Op1, Mask) && MaskedValueIsZero(Op0, Mask)) { 1956 // X srem Y -> X urem Y, iff X and Y don't have sign bit set 1957 return BinaryOperator::CreateURem(Op0, Op1, I.getName()); 1958 } 1959 } 1960 1961 // If it's a constant vector, flip any negative values positive. 1962 if (ConstantVector *RHSV = dyn_cast<ConstantVector>(Op1)) { 1963 unsigned VWidth = RHSV->getNumOperands(); 1964 1965 bool hasNegative = false; 1966 for (unsigned i = 0; !hasNegative && i != VWidth; ++i) 1967 if (ConstantInt *RHS = dyn_cast<ConstantInt>(RHSV->getOperand(i))) 1968 if (RHS->getValue().isNegative()) 1969 hasNegative = true; 1970 1971 if (hasNegative) { 1972 std::vector<Constant *> Elts(VWidth); 1973 for (unsigned i = 0; i != VWidth; ++i) { 1974 if (ConstantInt *RHS = dyn_cast<ConstantInt>(RHSV->getOperand(i))) { 1975 if (RHS->getValue().isNegative()) 1976 Elts[i] = cast<ConstantInt>(ConstantExpr::getNeg(RHS)); 1977 else 1978 Elts[i] = RHS; 1979 } 1980 } 1981 1982 Constant *NewRHSV = ConstantVector::get(Elts); 1983 if (NewRHSV != RHSV) { 1984 Worklist.AddValue(I.getOperand(1)); 1985 I.setOperand(1, NewRHSV); 1986 return &I; 1987 } 1988 } 1989 } 1990 1991 return 0; 1992} 1993 1994Instruction *InstCombiner::visitFRem(BinaryOperator &I) { 1995 return commonRemTransforms(I); 1996} 1997 1998// isOneBitSet - Return true if there is exactly one bit set in the specified 1999// constant. 2000static bool isOneBitSet(const ConstantInt *CI) { 2001 return CI->getValue().isPowerOf2(); 2002} 2003 2004/// getICmpCode - Encode a icmp predicate into a three bit mask. These bits 2005/// are carefully arranged to allow folding of expressions such as: 2006/// 2007/// (A < B) | (A > B) --> (A != B) 2008/// 2009/// Note that this is only valid if the first and second predicates have the 2010/// same sign. Is illegal to do: (A u< B) | (A s> B) 2011/// 2012/// Three bits are used to represent the condition, as follows: 2013/// 0 A > B 2014/// 1 A == B 2015/// 2 A < B 2016/// 2017/// <=> Value Definition 2018/// 000 0 Always false 2019/// 001 1 A > B 2020/// 010 2 A == B 2021/// 011 3 A >= B 2022/// 100 4 A < B 2023/// 101 5 A != B 2024/// 110 6 A <= B 2025/// 111 7 Always true 2026/// 2027static unsigned getICmpCode(const ICmpInst *ICI) { 2028 switch (ICI->getPredicate()) { 2029 // False -> 0 2030 case ICmpInst::ICMP_UGT: return 1; // 001 2031 case ICmpInst::ICMP_SGT: return 1; // 001 2032 case ICmpInst::ICMP_EQ: return 2; // 010 2033 case ICmpInst::ICMP_UGE: return 3; // 011 2034 case ICmpInst::ICMP_SGE: return 3; // 011 2035 case ICmpInst::ICMP_ULT: return 4; // 100 2036 case ICmpInst::ICMP_SLT: return 4; // 100 2037 case ICmpInst::ICMP_NE: return 5; // 101 2038 case ICmpInst::ICMP_ULE: return 6; // 110 2039 case ICmpInst::ICMP_SLE: return 6; // 110 2040 // True -> 7 2041 default: 2042 llvm_unreachable("Invalid ICmp predicate!"); 2043 return 0; 2044 } 2045} 2046 2047/// getFCmpCode - Similar to getICmpCode but for FCmpInst. This encodes a fcmp 2048/// predicate into a three bit mask. It also returns whether it is an ordered 2049/// predicate by reference. 2050static unsigned getFCmpCode(FCmpInst::Predicate CC, bool &isOrdered) { 2051 isOrdered = false; 2052 switch (CC) { 2053 case FCmpInst::FCMP_ORD: isOrdered = true; return 0; // 000 2054 case FCmpInst::FCMP_UNO: return 0; // 000 2055 case FCmpInst::FCMP_OGT: isOrdered = true; return 1; // 001 2056 case FCmpInst::FCMP_UGT: return 1; // 001 2057 case FCmpInst::FCMP_OEQ: isOrdered = true; return 2; // 010 2058 case FCmpInst::FCMP_UEQ: return 2; // 010 2059 case FCmpInst::FCMP_OGE: isOrdered = true; return 3; // 011 2060 case FCmpInst::FCMP_UGE: return 3; // 011 2061 case FCmpInst::FCMP_OLT: isOrdered = true; return 4; // 100 2062 case FCmpInst::FCMP_ULT: return 4; // 100 2063 case FCmpInst::FCMP_ONE: isOrdered = true; return 5; // 101 2064 case FCmpInst::FCMP_UNE: return 5; // 101 2065 case FCmpInst::FCMP_OLE: isOrdered = true; return 6; // 110 2066 case FCmpInst::FCMP_ULE: return 6; // 110 2067 // True -> 7 2068 default: 2069 // Not expecting FCMP_FALSE and FCMP_TRUE; 2070 llvm_unreachable("Unexpected FCmp predicate!"); 2071 return 0; 2072 } 2073} 2074 2075/// getICmpValue - This is the complement of getICmpCode, which turns an 2076/// opcode and two operands into either a constant true or false, or a brand 2077/// new ICmp instruction. The sign is passed in to determine which kind 2078/// of predicate to use in the new icmp instruction. 2079static Value *getICmpValue(bool sign, unsigned code, Value *LHS, Value *RHS) { 2080 switch (code) { 2081 default: llvm_unreachable("Illegal ICmp code!"); 2082 case 0: return ConstantInt::getFalse(LHS->getContext()); 2083 case 1: 2084 if (sign) 2085 return new ICmpInst(ICmpInst::ICMP_SGT, LHS, RHS); 2086 else 2087 return new ICmpInst(ICmpInst::ICMP_UGT, LHS, RHS); 2088 case 2: return new ICmpInst(ICmpInst::ICMP_EQ, LHS, RHS); 2089 case 3: 2090 if (sign) 2091 return new ICmpInst(ICmpInst::ICMP_SGE, LHS, RHS); 2092 else 2093 return new ICmpInst(ICmpInst::ICMP_UGE, LHS, RHS); 2094 case 4: 2095 if (sign) 2096 return new ICmpInst(ICmpInst::ICMP_SLT, LHS, RHS); 2097 else 2098 return new ICmpInst(ICmpInst::ICMP_ULT, LHS, RHS); 2099 case 5: return new ICmpInst(ICmpInst::ICMP_NE, LHS, RHS); 2100 case 6: 2101 if (sign) 2102 return new ICmpInst(ICmpInst::ICMP_SLE, LHS, RHS); 2103 else 2104 return new ICmpInst(ICmpInst::ICMP_ULE, LHS, RHS); 2105 case 7: return ConstantInt::getTrue(LHS->getContext()); 2106 } 2107} 2108 2109/// getFCmpValue - This is the complement of getFCmpCode, which turns an 2110/// opcode and two operands into either a FCmp instruction. isordered is passed 2111/// in to determine which kind of predicate to use in the new fcmp instruction. 2112static Value *getFCmpValue(bool isordered, unsigned code, 2113 Value *LHS, Value *RHS) { 2114 switch (code) { 2115 default: llvm_unreachable("Illegal FCmp code!"); 2116 case 0: 2117 if (isordered) 2118 return new FCmpInst(FCmpInst::FCMP_ORD, LHS, RHS); 2119 else 2120 return new FCmpInst(FCmpInst::FCMP_UNO, LHS, RHS); 2121 case 1: 2122 if (isordered) 2123 return new FCmpInst(FCmpInst::FCMP_OGT, LHS, RHS); 2124 else 2125 return new FCmpInst(FCmpInst::FCMP_UGT, LHS, RHS); 2126 case 2: 2127 if (isordered) 2128 return new FCmpInst(FCmpInst::FCMP_OEQ, LHS, RHS); 2129 else 2130 return new FCmpInst(FCmpInst::FCMP_UEQ, LHS, RHS); 2131 case 3: 2132 if (isordered) 2133 return new FCmpInst(FCmpInst::FCMP_OGE, LHS, RHS); 2134 else 2135 return new FCmpInst(FCmpInst::FCMP_UGE, LHS, RHS); 2136 case 4: 2137 if (isordered) 2138 return new FCmpInst(FCmpInst::FCMP_OLT, LHS, RHS); 2139 else 2140 return new FCmpInst(FCmpInst::FCMP_ULT, LHS, RHS); 2141 case 5: 2142 if (isordered) 2143 return new FCmpInst(FCmpInst::FCMP_ONE, LHS, RHS); 2144 else 2145 return new FCmpInst(FCmpInst::FCMP_UNE, LHS, RHS); 2146 case 6: 2147 if (isordered) 2148 return new FCmpInst(FCmpInst::FCMP_OLE, LHS, RHS); 2149 else 2150 return new FCmpInst(FCmpInst::FCMP_ULE, LHS, RHS); 2151 case 7: return ConstantInt::getTrue(LHS->getContext()); 2152 } 2153} 2154 2155/// PredicatesFoldable - Return true if both predicates match sign or if at 2156/// least one of them is an equality comparison (which is signless). 2157static bool PredicatesFoldable(ICmpInst::Predicate p1, ICmpInst::Predicate p2) { 2158 return (CmpInst::isSigned(p1) == CmpInst::isSigned(p2)) || 2159 (CmpInst::isSigned(p1) && ICmpInst::isEquality(p2)) || 2160 (CmpInst::isSigned(p2) && ICmpInst::isEquality(p1)); 2161} 2162 2163namespace { 2164// FoldICmpLogical - Implements (icmp1 A, B) & (icmp2 A, B) --> (icmp3 A, B) 2165struct FoldICmpLogical { 2166 InstCombiner &IC; 2167 Value *LHS, *RHS; 2168 ICmpInst::Predicate pred; 2169 FoldICmpLogical(InstCombiner &ic, ICmpInst *ICI) 2170 : IC(ic), LHS(ICI->getOperand(0)), RHS(ICI->getOperand(1)), 2171 pred(ICI->getPredicate()) {} 2172 bool shouldApply(Value *V) const { 2173 if (ICmpInst *ICI = dyn_cast<ICmpInst>(V)) 2174 if (PredicatesFoldable(pred, ICI->getPredicate())) 2175 return ((ICI->getOperand(0) == LHS && ICI->getOperand(1) == RHS) || 2176 (ICI->getOperand(0) == RHS && ICI->getOperand(1) == LHS)); 2177 return false; 2178 } 2179 Instruction *apply(Instruction &Log) const { 2180 ICmpInst *ICI = cast<ICmpInst>(Log.getOperand(0)); 2181 if (ICI->getOperand(0) != LHS) { 2182 assert(ICI->getOperand(1) == LHS); 2183 ICI->swapOperands(); // Swap the LHS and RHS of the ICmp 2184 } 2185 2186 ICmpInst *RHSICI = cast<ICmpInst>(Log.getOperand(1)); 2187 unsigned LHSCode = getICmpCode(ICI); 2188 unsigned RHSCode = getICmpCode(RHSICI); 2189 unsigned Code; 2190 switch (Log.getOpcode()) { 2191 case Instruction::And: Code = LHSCode & RHSCode; break; 2192 case Instruction::Or: Code = LHSCode | RHSCode; break; 2193 case Instruction::Xor: Code = LHSCode ^ RHSCode; break; 2194 default: llvm_unreachable("Illegal logical opcode!"); return 0; 2195 } 2196 2197 bool isSigned = RHSICI->isSigned() || ICI->isSigned(); 2198 Value *RV = getICmpValue(isSigned, Code, LHS, RHS); 2199 if (Instruction *I = dyn_cast<Instruction>(RV)) 2200 return I; 2201 // Otherwise, it's a constant boolean value... 2202 return IC.ReplaceInstUsesWith(Log, RV); 2203 } 2204}; 2205} // end anonymous namespace 2206 2207// OptAndOp - This handles expressions of the form ((val OP C1) & C2). Where 2208// the Op parameter is 'OP', OpRHS is 'C1', and AndRHS is 'C2'. Op is 2209// guaranteed to be a binary operator. 2210Instruction *InstCombiner::OptAndOp(Instruction *Op, 2211 ConstantInt *OpRHS, 2212 ConstantInt *AndRHS, 2213 BinaryOperator &TheAnd) { 2214 Value *X = Op->getOperand(0); 2215 Constant *Together = 0; 2216 if (!Op->isShift()) 2217 Together = ConstantExpr::getAnd(AndRHS, OpRHS); 2218 2219 switch (Op->getOpcode()) { 2220 case Instruction::Xor: 2221 if (Op->hasOneUse()) { 2222 // (X ^ C1) & C2 --> (X & C2) ^ (C1&C2) 2223 Value *And = Builder->CreateAnd(X, AndRHS); 2224 And->takeName(Op); 2225 return BinaryOperator::CreateXor(And, Together); 2226 } 2227 break; 2228 case Instruction::Or: 2229 if (Together == AndRHS) // (X | C) & C --> C 2230 return ReplaceInstUsesWith(TheAnd, AndRHS); 2231 2232 if (Op->hasOneUse() && Together != OpRHS) { 2233 // (X | C1) & C2 --> (X | (C1&C2)) & C2 2234 Value *Or = Builder->CreateOr(X, Together); 2235 Or->takeName(Op); 2236 return BinaryOperator::CreateAnd(Or, AndRHS); 2237 } 2238 break; 2239 case Instruction::Add: 2240 if (Op->hasOneUse()) { 2241 // Adding a one to a single bit bit-field should be turned into an XOR 2242 // of the bit. First thing to check is to see if this AND is with a 2243 // single bit constant. 2244 const APInt& AndRHSV = cast<ConstantInt>(AndRHS)->getValue(); 2245 2246 // If there is only one bit set... 2247 if (isOneBitSet(cast<ConstantInt>(AndRHS))) { 2248 // Ok, at this point, we know that we are masking the result of the 2249 // ADD down to exactly one bit. If the constant we are adding has 2250 // no bits set below this bit, then we can eliminate the ADD. 2251 const APInt& AddRHS = cast<ConstantInt>(OpRHS)->getValue(); 2252 2253 // Check to see if any bits below the one bit set in AndRHSV are set. 2254 if ((AddRHS & (AndRHSV-1)) == 0) { 2255 // If not, the only thing that can effect the output of the AND is 2256 // the bit specified by AndRHSV. If that bit is set, the effect of 2257 // the XOR is to toggle the bit. If it is clear, then the ADD has 2258 // no effect. 2259 if ((AddRHS & AndRHSV) == 0) { // Bit is not set, noop 2260 TheAnd.setOperand(0, X); 2261 return &TheAnd; 2262 } else { 2263 // Pull the XOR out of the AND. 2264 Value *NewAnd = Builder->CreateAnd(X, AndRHS); 2265 NewAnd->takeName(Op); 2266 return BinaryOperator::CreateXor(NewAnd, AndRHS); 2267 } 2268 } 2269 } 2270 } 2271 break; 2272 2273 case Instruction::Shl: { 2274 // We know that the AND will not produce any of the bits shifted in, so if 2275 // the anded constant includes them, clear them now! 2276 // 2277 uint32_t BitWidth = AndRHS->getType()->getBitWidth(); 2278 uint32_t OpRHSVal = OpRHS->getLimitedValue(BitWidth); 2279 APInt ShlMask(APInt::getHighBitsSet(BitWidth, BitWidth-OpRHSVal)); 2280 ConstantInt *CI = ConstantInt::get(AndRHS->getContext(), 2281 AndRHS->getValue() & ShlMask); 2282 2283 if (CI->getValue() == ShlMask) { 2284 // Masking out bits that the shift already masks 2285 return ReplaceInstUsesWith(TheAnd, Op); // No need for the and. 2286 } else if (CI != AndRHS) { // Reducing bits set in and. 2287 TheAnd.setOperand(1, CI); 2288 return &TheAnd; 2289 } 2290 break; 2291 } 2292 case Instruction::LShr: { 2293 // We know that the AND will not produce any of the bits shifted in, so if 2294 // the anded constant includes them, clear them now! This only applies to 2295 // unsigned shifts, because a signed shr may bring in set bits! 2296 // 2297 uint32_t BitWidth = AndRHS->getType()->getBitWidth(); 2298 uint32_t OpRHSVal = OpRHS->getLimitedValue(BitWidth); 2299 APInt ShrMask(APInt::getLowBitsSet(BitWidth, BitWidth - OpRHSVal)); 2300 ConstantInt *CI = ConstantInt::get(Op->getContext(), 2301 AndRHS->getValue() & ShrMask); 2302 2303 if (CI->getValue() == ShrMask) { 2304 // Masking out bits that the shift already masks. 2305 return ReplaceInstUsesWith(TheAnd, Op); 2306 } else if (CI != AndRHS) { 2307 TheAnd.setOperand(1, CI); // Reduce bits set in and cst. 2308 return &TheAnd; 2309 } 2310 break; 2311 } 2312 case Instruction::AShr: 2313 // Signed shr. 2314 // See if this is shifting in some sign extension, then masking it out 2315 // with an and. 2316 if (Op->hasOneUse()) { 2317 uint32_t BitWidth = AndRHS->getType()->getBitWidth(); 2318 uint32_t OpRHSVal = OpRHS->getLimitedValue(BitWidth); 2319 APInt ShrMask(APInt::getLowBitsSet(BitWidth, BitWidth - OpRHSVal)); 2320 Constant *C = ConstantInt::get(Op->getContext(), 2321 AndRHS->getValue() & ShrMask); 2322 if (C == AndRHS) { // Masking out bits shifted in. 2323 // (Val ashr C1) & C2 -> (Val lshr C1) & C2 2324 // Make the argument unsigned. 2325 Value *ShVal = Op->getOperand(0); 2326 ShVal = Builder->CreateLShr(ShVal, OpRHS, Op->getName()); 2327 return BinaryOperator::CreateAnd(ShVal, AndRHS, TheAnd.getName()); 2328 } 2329 } 2330 break; 2331 } 2332 return 0; 2333} 2334 2335 2336/// InsertRangeTest - Emit a computation of: (V >= Lo && V < Hi) if Inside is 2337/// true, otherwise (V < Lo || V >= Hi). In pratice, we emit the more efficient 2338/// (V-Lo) <u Hi-Lo. This method expects that Lo <= Hi. isSigned indicates 2339/// whether to treat the V, Lo and HI as signed or not. IB is the location to 2340/// insert new instructions. 2341Instruction *InstCombiner::InsertRangeTest(Value *V, Constant *Lo, Constant *Hi, 2342 bool isSigned, bool Inside, 2343 Instruction &IB) { 2344 assert(cast<ConstantInt>(ConstantExpr::getICmp((isSigned ? 2345 ICmpInst::ICMP_SLE:ICmpInst::ICMP_ULE), Lo, Hi))->getZExtValue() && 2346 "Lo is not <= Hi in range emission code!"); 2347 2348 if (Inside) { 2349 if (Lo == Hi) // Trivially false. 2350 return new ICmpInst(ICmpInst::ICMP_NE, V, V); 2351 2352 // V >= Min && V < Hi --> V < Hi 2353 if (cast<ConstantInt>(Lo)->isMinValue(isSigned)) { 2354 ICmpInst::Predicate pred = (isSigned ? 2355 ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT); 2356 return new ICmpInst(pred, V, Hi); 2357 } 2358 2359 // Emit V-Lo <u Hi-Lo 2360 Constant *NegLo = ConstantExpr::getNeg(Lo); 2361 Value *Add = Builder->CreateAdd(V, NegLo, V->getName()+".off"); 2362 Constant *UpperBound = ConstantExpr::getAdd(NegLo, Hi); 2363 return new ICmpInst(ICmpInst::ICMP_ULT, Add, UpperBound); 2364 } 2365 2366 if (Lo == Hi) // Trivially true. 2367 return new ICmpInst(ICmpInst::ICMP_EQ, V, V); 2368 2369 // V < Min || V >= Hi -> V > Hi-1 2370 Hi = SubOne(cast<ConstantInt>(Hi)); 2371 if (cast<ConstantInt>(Lo)->isMinValue(isSigned)) { 2372 ICmpInst::Predicate pred = (isSigned ? 2373 ICmpInst::ICMP_SGT : ICmpInst::ICMP_UGT); 2374 return new ICmpInst(pred, V, Hi); 2375 } 2376 2377 // Emit V-Lo >u Hi-1-Lo 2378 // Note that Hi has already had one subtracted from it, above. 2379 ConstantInt *NegLo = cast<ConstantInt>(ConstantExpr::getNeg(Lo)); 2380 Value *Add = Builder->CreateAdd(V, NegLo, V->getName()+".off"); 2381 Constant *LowerBound = ConstantExpr::getAdd(NegLo, Hi); 2382 return new ICmpInst(ICmpInst::ICMP_UGT, Add, LowerBound); 2383} 2384 2385// isRunOfOnes - Returns true iff Val consists of one contiguous run of 1s with 2386// any number of 0s on either side. The 1s are allowed to wrap from LSB to 2387// MSB, so 0x000FFF0, 0x0000FFFF, and 0xFF0000FF are all runs. 0x0F0F0000 is 2388// not, since all 1s are not contiguous. 2389static bool isRunOfOnes(ConstantInt *Val, uint32_t &MB, uint32_t &ME) { 2390 const APInt& V = Val->getValue(); 2391 uint32_t BitWidth = Val->getType()->getBitWidth(); 2392 if (!APIntOps::isShiftedMask(BitWidth, V)) return false; 2393 2394 // look for the first zero bit after the run of ones 2395 MB = BitWidth - ((V - 1) ^ V).countLeadingZeros(); 2396 // look for the first non-zero bit 2397 ME = V.getActiveBits(); 2398 return true; 2399} 2400 2401/// FoldLogicalPlusAnd - This is part of an expression (LHS +/- RHS) & Mask, 2402/// where isSub determines whether the operator is a sub. If we can fold one of 2403/// the following xforms: 2404/// 2405/// ((A & N) +/- B) & Mask -> (A +/- B) & Mask iff N&Mask == Mask 2406/// ((A | N) +/- B) & Mask -> (A +/- B) & Mask iff N&Mask == 0 2407/// ((A ^ N) +/- B) & Mask -> (A +/- B) & Mask iff N&Mask == 0 2408/// 2409/// return (A +/- B). 2410/// 2411Value *InstCombiner::FoldLogicalPlusAnd(Value *LHS, Value *RHS, 2412 ConstantInt *Mask, bool isSub, 2413 Instruction &I) { 2414 Instruction *LHSI = dyn_cast<Instruction>(LHS); 2415 if (!LHSI || LHSI->getNumOperands() != 2 || 2416 !isa<ConstantInt>(LHSI->getOperand(1))) return 0; 2417 2418 ConstantInt *N = cast<ConstantInt>(LHSI->getOperand(1)); 2419 2420 switch (LHSI->getOpcode()) { 2421 default: return 0; 2422 case Instruction::And: 2423 if (ConstantExpr::getAnd(N, Mask) == Mask) { 2424 // If the AndRHS is a power of two minus one (0+1+), this is simple. 2425 if ((Mask->getValue().countLeadingZeros() + 2426 Mask->getValue().countPopulation()) == 2427 Mask->getValue().getBitWidth()) 2428 break; 2429 2430 // Otherwise, if Mask is 0+1+0+, and if B is known to have the low 0+ 2431 // part, we don't need any explicit masks to take them out of A. If that 2432 // is all N is, ignore it. 2433 uint32_t MB = 0, ME = 0; 2434 if (isRunOfOnes(Mask, MB, ME)) { // begin/end bit of run, inclusive 2435 uint32_t BitWidth = cast<IntegerType>(RHS->getType())->getBitWidth(); 2436 APInt Mask(APInt::getLowBitsSet(BitWidth, MB-1)); 2437 if (MaskedValueIsZero(RHS, Mask)) 2438 break; 2439 } 2440 } 2441 return 0; 2442 case Instruction::Or: 2443 case Instruction::Xor: 2444 // If the AndRHS is a power of two minus one (0+1+), and N&Mask == 0 2445 if ((Mask->getValue().countLeadingZeros() + 2446 Mask->getValue().countPopulation()) == Mask->getValue().getBitWidth() 2447 && ConstantExpr::getAnd(N, Mask)->isNullValue()) 2448 break; 2449 return 0; 2450 } 2451 2452 if (isSub) 2453 return Builder->CreateSub(LHSI->getOperand(0), RHS, "fold"); 2454 return Builder->CreateAdd(LHSI->getOperand(0), RHS, "fold"); 2455} 2456 2457/// FoldAndOfICmps - Fold (icmp)&(icmp) if possible. 2458Instruction *InstCombiner::FoldAndOfICmps(Instruction &I, 2459 ICmpInst *LHS, ICmpInst *RHS) { 2460 Value *Val, *Val2; 2461 ConstantInt *LHSCst, *RHSCst; 2462 ICmpInst::Predicate LHSCC, RHSCC; 2463 2464 // This only handles icmp of constants: (icmp1 A, C1) & (icmp2 B, C2). 2465 if (!match(LHS, m_ICmp(LHSCC, m_Value(Val), 2466 m_ConstantInt(LHSCst))) || 2467 !match(RHS, m_ICmp(RHSCC, m_Value(Val2), 2468 m_ConstantInt(RHSCst)))) 2469 return 0; 2470 2471 if (LHSCst == RHSCst && LHSCC == RHSCC) { 2472 // (icmp ult A, C) & (icmp ult B, C) --> (icmp ult (A|B), C) 2473 // where C is a power of 2 2474 if (LHSCC == ICmpInst::ICMP_ULT && 2475 LHSCst->getValue().isPowerOf2()) { 2476 Value *NewOr = Builder->CreateOr(Val, Val2); 2477 return new ICmpInst(LHSCC, NewOr, LHSCst); 2478 } 2479 2480 // (icmp eq A, 0) & (icmp eq B, 0) --> (icmp eq (A|B), 0) 2481 if (LHSCC == ICmpInst::ICMP_EQ && LHSCst->isZero()) { 2482 Value *NewOr = Builder->CreateOr(Val, Val2); 2483 return new ICmpInst(LHSCC, NewOr, LHSCst); 2484 } 2485 } 2486 2487 // From here on, we only handle: 2488 // (icmp1 A, C1) & (icmp2 A, C2) --> something simpler. 2489 if (Val != Val2) return 0; 2490 2491 // ICMP_[US][GL]E X, CST is folded to ICMP_[US][GL]T elsewhere. 2492 if (LHSCC == ICmpInst::ICMP_UGE || LHSCC == ICmpInst::ICMP_ULE || 2493 RHSCC == ICmpInst::ICMP_UGE || RHSCC == ICmpInst::ICMP_ULE || 2494 LHSCC == ICmpInst::ICMP_SGE || LHSCC == ICmpInst::ICMP_SLE || 2495 RHSCC == ICmpInst::ICMP_SGE || RHSCC == ICmpInst::ICMP_SLE) 2496 return 0; 2497 2498 // We can't fold (ugt x, C) & (sgt x, C2). 2499 if (!PredicatesFoldable(LHSCC, RHSCC)) 2500 return 0; 2501 2502 // Ensure that the larger constant is on the RHS. 2503 bool ShouldSwap; 2504 if (CmpInst::isSigned(LHSCC) || 2505 (ICmpInst::isEquality(LHSCC) && 2506 CmpInst::isSigned(RHSCC))) 2507 ShouldSwap = LHSCst->getValue().sgt(RHSCst->getValue()); 2508 else 2509 ShouldSwap = LHSCst->getValue().ugt(RHSCst->getValue()); 2510 2511 if (ShouldSwap) { 2512 std::swap(LHS, RHS); 2513 std::swap(LHSCst, RHSCst); 2514 std::swap(LHSCC, RHSCC); 2515 } 2516 2517 // At this point, we know we have have two icmp instructions 2518 // comparing a value against two constants and and'ing the result 2519 // together. Because of the above check, we know that we only have 2520 // icmp eq, icmp ne, icmp [su]lt, and icmp [SU]gt here. We also know 2521 // (from the FoldICmpLogical check above), that the two constants 2522 // are not equal and that the larger constant is on the RHS 2523 assert(LHSCst != RHSCst && "Compares not folded above?"); 2524 2525 switch (LHSCC) { 2526 default: llvm_unreachable("Unknown integer condition code!"); 2527 case ICmpInst::ICMP_EQ: 2528 switch (RHSCC) { 2529 default: llvm_unreachable("Unknown integer condition code!"); 2530 case ICmpInst::ICMP_EQ: // (X == 13 & X == 15) -> false 2531 case ICmpInst::ICMP_UGT: // (X == 13 & X > 15) -> false 2532 case ICmpInst::ICMP_SGT: // (X == 13 & X > 15) -> false 2533 return ReplaceInstUsesWith(I, ConstantInt::getFalse(I.getContext())); 2534 case ICmpInst::ICMP_NE: // (X == 13 & X != 15) -> X == 13 2535 case ICmpInst::ICMP_ULT: // (X == 13 & X < 15) -> X == 13 2536 case ICmpInst::ICMP_SLT: // (X == 13 & X < 15) -> X == 13 2537 return ReplaceInstUsesWith(I, LHS); 2538 } 2539 case ICmpInst::ICMP_NE: 2540 switch (RHSCC) { 2541 default: llvm_unreachable("Unknown integer condition code!"); 2542 case ICmpInst::ICMP_ULT: 2543 if (LHSCst == SubOne(RHSCst)) // (X != 13 & X u< 14) -> X < 13 2544 return new ICmpInst(ICmpInst::ICMP_ULT, Val, LHSCst); 2545 break; // (X != 13 & X u< 15) -> no change 2546 case ICmpInst::ICMP_SLT: 2547 if (LHSCst == SubOne(RHSCst)) // (X != 13 & X s< 14) -> X < 13 2548 return new ICmpInst(ICmpInst::ICMP_SLT, Val, LHSCst); 2549 break; // (X != 13 & X s< 15) -> no change 2550 case ICmpInst::ICMP_EQ: // (X != 13 & X == 15) -> X == 15 2551 case ICmpInst::ICMP_UGT: // (X != 13 & X u> 15) -> X u> 15 2552 case ICmpInst::ICMP_SGT: // (X != 13 & X s> 15) -> X s> 15 2553 return ReplaceInstUsesWith(I, RHS); 2554 case ICmpInst::ICMP_NE: 2555 if (LHSCst == SubOne(RHSCst)){// (X != 13 & X != 14) -> X-13 >u 1 2556 Constant *AddCST = ConstantExpr::getNeg(LHSCst); 2557 Value *Add = Builder->CreateAdd(Val, AddCST, Val->getName()+".off"); 2558 return new ICmpInst(ICmpInst::ICMP_UGT, Add, 2559 ConstantInt::get(Add->getType(), 1)); 2560 } 2561 break; // (X != 13 & X != 15) -> no change 2562 } 2563 break; 2564 case ICmpInst::ICMP_ULT: 2565 switch (RHSCC) { 2566 default: llvm_unreachable("Unknown integer condition code!"); 2567 case ICmpInst::ICMP_EQ: // (X u< 13 & X == 15) -> false 2568 case ICmpInst::ICMP_UGT: // (X u< 13 & X u> 15) -> false 2569 return ReplaceInstUsesWith(I, ConstantInt::getFalse(I.getContext())); 2570 case ICmpInst::ICMP_SGT: // (X u< 13 & X s> 15) -> no change 2571 break; 2572 case ICmpInst::ICMP_NE: // (X u< 13 & X != 15) -> X u< 13 2573 case ICmpInst::ICMP_ULT: // (X u< 13 & X u< 15) -> X u< 13 2574 return ReplaceInstUsesWith(I, LHS); 2575 case ICmpInst::ICMP_SLT: // (X u< 13 & X s< 15) -> no change 2576 break; 2577 } 2578 break; 2579 case ICmpInst::ICMP_SLT: 2580 switch (RHSCC) { 2581 default: llvm_unreachable("Unknown integer condition code!"); 2582 case ICmpInst::ICMP_EQ: // (X s< 13 & X == 15) -> false 2583 case ICmpInst::ICMP_SGT: // (X s< 13 & X s> 15) -> false 2584 return ReplaceInstUsesWith(I, ConstantInt::getFalse(I.getContext())); 2585 case ICmpInst::ICMP_UGT: // (X s< 13 & X u> 15) -> no change 2586 break; 2587 case ICmpInst::ICMP_NE: // (X s< 13 & X != 15) -> X < 13 2588 case ICmpInst::ICMP_SLT: // (X s< 13 & X s< 15) -> X < 13 2589 return ReplaceInstUsesWith(I, LHS); 2590 case ICmpInst::ICMP_ULT: // (X s< 13 & X u< 15) -> no change 2591 break; 2592 } 2593 break; 2594 case ICmpInst::ICMP_UGT: 2595 switch (RHSCC) { 2596 default: llvm_unreachable("Unknown integer condition code!"); 2597 case ICmpInst::ICMP_EQ: // (X u> 13 & X == 15) -> X == 15 2598 case ICmpInst::ICMP_UGT: // (X u> 13 & X u> 15) -> X u> 15 2599 return ReplaceInstUsesWith(I, RHS); 2600 case ICmpInst::ICMP_SGT: // (X u> 13 & X s> 15) -> no change 2601 break; 2602 case ICmpInst::ICMP_NE: 2603 if (RHSCst == AddOne(LHSCst)) // (X u> 13 & X != 14) -> X u> 14 2604 return new ICmpInst(LHSCC, Val, RHSCst); 2605 break; // (X u> 13 & X != 15) -> no change 2606 case ICmpInst::ICMP_ULT: // (X u> 13 & X u< 15) -> (X-14) <u 1 2607 return InsertRangeTest(Val, AddOne(LHSCst), 2608 RHSCst, false, true, I); 2609 case ICmpInst::ICMP_SLT: // (X u> 13 & X s< 15) -> no change 2610 break; 2611 } 2612 break; 2613 case ICmpInst::ICMP_SGT: 2614 switch (RHSCC) { 2615 default: llvm_unreachable("Unknown integer condition code!"); 2616 case ICmpInst::ICMP_EQ: // (X s> 13 & X == 15) -> X == 15 2617 case ICmpInst::ICMP_SGT: // (X s> 13 & X s> 15) -> X s> 15 2618 return ReplaceInstUsesWith(I, RHS); 2619 case ICmpInst::ICMP_UGT: // (X s> 13 & X u> 15) -> no change 2620 break; 2621 case ICmpInst::ICMP_NE: 2622 if (RHSCst == AddOne(LHSCst)) // (X s> 13 & X != 14) -> X s> 14 2623 return new ICmpInst(LHSCC, Val, RHSCst); 2624 break; // (X s> 13 & X != 15) -> no change 2625 case ICmpInst::ICMP_SLT: // (X s> 13 & X s< 15) -> (X-14) s< 1 2626 return InsertRangeTest(Val, AddOne(LHSCst), 2627 RHSCst, true, true, I); 2628 case ICmpInst::ICMP_ULT: // (X s> 13 & X u< 15) -> no change 2629 break; 2630 } 2631 break; 2632 } 2633 2634 return 0; 2635} 2636 2637Instruction *InstCombiner::FoldAndOfFCmps(Instruction &I, FCmpInst *LHS, 2638 FCmpInst *RHS) { 2639 2640 if (LHS->getPredicate() == FCmpInst::FCMP_ORD && 2641 RHS->getPredicate() == FCmpInst::FCMP_ORD) { 2642 // (fcmp ord x, c) & (fcmp ord y, c) -> (fcmp ord x, y) 2643 if (ConstantFP *LHSC = dyn_cast<ConstantFP>(LHS->getOperand(1))) 2644 if (ConstantFP *RHSC = dyn_cast<ConstantFP>(RHS->getOperand(1))) { 2645 // If either of the constants are nans, then the whole thing returns 2646 // false. 2647 if (LHSC->getValueAPF().isNaN() || RHSC->getValueAPF().isNaN()) 2648 return ReplaceInstUsesWith(I, ConstantInt::getFalse(I.getContext())); 2649 return new FCmpInst(FCmpInst::FCMP_ORD, 2650 LHS->getOperand(0), RHS->getOperand(0)); 2651 } 2652 2653 // Handle vector zeros. This occurs because the canonical form of 2654 // "fcmp ord x,x" is "fcmp ord x, 0". 2655 if (isa<ConstantAggregateZero>(LHS->getOperand(1)) && 2656 isa<ConstantAggregateZero>(RHS->getOperand(1))) 2657 return new FCmpInst(FCmpInst::FCMP_ORD, 2658 LHS->getOperand(0), RHS->getOperand(0)); 2659 return 0; 2660 } 2661 2662 Value *Op0LHS = LHS->getOperand(0), *Op0RHS = LHS->getOperand(1); 2663 Value *Op1LHS = RHS->getOperand(0), *Op1RHS = RHS->getOperand(1); 2664 FCmpInst::Predicate Op0CC = LHS->getPredicate(), Op1CC = RHS->getPredicate(); 2665 2666 2667 if (Op0LHS == Op1RHS && Op0RHS == Op1LHS) { 2668 // Swap RHS operands to match LHS. 2669 Op1CC = FCmpInst::getSwappedPredicate(Op1CC); 2670 std::swap(Op1LHS, Op1RHS); 2671 } 2672 2673 if (Op0LHS == Op1LHS && Op0RHS == Op1RHS) { 2674 // Simplify (fcmp cc0 x, y) & (fcmp cc1 x, y). 2675 if (Op0CC == Op1CC) 2676 return new FCmpInst((FCmpInst::Predicate)Op0CC, Op0LHS, Op0RHS); 2677 2678 if (Op0CC == FCmpInst::FCMP_FALSE || Op1CC == FCmpInst::FCMP_FALSE) 2679 return ReplaceInstUsesWith(I, ConstantInt::getFalse(I.getContext())); 2680 if (Op0CC == FCmpInst::FCMP_TRUE) 2681 return ReplaceInstUsesWith(I, RHS); 2682 if (Op1CC == FCmpInst::FCMP_TRUE) 2683 return ReplaceInstUsesWith(I, LHS); 2684 2685 bool Op0Ordered; 2686 bool Op1Ordered; 2687 unsigned Op0Pred = getFCmpCode(Op0CC, Op0Ordered); 2688 unsigned Op1Pred = getFCmpCode(Op1CC, Op1Ordered); 2689 if (Op1Pred == 0) { 2690 std::swap(LHS, RHS); 2691 std::swap(Op0Pred, Op1Pred); 2692 std::swap(Op0Ordered, Op1Ordered); 2693 } 2694 if (Op0Pred == 0) { 2695 // uno && ueq -> uno && (uno || eq) -> ueq 2696 // ord && olt -> ord && (ord && lt) -> olt 2697 if (Op0Ordered == Op1Ordered) 2698 return ReplaceInstUsesWith(I, RHS); 2699 2700 // uno && oeq -> uno && (ord && eq) -> false 2701 // uno && ord -> false 2702 if (!Op0Ordered) 2703 return ReplaceInstUsesWith(I, ConstantInt::getFalse(I.getContext())); 2704 // ord && ueq -> ord && (uno || eq) -> oeq 2705 return cast<Instruction>(getFCmpValue(true, Op1Pred, Op0LHS, Op0RHS)); 2706 } 2707 } 2708 2709 return 0; 2710} 2711 2712 2713Instruction *InstCombiner::visitAnd(BinaryOperator &I) { 2714 bool Changed = SimplifyCommutative(I); 2715 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1); 2716 2717 if (Value *V = SimplifyAndInst(Op0, Op1, TD)) 2718 return ReplaceInstUsesWith(I, V); 2719 2720 // See if we can simplify any instructions used by the instruction whose sole 2721 // purpose is to compute bits we don't care about. 2722 if (SimplifyDemandedInstructionBits(I)) 2723 return &I; 2724 2725 if (ConstantInt *AndRHS = dyn_cast<ConstantInt>(Op1)) { 2726 const APInt &AndRHSMask = AndRHS->getValue(); 2727 APInt NotAndRHS(~AndRHSMask); 2728 2729 // Optimize a variety of ((val OP C1) & C2) combinations... 2730 if (BinaryOperator *Op0I = dyn_cast<BinaryOperator>(Op0)) { 2731 Value *Op0LHS = Op0I->getOperand(0); 2732 Value *Op0RHS = Op0I->getOperand(1); 2733 switch (Op0I->getOpcode()) { 2734 default: break; 2735 case Instruction::Xor: 2736 case Instruction::Or: 2737 // If the mask is only needed on one incoming arm, push it up. 2738 if (!Op0I->hasOneUse()) break; 2739 2740 if (MaskedValueIsZero(Op0LHS, NotAndRHS)) { 2741 // Not masking anything out for the LHS, move to RHS. 2742 Value *NewRHS = Builder->CreateAnd(Op0RHS, AndRHS, 2743 Op0RHS->getName()+".masked"); 2744 return BinaryOperator::Create(Op0I->getOpcode(), Op0LHS, NewRHS); 2745 } 2746 if (!isa<Constant>(Op0RHS) && 2747 MaskedValueIsZero(Op0RHS, NotAndRHS)) { 2748 // Not masking anything out for the RHS, move to LHS. 2749 Value *NewLHS = Builder->CreateAnd(Op0LHS, AndRHS, 2750 Op0LHS->getName()+".masked"); 2751 return BinaryOperator::Create(Op0I->getOpcode(), NewLHS, Op0RHS); 2752 } 2753 2754 break; 2755 case Instruction::Add: 2756 // ((A & N) + B) & AndRHS -> (A + B) & AndRHS iff N&AndRHS == AndRHS. 2757 // ((A | N) + B) & AndRHS -> (A + B) & AndRHS iff N&AndRHS == 0 2758 // ((A ^ N) + B) & AndRHS -> (A + B) & AndRHS iff N&AndRHS == 0 2759 if (Value *V = FoldLogicalPlusAnd(Op0LHS, Op0RHS, AndRHS, false, I)) 2760 return BinaryOperator::CreateAnd(V, AndRHS); 2761 if (Value *V = FoldLogicalPlusAnd(Op0RHS, Op0LHS, AndRHS, false, I)) 2762 return BinaryOperator::CreateAnd(V, AndRHS); // Add commutes 2763 break; 2764 2765 case Instruction::Sub: 2766 // ((A & N) - B) & AndRHS -> (A - B) & AndRHS iff N&AndRHS == AndRHS. 2767 // ((A | N) - B) & AndRHS -> (A - B) & AndRHS iff N&AndRHS == 0 2768 // ((A ^ N) - B) & AndRHS -> (A - B) & AndRHS iff N&AndRHS == 0 2769 if (Value *V = FoldLogicalPlusAnd(Op0LHS, Op0RHS, AndRHS, true, I)) 2770 return BinaryOperator::CreateAnd(V, AndRHS); 2771 2772 // (A - N) & AndRHS -> -N & AndRHS iff A&AndRHS==0 and AndRHS 2773 // has 1's for all bits that the subtraction with A might affect. 2774 if (Op0I->hasOneUse()) { 2775 uint32_t BitWidth = AndRHSMask.getBitWidth(); 2776 uint32_t Zeros = AndRHSMask.countLeadingZeros(); 2777 APInt Mask = APInt::getLowBitsSet(BitWidth, BitWidth - Zeros); 2778 2779 ConstantInt *A = dyn_cast<ConstantInt>(Op0LHS); 2780 if (!(A && A->isZero()) && // avoid infinite recursion. 2781 MaskedValueIsZero(Op0LHS, Mask)) { 2782 Value *NewNeg = Builder->CreateNeg(Op0RHS); 2783 return BinaryOperator::CreateAnd(NewNeg, AndRHS); 2784 } 2785 } 2786 break; 2787 2788 case Instruction::Shl: 2789 case Instruction::LShr: 2790 // (1 << x) & 1 --> zext(x == 0) 2791 // (1 >> x) & 1 --> zext(x == 0) 2792 if (AndRHSMask == 1 && Op0LHS == AndRHS) { 2793 Value *NewICmp = 2794 Builder->CreateICmpEQ(Op0RHS, Constant::getNullValue(I.getType())); 2795 return new ZExtInst(NewICmp, I.getType()); 2796 } 2797 break; 2798 } 2799 2800 if (ConstantInt *Op0CI = dyn_cast<ConstantInt>(Op0I->getOperand(1))) 2801 if (Instruction *Res = OptAndOp(Op0I, Op0CI, AndRHS, I)) 2802 return Res; 2803 } else if (CastInst *CI = dyn_cast<CastInst>(Op0)) { 2804 // If this is an integer truncation or change from signed-to-unsigned, and 2805 // if the source is an and/or with immediate, transform it. This 2806 // frequently occurs for bitfield accesses. 2807 if (Instruction *CastOp = dyn_cast<Instruction>(CI->getOperand(0))) { 2808 if ((isa<TruncInst>(CI) || isa<BitCastInst>(CI)) && 2809 CastOp->getNumOperands() == 2) 2810 if (ConstantInt *AndCI =dyn_cast<ConstantInt>(CastOp->getOperand(1))){ 2811 if (CastOp->getOpcode() == Instruction::And) { 2812 // Change: and (cast (and X, C1) to T), C2 2813 // into : and (cast X to T), trunc_or_bitcast(C1)&C2 2814 // This will fold the two constants together, which may allow 2815 // other simplifications. 2816 Value *NewCast = Builder->CreateTruncOrBitCast( 2817 CastOp->getOperand(0), I.getType(), 2818 CastOp->getName()+".shrunk"); 2819 // trunc_or_bitcast(C1)&C2 2820 Constant *C3 = ConstantExpr::getTruncOrBitCast(AndCI,I.getType()); 2821 C3 = ConstantExpr::getAnd(C3, AndRHS); 2822 return BinaryOperator::CreateAnd(NewCast, C3); 2823 } else if (CastOp->getOpcode() == Instruction::Or) { 2824 // Change: and (cast (or X, C1) to T), C2 2825 // into : trunc(C1)&C2 iff trunc(C1)&C2 == C2 2826 Constant *C3 = ConstantExpr::getTruncOrBitCast(AndCI,I.getType()); 2827 if (ConstantExpr::getAnd(C3, AndRHS) == AndRHS) 2828 // trunc(C1)&C2 2829 return ReplaceInstUsesWith(I, AndRHS); 2830 } 2831 } 2832 } 2833 } 2834 2835 // Try to fold constant and into select arguments. 2836 if (SelectInst *SI = dyn_cast<SelectInst>(Op0)) 2837 if (Instruction *R = FoldOpIntoSelect(I, SI)) 2838 return R; 2839 if (isa<PHINode>(Op0)) 2840 if (Instruction *NV = FoldOpIntoPhi(I)) 2841 return NV; 2842 } 2843 2844 2845 // (~A & ~B) == (~(A | B)) - De Morgan's Law 2846 if (Value *Op0NotVal = dyn_castNotVal(Op0)) 2847 if (Value *Op1NotVal = dyn_castNotVal(Op1)) 2848 if (Op0->hasOneUse() && Op1->hasOneUse()) { 2849 Value *Or = Builder->CreateOr(Op0NotVal, Op1NotVal, 2850 I.getName()+".demorgan"); 2851 return BinaryOperator::CreateNot(Or); 2852 } 2853 2854 { 2855 Value *A = 0, *B = 0, *C = 0, *D = 0; 2856 // (A|B) & ~(A&B) -> A^B 2857 if (match(Op0, m_Or(m_Value(A), m_Value(B))) && 2858 match(Op1, m_Not(m_And(m_Value(C), m_Value(D)))) && 2859 ((A == C && B == D) || (A == D && B == C))) 2860 return BinaryOperator::CreateXor(A, B); 2861 2862 // ~(A&B) & (A|B) -> A^B 2863 if (match(Op1, m_Or(m_Value(A), m_Value(B))) && 2864 match(Op0, m_Not(m_And(m_Value(C), m_Value(D)))) && 2865 ((A == C && B == D) || (A == D && B == C))) 2866 return BinaryOperator::CreateXor(A, B); 2867 2868 if (Op0->hasOneUse() && 2869 match(Op0, m_Xor(m_Value(A), m_Value(B)))) { 2870 if (A == Op1) { // (A^B)&A -> A&(A^B) 2871 I.swapOperands(); // Simplify below 2872 std::swap(Op0, Op1); 2873 } else if (B == Op1) { // (A^B)&B -> B&(B^A) 2874 cast<BinaryOperator>(Op0)->swapOperands(); 2875 I.swapOperands(); // Simplify below 2876 std::swap(Op0, Op1); 2877 } 2878 } 2879 2880 if (Op1->hasOneUse() && 2881 match(Op1, m_Xor(m_Value(A), m_Value(B)))) { 2882 if (B == Op0) { // B&(A^B) -> B&(B^A) 2883 cast<BinaryOperator>(Op1)->swapOperands(); 2884 std::swap(A, B); 2885 } 2886 if (A == Op0) // A&(A^B) -> A & ~B 2887 return BinaryOperator::CreateAnd(A, Builder->CreateNot(B, "tmp")); 2888 } 2889 2890 // (A&((~A)|B)) -> A&B 2891 if (match(Op0, m_Or(m_Not(m_Specific(Op1)), m_Value(A))) || 2892 match(Op0, m_Or(m_Value(A), m_Not(m_Specific(Op1))))) 2893 return BinaryOperator::CreateAnd(A, Op1); 2894 if (match(Op1, m_Or(m_Not(m_Specific(Op0)), m_Value(A))) || 2895 match(Op1, m_Or(m_Value(A), m_Not(m_Specific(Op0))))) 2896 return BinaryOperator::CreateAnd(A, Op0); 2897 } 2898 2899 if (ICmpInst *RHS = dyn_cast<ICmpInst>(Op1)) { 2900 // (icmp1 A, B) & (icmp2 A, B) --> (icmp3 A, B) 2901 if (Instruction *R = AssociativeOpt(I, FoldICmpLogical(*this, RHS))) 2902 return R; 2903 2904 if (ICmpInst *LHS = dyn_cast<ICmpInst>(Op0)) 2905 if (Instruction *Res = FoldAndOfICmps(I, LHS, RHS)) 2906 return Res; 2907 } 2908 2909 // fold (and (cast A), (cast B)) -> (cast (and A, B)) 2910 if (CastInst *Op0C = dyn_cast<CastInst>(Op0)) 2911 if (CastInst *Op1C = dyn_cast<CastInst>(Op1)) 2912 if (Op0C->getOpcode() == Op1C->getOpcode()) { // same cast kind ? 2913 const Type *SrcTy = Op0C->getOperand(0)->getType(); 2914 if (SrcTy == Op1C->getOperand(0)->getType() && 2915 SrcTy->isIntOrIntVector() && 2916 // Only do this if the casts both really cause code to be generated. 2917 ValueRequiresCast(Op0C->getOpcode(), Op0C->getOperand(0), 2918 I.getType()) && 2919 ValueRequiresCast(Op1C->getOpcode(), Op1C->getOperand(0), 2920 I.getType())) { 2921 Value *NewOp = Builder->CreateAnd(Op0C->getOperand(0), 2922 Op1C->getOperand(0), I.getName()); 2923 return CastInst::Create(Op0C->getOpcode(), NewOp, I.getType()); 2924 } 2925 } 2926 2927 // (X >> Z) & (Y >> Z) -> (X&Y) >> Z for all shifts. 2928 if (BinaryOperator *SI1 = dyn_cast<BinaryOperator>(Op1)) { 2929 if (BinaryOperator *SI0 = dyn_cast<BinaryOperator>(Op0)) 2930 if (SI0->isShift() && SI0->getOpcode() == SI1->getOpcode() && 2931 SI0->getOperand(1) == SI1->getOperand(1) && 2932 (SI0->hasOneUse() || SI1->hasOneUse())) { 2933 Value *NewOp = 2934 Builder->CreateAnd(SI0->getOperand(0), SI1->getOperand(0), 2935 SI0->getName()); 2936 return BinaryOperator::Create(SI1->getOpcode(), NewOp, 2937 SI1->getOperand(1)); 2938 } 2939 } 2940 2941 // If and'ing two fcmp, try combine them into one. 2942 if (FCmpInst *LHS = dyn_cast<FCmpInst>(I.getOperand(0))) { 2943 if (FCmpInst *RHS = dyn_cast<FCmpInst>(I.getOperand(1))) 2944 if (Instruction *Res = FoldAndOfFCmps(I, LHS, RHS)) 2945 return Res; 2946 } 2947 2948 return Changed ? &I : 0; 2949} 2950 2951/// CollectBSwapParts - Analyze the specified subexpression and see if it is 2952/// capable of providing pieces of a bswap. The subexpression provides pieces 2953/// of a bswap if it is proven that each of the non-zero bytes in the output of 2954/// the expression came from the corresponding "byte swapped" byte in some other 2955/// value. For example, if the current subexpression is "(shl i32 %X, 24)" then 2956/// we know that the expression deposits the low byte of %X into the high byte 2957/// of the bswap result and that all other bytes are zero. This expression is 2958/// accepted, the high byte of ByteValues is set to X to indicate a correct 2959/// match. 2960/// 2961/// This function returns true if the match was unsuccessful and false if so. 2962/// On entry to the function the "OverallLeftShift" is a signed integer value 2963/// indicating the number of bytes that the subexpression is later shifted. For 2964/// example, if the expression is later right shifted by 16 bits, the 2965/// OverallLeftShift value would be -2 on entry. This is used to specify which 2966/// byte of ByteValues is actually being set. 2967/// 2968/// Similarly, ByteMask is a bitmask where a bit is clear if its corresponding 2969/// byte is masked to zero by a user. For example, in (X & 255), X will be 2970/// processed with a bytemask of 1. Because bytemask is 32-bits, this limits 2971/// this function to working on up to 32-byte (256 bit) values. ByteMask is 2972/// always in the local (OverallLeftShift) coordinate space. 2973/// 2974static bool CollectBSwapParts(Value *V, int OverallLeftShift, uint32_t ByteMask, 2975 SmallVector<Value*, 8> &ByteValues) { 2976 if (Instruction *I = dyn_cast<Instruction>(V)) { 2977 // If this is an or instruction, it may be an inner node of the bswap. 2978 if (I->getOpcode() == Instruction::Or) { 2979 return CollectBSwapParts(I->getOperand(0), OverallLeftShift, ByteMask, 2980 ByteValues) || 2981 CollectBSwapParts(I->getOperand(1), OverallLeftShift, ByteMask, 2982 ByteValues); 2983 } 2984 2985 // If this is a logical shift by a constant multiple of 8, recurse with 2986 // OverallLeftShift and ByteMask adjusted. 2987 if (I->isLogicalShift() && isa<ConstantInt>(I->getOperand(1))) { 2988 unsigned ShAmt = 2989 cast<ConstantInt>(I->getOperand(1))->getLimitedValue(~0U); 2990 // Ensure the shift amount is defined and of a byte value. 2991 if ((ShAmt & 7) || (ShAmt > 8*ByteValues.size())) 2992 return true; 2993 2994 unsigned ByteShift = ShAmt >> 3; 2995 if (I->getOpcode() == Instruction::Shl) { 2996 // X << 2 -> collect(X, +2) 2997 OverallLeftShift += ByteShift; 2998 ByteMask >>= ByteShift; 2999 } else { 3000 // X >>u 2 -> collect(X, -2) 3001 OverallLeftShift -= ByteShift; 3002 ByteMask <<= ByteShift; 3003 ByteMask &= (~0U >> (32-ByteValues.size())); 3004 } 3005 3006 if (OverallLeftShift >= (int)ByteValues.size()) return true; 3007 if (OverallLeftShift <= -(int)ByteValues.size()) return true; 3008 3009 return CollectBSwapParts(I->getOperand(0), OverallLeftShift, ByteMask, 3010 ByteValues); 3011 } 3012 3013 // If this is a logical 'and' with a mask that clears bytes, clear the 3014 // corresponding bytes in ByteMask. 3015 if (I->getOpcode() == Instruction::And && 3016 isa<ConstantInt>(I->getOperand(1))) { 3017 // Scan every byte of the and mask, seeing if the byte is either 0 or 255. 3018 unsigned NumBytes = ByteValues.size(); 3019 APInt Byte(I->getType()->getPrimitiveSizeInBits(), 255); 3020 const APInt &AndMask = cast<ConstantInt>(I->getOperand(1))->getValue(); 3021 3022 for (unsigned i = 0; i != NumBytes; ++i, Byte <<= 8) { 3023 // If this byte is masked out by a later operation, we don't care what 3024 // the and mask is. 3025 if ((ByteMask & (1 << i)) == 0) 3026 continue; 3027 3028 // If the AndMask is all zeros for this byte, clear the bit. 3029 APInt MaskB = AndMask & Byte; 3030 if (MaskB == 0) { 3031 ByteMask &= ~(1U << i); 3032 continue; 3033 } 3034 3035 // If the AndMask is not all ones for this byte, it's not a bytezap. 3036 if (MaskB != Byte) 3037 return true; 3038 3039 // Otherwise, this byte is kept. 3040 } 3041 3042 return CollectBSwapParts(I->getOperand(0), OverallLeftShift, ByteMask, 3043 ByteValues); 3044 } 3045 } 3046 3047 // Okay, we got to something that isn't a shift, 'or' or 'and'. This must be 3048 // the input value to the bswap. Some observations: 1) if more than one byte 3049 // is demanded from this input, then it could not be successfully assembled 3050 // into a byteswap. At least one of the two bytes would not be aligned with 3051 // their ultimate destination. 3052 if (!isPowerOf2_32(ByteMask)) return true; 3053 unsigned InputByteNo = CountTrailingZeros_32(ByteMask); 3054 3055 // 2) The input and ultimate destinations must line up: if byte 3 of an i32 3056 // is demanded, it needs to go into byte 0 of the result. This means that the 3057 // byte needs to be shifted until it lands in the right byte bucket. The 3058 // shift amount depends on the position: if the byte is coming from the high 3059 // part of the value (e.g. byte 3) then it must be shifted right. If from the 3060 // low part, it must be shifted left. 3061 unsigned DestByteNo = InputByteNo + OverallLeftShift; 3062 if (InputByteNo < ByteValues.size()/2) { 3063 if (ByteValues.size()-1-DestByteNo != InputByteNo) 3064 return true; 3065 } else { 3066 if (ByteValues.size()-1-DestByteNo != InputByteNo) 3067 return true; 3068 } 3069 3070 // If the destination byte value is already defined, the values are or'd 3071 // together, which isn't a bswap (unless it's an or of the same bits). 3072 if (ByteValues[DestByteNo] && ByteValues[DestByteNo] != V) 3073 return true; 3074 ByteValues[DestByteNo] = V; 3075 return false; 3076} 3077 3078/// MatchBSwap - Given an OR instruction, check to see if this is a bswap idiom. 3079/// If so, insert the new bswap intrinsic and return it. 3080Instruction *InstCombiner::MatchBSwap(BinaryOperator &I) { 3081 const IntegerType *ITy = dyn_cast<IntegerType>(I.getType()); 3082 if (!ITy || ITy->getBitWidth() % 16 || 3083 // ByteMask only allows up to 32-byte values. 3084 ITy->getBitWidth() > 32*8) 3085 return 0; // Can only bswap pairs of bytes. Can't do vectors. 3086 3087 /// ByteValues - For each byte of the result, we keep track of which value 3088 /// defines each byte. 3089 SmallVector<Value*, 8> ByteValues; 3090 ByteValues.resize(ITy->getBitWidth()/8); 3091 3092 // Try to find all the pieces corresponding to the bswap. 3093 uint32_t ByteMask = ~0U >> (32-ByteValues.size()); 3094 if (CollectBSwapParts(&I, 0, ByteMask, ByteValues)) 3095 return 0; 3096 3097 // Check to see if all of the bytes come from the same value. 3098 Value *V = ByteValues[0]; 3099 if (V == 0) return 0; // Didn't find a byte? Must be zero. 3100 3101 // Check to make sure that all of the bytes come from the same value. 3102 for (unsigned i = 1, e = ByteValues.size(); i != e; ++i) 3103 if (ByteValues[i] != V) 3104 return 0; 3105 const Type *Tys[] = { ITy }; 3106 Module *M = I.getParent()->getParent()->getParent(); 3107 Function *F = Intrinsic::getDeclaration(M, Intrinsic::bswap, Tys, 1); 3108 return CallInst::Create(F, V); 3109} 3110 3111/// MatchSelectFromAndOr - We have an expression of the form (A&C)|(B&D). Check 3112/// If A is (cond?-1:0) and either B or D is ~(cond?-1,0) or (cond?0,-1), then 3113/// we can simplify this expression to "cond ? C : D or B". 3114static Instruction *MatchSelectFromAndOr(Value *A, Value *B, 3115 Value *C, Value *D) { 3116 // If A is not a select of -1/0, this cannot match. 3117 Value *Cond = 0; 3118 if (!match(A, m_SelectCst<-1, 0>(m_Value(Cond)))) 3119 return 0; 3120 3121 // ((cond?-1:0)&C) | (B&(cond?0:-1)) -> cond ? C : B. 3122 if (match(D, m_SelectCst<0, -1>(m_Specific(Cond)))) 3123 return SelectInst::Create(Cond, C, B); 3124 if (match(D, m_Not(m_SelectCst<-1, 0>(m_Specific(Cond))))) 3125 return SelectInst::Create(Cond, C, B); 3126 // ((cond?-1:0)&C) | ((cond?0:-1)&D) -> cond ? C : D. 3127 if (match(B, m_SelectCst<0, -1>(m_Specific(Cond)))) 3128 return SelectInst::Create(Cond, C, D); 3129 if (match(B, m_Not(m_SelectCst<-1, 0>(m_Specific(Cond))))) 3130 return SelectInst::Create(Cond, C, D); 3131 return 0; 3132} 3133 3134/// FoldOrOfICmps - Fold (icmp)|(icmp) if possible. 3135Instruction *InstCombiner::FoldOrOfICmps(Instruction &I, 3136 ICmpInst *LHS, ICmpInst *RHS) { 3137 Value *Val, *Val2; 3138 ConstantInt *LHSCst, *RHSCst; 3139 ICmpInst::Predicate LHSCC, RHSCC; 3140 3141 // This only handles icmp of constants: (icmp1 A, C1) | (icmp2 B, C2). 3142 if (!match(LHS, m_ICmp(LHSCC, m_Value(Val), m_ConstantInt(LHSCst))) || 3143 !match(RHS, m_ICmp(RHSCC, m_Value(Val2), m_ConstantInt(RHSCst)))) 3144 return 0; 3145 3146 3147 // (icmp ne A, 0) | (icmp ne B, 0) --> (icmp ne (A|B), 0) 3148 if (LHSCst == RHSCst && LHSCC == RHSCC && 3149 LHSCC == ICmpInst::ICMP_NE && LHSCst->isZero()) { 3150 Value *NewOr = Builder->CreateOr(Val, Val2); 3151 return new ICmpInst(LHSCC, NewOr, LHSCst); 3152 } 3153 3154 // From here on, we only handle: 3155 // (icmp1 A, C1) | (icmp2 A, C2) --> something simpler. 3156 if (Val != Val2) return 0; 3157 3158 // ICMP_[US][GL]E X, CST is folded to ICMP_[US][GL]T elsewhere. 3159 if (LHSCC == ICmpInst::ICMP_UGE || LHSCC == ICmpInst::ICMP_ULE || 3160 RHSCC == ICmpInst::ICMP_UGE || RHSCC == ICmpInst::ICMP_ULE || 3161 LHSCC == ICmpInst::ICMP_SGE || LHSCC == ICmpInst::ICMP_SLE || 3162 RHSCC == ICmpInst::ICMP_SGE || RHSCC == ICmpInst::ICMP_SLE) 3163 return 0; 3164 3165 // We can't fold (ugt x, C) | (sgt x, C2). 3166 if (!PredicatesFoldable(LHSCC, RHSCC)) 3167 return 0; 3168 3169 // Ensure that the larger constant is on the RHS. 3170 bool ShouldSwap; 3171 if (CmpInst::isSigned(LHSCC) || 3172 (ICmpInst::isEquality(LHSCC) && 3173 CmpInst::isSigned(RHSCC))) 3174 ShouldSwap = LHSCst->getValue().sgt(RHSCst->getValue()); 3175 else 3176 ShouldSwap = LHSCst->getValue().ugt(RHSCst->getValue()); 3177 3178 if (ShouldSwap) { 3179 std::swap(LHS, RHS); 3180 std::swap(LHSCst, RHSCst); 3181 std::swap(LHSCC, RHSCC); 3182 } 3183 3184 // At this point, we know we have have two icmp instructions 3185 // comparing a value against two constants and or'ing the result 3186 // together. Because of the above check, we know that we only have 3187 // ICMP_EQ, ICMP_NE, ICMP_LT, and ICMP_GT here. We also know (from the 3188 // FoldICmpLogical check above), that the two constants are not 3189 // equal. 3190 assert(LHSCst != RHSCst && "Compares not folded above?"); 3191 3192 switch (LHSCC) { 3193 default: llvm_unreachable("Unknown integer condition code!"); 3194 case ICmpInst::ICMP_EQ: 3195 switch (RHSCC) { 3196 default: llvm_unreachable("Unknown integer condition code!"); 3197 case ICmpInst::ICMP_EQ: 3198 if (LHSCst == SubOne(RHSCst)) { 3199 // (X == 13 | X == 14) -> X-13 <u 2 3200 Constant *AddCST = ConstantExpr::getNeg(LHSCst); 3201 Value *Add = Builder->CreateAdd(Val, AddCST, Val->getName()+".off"); 3202 AddCST = ConstantExpr::getSub(AddOne(RHSCst), LHSCst); 3203 return new ICmpInst(ICmpInst::ICMP_ULT, Add, AddCST); 3204 } 3205 break; // (X == 13 | X == 15) -> no change 3206 case ICmpInst::ICMP_UGT: // (X == 13 | X u> 14) -> no change 3207 case ICmpInst::ICMP_SGT: // (X == 13 | X s> 14) -> no change 3208 break; 3209 case ICmpInst::ICMP_NE: // (X == 13 | X != 15) -> X != 15 3210 case ICmpInst::ICMP_ULT: // (X == 13 | X u< 15) -> X u< 15 3211 case ICmpInst::ICMP_SLT: // (X == 13 | X s< 15) -> X s< 15 3212 return ReplaceInstUsesWith(I, RHS); 3213 } 3214 break; 3215 case ICmpInst::ICMP_NE: 3216 switch (RHSCC) { 3217 default: llvm_unreachable("Unknown integer condition code!"); 3218 case ICmpInst::ICMP_EQ: // (X != 13 | X == 15) -> X != 13 3219 case ICmpInst::ICMP_UGT: // (X != 13 | X u> 15) -> X != 13 3220 case ICmpInst::ICMP_SGT: // (X != 13 | X s> 15) -> X != 13 3221 return ReplaceInstUsesWith(I, LHS); 3222 case ICmpInst::ICMP_NE: // (X != 13 | X != 15) -> true 3223 case ICmpInst::ICMP_ULT: // (X != 13 | X u< 15) -> true 3224 case ICmpInst::ICMP_SLT: // (X != 13 | X s< 15) -> true 3225 return ReplaceInstUsesWith(I, ConstantInt::getTrue(I.getContext())); 3226 } 3227 break; 3228 case ICmpInst::ICMP_ULT: 3229 switch (RHSCC) { 3230 default: llvm_unreachable("Unknown integer condition code!"); 3231 case ICmpInst::ICMP_EQ: // (X u< 13 | X == 14) -> no change 3232 break; 3233 case ICmpInst::ICMP_UGT: // (X u< 13 | X u> 15) -> (X-13) u> 2 3234 // If RHSCst is [us]MAXINT, it is always false. Not handling 3235 // this can cause overflow. 3236 if (RHSCst->isMaxValue(false)) 3237 return ReplaceInstUsesWith(I, LHS); 3238 return InsertRangeTest(Val, LHSCst, AddOne(RHSCst), 3239 false, false, I); 3240 case ICmpInst::ICMP_SGT: // (X u< 13 | X s> 15) -> no change 3241 break; 3242 case ICmpInst::ICMP_NE: // (X u< 13 | X != 15) -> X != 15 3243 case ICmpInst::ICMP_ULT: // (X u< 13 | X u< 15) -> X u< 15 3244 return ReplaceInstUsesWith(I, RHS); 3245 case ICmpInst::ICMP_SLT: // (X u< 13 | X s< 15) -> no change 3246 break; 3247 } 3248 break; 3249 case ICmpInst::ICMP_SLT: 3250 switch (RHSCC) { 3251 default: llvm_unreachable("Unknown integer condition code!"); 3252 case ICmpInst::ICMP_EQ: // (X s< 13 | X == 14) -> no change 3253 break; 3254 case ICmpInst::ICMP_SGT: // (X s< 13 | X s> 15) -> (X-13) s> 2 3255 // If RHSCst is [us]MAXINT, it is always false. Not handling 3256 // this can cause overflow. 3257 if (RHSCst->isMaxValue(true)) 3258 return ReplaceInstUsesWith(I, LHS); 3259 return InsertRangeTest(Val, LHSCst, AddOne(RHSCst), 3260 true, false, I); 3261 case ICmpInst::ICMP_UGT: // (X s< 13 | X u> 15) -> no change 3262 break; 3263 case ICmpInst::ICMP_NE: // (X s< 13 | X != 15) -> X != 15 3264 case ICmpInst::ICMP_SLT: // (X s< 13 | X s< 15) -> X s< 15 3265 return ReplaceInstUsesWith(I, RHS); 3266 case ICmpInst::ICMP_ULT: // (X s< 13 | X u< 15) -> no change 3267 break; 3268 } 3269 break; 3270 case ICmpInst::ICMP_UGT: 3271 switch (RHSCC) { 3272 default: llvm_unreachable("Unknown integer condition code!"); 3273 case ICmpInst::ICMP_EQ: // (X u> 13 | X == 15) -> X u> 13 3274 case ICmpInst::ICMP_UGT: // (X u> 13 | X u> 15) -> X u> 13 3275 return ReplaceInstUsesWith(I, LHS); 3276 case ICmpInst::ICMP_SGT: // (X u> 13 | X s> 15) -> no change 3277 break; 3278 case ICmpInst::ICMP_NE: // (X u> 13 | X != 15) -> true 3279 case ICmpInst::ICMP_ULT: // (X u> 13 | X u< 15) -> true 3280 return ReplaceInstUsesWith(I, ConstantInt::getTrue(I.getContext())); 3281 case ICmpInst::ICMP_SLT: // (X u> 13 | X s< 15) -> no change 3282 break; 3283 } 3284 break; 3285 case ICmpInst::ICMP_SGT: 3286 switch (RHSCC) { 3287 default: llvm_unreachable("Unknown integer condition code!"); 3288 case ICmpInst::ICMP_EQ: // (X s> 13 | X == 15) -> X > 13 3289 case ICmpInst::ICMP_SGT: // (X s> 13 | X s> 15) -> X > 13 3290 return ReplaceInstUsesWith(I, LHS); 3291 case ICmpInst::ICMP_UGT: // (X s> 13 | X u> 15) -> no change 3292 break; 3293 case ICmpInst::ICMP_NE: // (X s> 13 | X != 15) -> true 3294 case ICmpInst::ICMP_SLT: // (X s> 13 | X s< 15) -> true 3295 return ReplaceInstUsesWith(I, ConstantInt::getTrue(I.getContext())); 3296 case ICmpInst::ICMP_ULT: // (X s> 13 | X u< 15) -> no change 3297 break; 3298 } 3299 break; 3300 } 3301 return 0; 3302} 3303 3304Instruction *InstCombiner::FoldOrOfFCmps(Instruction &I, FCmpInst *LHS, 3305 FCmpInst *RHS) { 3306 if (LHS->getPredicate() == FCmpInst::FCMP_UNO && 3307 RHS->getPredicate() == FCmpInst::FCMP_UNO && 3308 LHS->getOperand(0)->getType() == RHS->getOperand(0)->getType()) { 3309 if (ConstantFP *LHSC = dyn_cast<ConstantFP>(LHS->getOperand(1))) 3310 if (ConstantFP *RHSC = dyn_cast<ConstantFP>(RHS->getOperand(1))) { 3311 // If either of the constants are nans, then the whole thing returns 3312 // true. 3313 if (LHSC->getValueAPF().isNaN() || RHSC->getValueAPF().isNaN()) 3314 return ReplaceInstUsesWith(I, ConstantInt::getTrue(I.getContext())); 3315 3316 // Otherwise, no need to compare the two constants, compare the 3317 // rest. 3318 return new FCmpInst(FCmpInst::FCMP_UNO, 3319 LHS->getOperand(0), RHS->getOperand(0)); 3320 } 3321 3322 // Handle vector zeros. This occurs because the canonical form of 3323 // "fcmp uno x,x" is "fcmp uno x, 0". 3324 if (isa<ConstantAggregateZero>(LHS->getOperand(1)) && 3325 isa<ConstantAggregateZero>(RHS->getOperand(1))) 3326 return new FCmpInst(FCmpInst::FCMP_UNO, 3327 LHS->getOperand(0), RHS->getOperand(0)); 3328 3329 return 0; 3330 } 3331 3332 Value *Op0LHS = LHS->getOperand(0), *Op0RHS = LHS->getOperand(1); 3333 Value *Op1LHS = RHS->getOperand(0), *Op1RHS = RHS->getOperand(1); 3334 FCmpInst::Predicate Op0CC = LHS->getPredicate(), Op1CC = RHS->getPredicate(); 3335 3336 if (Op0LHS == Op1RHS && Op0RHS == Op1LHS) { 3337 // Swap RHS operands to match LHS. 3338 Op1CC = FCmpInst::getSwappedPredicate(Op1CC); 3339 std::swap(Op1LHS, Op1RHS); 3340 } 3341 if (Op0LHS == Op1LHS && Op0RHS == Op1RHS) { 3342 // Simplify (fcmp cc0 x, y) | (fcmp cc1 x, y). 3343 if (Op0CC == Op1CC) 3344 return new FCmpInst((FCmpInst::Predicate)Op0CC, 3345 Op0LHS, Op0RHS); 3346 if (Op0CC == FCmpInst::FCMP_TRUE || Op1CC == FCmpInst::FCMP_TRUE) 3347 return ReplaceInstUsesWith(I, ConstantInt::getTrue(I.getContext())); 3348 if (Op0CC == FCmpInst::FCMP_FALSE) 3349 return ReplaceInstUsesWith(I, RHS); 3350 if (Op1CC == FCmpInst::FCMP_FALSE) 3351 return ReplaceInstUsesWith(I, LHS); 3352 bool Op0Ordered; 3353 bool Op1Ordered; 3354 unsigned Op0Pred = getFCmpCode(Op0CC, Op0Ordered); 3355 unsigned Op1Pred = getFCmpCode(Op1CC, Op1Ordered); 3356 if (Op0Ordered == Op1Ordered) { 3357 // If both are ordered or unordered, return a new fcmp with 3358 // or'ed predicates. 3359 Value *RV = getFCmpValue(Op0Ordered, Op0Pred|Op1Pred, Op0LHS, Op0RHS); 3360 if (Instruction *I = dyn_cast<Instruction>(RV)) 3361 return I; 3362 // Otherwise, it's a constant boolean value... 3363 return ReplaceInstUsesWith(I, RV); 3364 } 3365 } 3366 return 0; 3367} 3368 3369/// FoldOrWithConstants - This helper function folds: 3370/// 3371/// ((A | B) & C1) | (B & C2) 3372/// 3373/// into: 3374/// 3375/// (A & C1) | B 3376/// 3377/// when the XOR of the two constants is "all ones" (-1). 3378Instruction *InstCombiner::FoldOrWithConstants(BinaryOperator &I, Value *Op, 3379 Value *A, Value *B, Value *C) { 3380 ConstantInt *CI1 = dyn_cast<ConstantInt>(C); 3381 if (!CI1) return 0; 3382 3383 Value *V1 = 0; 3384 ConstantInt *CI2 = 0; 3385 if (!match(Op, m_And(m_Value(V1), m_ConstantInt(CI2)))) return 0; 3386 3387 APInt Xor = CI1->getValue() ^ CI2->getValue(); 3388 if (!Xor.isAllOnesValue()) return 0; 3389 3390 if (V1 == A || V1 == B) { 3391 Value *NewOp = Builder->CreateAnd((V1 == A) ? B : A, CI1); 3392 return BinaryOperator::CreateOr(NewOp, V1); 3393 } 3394 3395 return 0; 3396} 3397 3398Instruction *InstCombiner::visitOr(BinaryOperator &I) { 3399 bool Changed = SimplifyCommutative(I); 3400 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1); 3401 3402 if (Value *V = SimplifyOrInst(Op0, Op1, TD)) 3403 return ReplaceInstUsesWith(I, V); 3404 3405 3406 // See if we can simplify any instructions used by the instruction whose sole 3407 // purpose is to compute bits we don't care about. 3408 if (SimplifyDemandedInstructionBits(I)) 3409 return &I; 3410 3411 if (ConstantInt *RHS = dyn_cast<ConstantInt>(Op1)) { 3412 ConstantInt *C1 = 0; Value *X = 0; 3413 // (X & C1) | C2 --> (X | C2) & (C1|C2) 3414 if (match(Op0, m_And(m_Value(X), m_ConstantInt(C1))) && 3415 isOnlyUse(Op0)) { 3416 Value *Or = Builder->CreateOr(X, RHS); 3417 Or->takeName(Op0); 3418 return BinaryOperator::CreateAnd(Or, 3419 ConstantInt::get(I.getContext(), 3420 RHS->getValue() | C1->getValue())); 3421 } 3422 3423 // (X ^ C1) | C2 --> (X | C2) ^ (C1&~C2) 3424 if (match(Op0, m_Xor(m_Value(X), m_ConstantInt(C1))) && 3425 isOnlyUse(Op0)) { 3426 Value *Or = Builder->CreateOr(X, RHS); 3427 Or->takeName(Op0); 3428 return BinaryOperator::CreateXor(Or, 3429 ConstantInt::get(I.getContext(), 3430 C1->getValue() & ~RHS->getValue())); 3431 } 3432 3433 // Try to fold constant and into select arguments. 3434 if (SelectInst *SI = dyn_cast<SelectInst>(Op0)) 3435 if (Instruction *R = FoldOpIntoSelect(I, SI)) 3436 return R; 3437 if (isa<PHINode>(Op0)) 3438 if (Instruction *NV = FoldOpIntoPhi(I)) 3439 return NV; 3440 } 3441 3442 Value *A = 0, *B = 0; 3443 ConstantInt *C1 = 0, *C2 = 0; 3444 3445 // (A | B) | C and A | (B | C) -> bswap if possible. 3446 // (A >> B) | (C << D) and (A << B) | (B >> C) -> bswap if possible. 3447 if (match(Op0, m_Or(m_Value(), m_Value())) || 3448 match(Op1, m_Or(m_Value(), m_Value())) || 3449 (match(Op0, m_Shift(m_Value(), m_Value())) && 3450 match(Op1, m_Shift(m_Value(), m_Value())))) { 3451 if (Instruction *BSwap = MatchBSwap(I)) 3452 return BSwap; 3453 } 3454 3455 // (X^C)|Y -> (X|Y)^C iff Y&C == 0 3456 if (Op0->hasOneUse() && 3457 match(Op0, m_Xor(m_Value(A), m_ConstantInt(C1))) && 3458 MaskedValueIsZero(Op1, C1->getValue())) { 3459 Value *NOr = Builder->CreateOr(A, Op1); 3460 NOr->takeName(Op0); 3461 return BinaryOperator::CreateXor(NOr, C1); 3462 } 3463 3464 // Y|(X^C) -> (X|Y)^C iff Y&C == 0 3465 if (Op1->hasOneUse() && 3466 match(Op1, m_Xor(m_Value(A), m_ConstantInt(C1))) && 3467 MaskedValueIsZero(Op0, C1->getValue())) { 3468 Value *NOr = Builder->CreateOr(A, Op0); 3469 NOr->takeName(Op0); 3470 return BinaryOperator::CreateXor(NOr, C1); 3471 } 3472 3473 // (A & C)|(B & D) 3474 Value *C = 0, *D = 0; 3475 if (match(Op0, m_And(m_Value(A), m_Value(C))) && 3476 match(Op1, m_And(m_Value(B), m_Value(D)))) { 3477 Value *V1 = 0, *V2 = 0, *V3 = 0; 3478 C1 = dyn_cast<ConstantInt>(C); 3479 C2 = dyn_cast<ConstantInt>(D); 3480 if (C1 && C2) { // (A & C1)|(B & C2) 3481 // If we have: ((V + N) & C1) | (V & C2) 3482 // .. and C2 = ~C1 and C2 is 0+1+ and (N & C2) == 0 3483 // replace with V+N. 3484 if (C1->getValue() == ~C2->getValue()) { 3485 if ((C2->getValue() & (C2->getValue()+1)) == 0 && // C2 == 0+1+ 3486 match(A, m_Add(m_Value(V1), m_Value(V2)))) { 3487 // Add commutes, try both ways. 3488 if (V1 == B && MaskedValueIsZero(V2, C2->getValue())) 3489 return ReplaceInstUsesWith(I, A); 3490 if (V2 == B && MaskedValueIsZero(V1, C2->getValue())) 3491 return ReplaceInstUsesWith(I, A); 3492 } 3493 // Or commutes, try both ways. 3494 if ((C1->getValue() & (C1->getValue()+1)) == 0 && 3495 match(B, m_Add(m_Value(V1), m_Value(V2)))) { 3496 // Add commutes, try both ways. 3497 if (V1 == A && MaskedValueIsZero(V2, C1->getValue())) 3498 return ReplaceInstUsesWith(I, B); 3499 if (V2 == A && MaskedValueIsZero(V1, C1->getValue())) 3500 return ReplaceInstUsesWith(I, B); 3501 } 3502 } 3503 3504 // ((V | N) & C1) | (V & C2) --> (V|N) & (C1|C2) 3505 // iff (C1&C2) == 0 and (N&~C1) == 0 3506 if ((C1->getValue() & C2->getValue()) == 0) { 3507 if (match(A, m_Or(m_Value(V1), m_Value(V2))) && 3508 ((V1 == B && MaskedValueIsZero(V2, ~C1->getValue())) || // (V|N) 3509 (V2 == B && MaskedValueIsZero(V1, ~C1->getValue())))) // (N|V) 3510 return BinaryOperator::CreateAnd(A, 3511 ConstantInt::get(A->getContext(), 3512 C1->getValue()|C2->getValue())); 3513 // Or commutes, try both ways. 3514 if (match(B, m_Or(m_Value(V1), m_Value(V2))) && 3515 ((V1 == A && MaskedValueIsZero(V2, ~C2->getValue())) || // (V|N) 3516 (V2 == A && MaskedValueIsZero(V1, ~C2->getValue())))) // (N|V) 3517 return BinaryOperator::CreateAnd(B, 3518 ConstantInt::get(B->getContext(), 3519 C1->getValue()|C2->getValue())); 3520 } 3521 } 3522 3523 // Check to see if we have any common things being and'ed. If so, find the 3524 // terms for V1 & (V2|V3). 3525 if (isOnlyUse(Op0) || isOnlyUse(Op1)) { 3526 V1 = 0; 3527 if (A == B) // (A & C)|(A & D) == A & (C|D) 3528 V1 = A, V2 = C, V3 = D; 3529 else if (A == D) // (A & C)|(B & A) == A & (B|C) 3530 V1 = A, V2 = B, V3 = C; 3531 else if (C == B) // (A & C)|(C & D) == C & (A|D) 3532 V1 = C, V2 = A, V3 = D; 3533 else if (C == D) // (A & C)|(B & C) == C & (A|B) 3534 V1 = C, V2 = A, V3 = B; 3535 3536 if (V1) { 3537 Value *Or = Builder->CreateOr(V2, V3, "tmp"); 3538 return BinaryOperator::CreateAnd(V1, Or); 3539 } 3540 } 3541 3542 // (A & (C0?-1:0)) | (B & ~(C0?-1:0)) -> C0 ? A : B, and commuted variants 3543 if (Instruction *Match = MatchSelectFromAndOr(A, B, C, D)) 3544 return Match; 3545 if (Instruction *Match = MatchSelectFromAndOr(B, A, D, C)) 3546 return Match; 3547 if (Instruction *Match = MatchSelectFromAndOr(C, B, A, D)) 3548 return Match; 3549 if (Instruction *Match = MatchSelectFromAndOr(D, A, B, C)) 3550 return Match; 3551 3552 // ((A&~B)|(~A&B)) -> A^B 3553 if ((match(C, m_Not(m_Specific(D))) && 3554 match(B, m_Not(m_Specific(A))))) 3555 return BinaryOperator::CreateXor(A, D); 3556 // ((~B&A)|(~A&B)) -> A^B 3557 if ((match(A, m_Not(m_Specific(D))) && 3558 match(B, m_Not(m_Specific(C))))) 3559 return BinaryOperator::CreateXor(C, D); 3560 // ((A&~B)|(B&~A)) -> A^B 3561 if ((match(C, m_Not(m_Specific(B))) && 3562 match(D, m_Not(m_Specific(A))))) 3563 return BinaryOperator::CreateXor(A, B); 3564 // ((~B&A)|(B&~A)) -> A^B 3565 if ((match(A, m_Not(m_Specific(B))) && 3566 match(D, m_Not(m_Specific(C))))) 3567 return BinaryOperator::CreateXor(C, B); 3568 } 3569 3570 // (X >> Z) | (Y >> Z) -> (X|Y) >> Z for all shifts. 3571 if (BinaryOperator *SI1 = dyn_cast<BinaryOperator>(Op1)) { 3572 if (BinaryOperator *SI0 = dyn_cast<BinaryOperator>(Op0)) 3573 if (SI0->isShift() && SI0->getOpcode() == SI1->getOpcode() && 3574 SI0->getOperand(1) == SI1->getOperand(1) && 3575 (SI0->hasOneUse() || SI1->hasOneUse())) { 3576 Value *NewOp = Builder->CreateOr(SI0->getOperand(0), SI1->getOperand(0), 3577 SI0->getName()); 3578 return BinaryOperator::Create(SI1->getOpcode(), NewOp, 3579 SI1->getOperand(1)); 3580 } 3581 } 3582 3583 // ((A|B)&1)|(B&-2) -> (A&1) | B 3584 if (match(Op0, m_And(m_Or(m_Value(A), m_Value(B)), m_Value(C))) || 3585 match(Op0, m_And(m_Value(C), m_Or(m_Value(A), m_Value(B))))) { 3586 Instruction *Ret = FoldOrWithConstants(I, Op1, A, B, C); 3587 if (Ret) return Ret; 3588 } 3589 // (B&-2)|((A|B)&1) -> (A&1) | B 3590 if (match(Op1, m_And(m_Or(m_Value(A), m_Value(B)), m_Value(C))) || 3591 match(Op1, m_And(m_Value(C), m_Or(m_Value(A), m_Value(B))))) { 3592 Instruction *Ret = FoldOrWithConstants(I, Op0, A, B, C); 3593 if (Ret) return Ret; 3594 } 3595 3596 // (~A | ~B) == (~(A & B)) - De Morgan's Law 3597 if (Value *Op0NotVal = dyn_castNotVal(Op0)) 3598 if (Value *Op1NotVal = dyn_castNotVal(Op1)) 3599 if (Op0->hasOneUse() && Op1->hasOneUse()) { 3600 Value *And = Builder->CreateAnd(Op0NotVal, Op1NotVal, 3601 I.getName()+".demorgan"); 3602 return BinaryOperator::CreateNot(And); 3603 } 3604 3605 // (icmp1 A, B) | (icmp2 A, B) --> (icmp3 A, B) 3606 if (ICmpInst *RHS = dyn_cast<ICmpInst>(I.getOperand(1))) { 3607 if (Instruction *R = AssociativeOpt(I, FoldICmpLogical(*this, RHS))) 3608 return R; 3609 3610 if (ICmpInst *LHS = dyn_cast<ICmpInst>(I.getOperand(0))) 3611 if (Instruction *Res = FoldOrOfICmps(I, LHS, RHS)) 3612 return Res; 3613 } 3614 3615 // fold (or (cast A), (cast B)) -> (cast (or A, B)) 3616 if (CastInst *Op0C = dyn_cast<CastInst>(Op0)) { 3617 if (CastInst *Op1C = dyn_cast<CastInst>(Op1)) 3618 if (Op0C->getOpcode() == Op1C->getOpcode()) {// same cast kind ? 3619 if (!isa<ICmpInst>(Op0C->getOperand(0)) || 3620 !isa<ICmpInst>(Op1C->getOperand(0))) { 3621 const Type *SrcTy = Op0C->getOperand(0)->getType(); 3622 if (SrcTy == Op1C->getOperand(0)->getType() && 3623 SrcTy->isIntOrIntVector() && 3624 // Only do this if the casts both really cause code to be 3625 // generated. 3626 ValueRequiresCast(Op0C->getOpcode(), Op0C->getOperand(0), 3627 I.getType()) && 3628 ValueRequiresCast(Op1C->getOpcode(), Op1C->getOperand(0), 3629 I.getType())) { 3630 Value *NewOp = Builder->CreateOr(Op0C->getOperand(0), 3631 Op1C->getOperand(0), I.getName()); 3632 return CastInst::Create(Op0C->getOpcode(), NewOp, I.getType()); 3633 } 3634 } 3635 } 3636 } 3637 3638 3639 // (fcmp uno x, c) | (fcmp uno y, c) -> (fcmp uno x, y) 3640 if (FCmpInst *LHS = dyn_cast<FCmpInst>(I.getOperand(0))) { 3641 if (FCmpInst *RHS = dyn_cast<FCmpInst>(I.getOperand(1))) 3642 if (Instruction *Res = FoldOrOfFCmps(I, LHS, RHS)) 3643 return Res; 3644 } 3645 3646 return Changed ? &I : 0; 3647} 3648 3649namespace { 3650 3651// XorSelf - Implements: X ^ X --> 0 3652struct XorSelf { 3653 Value *RHS; 3654 XorSelf(Value *rhs) : RHS(rhs) {} 3655 bool shouldApply(Value *LHS) const { return LHS == RHS; } 3656 Instruction *apply(BinaryOperator &Xor) const { 3657 return &Xor; 3658 } 3659}; 3660 3661} 3662 3663Instruction *InstCombiner::visitXor(BinaryOperator &I) { 3664 bool Changed = SimplifyCommutative(I); 3665 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1); 3666 3667 if (isa<UndefValue>(Op1)) { 3668 if (isa<UndefValue>(Op0)) 3669 // Handle undef ^ undef -> 0 special case. This is a common 3670 // idiom (misuse). 3671 return ReplaceInstUsesWith(I, Constant::getNullValue(I.getType())); 3672 return ReplaceInstUsesWith(I, Op1); // X ^ undef -> undef 3673 } 3674 3675 // xor X, X = 0, even if X is nested in a sequence of Xor's. 3676 if (Instruction *Result = AssociativeOpt(I, XorSelf(Op1))) { 3677 assert(Result == &I && "AssociativeOpt didn't work?"); Result=Result; 3678 return ReplaceInstUsesWith(I, Constant::getNullValue(I.getType())); 3679 } 3680 3681 // See if we can simplify any instructions used by the instruction whose sole 3682 // purpose is to compute bits we don't care about. 3683 if (SimplifyDemandedInstructionBits(I)) 3684 return &I; 3685 if (isa<VectorType>(I.getType())) 3686 if (isa<ConstantAggregateZero>(Op1)) 3687 return ReplaceInstUsesWith(I, Op0); // X ^ <0,0> -> X 3688 3689 // Is this a ~ operation? 3690 if (Value *NotOp = dyn_castNotVal(&I)) { 3691 if (BinaryOperator *Op0I = dyn_cast<BinaryOperator>(NotOp)) { 3692 if (Op0I->getOpcode() == Instruction::And || 3693 Op0I->getOpcode() == Instruction::Or) { 3694 // ~(~X & Y) --> (X | ~Y) - De Morgan's Law 3695 // ~(~X | Y) === (X & ~Y) - De Morgan's Law 3696 if (dyn_castNotVal(Op0I->getOperand(1))) 3697 Op0I->swapOperands(); 3698 if (Value *Op0NotVal = dyn_castNotVal(Op0I->getOperand(0))) { 3699 Value *NotY = 3700 Builder->CreateNot(Op0I->getOperand(1), 3701 Op0I->getOperand(1)->getName()+".not"); 3702 if (Op0I->getOpcode() == Instruction::And) 3703 return BinaryOperator::CreateOr(Op0NotVal, NotY); 3704 return BinaryOperator::CreateAnd(Op0NotVal, NotY); 3705 } 3706 3707 // ~(X & Y) --> (~X | ~Y) - De Morgan's Law 3708 // ~(X | Y) === (~X & ~Y) - De Morgan's Law 3709 if (isFreeToInvert(Op0I->getOperand(0)) && 3710 isFreeToInvert(Op0I->getOperand(1))) { 3711 Value *NotX = 3712 Builder->CreateNot(Op0I->getOperand(0), "notlhs"); 3713 Value *NotY = 3714 Builder->CreateNot(Op0I->getOperand(1), "notrhs"); 3715 if (Op0I->getOpcode() == Instruction::And) 3716 return BinaryOperator::CreateOr(NotX, NotY); 3717 return BinaryOperator::CreateAnd(NotX, NotY); 3718 } 3719 } 3720 } 3721 } 3722 3723 3724 if (ConstantInt *RHS = dyn_cast<ConstantInt>(Op1)) { 3725 if (RHS->isOne() && Op0->hasOneUse()) { 3726 // xor (cmp A, B), true = not (cmp A, B) = !cmp A, B 3727 if (ICmpInst *ICI = dyn_cast<ICmpInst>(Op0)) 3728 return new ICmpInst(ICI->getInversePredicate(), 3729 ICI->getOperand(0), ICI->getOperand(1)); 3730 3731 if (FCmpInst *FCI = dyn_cast<FCmpInst>(Op0)) 3732 return new FCmpInst(FCI->getInversePredicate(), 3733 FCI->getOperand(0), FCI->getOperand(1)); 3734 } 3735 3736 // fold (xor(zext(cmp)), 1) and (xor(sext(cmp)), -1) to ext(!cmp). 3737 if (CastInst *Op0C = dyn_cast<CastInst>(Op0)) { 3738 if (CmpInst *CI = dyn_cast<CmpInst>(Op0C->getOperand(0))) { 3739 if (CI->hasOneUse() && Op0C->hasOneUse()) { 3740 Instruction::CastOps Opcode = Op0C->getOpcode(); 3741 if ((Opcode == Instruction::ZExt || Opcode == Instruction::SExt) && 3742 (RHS == ConstantExpr::getCast(Opcode, 3743 ConstantInt::getTrue(I.getContext()), 3744 Op0C->getDestTy()))) { 3745 CI->setPredicate(CI->getInversePredicate()); 3746 return CastInst::Create(Opcode, CI, Op0C->getType()); 3747 } 3748 } 3749 } 3750 } 3751 3752 if (BinaryOperator *Op0I = dyn_cast<BinaryOperator>(Op0)) { 3753 // ~(c-X) == X-c-1 == X+(-c-1) 3754 if (Op0I->getOpcode() == Instruction::Sub && RHS->isAllOnesValue()) 3755 if (Constant *Op0I0C = dyn_cast<Constant>(Op0I->getOperand(0))) { 3756 Constant *NegOp0I0C = ConstantExpr::getNeg(Op0I0C); 3757 Constant *ConstantRHS = ConstantExpr::getSub(NegOp0I0C, 3758 ConstantInt::get(I.getType(), 1)); 3759 return BinaryOperator::CreateAdd(Op0I->getOperand(1), ConstantRHS); 3760 } 3761 3762 if (ConstantInt *Op0CI = dyn_cast<ConstantInt>(Op0I->getOperand(1))) { 3763 if (Op0I->getOpcode() == Instruction::Add) { 3764 // ~(X-c) --> (-c-1)-X 3765 if (RHS->isAllOnesValue()) { 3766 Constant *NegOp0CI = ConstantExpr::getNeg(Op0CI); 3767 return BinaryOperator::CreateSub( 3768 ConstantExpr::getSub(NegOp0CI, 3769 ConstantInt::get(I.getType(), 1)), 3770 Op0I->getOperand(0)); 3771 } else if (RHS->getValue().isSignBit()) { 3772 // (X + C) ^ signbit -> (X + C + signbit) 3773 Constant *C = ConstantInt::get(I.getContext(), 3774 RHS->getValue() + Op0CI->getValue()); 3775 return BinaryOperator::CreateAdd(Op0I->getOperand(0), C); 3776 3777 } 3778 } else if (Op0I->getOpcode() == Instruction::Or) { 3779 // (X|C1)^C2 -> X^(C1|C2) iff X&~C1 == 0 3780 if (MaskedValueIsZero(Op0I->getOperand(0), Op0CI->getValue())) { 3781 Constant *NewRHS = ConstantExpr::getOr(Op0CI, RHS); 3782 // Anything in both C1 and C2 is known to be zero, remove it from 3783 // NewRHS. 3784 Constant *CommonBits = ConstantExpr::getAnd(Op0CI, RHS); 3785 NewRHS = ConstantExpr::getAnd(NewRHS, 3786 ConstantExpr::getNot(CommonBits)); 3787 Worklist.Add(Op0I); 3788 I.setOperand(0, Op0I->getOperand(0)); 3789 I.setOperand(1, NewRHS); 3790 return &I; 3791 } 3792 } 3793 } 3794 } 3795 3796 // Try to fold constant and into select arguments. 3797 if (SelectInst *SI = dyn_cast<SelectInst>(Op0)) 3798 if (Instruction *R = FoldOpIntoSelect(I, SI)) 3799 return R; 3800 if (isa<PHINode>(Op0)) 3801 if (Instruction *NV = FoldOpIntoPhi(I)) 3802 return NV; 3803 } 3804 3805 if (Value *X = dyn_castNotVal(Op0)) // ~A ^ A == -1 3806 if (X == Op1) 3807 return ReplaceInstUsesWith(I, Constant::getAllOnesValue(I.getType())); 3808 3809 if (Value *X = dyn_castNotVal(Op1)) // A ^ ~A == -1 3810 if (X == Op0) 3811 return ReplaceInstUsesWith(I, Constant::getAllOnesValue(I.getType())); 3812 3813 3814 BinaryOperator *Op1I = dyn_cast<BinaryOperator>(Op1); 3815 if (Op1I) { 3816 Value *A, *B; 3817 if (match(Op1I, m_Or(m_Value(A), m_Value(B)))) { 3818 if (A == Op0) { // B^(B|A) == (A|B)^B 3819 Op1I->swapOperands(); 3820 I.swapOperands(); 3821 std::swap(Op0, Op1); 3822 } else if (B == Op0) { // B^(A|B) == (A|B)^B 3823 I.swapOperands(); // Simplified below. 3824 std::swap(Op0, Op1); 3825 } 3826 } else if (match(Op1I, m_Xor(m_Specific(Op0), m_Value(B)))) { 3827 return ReplaceInstUsesWith(I, B); // A^(A^B) == B 3828 } else if (match(Op1I, m_Xor(m_Value(A), m_Specific(Op0)))) { 3829 return ReplaceInstUsesWith(I, A); // A^(B^A) == B 3830 } else if (match(Op1I, m_And(m_Value(A), m_Value(B))) && 3831 Op1I->hasOneUse()){ 3832 if (A == Op0) { // A^(A&B) -> A^(B&A) 3833 Op1I->swapOperands(); 3834 std::swap(A, B); 3835 } 3836 if (B == Op0) { // A^(B&A) -> (B&A)^A 3837 I.swapOperands(); // Simplified below. 3838 std::swap(Op0, Op1); 3839 } 3840 } 3841 } 3842 3843 BinaryOperator *Op0I = dyn_cast<BinaryOperator>(Op0); 3844 if (Op0I) { 3845 Value *A, *B; 3846 if (match(Op0I, m_Or(m_Value(A), m_Value(B))) && 3847 Op0I->hasOneUse()) { 3848 if (A == Op1) // (B|A)^B == (A|B)^B 3849 std::swap(A, B); 3850 if (B == Op1) // (A|B)^B == A & ~B 3851 return BinaryOperator::CreateAnd(A, Builder->CreateNot(Op1, "tmp")); 3852 } else if (match(Op0I, m_Xor(m_Specific(Op1), m_Value(B)))) { 3853 return ReplaceInstUsesWith(I, B); // (A^B)^A == B 3854 } else if (match(Op0I, m_Xor(m_Value(A), m_Specific(Op1)))) { 3855 return ReplaceInstUsesWith(I, A); // (B^A)^A == B 3856 } else if (match(Op0I, m_And(m_Value(A), m_Value(B))) && 3857 Op0I->hasOneUse()){ 3858 if (A == Op1) // (A&B)^A -> (B&A)^A 3859 std::swap(A, B); 3860 if (B == Op1 && // (B&A)^A == ~B & A 3861 !isa<ConstantInt>(Op1)) { // Canonical form is (B&C)^C 3862 return BinaryOperator::CreateAnd(Builder->CreateNot(A, "tmp"), Op1); 3863 } 3864 } 3865 } 3866 3867 // (X >> Z) ^ (Y >> Z) -> (X^Y) >> Z for all shifts. 3868 if (Op0I && Op1I && Op0I->isShift() && 3869 Op0I->getOpcode() == Op1I->getOpcode() && 3870 Op0I->getOperand(1) == Op1I->getOperand(1) && 3871 (Op1I->hasOneUse() || Op1I->hasOneUse())) { 3872 Value *NewOp = 3873 Builder->CreateXor(Op0I->getOperand(0), Op1I->getOperand(0), 3874 Op0I->getName()); 3875 return BinaryOperator::Create(Op1I->getOpcode(), NewOp, 3876 Op1I->getOperand(1)); 3877 } 3878 3879 if (Op0I && Op1I) { 3880 Value *A, *B, *C, *D; 3881 // (A & B)^(A | B) -> A ^ B 3882 if (match(Op0I, m_And(m_Value(A), m_Value(B))) && 3883 match(Op1I, m_Or(m_Value(C), m_Value(D)))) { 3884 if ((A == C && B == D) || (A == D && B == C)) 3885 return BinaryOperator::CreateXor(A, B); 3886 } 3887 // (A | B)^(A & B) -> A ^ B 3888 if (match(Op0I, m_Or(m_Value(A), m_Value(B))) && 3889 match(Op1I, m_And(m_Value(C), m_Value(D)))) { 3890 if ((A == C && B == D) || (A == D && B == C)) 3891 return BinaryOperator::CreateXor(A, B); 3892 } 3893 3894 // (A & B)^(C & D) 3895 if ((Op0I->hasOneUse() || Op1I->hasOneUse()) && 3896 match(Op0I, m_And(m_Value(A), m_Value(B))) && 3897 match(Op1I, m_And(m_Value(C), m_Value(D)))) { 3898 // (X & Y)^(X & Y) -> (Y^Z) & X 3899 Value *X = 0, *Y = 0, *Z = 0; 3900 if (A == C) 3901 X = A, Y = B, Z = D; 3902 else if (A == D) 3903 X = A, Y = B, Z = C; 3904 else if (B == C) 3905 X = B, Y = A, Z = D; 3906 else if (B == D) 3907 X = B, Y = A, Z = C; 3908 3909 if (X) { 3910 Value *NewOp = Builder->CreateXor(Y, Z, Op0->getName()); 3911 return BinaryOperator::CreateAnd(NewOp, X); 3912 } 3913 } 3914 } 3915 3916 // (icmp1 A, B) ^ (icmp2 A, B) --> (icmp3 A, B) 3917 if (ICmpInst *RHS = dyn_cast<ICmpInst>(I.getOperand(1))) 3918 if (Instruction *R = AssociativeOpt(I, FoldICmpLogical(*this, RHS))) 3919 return R; 3920 3921 // fold (xor (cast A), (cast B)) -> (cast (xor A, B)) 3922 if (CastInst *Op0C = dyn_cast<CastInst>(Op0)) { 3923 if (CastInst *Op1C = dyn_cast<CastInst>(Op1)) 3924 if (Op0C->getOpcode() == Op1C->getOpcode()) { // same cast kind? 3925 const Type *SrcTy = Op0C->getOperand(0)->getType(); 3926 if (SrcTy == Op1C->getOperand(0)->getType() && SrcTy->isInteger() && 3927 // Only do this if the casts both really cause code to be generated. 3928 ValueRequiresCast(Op0C->getOpcode(), Op0C->getOperand(0), 3929 I.getType()) && 3930 ValueRequiresCast(Op1C->getOpcode(), Op1C->getOperand(0), 3931 I.getType())) { 3932 Value *NewOp = Builder->CreateXor(Op0C->getOperand(0), 3933 Op1C->getOperand(0), I.getName()); 3934 return CastInst::Create(Op0C->getOpcode(), NewOp, I.getType()); 3935 } 3936 } 3937 } 3938 3939 return Changed ? &I : 0; 3940} 3941 3942 3943Instruction *InstCombiner::visitShl(BinaryOperator &I) { 3944 return commonShiftTransforms(I); 3945} 3946 3947Instruction *InstCombiner::visitLShr(BinaryOperator &I) { 3948 return commonShiftTransforms(I); 3949} 3950 3951Instruction *InstCombiner::visitAShr(BinaryOperator &I) { 3952 if (Instruction *R = commonShiftTransforms(I)) 3953 return R; 3954 3955 Value *Op0 = I.getOperand(0); 3956 3957 // ashr int -1, X = -1 (for any arithmetic shift rights of ~0) 3958 if (ConstantInt *CSI = dyn_cast<ConstantInt>(Op0)) 3959 if (CSI->isAllOnesValue()) 3960 return ReplaceInstUsesWith(I, CSI); 3961 3962 // See if we can turn a signed shr into an unsigned shr. 3963 if (MaskedValueIsZero(Op0, 3964 APInt::getSignBit(I.getType()->getScalarSizeInBits()))) 3965 return BinaryOperator::CreateLShr(Op0, I.getOperand(1)); 3966 3967 // Arithmetic shifting an all-sign-bit value is a no-op. 3968 unsigned NumSignBits = ComputeNumSignBits(Op0); 3969 if (NumSignBits == Op0->getType()->getScalarSizeInBits()) 3970 return ReplaceInstUsesWith(I, Op0); 3971 3972 return 0; 3973} 3974 3975Instruction *InstCombiner::commonShiftTransforms(BinaryOperator &I) { 3976 assert(I.getOperand(1)->getType() == I.getOperand(0)->getType()); 3977 Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1); 3978 3979 // shl X, 0 == X and shr X, 0 == X 3980 // shl 0, X == 0 and shr 0, X == 0 3981 if (Op1 == Constant::getNullValue(Op1->getType()) || 3982 Op0 == Constant::getNullValue(Op0->getType())) 3983 return ReplaceInstUsesWith(I, Op0); 3984 3985 if (isa<UndefValue>(Op0)) { 3986 if (I.getOpcode() == Instruction::AShr) // undef >>s X -> undef 3987 return ReplaceInstUsesWith(I, Op0); 3988 else // undef << X -> 0, undef >>u X -> 0 3989 return ReplaceInstUsesWith(I, Constant::getNullValue(I.getType())); 3990 } 3991 if (isa<UndefValue>(Op1)) { 3992 if (I.getOpcode() == Instruction::AShr) // X >>s undef -> X 3993 return ReplaceInstUsesWith(I, Op0); 3994 else // X << undef, X >>u undef -> 0 3995 return ReplaceInstUsesWith(I, Constant::getNullValue(I.getType())); 3996 } 3997 3998 // See if we can fold away this shift. 3999 if (SimplifyDemandedInstructionBits(I)) 4000 return &I; 4001 4002 // Try to fold constant and into select arguments. 4003 if (isa<Constant>(Op0)) 4004 if (SelectInst *SI = dyn_cast<SelectInst>(Op1)) 4005 if (Instruction *R = FoldOpIntoSelect(I, SI)) 4006 return R; 4007 4008 if (ConstantInt *CUI = dyn_cast<ConstantInt>(Op1)) 4009 if (Instruction *Res = FoldShiftByConstant(Op0, CUI, I)) 4010 return Res; 4011 return 0; 4012} 4013 4014Instruction *InstCombiner::FoldShiftByConstant(Value *Op0, ConstantInt *Op1, 4015 BinaryOperator &I) { 4016 bool isLeftShift = I.getOpcode() == Instruction::Shl; 4017 4018 // See if we can simplify any instructions used by the instruction whose sole 4019 // purpose is to compute bits we don't care about. 4020 uint32_t TypeBits = Op0->getType()->getScalarSizeInBits(); 4021 4022 // shl i32 X, 32 = 0 and srl i8 Y, 9 = 0, ... just don't eliminate 4023 // a signed shift. 4024 // 4025 if (Op1->uge(TypeBits)) { 4026 if (I.getOpcode() != Instruction::AShr) 4027 return ReplaceInstUsesWith(I, Constant::getNullValue(Op0->getType())); 4028 else { 4029 I.setOperand(1, ConstantInt::get(I.getType(), TypeBits-1)); 4030 return &I; 4031 } 4032 } 4033 4034 // ((X*C1) << C2) == (X * (C1 << C2)) 4035 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(Op0)) 4036 if (BO->getOpcode() == Instruction::Mul && isLeftShift) 4037 if (Constant *BOOp = dyn_cast<Constant>(BO->getOperand(1))) 4038 return BinaryOperator::CreateMul(BO->getOperand(0), 4039 ConstantExpr::getShl(BOOp, Op1)); 4040 4041 // Try to fold constant and into select arguments. 4042 if (SelectInst *SI = dyn_cast<SelectInst>(Op0)) 4043 if (Instruction *R = FoldOpIntoSelect(I, SI)) 4044 return R; 4045 if (isa<PHINode>(Op0)) 4046 if (Instruction *NV = FoldOpIntoPhi(I)) 4047 return NV; 4048 4049 // Fold shift2(trunc(shift1(x,c1)), c2) -> trunc(shift2(shift1(x,c1),c2)) 4050 if (TruncInst *TI = dyn_cast<TruncInst>(Op0)) { 4051 Instruction *TrOp = dyn_cast<Instruction>(TI->getOperand(0)); 4052 // If 'shift2' is an ashr, we would have to get the sign bit into a funny 4053 // place. Don't try to do this transformation in this case. Also, we 4054 // require that the input operand is a shift-by-constant so that we have 4055 // confidence that the shifts will get folded together. We could do this 4056 // xform in more cases, but it is unlikely to be profitable. 4057 if (TrOp && I.isLogicalShift() && TrOp->isShift() && 4058 isa<ConstantInt>(TrOp->getOperand(1))) { 4059 // Okay, we'll do this xform. Make the shift of shift. 4060 Constant *ShAmt = ConstantExpr::getZExt(Op1, TrOp->getType()); 4061 // (shift2 (shift1 & 0x00FF), c2) 4062 Value *NSh = Builder->CreateBinOp(I.getOpcode(), TrOp, ShAmt,I.getName()); 4063 4064 // For logical shifts, the truncation has the effect of making the high 4065 // part of the register be zeros. Emulate this by inserting an AND to 4066 // clear the top bits as needed. This 'and' will usually be zapped by 4067 // other xforms later if dead. 4068 unsigned SrcSize = TrOp->getType()->getScalarSizeInBits(); 4069 unsigned DstSize = TI->getType()->getScalarSizeInBits(); 4070 APInt MaskV(APInt::getLowBitsSet(SrcSize, DstSize)); 4071 4072 // The mask we constructed says what the trunc would do if occurring 4073 // between the shifts. We want to know the effect *after* the second 4074 // shift. We know that it is a logical shift by a constant, so adjust the 4075 // mask as appropriate. 4076 if (I.getOpcode() == Instruction::Shl) 4077 MaskV <<= Op1->getZExtValue(); 4078 else { 4079 assert(I.getOpcode() == Instruction::LShr && "Unknown logical shift"); 4080 MaskV = MaskV.lshr(Op1->getZExtValue()); 4081 } 4082 4083 // shift1 & 0x00FF 4084 Value *And = Builder->CreateAnd(NSh, 4085 ConstantInt::get(I.getContext(), MaskV), 4086 TI->getName()); 4087 4088 // Return the value truncated to the interesting size. 4089 return new TruncInst(And, I.getType()); 4090 } 4091 } 4092 4093 if (Op0->hasOneUse()) { 4094 if (BinaryOperator *Op0BO = dyn_cast<BinaryOperator>(Op0)) { 4095 // Turn ((X >> C) + Y) << C -> (X + (Y << C)) & (~0 << C) 4096 Value *V1, *V2; 4097 ConstantInt *CC; 4098 switch (Op0BO->getOpcode()) { 4099 default: break; 4100 case Instruction::Add: 4101 case Instruction::And: 4102 case Instruction::Or: 4103 case Instruction::Xor: { 4104 // These operators commute. 4105 // Turn (Y + (X >> C)) << C -> (X + (Y << C)) & (~0 << C) 4106 if (isLeftShift && Op0BO->getOperand(1)->hasOneUse() && 4107 match(Op0BO->getOperand(1), m_Shr(m_Value(V1), 4108 m_Specific(Op1)))) { 4109 Value *YS = // (Y << C) 4110 Builder->CreateShl(Op0BO->getOperand(0), Op1, Op0BO->getName()); 4111 // (X + (Y << C)) 4112 Value *X = Builder->CreateBinOp(Op0BO->getOpcode(), YS, V1, 4113 Op0BO->getOperand(1)->getName()); 4114 uint32_t Op1Val = Op1->getLimitedValue(TypeBits); 4115 return BinaryOperator::CreateAnd(X, ConstantInt::get(I.getContext(), 4116 APInt::getHighBitsSet(TypeBits, TypeBits-Op1Val))); 4117 } 4118 4119 // Turn (Y + ((X >> C) & CC)) << C -> ((X & (CC << C)) + (Y << C)) 4120 Value *Op0BOOp1 = Op0BO->getOperand(1); 4121 if (isLeftShift && Op0BOOp1->hasOneUse() && 4122 match(Op0BOOp1, 4123 m_And(m_Shr(m_Value(V1), m_Specific(Op1)), 4124 m_ConstantInt(CC))) && 4125 cast<BinaryOperator>(Op0BOOp1)->getOperand(0)->hasOneUse()) { 4126 Value *YS = // (Y << C) 4127 Builder->CreateShl(Op0BO->getOperand(0), Op1, 4128 Op0BO->getName()); 4129 // X & (CC << C) 4130 Value *XM = Builder->CreateAnd(V1, ConstantExpr::getShl(CC, Op1), 4131 V1->getName()+".mask"); 4132 return BinaryOperator::Create(Op0BO->getOpcode(), YS, XM); 4133 } 4134 } 4135 4136 // FALL THROUGH. 4137 case Instruction::Sub: { 4138 // Turn ((X >> C) + Y) << C -> (X + (Y << C)) & (~0 << C) 4139 if (isLeftShift && Op0BO->getOperand(0)->hasOneUse() && 4140 match(Op0BO->getOperand(0), m_Shr(m_Value(V1), 4141 m_Specific(Op1)))) { 4142 Value *YS = // (Y << C) 4143 Builder->CreateShl(Op0BO->getOperand(1), Op1, Op0BO->getName()); 4144 // (X + (Y << C)) 4145 Value *X = Builder->CreateBinOp(Op0BO->getOpcode(), V1, YS, 4146 Op0BO->getOperand(0)->getName()); 4147 uint32_t Op1Val = Op1->getLimitedValue(TypeBits); 4148 return BinaryOperator::CreateAnd(X, ConstantInt::get(I.getContext(), 4149 APInt::getHighBitsSet(TypeBits, TypeBits-Op1Val))); 4150 } 4151 4152 // Turn (((X >> C)&CC) + Y) << C -> (X + (Y << C)) & (CC << C) 4153 if (isLeftShift && Op0BO->getOperand(0)->hasOneUse() && 4154 match(Op0BO->getOperand(0), 4155 m_And(m_Shr(m_Value(V1), m_Value(V2)), 4156 m_ConstantInt(CC))) && V2 == Op1 && 4157 cast<BinaryOperator>(Op0BO->getOperand(0)) 4158 ->getOperand(0)->hasOneUse()) { 4159 Value *YS = // (Y << C) 4160 Builder->CreateShl(Op0BO->getOperand(1), Op1, Op0BO->getName()); 4161 // X & (CC << C) 4162 Value *XM = Builder->CreateAnd(V1, ConstantExpr::getShl(CC, Op1), 4163 V1->getName()+".mask"); 4164 4165 return BinaryOperator::Create(Op0BO->getOpcode(), XM, YS); 4166 } 4167 4168 break; 4169 } 4170 } 4171 4172 4173 // If the operand is an bitwise operator with a constant RHS, and the 4174 // shift is the only use, we can pull it out of the shift. 4175 if (ConstantInt *Op0C = dyn_cast<ConstantInt>(Op0BO->getOperand(1))) { 4176 bool isValid = true; // Valid only for And, Or, Xor 4177 bool highBitSet = false; // Transform if high bit of constant set? 4178 4179 switch (Op0BO->getOpcode()) { 4180 default: isValid = false; break; // Do not perform transform! 4181 case Instruction::Add: 4182 isValid = isLeftShift; 4183 break; 4184 case Instruction::Or: 4185 case Instruction::Xor: 4186 highBitSet = false; 4187 break; 4188 case Instruction::And: 4189 highBitSet = true; 4190 break; 4191 } 4192 4193 // If this is a signed shift right, and the high bit is modified 4194 // by the logical operation, do not perform the transformation. 4195 // The highBitSet boolean indicates the value of the high bit of 4196 // the constant which would cause it to be modified for this 4197 // operation. 4198 // 4199 if (isValid && I.getOpcode() == Instruction::AShr) 4200 isValid = Op0C->getValue()[TypeBits-1] == highBitSet; 4201 4202 if (isValid) { 4203 Constant *NewRHS = ConstantExpr::get(I.getOpcode(), Op0C, Op1); 4204 4205 Value *NewShift = 4206 Builder->CreateBinOp(I.getOpcode(), Op0BO->getOperand(0), Op1); 4207 NewShift->takeName(Op0BO); 4208 4209 return BinaryOperator::Create(Op0BO->getOpcode(), NewShift, 4210 NewRHS); 4211 } 4212 } 4213 } 4214 } 4215 4216 // Find out if this is a shift of a shift by a constant. 4217 BinaryOperator *ShiftOp = dyn_cast<BinaryOperator>(Op0); 4218 if (ShiftOp && !ShiftOp->isShift()) 4219 ShiftOp = 0; 4220 4221 if (ShiftOp && isa<ConstantInt>(ShiftOp->getOperand(1))) { 4222 ConstantInt *ShiftAmt1C = cast<ConstantInt>(ShiftOp->getOperand(1)); 4223 uint32_t ShiftAmt1 = ShiftAmt1C->getLimitedValue(TypeBits); 4224 uint32_t ShiftAmt2 = Op1->getLimitedValue(TypeBits); 4225 assert(ShiftAmt2 != 0 && "Should have been simplified earlier"); 4226 if (ShiftAmt1 == 0) return 0; // Will be simplified in the future. 4227 Value *X = ShiftOp->getOperand(0); 4228 4229 uint32_t AmtSum = ShiftAmt1+ShiftAmt2; // Fold into one big shift. 4230 4231 const IntegerType *Ty = cast<IntegerType>(I.getType()); 4232 4233 // Check for (X << c1) << c2 and (X >> c1) >> c2 4234 if (I.getOpcode() == ShiftOp->getOpcode()) { 4235 // If this is oversized composite shift, then unsigned shifts get 0, ashr 4236 // saturates. 4237 if (AmtSum >= TypeBits) { 4238 if (I.getOpcode() != Instruction::AShr) 4239 return ReplaceInstUsesWith(I, Constant::getNullValue(I.getType())); 4240 AmtSum = TypeBits-1; // Saturate to 31 for i32 ashr. 4241 } 4242 4243 return BinaryOperator::Create(I.getOpcode(), X, 4244 ConstantInt::get(Ty, AmtSum)); 4245 } 4246 4247 if (ShiftOp->getOpcode() == Instruction::LShr && 4248 I.getOpcode() == Instruction::AShr) { 4249 if (AmtSum >= TypeBits) 4250 return ReplaceInstUsesWith(I, Constant::getNullValue(I.getType())); 4251 4252 // ((X >>u C1) >>s C2) -> (X >>u (C1+C2)) since C1 != 0. 4253 return BinaryOperator::CreateLShr(X, ConstantInt::get(Ty, AmtSum)); 4254 } 4255 4256 if (ShiftOp->getOpcode() == Instruction::AShr && 4257 I.getOpcode() == Instruction::LShr) { 4258 // ((X >>s C1) >>u C2) -> ((X >>s (C1+C2)) & mask) since C1 != 0. 4259 if (AmtSum >= TypeBits) 4260 AmtSum = TypeBits-1; 4261 4262 Value *Shift = Builder->CreateAShr(X, ConstantInt::get(Ty, AmtSum)); 4263 4264 APInt Mask(APInt::getLowBitsSet(TypeBits, TypeBits - ShiftAmt2)); 4265 return BinaryOperator::CreateAnd(Shift, 4266 ConstantInt::get(I.getContext(), Mask)); 4267 } 4268 4269 // Okay, if we get here, one shift must be left, and the other shift must be 4270 // right. See if the amounts are equal. 4271 if (ShiftAmt1 == ShiftAmt2) { 4272 // If we have ((X >>? C) << C), turn this into X & (-1 << C). 4273 if (I.getOpcode() == Instruction::Shl) { 4274 APInt Mask(APInt::getHighBitsSet(TypeBits, TypeBits - ShiftAmt1)); 4275 return BinaryOperator::CreateAnd(X, 4276 ConstantInt::get(I.getContext(),Mask)); 4277 } 4278 // If we have ((X << C) >>u C), turn this into X & (-1 >>u C). 4279 if (I.getOpcode() == Instruction::LShr) { 4280 APInt Mask(APInt::getLowBitsSet(TypeBits, TypeBits - ShiftAmt1)); 4281 return BinaryOperator::CreateAnd(X, 4282 ConstantInt::get(I.getContext(), Mask)); 4283 } 4284 // We can simplify ((X << C) >>s C) into a trunc + sext. 4285 // NOTE: we could do this for any C, but that would make 'unusual' integer 4286 // types. For now, just stick to ones well-supported by the code 4287 // generators. 4288 const Type *SExtType = 0; 4289 switch (Ty->getBitWidth() - ShiftAmt1) { 4290 case 1 : 4291 case 8 : 4292 case 16 : 4293 case 32 : 4294 case 64 : 4295 case 128: 4296 SExtType = IntegerType::get(I.getContext(), 4297 Ty->getBitWidth() - ShiftAmt1); 4298 break; 4299 default: break; 4300 } 4301 if (SExtType) 4302 return new SExtInst(Builder->CreateTrunc(X, SExtType, "sext"), Ty); 4303 // Otherwise, we can't handle it yet. 4304 } else if (ShiftAmt1 < ShiftAmt2) { 4305 uint32_t ShiftDiff = ShiftAmt2-ShiftAmt1; 4306 4307 // (X >>? C1) << C2 --> X << (C2-C1) & (-1 << C2) 4308 if (I.getOpcode() == Instruction::Shl) { 4309 assert(ShiftOp->getOpcode() == Instruction::LShr || 4310 ShiftOp->getOpcode() == Instruction::AShr); 4311 Value *Shift = Builder->CreateShl(X, ConstantInt::get(Ty, ShiftDiff)); 4312 4313 APInt Mask(APInt::getHighBitsSet(TypeBits, TypeBits - ShiftAmt2)); 4314 return BinaryOperator::CreateAnd(Shift, 4315 ConstantInt::get(I.getContext(),Mask)); 4316 } 4317 4318 // (X << C1) >>u C2 --> X >>u (C2-C1) & (-1 >> C2) 4319 if (I.getOpcode() == Instruction::LShr) { 4320 assert(ShiftOp->getOpcode() == Instruction::Shl); 4321 Value *Shift = Builder->CreateLShr(X, ConstantInt::get(Ty, ShiftDiff)); 4322 4323 APInt Mask(APInt::getLowBitsSet(TypeBits, TypeBits - ShiftAmt2)); 4324 return BinaryOperator::CreateAnd(Shift, 4325 ConstantInt::get(I.getContext(),Mask)); 4326 } 4327 4328 // We can't handle (X << C1) >>s C2, it shifts arbitrary bits in. 4329 } else { 4330 assert(ShiftAmt2 < ShiftAmt1); 4331 uint32_t ShiftDiff = ShiftAmt1-ShiftAmt2; 4332 4333 // (X >>? C1) << C2 --> X >>? (C1-C2) & (-1 << C2) 4334 if (I.getOpcode() == Instruction::Shl) { 4335 assert(ShiftOp->getOpcode() == Instruction::LShr || 4336 ShiftOp->getOpcode() == Instruction::AShr); 4337 Value *Shift = Builder->CreateBinOp(ShiftOp->getOpcode(), X, 4338 ConstantInt::get(Ty, ShiftDiff)); 4339 4340 APInt Mask(APInt::getHighBitsSet(TypeBits, TypeBits - ShiftAmt2)); 4341 return BinaryOperator::CreateAnd(Shift, 4342 ConstantInt::get(I.getContext(),Mask)); 4343 } 4344 4345 // (X << C1) >>u C2 --> X << (C1-C2) & (-1 >> C2) 4346 if (I.getOpcode() == Instruction::LShr) { 4347 assert(ShiftOp->getOpcode() == Instruction::Shl); 4348 Value *Shift = Builder->CreateShl(X, ConstantInt::get(Ty, ShiftDiff)); 4349 4350 APInt Mask(APInt::getLowBitsSet(TypeBits, TypeBits - ShiftAmt2)); 4351 return BinaryOperator::CreateAnd(Shift, 4352 ConstantInt::get(I.getContext(),Mask)); 4353 } 4354 4355 // We can't handle (X << C1) >>a C2, it shifts arbitrary bits in. 4356 } 4357 } 4358 return 0; 4359} 4360 4361 4362 4363/// FindElementAtOffset - Given a type and a constant offset, determine whether 4364/// or not there is a sequence of GEP indices into the type that will land us at 4365/// the specified offset. If so, fill them into NewIndices and return the 4366/// resultant element type, otherwise return null. 4367const Type *InstCombiner::FindElementAtOffset(const Type *Ty, int64_t Offset, 4368 SmallVectorImpl<Value*> &NewIndices) { 4369 if (!TD) return 0; 4370 if (!Ty->isSized()) return 0; 4371 4372 // Start with the index over the outer type. Note that the type size 4373 // might be zero (even if the offset isn't zero) if the indexed type 4374 // is something like [0 x {int, int}] 4375 const Type *IntPtrTy = TD->getIntPtrType(Ty->getContext()); 4376 int64_t FirstIdx = 0; 4377 if (int64_t TySize = TD->getTypeAllocSize(Ty)) { 4378 FirstIdx = Offset/TySize; 4379 Offset -= FirstIdx*TySize; 4380 4381 // Handle hosts where % returns negative instead of values [0..TySize). 4382 if (Offset < 0) { 4383 --FirstIdx; 4384 Offset += TySize; 4385 assert(Offset >= 0); 4386 } 4387 assert((uint64_t)Offset < (uint64_t)TySize && "Out of range offset"); 4388 } 4389 4390 NewIndices.push_back(ConstantInt::get(IntPtrTy, FirstIdx)); 4391 4392 // Index into the types. If we fail, set OrigBase to null. 4393 while (Offset) { 4394 // Indexing into tail padding between struct/array elements. 4395 if (uint64_t(Offset*8) >= TD->getTypeSizeInBits(Ty)) 4396 return 0; 4397 4398 if (const StructType *STy = dyn_cast<StructType>(Ty)) { 4399 const StructLayout *SL = TD->getStructLayout(STy); 4400 assert(Offset < (int64_t)SL->getSizeInBytes() && 4401 "Offset must stay within the indexed type"); 4402 4403 unsigned Elt = SL->getElementContainingOffset(Offset); 4404 NewIndices.push_back(ConstantInt::get(Type::getInt32Ty(Ty->getContext()), 4405 Elt)); 4406 4407 Offset -= SL->getElementOffset(Elt); 4408 Ty = STy->getElementType(Elt); 4409 } else if (const ArrayType *AT = dyn_cast<ArrayType>(Ty)) { 4410 uint64_t EltSize = TD->getTypeAllocSize(AT->getElementType()); 4411 assert(EltSize && "Cannot index into a zero-sized array"); 4412 NewIndices.push_back(ConstantInt::get(IntPtrTy,Offset/EltSize)); 4413 Offset %= EltSize; 4414 Ty = AT->getElementType(); 4415 } else { 4416 // Otherwise, we can't index into the middle of this atomic type, bail. 4417 return 0; 4418 } 4419 } 4420 4421 return Ty; 4422} 4423 4424 4425/// GetSelectFoldableOperands - We want to turn code that looks like this: 4426/// %C = or %A, %B 4427/// %D = select %cond, %C, %A 4428/// into: 4429/// %C = select %cond, %B, 0 4430/// %D = or %A, %C 4431/// 4432/// Assuming that the specified instruction is an operand to the select, return 4433/// a bitmask indicating which operands of this instruction are foldable if they 4434/// equal the other incoming value of the select. 4435/// 4436static unsigned GetSelectFoldableOperands(Instruction *I) { 4437 switch (I->getOpcode()) { 4438 case Instruction::Add: 4439 case Instruction::Mul: 4440 case Instruction::And: 4441 case Instruction::Or: 4442 case Instruction::Xor: 4443 return 3; // Can fold through either operand. 4444 case Instruction::Sub: // Can only fold on the amount subtracted. 4445 case Instruction::Shl: // Can only fold on the shift amount. 4446 case Instruction::LShr: 4447 case Instruction::AShr: 4448 return 1; 4449 default: 4450 return 0; // Cannot fold 4451 } 4452} 4453 4454/// GetSelectFoldableConstant - For the same transformation as the previous 4455/// function, return the identity constant that goes into the select. 4456static Constant *GetSelectFoldableConstant(Instruction *I) { 4457 switch (I->getOpcode()) { 4458 default: llvm_unreachable("This cannot happen!"); 4459 case Instruction::Add: 4460 case Instruction::Sub: 4461 case Instruction::Or: 4462 case Instruction::Xor: 4463 case Instruction::Shl: 4464 case Instruction::LShr: 4465 case Instruction::AShr: 4466 return Constant::getNullValue(I->getType()); 4467 case Instruction::And: 4468 return Constant::getAllOnesValue(I->getType()); 4469 case Instruction::Mul: 4470 return ConstantInt::get(I->getType(), 1); 4471 } 4472} 4473 4474/// FoldSelectOpOp - Here we have (select c, TI, FI), and we know that TI and FI 4475/// have the same opcode and only one use each. Try to simplify this. 4476Instruction *InstCombiner::FoldSelectOpOp(SelectInst &SI, Instruction *TI, 4477 Instruction *FI) { 4478 if (TI->getNumOperands() == 1) { 4479 // If this is a non-volatile load or a cast from the same type, 4480 // merge. 4481 if (TI->isCast()) { 4482 if (TI->getOperand(0)->getType() != FI->getOperand(0)->getType()) 4483 return 0; 4484 } else { 4485 return 0; // unknown unary op. 4486 } 4487 4488 // Fold this by inserting a select from the input values. 4489 SelectInst *NewSI = SelectInst::Create(SI.getCondition(), TI->getOperand(0), 4490 FI->getOperand(0), SI.getName()+".v"); 4491 InsertNewInstBefore(NewSI, SI); 4492 return CastInst::Create(Instruction::CastOps(TI->getOpcode()), NewSI, 4493 TI->getType()); 4494 } 4495 4496 // Only handle binary operators here. 4497 if (!isa<BinaryOperator>(TI)) 4498 return 0; 4499 4500 // Figure out if the operations have any operands in common. 4501 Value *MatchOp, *OtherOpT, *OtherOpF; 4502 bool MatchIsOpZero; 4503 if (TI->getOperand(0) == FI->getOperand(0)) { 4504 MatchOp = TI->getOperand(0); 4505 OtherOpT = TI->getOperand(1); 4506 OtherOpF = FI->getOperand(1); 4507 MatchIsOpZero = true; 4508 } else if (TI->getOperand(1) == FI->getOperand(1)) { 4509 MatchOp = TI->getOperand(1); 4510 OtherOpT = TI->getOperand(0); 4511 OtherOpF = FI->getOperand(0); 4512 MatchIsOpZero = false; 4513 } else if (!TI->isCommutative()) { 4514 return 0; 4515 } else if (TI->getOperand(0) == FI->getOperand(1)) { 4516 MatchOp = TI->getOperand(0); 4517 OtherOpT = TI->getOperand(1); 4518 OtherOpF = FI->getOperand(0); 4519 MatchIsOpZero = true; 4520 } else if (TI->getOperand(1) == FI->getOperand(0)) { 4521 MatchOp = TI->getOperand(1); 4522 OtherOpT = TI->getOperand(0); 4523 OtherOpF = FI->getOperand(1); 4524 MatchIsOpZero = true; 4525 } else { 4526 return 0; 4527 } 4528 4529 // If we reach here, they do have operations in common. 4530 SelectInst *NewSI = SelectInst::Create(SI.getCondition(), OtherOpT, 4531 OtherOpF, SI.getName()+".v"); 4532 InsertNewInstBefore(NewSI, SI); 4533 4534 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(TI)) { 4535 if (MatchIsOpZero) 4536 return BinaryOperator::Create(BO->getOpcode(), MatchOp, NewSI); 4537 else 4538 return BinaryOperator::Create(BO->getOpcode(), NewSI, MatchOp); 4539 } 4540 llvm_unreachable("Shouldn't get here"); 4541 return 0; 4542} 4543 4544static bool isSelect01(Constant *C1, Constant *C2) { 4545 ConstantInt *C1I = dyn_cast<ConstantInt>(C1); 4546 if (!C1I) 4547 return false; 4548 ConstantInt *C2I = dyn_cast<ConstantInt>(C2); 4549 if (!C2I) 4550 return false; 4551 return (C1I->isZero() || C1I->isOne()) && (C2I->isZero() || C2I->isOne()); 4552} 4553 4554/// FoldSelectIntoOp - Try fold the select into one of the operands to 4555/// facilitate further optimization. 4556Instruction *InstCombiner::FoldSelectIntoOp(SelectInst &SI, Value *TrueVal, 4557 Value *FalseVal) { 4558 // See the comment above GetSelectFoldableOperands for a description of the 4559 // transformation we are doing here. 4560 if (Instruction *TVI = dyn_cast<Instruction>(TrueVal)) { 4561 if (TVI->hasOneUse() && TVI->getNumOperands() == 2 && 4562 !isa<Constant>(FalseVal)) { 4563 if (unsigned SFO = GetSelectFoldableOperands(TVI)) { 4564 unsigned OpToFold = 0; 4565 if ((SFO & 1) && FalseVal == TVI->getOperand(0)) { 4566 OpToFold = 1; 4567 } else if ((SFO & 2) && FalseVal == TVI->getOperand(1)) { 4568 OpToFold = 2; 4569 } 4570 4571 if (OpToFold) { 4572 Constant *C = GetSelectFoldableConstant(TVI); 4573 Value *OOp = TVI->getOperand(2-OpToFold); 4574 // Avoid creating select between 2 constants unless it's selecting 4575 // between 0 and 1. 4576 if (!isa<Constant>(OOp) || isSelect01(C, cast<Constant>(OOp))) { 4577 Instruction *NewSel = SelectInst::Create(SI.getCondition(), OOp, C); 4578 InsertNewInstBefore(NewSel, SI); 4579 NewSel->takeName(TVI); 4580 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(TVI)) 4581 return BinaryOperator::Create(BO->getOpcode(), FalseVal, NewSel); 4582 llvm_unreachable("Unknown instruction!!"); 4583 } 4584 } 4585 } 4586 } 4587 } 4588 4589 if (Instruction *FVI = dyn_cast<Instruction>(FalseVal)) { 4590 if (FVI->hasOneUse() && FVI->getNumOperands() == 2 && 4591 !isa<Constant>(TrueVal)) { 4592 if (unsigned SFO = GetSelectFoldableOperands(FVI)) { 4593 unsigned OpToFold = 0; 4594 if ((SFO & 1) && TrueVal == FVI->getOperand(0)) { 4595 OpToFold = 1; 4596 } else if ((SFO & 2) && TrueVal == FVI->getOperand(1)) { 4597 OpToFold = 2; 4598 } 4599 4600 if (OpToFold) { 4601 Constant *C = GetSelectFoldableConstant(FVI); 4602 Value *OOp = FVI->getOperand(2-OpToFold); 4603 // Avoid creating select between 2 constants unless it's selecting 4604 // between 0 and 1. 4605 if (!isa<Constant>(OOp) || isSelect01(C, cast<Constant>(OOp))) { 4606 Instruction *NewSel = SelectInst::Create(SI.getCondition(), C, OOp); 4607 InsertNewInstBefore(NewSel, SI); 4608 NewSel->takeName(FVI); 4609 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(FVI)) 4610 return BinaryOperator::Create(BO->getOpcode(), TrueVal, NewSel); 4611 llvm_unreachable("Unknown instruction!!"); 4612 } 4613 } 4614 } 4615 } 4616 } 4617 4618 return 0; 4619} 4620 4621/// visitSelectInstWithICmp - Visit a SelectInst that has an 4622/// ICmpInst as its first operand. 4623/// 4624Instruction *InstCombiner::visitSelectInstWithICmp(SelectInst &SI, 4625 ICmpInst *ICI) { 4626 bool Changed = false; 4627 ICmpInst::Predicate Pred = ICI->getPredicate(); 4628 Value *CmpLHS = ICI->getOperand(0); 4629 Value *CmpRHS = ICI->getOperand(1); 4630 Value *TrueVal = SI.getTrueValue(); 4631 Value *FalseVal = SI.getFalseValue(); 4632 4633 // Check cases where the comparison is with a constant that 4634 // can be adjusted to fit the min/max idiom. We may edit ICI in 4635 // place here, so make sure the select is the only user. 4636 if (ICI->hasOneUse()) 4637 if (ConstantInt *CI = dyn_cast<ConstantInt>(CmpRHS)) { 4638 switch (Pred) { 4639 default: break; 4640 case ICmpInst::ICMP_ULT: 4641 case ICmpInst::ICMP_SLT: { 4642 // X < MIN ? T : F --> F 4643 if (CI->isMinValue(Pred == ICmpInst::ICMP_SLT)) 4644 return ReplaceInstUsesWith(SI, FalseVal); 4645 // X < C ? X : C-1 --> X > C-1 ? C-1 : X 4646 Constant *AdjustedRHS = SubOne(CI); 4647 if ((CmpLHS == TrueVal && AdjustedRHS == FalseVal) || 4648 (CmpLHS == FalseVal && AdjustedRHS == TrueVal)) { 4649 Pred = ICmpInst::getSwappedPredicate(Pred); 4650 CmpRHS = AdjustedRHS; 4651 std::swap(FalseVal, TrueVal); 4652 ICI->setPredicate(Pred); 4653 ICI->setOperand(1, CmpRHS); 4654 SI.setOperand(1, TrueVal); 4655 SI.setOperand(2, FalseVal); 4656 Changed = true; 4657 } 4658 break; 4659 } 4660 case ICmpInst::ICMP_UGT: 4661 case ICmpInst::ICMP_SGT: { 4662 // X > MAX ? T : F --> F 4663 if (CI->isMaxValue(Pred == ICmpInst::ICMP_SGT)) 4664 return ReplaceInstUsesWith(SI, FalseVal); 4665 // X > C ? X : C+1 --> X < C+1 ? C+1 : X 4666 Constant *AdjustedRHS = AddOne(CI); 4667 if ((CmpLHS == TrueVal && AdjustedRHS == FalseVal) || 4668 (CmpLHS == FalseVal && AdjustedRHS == TrueVal)) { 4669 Pred = ICmpInst::getSwappedPredicate(Pred); 4670 CmpRHS = AdjustedRHS; 4671 std::swap(FalseVal, TrueVal); 4672 ICI->setPredicate(Pred); 4673 ICI->setOperand(1, CmpRHS); 4674 SI.setOperand(1, TrueVal); 4675 SI.setOperand(2, FalseVal); 4676 Changed = true; 4677 } 4678 break; 4679 } 4680 } 4681 4682 // (x <s 0) ? -1 : 0 -> ashr x, 31 -> all ones if signed 4683 // (x >s -1) ? -1 : 0 -> ashr x, 31 -> all ones if not signed 4684 CmpInst::Predicate Pred = CmpInst::BAD_ICMP_PREDICATE; 4685 if (match(TrueVal, m_ConstantInt<-1>()) && 4686 match(FalseVal, m_ConstantInt<0>())) 4687 Pred = ICI->getPredicate(); 4688 else if (match(TrueVal, m_ConstantInt<0>()) && 4689 match(FalseVal, m_ConstantInt<-1>())) 4690 Pred = CmpInst::getInversePredicate(ICI->getPredicate()); 4691 4692 if (Pred != CmpInst::BAD_ICMP_PREDICATE) { 4693 // If we are just checking for a icmp eq of a single bit and zext'ing it 4694 // to an integer, then shift the bit to the appropriate place and then 4695 // cast to integer to avoid the comparison. 4696 const APInt &Op1CV = CI->getValue(); 4697 4698 // sext (x <s 0) to i32 --> x>>s31 true if signbit set. 4699 // sext (x >s -1) to i32 --> (x>>s31)^-1 true if signbit clear. 4700 if ((Pred == ICmpInst::ICMP_SLT && Op1CV == 0) || 4701 (Pred == ICmpInst::ICMP_SGT && Op1CV.isAllOnesValue())) { 4702 Value *In = ICI->getOperand(0); 4703 Value *Sh = ConstantInt::get(In->getType(), 4704 In->getType()->getScalarSizeInBits()-1); 4705 In = InsertNewInstBefore(BinaryOperator::CreateAShr(In, Sh, 4706 In->getName()+".lobit"), 4707 *ICI); 4708 if (In->getType() != SI.getType()) 4709 In = CastInst::CreateIntegerCast(In, SI.getType(), 4710 true/*SExt*/, "tmp", ICI); 4711 4712 if (Pred == ICmpInst::ICMP_SGT) 4713 In = InsertNewInstBefore(BinaryOperator::CreateNot(In, 4714 In->getName()+".not"), *ICI); 4715 4716 return ReplaceInstUsesWith(SI, In); 4717 } 4718 } 4719 } 4720 4721 if (CmpLHS == TrueVal && CmpRHS == FalseVal) { 4722 // Transform (X == Y) ? X : Y -> Y 4723 if (Pred == ICmpInst::ICMP_EQ) 4724 return ReplaceInstUsesWith(SI, FalseVal); 4725 // Transform (X != Y) ? X : Y -> X 4726 if (Pred == ICmpInst::ICMP_NE) 4727 return ReplaceInstUsesWith(SI, TrueVal); 4728 /// NOTE: if we wanted to, this is where to detect integer MIN/MAX 4729 4730 } else if (CmpLHS == FalseVal && CmpRHS == TrueVal) { 4731 // Transform (X == Y) ? Y : X -> X 4732 if (Pred == ICmpInst::ICMP_EQ) 4733 return ReplaceInstUsesWith(SI, FalseVal); 4734 // Transform (X != Y) ? Y : X -> Y 4735 if (Pred == ICmpInst::ICMP_NE) 4736 return ReplaceInstUsesWith(SI, TrueVal); 4737 /// NOTE: if we wanted to, this is where to detect integer MIN/MAX 4738 } 4739 return Changed ? &SI : 0; 4740} 4741 4742 4743/// CanSelectOperandBeMappingIntoPredBlock - SI is a select whose condition is a 4744/// PHI node (but the two may be in different blocks). See if the true/false 4745/// values (V) are live in all of the predecessor blocks of the PHI. For 4746/// example, cases like this cannot be mapped: 4747/// 4748/// X = phi [ C1, BB1], [C2, BB2] 4749/// Y = add 4750/// Z = select X, Y, 0 4751/// 4752/// because Y is not live in BB1/BB2. 4753/// 4754static bool CanSelectOperandBeMappingIntoPredBlock(const Value *V, 4755 const SelectInst &SI) { 4756 // If the value is a non-instruction value like a constant or argument, it 4757 // can always be mapped. 4758 const Instruction *I = dyn_cast<Instruction>(V); 4759 if (I == 0) return true; 4760 4761 // If V is a PHI node defined in the same block as the condition PHI, we can 4762 // map the arguments. 4763 const PHINode *CondPHI = cast<PHINode>(SI.getCondition()); 4764 4765 if (const PHINode *VP = dyn_cast<PHINode>(I)) 4766 if (VP->getParent() == CondPHI->getParent()) 4767 return true; 4768 4769 // Otherwise, if the PHI and select are defined in the same block and if V is 4770 // defined in a different block, then we can transform it. 4771 if (SI.getParent() == CondPHI->getParent() && 4772 I->getParent() != CondPHI->getParent()) 4773 return true; 4774 4775 // Otherwise we have a 'hard' case and we can't tell without doing more 4776 // detailed dominator based analysis, punt. 4777 return false; 4778} 4779 4780/// FoldSPFofSPF - We have an SPF (e.g. a min or max) of an SPF of the form: 4781/// SPF2(SPF1(A, B), C) 4782Instruction *InstCombiner::FoldSPFofSPF(Instruction *Inner, 4783 SelectPatternFlavor SPF1, 4784 Value *A, Value *B, 4785 Instruction &Outer, 4786 SelectPatternFlavor SPF2, Value *C) { 4787 if (C == A || C == B) { 4788 // MAX(MAX(A, B), B) -> MAX(A, B) 4789 // MIN(MIN(a, b), a) -> MIN(a, b) 4790 if (SPF1 == SPF2) 4791 return ReplaceInstUsesWith(Outer, Inner); 4792 4793 // MAX(MIN(a, b), a) -> a 4794 // MIN(MAX(a, b), a) -> a 4795 if ((SPF1 == SPF_SMIN && SPF2 == SPF_SMAX) || 4796 (SPF1 == SPF_SMAX && SPF2 == SPF_SMIN) || 4797 (SPF1 == SPF_UMIN && SPF2 == SPF_UMAX) || 4798 (SPF1 == SPF_UMAX && SPF2 == SPF_UMIN)) 4799 return ReplaceInstUsesWith(Outer, C); 4800 } 4801 4802 // TODO: MIN(MIN(A, 23), 97) 4803 return 0; 4804} 4805 4806 4807 4808 4809Instruction *InstCombiner::visitSelectInst(SelectInst &SI) { 4810 Value *CondVal = SI.getCondition(); 4811 Value *TrueVal = SI.getTrueValue(); 4812 Value *FalseVal = SI.getFalseValue(); 4813 4814 // select true, X, Y -> X 4815 // select false, X, Y -> Y 4816 if (ConstantInt *C = dyn_cast<ConstantInt>(CondVal)) 4817 return ReplaceInstUsesWith(SI, C->getZExtValue() ? TrueVal : FalseVal); 4818 4819 // select C, X, X -> X 4820 if (TrueVal == FalseVal) 4821 return ReplaceInstUsesWith(SI, TrueVal); 4822 4823 if (isa<UndefValue>(TrueVal)) // select C, undef, X -> X 4824 return ReplaceInstUsesWith(SI, FalseVal); 4825 if (isa<UndefValue>(FalseVal)) // select C, X, undef -> X 4826 return ReplaceInstUsesWith(SI, TrueVal); 4827 if (isa<UndefValue>(CondVal)) { // select undef, X, Y -> X or Y 4828 if (isa<Constant>(TrueVal)) 4829 return ReplaceInstUsesWith(SI, TrueVal); 4830 else 4831 return ReplaceInstUsesWith(SI, FalseVal); 4832 } 4833 4834 if (SI.getType() == Type::getInt1Ty(SI.getContext())) { 4835 if (ConstantInt *C = dyn_cast<ConstantInt>(TrueVal)) { 4836 if (C->getZExtValue()) { 4837 // Change: A = select B, true, C --> A = or B, C 4838 return BinaryOperator::CreateOr(CondVal, FalseVal); 4839 } else { 4840 // Change: A = select B, false, C --> A = and !B, C 4841 Value *NotCond = 4842 InsertNewInstBefore(BinaryOperator::CreateNot(CondVal, 4843 "not."+CondVal->getName()), SI); 4844 return BinaryOperator::CreateAnd(NotCond, FalseVal); 4845 } 4846 } else if (ConstantInt *C = dyn_cast<ConstantInt>(FalseVal)) { 4847 if (C->getZExtValue() == false) { 4848 // Change: A = select B, C, false --> A = and B, C 4849 return BinaryOperator::CreateAnd(CondVal, TrueVal); 4850 } else { 4851 // Change: A = select B, C, true --> A = or !B, C 4852 Value *NotCond = 4853 InsertNewInstBefore(BinaryOperator::CreateNot(CondVal, 4854 "not."+CondVal->getName()), SI); 4855 return BinaryOperator::CreateOr(NotCond, TrueVal); 4856 } 4857 } 4858 4859 // select a, b, a -> a&b 4860 // select a, a, b -> a|b 4861 if (CondVal == TrueVal) 4862 return BinaryOperator::CreateOr(CondVal, FalseVal); 4863 else if (CondVal == FalseVal) 4864 return BinaryOperator::CreateAnd(CondVal, TrueVal); 4865 } 4866 4867 // Selecting between two integer constants? 4868 if (ConstantInt *TrueValC = dyn_cast<ConstantInt>(TrueVal)) 4869 if (ConstantInt *FalseValC = dyn_cast<ConstantInt>(FalseVal)) { 4870 // select C, 1, 0 -> zext C to int 4871 if (FalseValC->isZero() && TrueValC->getValue() == 1) { 4872 return CastInst::Create(Instruction::ZExt, CondVal, SI.getType()); 4873 } else if (TrueValC->isZero() && FalseValC->getValue() == 1) { 4874 // select C, 0, 1 -> zext !C to int 4875 Value *NotCond = 4876 InsertNewInstBefore(BinaryOperator::CreateNot(CondVal, 4877 "not."+CondVal->getName()), SI); 4878 return CastInst::Create(Instruction::ZExt, NotCond, SI.getType()); 4879 } 4880 4881 if (ICmpInst *IC = dyn_cast<ICmpInst>(SI.getCondition())) { 4882 // If one of the constants is zero (we know they can't both be) and we 4883 // have an icmp instruction with zero, and we have an 'and' with the 4884 // non-constant value, eliminate this whole mess. This corresponds to 4885 // cases like this: ((X & 27) ? 27 : 0) 4886 if (TrueValC->isZero() || FalseValC->isZero()) 4887 if (IC->isEquality() && isa<ConstantInt>(IC->getOperand(1)) && 4888 cast<Constant>(IC->getOperand(1))->isNullValue()) 4889 if (Instruction *ICA = dyn_cast<Instruction>(IC->getOperand(0))) 4890 if (ICA->getOpcode() == Instruction::And && 4891 isa<ConstantInt>(ICA->getOperand(1)) && 4892 (ICA->getOperand(1) == TrueValC || 4893 ICA->getOperand(1) == FalseValC) && 4894 isOneBitSet(cast<ConstantInt>(ICA->getOperand(1)))) { 4895 // Okay, now we know that everything is set up, we just don't 4896 // know whether we have a icmp_ne or icmp_eq and whether the 4897 // true or false val is the zero. 4898 bool ShouldNotVal = !TrueValC->isZero(); 4899 ShouldNotVal ^= IC->getPredicate() == ICmpInst::ICMP_NE; 4900 Value *V = ICA; 4901 if (ShouldNotVal) 4902 V = InsertNewInstBefore(BinaryOperator::Create( 4903 Instruction::Xor, V, ICA->getOperand(1)), SI); 4904 return ReplaceInstUsesWith(SI, V); 4905 } 4906 } 4907 } 4908 4909 // See if we are selecting two values based on a comparison of the two values. 4910 if (FCmpInst *FCI = dyn_cast<FCmpInst>(CondVal)) { 4911 if (FCI->getOperand(0) == TrueVal && FCI->getOperand(1) == FalseVal) { 4912 // Transform (X == Y) ? X : Y -> Y 4913 if (FCI->getPredicate() == FCmpInst::FCMP_OEQ) { 4914 // This is not safe in general for floating point: 4915 // consider X== -0, Y== +0. 4916 // It becomes safe if either operand is a nonzero constant. 4917 ConstantFP *CFPt, *CFPf; 4918 if (((CFPt = dyn_cast<ConstantFP>(TrueVal)) && 4919 !CFPt->getValueAPF().isZero()) || 4920 ((CFPf = dyn_cast<ConstantFP>(FalseVal)) && 4921 !CFPf->getValueAPF().isZero())) 4922 return ReplaceInstUsesWith(SI, FalseVal); 4923 } 4924 // Transform (X != Y) ? X : Y -> X 4925 if (FCI->getPredicate() == FCmpInst::FCMP_ONE) 4926 return ReplaceInstUsesWith(SI, TrueVal); 4927 // NOTE: if we wanted to, this is where to detect MIN/MAX 4928 4929 } else if (FCI->getOperand(0) == FalseVal && FCI->getOperand(1) == TrueVal){ 4930 // Transform (X == Y) ? Y : X -> X 4931 if (FCI->getPredicate() == FCmpInst::FCMP_OEQ) { 4932 // This is not safe in general for floating point: 4933 // consider X== -0, Y== +0. 4934 // It becomes safe if either operand is a nonzero constant. 4935 ConstantFP *CFPt, *CFPf; 4936 if (((CFPt = dyn_cast<ConstantFP>(TrueVal)) && 4937 !CFPt->getValueAPF().isZero()) || 4938 ((CFPf = dyn_cast<ConstantFP>(FalseVal)) && 4939 !CFPf->getValueAPF().isZero())) 4940 return ReplaceInstUsesWith(SI, FalseVal); 4941 } 4942 // Transform (X != Y) ? Y : X -> Y 4943 if (FCI->getPredicate() == FCmpInst::FCMP_ONE) 4944 return ReplaceInstUsesWith(SI, TrueVal); 4945 // NOTE: if we wanted to, this is where to detect MIN/MAX 4946 } 4947 // NOTE: if we wanted to, this is where to detect ABS 4948 } 4949 4950 // See if we are selecting two values based on a comparison of the two values. 4951 if (ICmpInst *ICI = dyn_cast<ICmpInst>(CondVal)) 4952 if (Instruction *Result = visitSelectInstWithICmp(SI, ICI)) 4953 return Result; 4954 4955 if (Instruction *TI = dyn_cast<Instruction>(TrueVal)) 4956 if (Instruction *FI = dyn_cast<Instruction>(FalseVal)) 4957 if (TI->hasOneUse() && FI->hasOneUse()) { 4958 Instruction *AddOp = 0, *SubOp = 0; 4959 4960 // Turn (select C, (op X, Y), (op X, Z)) -> (op X, (select C, Y, Z)) 4961 if (TI->getOpcode() == FI->getOpcode()) 4962 if (Instruction *IV = FoldSelectOpOp(SI, TI, FI)) 4963 return IV; 4964 4965 // Turn select C, (X+Y), (X-Y) --> (X+(select C, Y, (-Y))). This is 4966 // even legal for FP. 4967 if ((TI->getOpcode() == Instruction::Sub && 4968 FI->getOpcode() == Instruction::Add) || 4969 (TI->getOpcode() == Instruction::FSub && 4970 FI->getOpcode() == Instruction::FAdd)) { 4971 AddOp = FI; SubOp = TI; 4972 } else if ((FI->getOpcode() == Instruction::Sub && 4973 TI->getOpcode() == Instruction::Add) || 4974 (FI->getOpcode() == Instruction::FSub && 4975 TI->getOpcode() == Instruction::FAdd)) { 4976 AddOp = TI; SubOp = FI; 4977 } 4978 4979 if (AddOp) { 4980 Value *OtherAddOp = 0; 4981 if (SubOp->getOperand(0) == AddOp->getOperand(0)) { 4982 OtherAddOp = AddOp->getOperand(1); 4983 } else if (SubOp->getOperand(0) == AddOp->getOperand(1)) { 4984 OtherAddOp = AddOp->getOperand(0); 4985 } 4986 4987 if (OtherAddOp) { 4988 // So at this point we know we have (Y -> OtherAddOp): 4989 // select C, (add X, Y), (sub X, Z) 4990 Value *NegVal; // Compute -Z 4991 if (Constant *C = dyn_cast<Constant>(SubOp->getOperand(1))) { 4992 NegVal = ConstantExpr::getNeg(C); 4993 } else { 4994 NegVal = InsertNewInstBefore( 4995 BinaryOperator::CreateNeg(SubOp->getOperand(1), 4996 "tmp"), SI); 4997 } 4998 4999 Value *NewTrueOp = OtherAddOp; 5000 Value *NewFalseOp = NegVal; 5001 if (AddOp != TI) 5002 std::swap(NewTrueOp, NewFalseOp); 5003 Instruction *NewSel = 5004 SelectInst::Create(CondVal, NewTrueOp, 5005 NewFalseOp, SI.getName() + ".p"); 5006 5007 NewSel = InsertNewInstBefore(NewSel, SI); 5008 return BinaryOperator::CreateAdd(SubOp->getOperand(0), NewSel); 5009 } 5010 } 5011 } 5012 5013 // See if we can fold the select into one of our operands. 5014 if (SI.getType()->isInteger()) { 5015 if (Instruction *FoldI = FoldSelectIntoOp(SI, TrueVal, FalseVal)) 5016 return FoldI; 5017 5018 // MAX(MAX(a, b), a) -> MAX(a, b) 5019 // MIN(MIN(a, b), a) -> MIN(a, b) 5020 // MAX(MIN(a, b), a) -> a 5021 // MIN(MAX(a, b), a) -> a 5022 Value *LHS, *RHS, *LHS2, *RHS2; 5023 if (SelectPatternFlavor SPF = MatchSelectPattern(&SI, LHS, RHS)) { 5024 if (SelectPatternFlavor SPF2 = MatchSelectPattern(LHS, LHS2, RHS2)) 5025 if (Instruction *R = FoldSPFofSPF(cast<Instruction>(LHS),SPF2,LHS2,RHS2, 5026 SI, SPF, RHS)) 5027 return R; 5028 if (SelectPatternFlavor SPF2 = MatchSelectPattern(RHS, LHS2, RHS2)) 5029 if (Instruction *R = FoldSPFofSPF(cast<Instruction>(RHS),SPF2,LHS2,RHS2, 5030 SI, SPF, LHS)) 5031 return R; 5032 } 5033 5034 // TODO. 5035 // ABS(-X) -> ABS(X) 5036 // ABS(ABS(X)) -> ABS(X) 5037 } 5038 5039 // See if we can fold the select into a phi node if the condition is a select. 5040 if (isa<PHINode>(SI.getCondition())) 5041 // The true/false values have to be live in the PHI predecessor's blocks. 5042 if (CanSelectOperandBeMappingIntoPredBlock(TrueVal, SI) && 5043 CanSelectOperandBeMappingIntoPredBlock(FalseVal, SI)) 5044 if (Instruction *NV = FoldOpIntoPhi(SI)) 5045 return NV; 5046 5047 if (BinaryOperator::isNot(CondVal)) { 5048 SI.setOperand(0, BinaryOperator::getNotArgument(CondVal)); 5049 SI.setOperand(1, FalseVal); 5050 SI.setOperand(2, TrueVal); 5051 return &SI; 5052 } 5053 5054 return 0; 5055} 5056 5057/// EnforceKnownAlignment - If the specified pointer points to an object that 5058/// we control, modify the object's alignment to PrefAlign. This isn't 5059/// often possible though. If alignment is important, a more reliable approach 5060/// is to simply align all global variables and allocation instructions to 5061/// their preferred alignment from the beginning. 5062/// 5063static unsigned EnforceKnownAlignment(Value *V, 5064 unsigned Align, unsigned PrefAlign) { 5065 5066 User *U = dyn_cast<User>(V); 5067 if (!U) return Align; 5068 5069 switch (Operator::getOpcode(U)) { 5070 default: break; 5071 case Instruction::BitCast: 5072 return EnforceKnownAlignment(U->getOperand(0), Align, PrefAlign); 5073 case Instruction::GetElementPtr: { 5074 // If all indexes are zero, it is just the alignment of the base pointer. 5075 bool AllZeroOperands = true; 5076 for (User::op_iterator i = U->op_begin() + 1, e = U->op_end(); i != e; ++i) 5077 if (!isa<Constant>(*i) || 5078 !cast<Constant>(*i)->isNullValue()) { 5079 AllZeroOperands = false; 5080 break; 5081 } 5082 5083 if (AllZeroOperands) { 5084 // Treat this like a bitcast. 5085 return EnforceKnownAlignment(U->getOperand(0), Align, PrefAlign); 5086 } 5087 break; 5088 } 5089 } 5090 5091 if (GlobalValue *GV = dyn_cast<GlobalValue>(V)) { 5092 // If there is a large requested alignment and we can, bump up the alignment 5093 // of the global. 5094 if (!GV->isDeclaration()) { 5095 if (GV->getAlignment() >= PrefAlign) 5096 Align = GV->getAlignment(); 5097 else { 5098 GV->setAlignment(PrefAlign); 5099 Align = PrefAlign; 5100 } 5101 } 5102 } else if (AllocaInst *AI = dyn_cast<AllocaInst>(V)) { 5103 // If there is a requested alignment and if this is an alloca, round up. 5104 if (AI->getAlignment() >= PrefAlign) 5105 Align = AI->getAlignment(); 5106 else { 5107 AI->setAlignment(PrefAlign); 5108 Align = PrefAlign; 5109 } 5110 } 5111 5112 return Align; 5113} 5114 5115/// GetOrEnforceKnownAlignment - If the specified pointer has an alignment that 5116/// we can determine, return it, otherwise return 0. If PrefAlign is specified, 5117/// and it is more than the alignment of the ultimate object, see if we can 5118/// increase the alignment of the ultimate object, making this check succeed. 5119unsigned InstCombiner::GetOrEnforceKnownAlignment(Value *V, 5120 unsigned PrefAlign) { 5121 unsigned BitWidth = TD ? TD->getTypeSizeInBits(V->getType()) : 5122 sizeof(PrefAlign) * CHAR_BIT; 5123 APInt Mask = APInt::getAllOnesValue(BitWidth); 5124 APInt KnownZero(BitWidth, 0), KnownOne(BitWidth, 0); 5125 ComputeMaskedBits(V, Mask, KnownZero, KnownOne); 5126 unsigned TrailZ = KnownZero.countTrailingOnes(); 5127 unsigned Align = 1u << std::min(BitWidth - 1, TrailZ); 5128 5129 if (PrefAlign > Align) 5130 Align = EnforceKnownAlignment(V, Align, PrefAlign); 5131 5132 // We don't need to make any adjustment. 5133 return Align; 5134} 5135 5136Instruction *InstCombiner::SimplifyMemTransfer(MemIntrinsic *MI) { 5137 unsigned DstAlign = GetOrEnforceKnownAlignment(MI->getOperand(1)); 5138 unsigned SrcAlign = GetOrEnforceKnownAlignment(MI->getOperand(2)); 5139 unsigned MinAlign = std::min(DstAlign, SrcAlign); 5140 unsigned CopyAlign = MI->getAlignment(); 5141 5142 if (CopyAlign < MinAlign) { 5143 MI->setAlignment(ConstantInt::get(MI->getAlignmentType(), 5144 MinAlign, false)); 5145 return MI; 5146 } 5147 5148 // If MemCpyInst length is 1/2/4/8 bytes then replace memcpy with 5149 // load/store. 5150 ConstantInt *MemOpLength = dyn_cast<ConstantInt>(MI->getOperand(3)); 5151 if (MemOpLength == 0) return 0; 5152 5153 // Source and destination pointer types are always "i8*" for intrinsic. See 5154 // if the size is something we can handle with a single primitive load/store. 5155 // A single load+store correctly handles overlapping memory in the memmove 5156 // case. 5157 unsigned Size = MemOpLength->getZExtValue(); 5158 if (Size == 0) return MI; // Delete this mem transfer. 5159 5160 if (Size > 8 || (Size&(Size-1))) 5161 return 0; // If not 1/2/4/8 bytes, exit. 5162 5163 // Use an integer load+store unless we can find something better. 5164 Type *NewPtrTy = 5165 PointerType::getUnqual(IntegerType::get(MI->getContext(), Size<<3)); 5166 5167 // Memcpy forces the use of i8* for the source and destination. That means 5168 // that if you're using memcpy to move one double around, you'll get a cast 5169 // from double* to i8*. We'd much rather use a double load+store rather than 5170 // an i64 load+store, here because this improves the odds that the source or 5171 // dest address will be promotable. See if we can find a better type than the 5172 // integer datatype. 5173 if (Value *Op = getBitCastOperand(MI->getOperand(1))) { 5174 const Type *SrcETy = cast<PointerType>(Op->getType())->getElementType(); 5175 if (TD && SrcETy->isSized() && TD->getTypeStoreSize(SrcETy) == Size) { 5176 // The SrcETy might be something like {{{double}}} or [1 x double]. Rip 5177 // down through these levels if so. 5178 while (!SrcETy->isSingleValueType()) { 5179 if (const StructType *STy = dyn_cast<StructType>(SrcETy)) { 5180 if (STy->getNumElements() == 1) 5181 SrcETy = STy->getElementType(0); 5182 else 5183 break; 5184 } else if (const ArrayType *ATy = dyn_cast<ArrayType>(SrcETy)) { 5185 if (ATy->getNumElements() == 1) 5186 SrcETy = ATy->getElementType(); 5187 else 5188 break; 5189 } else 5190 break; 5191 } 5192 5193 if (SrcETy->isSingleValueType()) 5194 NewPtrTy = PointerType::getUnqual(SrcETy); 5195 } 5196 } 5197 5198 5199 // If the memcpy/memmove provides better alignment info than we can 5200 // infer, use it. 5201 SrcAlign = std::max(SrcAlign, CopyAlign); 5202 DstAlign = std::max(DstAlign, CopyAlign); 5203 5204 Value *Src = Builder->CreateBitCast(MI->getOperand(2), NewPtrTy); 5205 Value *Dest = Builder->CreateBitCast(MI->getOperand(1), NewPtrTy); 5206 Instruction *L = new LoadInst(Src, "tmp", false, SrcAlign); 5207 InsertNewInstBefore(L, *MI); 5208 InsertNewInstBefore(new StoreInst(L, Dest, false, DstAlign), *MI); 5209 5210 // Set the size of the copy to 0, it will be deleted on the next iteration. 5211 MI->setOperand(3, Constant::getNullValue(MemOpLength->getType())); 5212 return MI; 5213} 5214 5215Instruction *InstCombiner::SimplifyMemSet(MemSetInst *MI) { 5216 unsigned Alignment = GetOrEnforceKnownAlignment(MI->getDest()); 5217 if (MI->getAlignment() < Alignment) { 5218 MI->setAlignment(ConstantInt::get(MI->getAlignmentType(), 5219 Alignment, false)); 5220 return MI; 5221 } 5222 5223 // Extract the length and alignment and fill if they are constant. 5224 ConstantInt *LenC = dyn_cast<ConstantInt>(MI->getLength()); 5225 ConstantInt *FillC = dyn_cast<ConstantInt>(MI->getValue()); 5226 if (!LenC || !FillC || FillC->getType() != Type::getInt8Ty(MI->getContext())) 5227 return 0; 5228 uint64_t Len = LenC->getZExtValue(); 5229 Alignment = MI->getAlignment(); 5230 5231 // If the length is zero, this is a no-op 5232 if (Len == 0) return MI; // memset(d,c,0,a) -> noop 5233 5234 // memset(s,c,n) -> store s, c (for n=1,2,4,8) 5235 if (Len <= 8 && isPowerOf2_32((uint32_t)Len)) { 5236 const Type *ITy = IntegerType::get(MI->getContext(), Len*8); // n=1 -> i8. 5237 5238 Value *Dest = MI->getDest(); 5239 Dest = Builder->CreateBitCast(Dest, PointerType::getUnqual(ITy)); 5240 5241 // Alignment 0 is identity for alignment 1 for memset, but not store. 5242 if (Alignment == 0) Alignment = 1; 5243 5244 // Extract the fill value and store. 5245 uint64_t Fill = FillC->getZExtValue()*0x0101010101010101ULL; 5246 InsertNewInstBefore(new StoreInst(ConstantInt::get(ITy, Fill), 5247 Dest, false, Alignment), *MI); 5248 5249 // Set the size of the copy to 0, it will be deleted on the next iteration. 5250 MI->setLength(Constant::getNullValue(LenC->getType())); 5251 return MI; 5252 } 5253 5254 return 0; 5255} 5256 5257 5258/// visitCallInst - CallInst simplification. This mostly only handles folding 5259/// of intrinsic instructions. For normal calls, it allows visitCallSite to do 5260/// the heavy lifting. 5261/// 5262Instruction *InstCombiner::visitCallInst(CallInst &CI) { 5263 if (isFreeCall(&CI)) 5264 return visitFree(CI); 5265 5266 // If the caller function is nounwind, mark the call as nounwind, even if the 5267 // callee isn't. 5268 if (CI.getParent()->getParent()->doesNotThrow() && 5269 !CI.doesNotThrow()) { 5270 CI.setDoesNotThrow(); 5271 return &CI; 5272 } 5273 5274 IntrinsicInst *II = dyn_cast<IntrinsicInst>(&CI); 5275 if (!II) return visitCallSite(&CI); 5276 5277 // Intrinsics cannot occur in an invoke, so handle them here instead of in 5278 // visitCallSite. 5279 if (MemIntrinsic *MI = dyn_cast<MemIntrinsic>(II)) { 5280 bool Changed = false; 5281 5282 // memmove/cpy/set of zero bytes is a noop. 5283 if (Constant *NumBytes = dyn_cast<Constant>(MI->getLength())) { 5284 if (NumBytes->isNullValue()) return EraseInstFromFunction(CI); 5285 5286 if (ConstantInt *CI = dyn_cast<ConstantInt>(NumBytes)) 5287 if (CI->getZExtValue() == 1) { 5288 // Replace the instruction with just byte operations. We would 5289 // transform other cases to loads/stores, but we don't know if 5290 // alignment is sufficient. 5291 } 5292 } 5293 5294 // If we have a memmove and the source operation is a constant global, 5295 // then the source and dest pointers can't alias, so we can change this 5296 // into a call to memcpy. 5297 if (MemMoveInst *MMI = dyn_cast<MemMoveInst>(MI)) { 5298 if (GlobalVariable *GVSrc = dyn_cast<GlobalVariable>(MMI->getSource())) 5299 if (GVSrc->isConstant()) { 5300 Module *M = CI.getParent()->getParent()->getParent(); 5301 Intrinsic::ID MemCpyID = Intrinsic::memcpy; 5302 const Type *Tys[1]; 5303 Tys[0] = CI.getOperand(3)->getType(); 5304 CI.setOperand(0, 5305 Intrinsic::getDeclaration(M, MemCpyID, Tys, 1)); 5306 Changed = true; 5307 } 5308 } 5309 5310 if (MemTransferInst *MTI = dyn_cast<MemTransferInst>(MI)) { 5311 // memmove(x,x,size) -> noop. 5312 if (MTI->getSource() == MTI->getDest()) 5313 return EraseInstFromFunction(CI); 5314 } 5315 5316 // If we can determine a pointer alignment that is bigger than currently 5317 // set, update the alignment. 5318 if (isa<MemTransferInst>(MI)) { 5319 if (Instruction *I = SimplifyMemTransfer(MI)) 5320 return I; 5321 } else if (MemSetInst *MSI = dyn_cast<MemSetInst>(MI)) { 5322 if (Instruction *I = SimplifyMemSet(MSI)) 5323 return I; 5324 } 5325 5326 if (Changed) return II; 5327 } 5328 5329 switch (II->getIntrinsicID()) { 5330 default: break; 5331 case Intrinsic::bswap: 5332 // bswap(bswap(x)) -> x 5333 if (IntrinsicInst *Operand = dyn_cast<IntrinsicInst>(II->getOperand(1))) 5334 if (Operand->getIntrinsicID() == Intrinsic::bswap) 5335 return ReplaceInstUsesWith(CI, Operand->getOperand(1)); 5336 5337 // bswap(trunc(bswap(x))) -> trunc(lshr(x, c)) 5338 if (TruncInst *TI = dyn_cast<TruncInst>(II->getOperand(1))) { 5339 if (IntrinsicInst *Operand = dyn_cast<IntrinsicInst>(TI->getOperand(0))) 5340 if (Operand->getIntrinsicID() == Intrinsic::bswap) { 5341 unsigned C = Operand->getType()->getPrimitiveSizeInBits() - 5342 TI->getType()->getPrimitiveSizeInBits(); 5343 Value *CV = ConstantInt::get(Operand->getType(), C); 5344 Value *V = Builder->CreateLShr(Operand->getOperand(1), CV); 5345 return new TruncInst(V, TI->getType()); 5346 } 5347 } 5348 5349 break; 5350 case Intrinsic::powi: 5351 if (ConstantInt *Power = dyn_cast<ConstantInt>(II->getOperand(2))) { 5352 // powi(x, 0) -> 1.0 5353 if (Power->isZero()) 5354 return ReplaceInstUsesWith(CI, ConstantFP::get(CI.getType(), 1.0)); 5355 // powi(x, 1) -> x 5356 if (Power->isOne()) 5357 return ReplaceInstUsesWith(CI, II->getOperand(1)); 5358 // powi(x, -1) -> 1/x 5359 if (Power->isAllOnesValue()) 5360 return BinaryOperator::CreateFDiv(ConstantFP::get(CI.getType(), 1.0), 5361 II->getOperand(1)); 5362 } 5363 break; 5364 5365 case Intrinsic::uadd_with_overflow: { 5366 Value *LHS = II->getOperand(1), *RHS = II->getOperand(2); 5367 const IntegerType *IT = cast<IntegerType>(II->getOperand(1)->getType()); 5368 uint32_t BitWidth = IT->getBitWidth(); 5369 APInt Mask = APInt::getSignBit(BitWidth); 5370 APInt LHSKnownZero(BitWidth, 0); 5371 APInt LHSKnownOne(BitWidth, 0); 5372 ComputeMaskedBits(LHS, Mask, LHSKnownZero, LHSKnownOne); 5373 bool LHSKnownNegative = LHSKnownOne[BitWidth - 1]; 5374 bool LHSKnownPositive = LHSKnownZero[BitWidth - 1]; 5375 5376 if (LHSKnownNegative || LHSKnownPositive) { 5377 APInt RHSKnownZero(BitWidth, 0); 5378 APInt RHSKnownOne(BitWidth, 0); 5379 ComputeMaskedBits(RHS, Mask, RHSKnownZero, RHSKnownOne); 5380 bool RHSKnownNegative = RHSKnownOne[BitWidth - 1]; 5381 bool RHSKnownPositive = RHSKnownZero[BitWidth - 1]; 5382 if (LHSKnownNegative && RHSKnownNegative) { 5383 // The sign bit is set in both cases: this MUST overflow. 5384 // Create a simple add instruction, and insert it into the struct. 5385 Instruction *Add = BinaryOperator::CreateAdd(LHS, RHS, "", &CI); 5386 Worklist.Add(Add); 5387 Constant *V[] = { 5388 UndefValue::get(LHS->getType()),ConstantInt::getTrue(II->getContext()) 5389 }; 5390 Constant *Struct = ConstantStruct::get(II->getContext(), V, 2, false); 5391 return InsertValueInst::Create(Struct, Add, 0); 5392 } 5393 5394 if (LHSKnownPositive && RHSKnownPositive) { 5395 // The sign bit is clear in both cases: this CANNOT overflow. 5396 // Create a simple add instruction, and insert it into the struct. 5397 Instruction *Add = BinaryOperator::CreateNUWAdd(LHS, RHS, "", &CI); 5398 Worklist.Add(Add); 5399 Constant *V[] = { 5400 UndefValue::get(LHS->getType()), 5401 ConstantInt::getFalse(II->getContext()) 5402 }; 5403 Constant *Struct = ConstantStruct::get(II->getContext(), V, 2, false); 5404 return InsertValueInst::Create(Struct, Add, 0); 5405 } 5406 } 5407 } 5408 // FALL THROUGH uadd into sadd 5409 case Intrinsic::sadd_with_overflow: 5410 // Canonicalize constants into the RHS. 5411 if (isa<Constant>(II->getOperand(1)) && 5412 !isa<Constant>(II->getOperand(2))) { 5413 Value *LHS = II->getOperand(1); 5414 II->setOperand(1, II->getOperand(2)); 5415 II->setOperand(2, LHS); 5416 return II; 5417 } 5418 5419 // X + undef -> undef 5420 if (isa<UndefValue>(II->getOperand(2))) 5421 return ReplaceInstUsesWith(CI, UndefValue::get(II->getType())); 5422 5423 if (ConstantInt *RHS = dyn_cast<ConstantInt>(II->getOperand(2))) { 5424 // X + 0 -> {X, false} 5425 if (RHS->isZero()) { 5426 Constant *V[] = { 5427 UndefValue::get(II->getOperand(0)->getType()), 5428 ConstantInt::getFalse(II->getContext()) 5429 }; 5430 Constant *Struct = ConstantStruct::get(II->getContext(), V, 2, false); 5431 return InsertValueInst::Create(Struct, II->getOperand(1), 0); 5432 } 5433 } 5434 break; 5435 case Intrinsic::usub_with_overflow: 5436 case Intrinsic::ssub_with_overflow: 5437 // undef - X -> undef 5438 // X - undef -> undef 5439 if (isa<UndefValue>(II->getOperand(1)) || 5440 isa<UndefValue>(II->getOperand(2))) 5441 return ReplaceInstUsesWith(CI, UndefValue::get(II->getType())); 5442 5443 if (ConstantInt *RHS = dyn_cast<ConstantInt>(II->getOperand(2))) { 5444 // X - 0 -> {X, false} 5445 if (RHS->isZero()) { 5446 Constant *V[] = { 5447 UndefValue::get(II->getOperand(1)->getType()), 5448 ConstantInt::getFalse(II->getContext()) 5449 }; 5450 Constant *Struct = ConstantStruct::get(II->getContext(), V, 2, false); 5451 return InsertValueInst::Create(Struct, II->getOperand(1), 0); 5452 } 5453 } 5454 break; 5455 case Intrinsic::umul_with_overflow: 5456 case Intrinsic::smul_with_overflow: 5457 // Canonicalize constants into the RHS. 5458 if (isa<Constant>(II->getOperand(1)) && 5459 !isa<Constant>(II->getOperand(2))) { 5460 Value *LHS = II->getOperand(1); 5461 II->setOperand(1, II->getOperand(2)); 5462 II->setOperand(2, LHS); 5463 return II; 5464 } 5465 5466 // X * undef -> undef 5467 if (isa<UndefValue>(II->getOperand(2))) 5468 return ReplaceInstUsesWith(CI, UndefValue::get(II->getType())); 5469 5470 if (ConstantInt *RHSI = dyn_cast<ConstantInt>(II->getOperand(2))) { 5471 // X*0 -> {0, false} 5472 if (RHSI->isZero()) 5473 return ReplaceInstUsesWith(CI, Constant::getNullValue(II->getType())); 5474 5475 // X * 1 -> {X, false} 5476 if (RHSI->equalsInt(1)) { 5477 Constant *V[] = { 5478 UndefValue::get(II->getOperand(1)->getType()), 5479 ConstantInt::getFalse(II->getContext()) 5480 }; 5481 Constant *Struct = ConstantStruct::get(II->getContext(), V, 2, false); 5482 return InsertValueInst::Create(Struct, II->getOperand(1), 0); 5483 } 5484 } 5485 break; 5486 case Intrinsic::ppc_altivec_lvx: 5487 case Intrinsic::ppc_altivec_lvxl: 5488 case Intrinsic::x86_sse_loadu_ps: 5489 case Intrinsic::x86_sse2_loadu_pd: 5490 case Intrinsic::x86_sse2_loadu_dq: 5491 // Turn PPC lvx -> load if the pointer is known aligned. 5492 // Turn X86 loadups -> load if the pointer is known aligned. 5493 if (GetOrEnforceKnownAlignment(II->getOperand(1), 16) >= 16) { 5494 Value *Ptr = Builder->CreateBitCast(II->getOperand(1), 5495 PointerType::getUnqual(II->getType())); 5496 return new LoadInst(Ptr); 5497 } 5498 break; 5499 case Intrinsic::ppc_altivec_stvx: 5500 case Intrinsic::ppc_altivec_stvxl: 5501 // Turn stvx -> store if the pointer is known aligned. 5502 if (GetOrEnforceKnownAlignment(II->getOperand(2), 16) >= 16) { 5503 const Type *OpPtrTy = 5504 PointerType::getUnqual(II->getOperand(1)->getType()); 5505 Value *Ptr = Builder->CreateBitCast(II->getOperand(2), OpPtrTy); 5506 return new StoreInst(II->getOperand(1), Ptr); 5507 } 5508 break; 5509 case Intrinsic::x86_sse_storeu_ps: 5510 case Intrinsic::x86_sse2_storeu_pd: 5511 case Intrinsic::x86_sse2_storeu_dq: 5512 // Turn X86 storeu -> store if the pointer is known aligned. 5513 if (GetOrEnforceKnownAlignment(II->getOperand(1), 16) >= 16) { 5514 const Type *OpPtrTy = 5515 PointerType::getUnqual(II->getOperand(2)->getType()); 5516 Value *Ptr = Builder->CreateBitCast(II->getOperand(1), OpPtrTy); 5517 return new StoreInst(II->getOperand(2), Ptr); 5518 } 5519 break; 5520 5521 case Intrinsic::x86_sse_cvttss2si: { 5522 // These intrinsics only demands the 0th element of its input vector. If 5523 // we can simplify the input based on that, do so now. 5524 unsigned VWidth = 5525 cast<VectorType>(II->getOperand(1)->getType())->getNumElements(); 5526 APInt DemandedElts(VWidth, 1); 5527 APInt UndefElts(VWidth, 0); 5528 if (Value *V = SimplifyDemandedVectorElts(II->getOperand(1), DemandedElts, 5529 UndefElts)) { 5530 II->setOperand(1, V); 5531 return II; 5532 } 5533 break; 5534 } 5535 5536 case Intrinsic::ppc_altivec_vperm: 5537 // Turn vperm(V1,V2,mask) -> shuffle(V1,V2,mask) if mask is a constant. 5538 if (ConstantVector *Mask = dyn_cast<ConstantVector>(II->getOperand(3))) { 5539 assert(Mask->getNumOperands() == 16 && "Bad type for intrinsic!"); 5540 5541 // Check that all of the elements are integer constants or undefs. 5542 bool AllEltsOk = true; 5543 for (unsigned i = 0; i != 16; ++i) { 5544 if (!isa<ConstantInt>(Mask->getOperand(i)) && 5545 !isa<UndefValue>(Mask->getOperand(i))) { 5546 AllEltsOk = false; 5547 break; 5548 } 5549 } 5550 5551 if (AllEltsOk) { 5552 // Cast the input vectors to byte vectors. 5553 Value *Op0 = Builder->CreateBitCast(II->getOperand(1), Mask->getType()); 5554 Value *Op1 = Builder->CreateBitCast(II->getOperand(2), Mask->getType()); 5555 Value *Result = UndefValue::get(Op0->getType()); 5556 5557 // Only extract each element once. 5558 Value *ExtractedElts[32]; 5559 memset(ExtractedElts, 0, sizeof(ExtractedElts)); 5560 5561 for (unsigned i = 0; i != 16; ++i) { 5562 if (isa<UndefValue>(Mask->getOperand(i))) 5563 continue; 5564 unsigned Idx=cast<ConstantInt>(Mask->getOperand(i))->getZExtValue(); 5565 Idx &= 31; // Match the hardware behavior. 5566 5567 if (ExtractedElts[Idx] == 0) { 5568 ExtractedElts[Idx] = 5569 Builder->CreateExtractElement(Idx < 16 ? Op0 : Op1, 5570 ConstantInt::get(Type::getInt32Ty(II->getContext()), 5571 Idx&15, false), "tmp"); 5572 } 5573 5574 // Insert this value into the result vector. 5575 Result = Builder->CreateInsertElement(Result, ExtractedElts[Idx], 5576 ConstantInt::get(Type::getInt32Ty(II->getContext()), 5577 i, false), "tmp"); 5578 } 5579 return CastInst::Create(Instruction::BitCast, Result, CI.getType()); 5580 } 5581 } 5582 break; 5583 5584 case Intrinsic::stackrestore: { 5585 // If the save is right next to the restore, remove the restore. This can 5586 // happen when variable allocas are DCE'd. 5587 if (IntrinsicInst *SS = dyn_cast<IntrinsicInst>(II->getOperand(1))) { 5588 if (SS->getIntrinsicID() == Intrinsic::stacksave) { 5589 BasicBlock::iterator BI = SS; 5590 if (&*++BI == II) 5591 return EraseInstFromFunction(CI); 5592 } 5593 } 5594 5595 // Scan down this block to see if there is another stack restore in the 5596 // same block without an intervening call/alloca. 5597 BasicBlock::iterator BI = II; 5598 TerminatorInst *TI = II->getParent()->getTerminator(); 5599 bool CannotRemove = false; 5600 for (++BI; &*BI != TI; ++BI) { 5601 if (isa<AllocaInst>(BI) || isMalloc(BI)) { 5602 CannotRemove = true; 5603 break; 5604 } 5605 if (CallInst *BCI = dyn_cast<CallInst>(BI)) { 5606 if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(BCI)) { 5607 // If there is a stackrestore below this one, remove this one. 5608 if (II->getIntrinsicID() == Intrinsic::stackrestore) 5609 return EraseInstFromFunction(CI); 5610 // Otherwise, ignore the intrinsic. 5611 } else { 5612 // If we found a non-intrinsic call, we can't remove the stack 5613 // restore. 5614 CannotRemove = true; 5615 break; 5616 } 5617 } 5618 } 5619 5620 // If the stack restore is in a return/unwind block and if there are no 5621 // allocas or calls between the restore and the return, nuke the restore. 5622 if (!CannotRemove && (isa<ReturnInst>(TI) || isa<UnwindInst>(TI))) 5623 return EraseInstFromFunction(CI); 5624 break; 5625 } 5626 } 5627 5628 return visitCallSite(II); 5629} 5630 5631// InvokeInst simplification 5632// 5633Instruction *InstCombiner::visitInvokeInst(InvokeInst &II) { 5634 return visitCallSite(&II); 5635} 5636 5637/// isSafeToEliminateVarargsCast - If this cast does not affect the value 5638/// passed through the varargs area, we can eliminate the use of the cast. 5639static bool isSafeToEliminateVarargsCast(const CallSite CS, 5640 const CastInst * const CI, 5641 const TargetData * const TD, 5642 const int ix) { 5643 if (!CI->isLosslessCast()) 5644 return false; 5645 5646 // The size of ByVal arguments is derived from the type, so we 5647 // can't change to a type with a different size. If the size were 5648 // passed explicitly we could avoid this check. 5649 if (!CS.paramHasAttr(ix, Attribute::ByVal)) 5650 return true; 5651 5652 const Type* SrcTy = 5653 cast<PointerType>(CI->getOperand(0)->getType())->getElementType(); 5654 const Type* DstTy = cast<PointerType>(CI->getType())->getElementType(); 5655 if (!SrcTy->isSized() || !DstTy->isSized()) 5656 return false; 5657 if (!TD || TD->getTypeAllocSize(SrcTy) != TD->getTypeAllocSize(DstTy)) 5658 return false; 5659 return true; 5660} 5661 5662// visitCallSite - Improvements for call and invoke instructions. 5663// 5664Instruction *InstCombiner::visitCallSite(CallSite CS) { 5665 bool Changed = false; 5666 5667 // If the callee is a constexpr cast of a function, attempt to move the cast 5668 // to the arguments of the call/invoke. 5669 if (transformConstExprCastCall(CS)) return 0; 5670 5671 Value *Callee = CS.getCalledValue(); 5672 5673 if (Function *CalleeF = dyn_cast<Function>(Callee)) 5674 if (CalleeF->getCallingConv() != CS.getCallingConv()) { 5675 Instruction *OldCall = CS.getInstruction(); 5676 // If the call and callee calling conventions don't match, this call must 5677 // be unreachable, as the call is undefined. 5678 new StoreInst(ConstantInt::getTrue(Callee->getContext()), 5679 UndefValue::get(Type::getInt1PtrTy(Callee->getContext())), 5680 OldCall); 5681 // If OldCall dues not return void then replaceAllUsesWith undef. 5682 // This allows ValueHandlers and custom metadata to adjust itself. 5683 if (!OldCall->getType()->isVoidTy()) 5684 OldCall->replaceAllUsesWith(UndefValue::get(OldCall->getType())); 5685 if (isa<CallInst>(OldCall)) // Not worth removing an invoke here. 5686 return EraseInstFromFunction(*OldCall); 5687 return 0; 5688 } 5689 5690 if (isa<ConstantPointerNull>(Callee) || isa<UndefValue>(Callee)) { 5691 // This instruction is not reachable, just remove it. We insert a store to 5692 // undef so that we know that this code is not reachable, despite the fact 5693 // that we can't modify the CFG here. 5694 new StoreInst(ConstantInt::getTrue(Callee->getContext()), 5695 UndefValue::get(Type::getInt1PtrTy(Callee->getContext())), 5696 CS.getInstruction()); 5697 5698 // If CS dues not return void then replaceAllUsesWith undef. 5699 // This allows ValueHandlers and custom metadata to adjust itself. 5700 if (!CS.getInstruction()->getType()->isVoidTy()) 5701 CS.getInstruction()-> 5702 replaceAllUsesWith(UndefValue::get(CS.getInstruction()->getType())); 5703 5704 if (InvokeInst *II = dyn_cast<InvokeInst>(CS.getInstruction())) { 5705 // Don't break the CFG, insert a dummy cond branch. 5706 BranchInst::Create(II->getNormalDest(), II->getUnwindDest(), 5707 ConstantInt::getTrue(Callee->getContext()), II); 5708 } 5709 return EraseInstFromFunction(*CS.getInstruction()); 5710 } 5711 5712 if (BitCastInst *BC = dyn_cast<BitCastInst>(Callee)) 5713 if (IntrinsicInst *In = dyn_cast<IntrinsicInst>(BC->getOperand(0))) 5714 if (In->getIntrinsicID() == Intrinsic::init_trampoline) 5715 return transformCallThroughTrampoline(CS); 5716 5717 const PointerType *PTy = cast<PointerType>(Callee->getType()); 5718 const FunctionType *FTy = cast<FunctionType>(PTy->getElementType()); 5719 if (FTy->isVarArg()) { 5720 int ix = FTy->getNumParams() + (isa<InvokeInst>(Callee) ? 3 : 1); 5721 // See if we can optimize any arguments passed through the varargs area of 5722 // the call. 5723 for (CallSite::arg_iterator I = CS.arg_begin()+FTy->getNumParams(), 5724 E = CS.arg_end(); I != E; ++I, ++ix) { 5725 CastInst *CI = dyn_cast<CastInst>(*I); 5726 if (CI && isSafeToEliminateVarargsCast(CS, CI, TD, ix)) { 5727 *I = CI->getOperand(0); 5728 Changed = true; 5729 } 5730 } 5731 } 5732 5733 if (isa<InlineAsm>(Callee) && !CS.doesNotThrow()) { 5734 // Inline asm calls cannot throw - mark them 'nounwind'. 5735 CS.setDoesNotThrow(); 5736 Changed = true; 5737 } 5738 5739 return Changed ? CS.getInstruction() : 0; 5740} 5741 5742// transformConstExprCastCall - If the callee is a constexpr cast of a function, 5743// attempt to move the cast to the arguments of the call/invoke. 5744// 5745bool InstCombiner::transformConstExprCastCall(CallSite CS) { 5746 if (!isa<ConstantExpr>(CS.getCalledValue())) return false; 5747 ConstantExpr *CE = cast<ConstantExpr>(CS.getCalledValue()); 5748 if (CE->getOpcode() != Instruction::BitCast || 5749 !isa<Function>(CE->getOperand(0))) 5750 return false; 5751 Function *Callee = cast<Function>(CE->getOperand(0)); 5752 Instruction *Caller = CS.getInstruction(); 5753 const AttrListPtr &CallerPAL = CS.getAttributes(); 5754 5755 // Okay, this is a cast from a function to a different type. Unless doing so 5756 // would cause a type conversion of one of our arguments, change this call to 5757 // be a direct call with arguments casted to the appropriate types. 5758 // 5759 const FunctionType *FT = Callee->getFunctionType(); 5760 const Type *OldRetTy = Caller->getType(); 5761 const Type *NewRetTy = FT->getReturnType(); 5762 5763 if (isa<StructType>(NewRetTy)) 5764 return false; // TODO: Handle multiple return values. 5765 5766 // Check to see if we are changing the return type... 5767 if (OldRetTy != NewRetTy) { 5768 if (Callee->isDeclaration() && 5769 // Conversion is ok if changing from one pointer type to another or from 5770 // a pointer to an integer of the same size. 5771 !((isa<PointerType>(OldRetTy) || !TD || 5772 OldRetTy == TD->getIntPtrType(Caller->getContext())) && 5773 (isa<PointerType>(NewRetTy) || !TD || 5774 NewRetTy == TD->getIntPtrType(Caller->getContext())))) 5775 return false; // Cannot transform this return value. 5776 5777 if (!Caller->use_empty() && 5778 // void -> non-void is handled specially 5779 !NewRetTy->isVoidTy() && !CastInst::isCastable(NewRetTy, OldRetTy)) 5780 return false; // Cannot transform this return value. 5781 5782 if (!CallerPAL.isEmpty() && !Caller->use_empty()) { 5783 Attributes RAttrs = CallerPAL.getRetAttributes(); 5784 if (RAttrs & Attribute::typeIncompatible(NewRetTy)) 5785 return false; // Attribute not compatible with transformed value. 5786 } 5787 5788 // If the callsite is an invoke instruction, and the return value is used by 5789 // a PHI node in a successor, we cannot change the return type of the call 5790 // because there is no place to put the cast instruction (without breaking 5791 // the critical edge). Bail out in this case. 5792 if (!Caller->use_empty()) 5793 if (InvokeInst *II = dyn_cast<InvokeInst>(Caller)) 5794 for (Value::use_iterator UI = II->use_begin(), E = II->use_end(); 5795 UI != E; ++UI) 5796 if (PHINode *PN = dyn_cast<PHINode>(*UI)) 5797 if (PN->getParent() == II->getNormalDest() || 5798 PN->getParent() == II->getUnwindDest()) 5799 return false; 5800 } 5801 5802 unsigned NumActualArgs = unsigned(CS.arg_end()-CS.arg_begin()); 5803 unsigned NumCommonArgs = std::min(FT->getNumParams(), NumActualArgs); 5804 5805 CallSite::arg_iterator AI = CS.arg_begin(); 5806 for (unsigned i = 0, e = NumCommonArgs; i != e; ++i, ++AI) { 5807 const Type *ParamTy = FT->getParamType(i); 5808 const Type *ActTy = (*AI)->getType(); 5809 5810 if (!CastInst::isCastable(ActTy, ParamTy)) 5811 return false; // Cannot transform this parameter value. 5812 5813 if (CallerPAL.getParamAttributes(i + 1) 5814 & Attribute::typeIncompatible(ParamTy)) 5815 return false; // Attribute not compatible with transformed value. 5816 5817 // Converting from one pointer type to another or between a pointer and an 5818 // integer of the same size is safe even if we do not have a body. 5819 bool isConvertible = ActTy == ParamTy || 5820 (TD && ((isa<PointerType>(ParamTy) || 5821 ParamTy == TD->getIntPtrType(Caller->getContext())) && 5822 (isa<PointerType>(ActTy) || 5823 ActTy == TD->getIntPtrType(Caller->getContext())))); 5824 if (Callee->isDeclaration() && !isConvertible) return false; 5825 } 5826 5827 if (FT->getNumParams() < NumActualArgs && !FT->isVarArg() && 5828 Callee->isDeclaration()) 5829 return false; // Do not delete arguments unless we have a function body. 5830 5831 if (FT->getNumParams() < NumActualArgs && FT->isVarArg() && 5832 !CallerPAL.isEmpty()) 5833 // In this case we have more arguments than the new function type, but we 5834 // won't be dropping them. Check that these extra arguments have attributes 5835 // that are compatible with being a vararg call argument. 5836 for (unsigned i = CallerPAL.getNumSlots(); i; --i) { 5837 if (CallerPAL.getSlot(i - 1).Index <= FT->getNumParams()) 5838 break; 5839 Attributes PAttrs = CallerPAL.getSlot(i - 1).Attrs; 5840 if (PAttrs & Attribute::VarArgsIncompatible) 5841 return false; 5842 } 5843 5844 // Okay, we decided that this is a safe thing to do: go ahead and start 5845 // inserting cast instructions as necessary... 5846 std::vector<Value*> Args; 5847 Args.reserve(NumActualArgs); 5848 SmallVector<AttributeWithIndex, 8> attrVec; 5849 attrVec.reserve(NumCommonArgs); 5850 5851 // Get any return attributes. 5852 Attributes RAttrs = CallerPAL.getRetAttributes(); 5853 5854 // If the return value is not being used, the type may not be compatible 5855 // with the existing attributes. Wipe out any problematic attributes. 5856 RAttrs &= ~Attribute::typeIncompatible(NewRetTy); 5857 5858 // Add the new return attributes. 5859 if (RAttrs) 5860 attrVec.push_back(AttributeWithIndex::get(0, RAttrs)); 5861 5862 AI = CS.arg_begin(); 5863 for (unsigned i = 0; i != NumCommonArgs; ++i, ++AI) { 5864 const Type *ParamTy = FT->getParamType(i); 5865 if ((*AI)->getType() == ParamTy) { 5866 Args.push_back(*AI); 5867 } else { 5868 Instruction::CastOps opcode = CastInst::getCastOpcode(*AI, 5869 false, ParamTy, false); 5870 Args.push_back(Builder->CreateCast(opcode, *AI, ParamTy, "tmp")); 5871 } 5872 5873 // Add any parameter attributes. 5874 if (Attributes PAttrs = CallerPAL.getParamAttributes(i + 1)) 5875 attrVec.push_back(AttributeWithIndex::get(i + 1, PAttrs)); 5876 } 5877 5878 // If the function takes more arguments than the call was taking, add them 5879 // now. 5880 for (unsigned i = NumCommonArgs; i != FT->getNumParams(); ++i) 5881 Args.push_back(Constant::getNullValue(FT->getParamType(i))); 5882 5883 // If we are removing arguments to the function, emit an obnoxious warning. 5884 if (FT->getNumParams() < NumActualArgs) { 5885 if (!FT->isVarArg()) { 5886 errs() << "WARNING: While resolving call to function '" 5887 << Callee->getName() << "' arguments were dropped!\n"; 5888 } else { 5889 // Add all of the arguments in their promoted form to the arg list. 5890 for (unsigned i = FT->getNumParams(); i != NumActualArgs; ++i, ++AI) { 5891 const Type *PTy = getPromotedType((*AI)->getType()); 5892 if (PTy != (*AI)->getType()) { 5893 // Must promote to pass through va_arg area! 5894 Instruction::CastOps opcode = 5895 CastInst::getCastOpcode(*AI, false, PTy, false); 5896 Args.push_back(Builder->CreateCast(opcode, *AI, PTy, "tmp")); 5897 } else { 5898 Args.push_back(*AI); 5899 } 5900 5901 // Add any parameter attributes. 5902 if (Attributes PAttrs = CallerPAL.getParamAttributes(i + 1)) 5903 attrVec.push_back(AttributeWithIndex::get(i + 1, PAttrs)); 5904 } 5905 } 5906 } 5907 5908 if (Attributes FnAttrs = CallerPAL.getFnAttributes()) 5909 attrVec.push_back(AttributeWithIndex::get(~0, FnAttrs)); 5910 5911 if (NewRetTy->isVoidTy()) 5912 Caller->setName(""); // Void type should not have a name. 5913 5914 const AttrListPtr &NewCallerPAL = AttrListPtr::get(attrVec.begin(), 5915 attrVec.end()); 5916 5917 Instruction *NC; 5918 if (InvokeInst *II = dyn_cast<InvokeInst>(Caller)) { 5919 NC = InvokeInst::Create(Callee, II->getNormalDest(), II->getUnwindDest(), 5920 Args.begin(), Args.end(), 5921 Caller->getName(), Caller); 5922 cast<InvokeInst>(NC)->setCallingConv(II->getCallingConv()); 5923 cast<InvokeInst>(NC)->setAttributes(NewCallerPAL); 5924 } else { 5925 NC = CallInst::Create(Callee, Args.begin(), Args.end(), 5926 Caller->getName(), Caller); 5927 CallInst *CI = cast<CallInst>(Caller); 5928 if (CI->isTailCall()) 5929 cast<CallInst>(NC)->setTailCall(); 5930 cast<CallInst>(NC)->setCallingConv(CI->getCallingConv()); 5931 cast<CallInst>(NC)->setAttributes(NewCallerPAL); 5932 } 5933 5934 // Insert a cast of the return type as necessary. 5935 Value *NV = NC; 5936 if (OldRetTy != NV->getType() && !Caller->use_empty()) { 5937 if (!NV->getType()->isVoidTy()) { 5938 Instruction::CastOps opcode = CastInst::getCastOpcode(NC, false, 5939 OldRetTy, false); 5940 NV = NC = CastInst::Create(opcode, NC, OldRetTy, "tmp"); 5941 5942 // If this is an invoke instruction, we should insert it after the first 5943 // non-phi, instruction in the normal successor block. 5944 if (InvokeInst *II = dyn_cast<InvokeInst>(Caller)) { 5945 BasicBlock::iterator I = II->getNormalDest()->getFirstNonPHI(); 5946 InsertNewInstBefore(NC, *I); 5947 } else { 5948 // Otherwise, it's a call, just insert cast right after the call instr 5949 InsertNewInstBefore(NC, *Caller); 5950 } 5951 Worklist.AddUsersToWorkList(*Caller); 5952 } else { 5953 NV = UndefValue::get(Caller->getType()); 5954 } 5955 } 5956 5957 5958 if (!Caller->use_empty()) 5959 Caller->replaceAllUsesWith(NV); 5960 5961 EraseInstFromFunction(*Caller); 5962 return true; 5963} 5964 5965// transformCallThroughTrampoline - Turn a call to a function created by the 5966// init_trampoline intrinsic into a direct call to the underlying function. 5967// 5968Instruction *InstCombiner::transformCallThroughTrampoline(CallSite CS) { 5969 Value *Callee = CS.getCalledValue(); 5970 const PointerType *PTy = cast<PointerType>(Callee->getType()); 5971 const FunctionType *FTy = cast<FunctionType>(PTy->getElementType()); 5972 const AttrListPtr &Attrs = CS.getAttributes(); 5973 5974 // If the call already has the 'nest' attribute somewhere then give up - 5975 // otherwise 'nest' would occur twice after splicing in the chain. 5976 if (Attrs.hasAttrSomewhere(Attribute::Nest)) 5977 return 0; 5978 5979 IntrinsicInst *Tramp = 5980 cast<IntrinsicInst>(cast<BitCastInst>(Callee)->getOperand(0)); 5981 5982 Function *NestF = cast<Function>(Tramp->getOperand(2)->stripPointerCasts()); 5983 const PointerType *NestFPTy = cast<PointerType>(NestF->getType()); 5984 const FunctionType *NestFTy = cast<FunctionType>(NestFPTy->getElementType()); 5985 5986 const AttrListPtr &NestAttrs = NestF->getAttributes(); 5987 if (!NestAttrs.isEmpty()) { 5988 unsigned NestIdx = 1; 5989 const Type *NestTy = 0; 5990 Attributes NestAttr = Attribute::None; 5991 5992 // Look for a parameter marked with the 'nest' attribute. 5993 for (FunctionType::param_iterator I = NestFTy->param_begin(), 5994 E = NestFTy->param_end(); I != E; ++NestIdx, ++I) 5995 if (NestAttrs.paramHasAttr(NestIdx, Attribute::Nest)) { 5996 // Record the parameter type and any other attributes. 5997 NestTy = *I; 5998 NestAttr = NestAttrs.getParamAttributes(NestIdx); 5999 break; 6000 } 6001 6002 if (NestTy) { 6003 Instruction *Caller = CS.getInstruction(); 6004 std::vector<Value*> NewArgs; 6005 NewArgs.reserve(unsigned(CS.arg_end()-CS.arg_begin())+1); 6006 6007 SmallVector<AttributeWithIndex, 8> NewAttrs; 6008 NewAttrs.reserve(Attrs.getNumSlots() + 1); 6009 6010 // Insert the nest argument into the call argument list, which may 6011 // mean appending it. Likewise for attributes. 6012 6013 // Add any result attributes. 6014 if (Attributes Attr = Attrs.getRetAttributes()) 6015 NewAttrs.push_back(AttributeWithIndex::get(0, Attr)); 6016 6017 { 6018 unsigned Idx = 1; 6019 CallSite::arg_iterator I = CS.arg_begin(), E = CS.arg_end(); 6020 do { 6021 if (Idx == NestIdx) { 6022 // Add the chain argument and attributes. 6023 Value *NestVal = Tramp->getOperand(3); 6024 if (NestVal->getType() != NestTy) 6025 NestVal = new BitCastInst(NestVal, NestTy, "nest", Caller); 6026 NewArgs.push_back(NestVal); 6027 NewAttrs.push_back(AttributeWithIndex::get(NestIdx, NestAttr)); 6028 } 6029 6030 if (I == E) 6031 break; 6032 6033 // Add the original argument and attributes. 6034 NewArgs.push_back(*I); 6035 if (Attributes Attr = Attrs.getParamAttributes(Idx)) 6036 NewAttrs.push_back 6037 (AttributeWithIndex::get(Idx + (Idx >= NestIdx), Attr)); 6038 6039 ++Idx, ++I; 6040 } while (1); 6041 } 6042 6043 // Add any function attributes. 6044 if (Attributes Attr = Attrs.getFnAttributes()) 6045 NewAttrs.push_back(AttributeWithIndex::get(~0, Attr)); 6046 6047 // The trampoline may have been bitcast to a bogus type (FTy). 6048 // Handle this by synthesizing a new function type, equal to FTy 6049 // with the chain parameter inserted. 6050 6051 std::vector<const Type*> NewTypes; 6052 NewTypes.reserve(FTy->getNumParams()+1); 6053 6054 // Insert the chain's type into the list of parameter types, which may 6055 // mean appending it. 6056 { 6057 unsigned Idx = 1; 6058 FunctionType::param_iterator I = FTy->param_begin(), 6059 E = FTy->param_end(); 6060 6061 do { 6062 if (Idx == NestIdx) 6063 // Add the chain's type. 6064 NewTypes.push_back(NestTy); 6065 6066 if (I == E) 6067 break; 6068 6069 // Add the original type. 6070 NewTypes.push_back(*I); 6071 6072 ++Idx, ++I; 6073 } while (1); 6074 } 6075 6076 // Replace the trampoline call with a direct call. Let the generic 6077 // code sort out any function type mismatches. 6078 FunctionType *NewFTy = FunctionType::get(FTy->getReturnType(), NewTypes, 6079 FTy->isVarArg()); 6080 Constant *NewCallee = 6081 NestF->getType() == PointerType::getUnqual(NewFTy) ? 6082 NestF : ConstantExpr::getBitCast(NestF, 6083 PointerType::getUnqual(NewFTy)); 6084 const AttrListPtr &NewPAL = AttrListPtr::get(NewAttrs.begin(), 6085 NewAttrs.end()); 6086 6087 Instruction *NewCaller; 6088 if (InvokeInst *II = dyn_cast<InvokeInst>(Caller)) { 6089 NewCaller = InvokeInst::Create(NewCallee, 6090 II->getNormalDest(), II->getUnwindDest(), 6091 NewArgs.begin(), NewArgs.end(), 6092 Caller->getName(), Caller); 6093 cast<InvokeInst>(NewCaller)->setCallingConv(II->getCallingConv()); 6094 cast<InvokeInst>(NewCaller)->setAttributes(NewPAL); 6095 } else { 6096 NewCaller = CallInst::Create(NewCallee, NewArgs.begin(), NewArgs.end(), 6097 Caller->getName(), Caller); 6098 if (cast<CallInst>(Caller)->isTailCall()) 6099 cast<CallInst>(NewCaller)->setTailCall(); 6100 cast<CallInst>(NewCaller)-> 6101 setCallingConv(cast<CallInst>(Caller)->getCallingConv()); 6102 cast<CallInst>(NewCaller)->setAttributes(NewPAL); 6103 } 6104 if (!Caller->getType()->isVoidTy()) 6105 Caller->replaceAllUsesWith(NewCaller); 6106 Caller->eraseFromParent(); 6107 Worklist.Remove(Caller); 6108 return 0; 6109 } 6110 } 6111 6112 // Replace the trampoline call with a direct call. Since there is no 'nest' 6113 // parameter, there is no need to adjust the argument list. Let the generic 6114 // code sort out any function type mismatches. 6115 Constant *NewCallee = 6116 NestF->getType() == PTy ? NestF : 6117 ConstantExpr::getBitCast(NestF, PTy); 6118 CS.setCalledFunction(NewCallee); 6119 return CS.getInstruction(); 6120} 6121 6122 6123 6124Instruction *InstCombiner::visitGetElementPtrInst(GetElementPtrInst &GEP) { 6125 SmallVector<Value*, 8> Ops(GEP.op_begin(), GEP.op_end()); 6126 6127 if (Value *V = SimplifyGEPInst(&Ops[0], Ops.size(), TD)) 6128 return ReplaceInstUsesWith(GEP, V); 6129 6130 Value *PtrOp = GEP.getOperand(0); 6131 6132 if (isa<UndefValue>(GEP.getOperand(0))) 6133 return ReplaceInstUsesWith(GEP, UndefValue::get(GEP.getType())); 6134 6135 // Eliminate unneeded casts for indices. 6136 if (TD) { 6137 bool MadeChange = false; 6138 unsigned PtrSize = TD->getPointerSizeInBits(); 6139 6140 gep_type_iterator GTI = gep_type_begin(GEP); 6141 for (User::op_iterator I = GEP.op_begin() + 1, E = GEP.op_end(); 6142 I != E; ++I, ++GTI) { 6143 if (!isa<SequentialType>(*GTI)) continue; 6144 6145 // If we are using a wider index than needed for this platform, shrink it 6146 // to what we need. If narrower, sign-extend it to what we need. This 6147 // explicit cast can make subsequent optimizations more obvious. 6148 unsigned OpBits = cast<IntegerType>((*I)->getType())->getBitWidth(); 6149 if (OpBits == PtrSize) 6150 continue; 6151 6152 *I = Builder->CreateIntCast(*I, TD->getIntPtrType(GEP.getContext()),true); 6153 MadeChange = true; 6154 } 6155 if (MadeChange) return &GEP; 6156 } 6157 6158 // Combine Indices - If the source pointer to this getelementptr instruction 6159 // is a getelementptr instruction, combine the indices of the two 6160 // getelementptr instructions into a single instruction. 6161 // 6162 if (GEPOperator *Src = dyn_cast<GEPOperator>(PtrOp)) { 6163 // Note that if our source is a gep chain itself that we wait for that 6164 // chain to be resolved before we perform this transformation. This 6165 // avoids us creating a TON of code in some cases. 6166 // 6167 if (GetElementPtrInst *SrcGEP = 6168 dyn_cast<GetElementPtrInst>(Src->getOperand(0))) 6169 if (SrcGEP->getNumOperands() == 2) 6170 return 0; // Wait until our source is folded to completion. 6171 6172 SmallVector<Value*, 8> Indices; 6173 6174 // Find out whether the last index in the source GEP is a sequential idx. 6175 bool EndsWithSequential = false; 6176 for (gep_type_iterator I = gep_type_begin(*Src), E = gep_type_end(*Src); 6177 I != E; ++I) 6178 EndsWithSequential = !isa<StructType>(*I); 6179 6180 // Can we combine the two pointer arithmetics offsets? 6181 if (EndsWithSequential) { 6182 // Replace: gep (gep %P, long B), long A, ... 6183 // With: T = long A+B; gep %P, T, ... 6184 // 6185 Value *Sum; 6186 Value *SO1 = Src->getOperand(Src->getNumOperands()-1); 6187 Value *GO1 = GEP.getOperand(1); 6188 if (SO1 == Constant::getNullValue(SO1->getType())) { 6189 Sum = GO1; 6190 } else if (GO1 == Constant::getNullValue(GO1->getType())) { 6191 Sum = SO1; 6192 } else { 6193 // If they aren't the same type, then the input hasn't been processed 6194 // by the loop above yet (which canonicalizes sequential index types to 6195 // intptr_t). Just avoid transforming this until the input has been 6196 // normalized. 6197 if (SO1->getType() != GO1->getType()) 6198 return 0; 6199 Sum = Builder->CreateAdd(SO1, GO1, PtrOp->getName()+".sum"); 6200 } 6201 6202 // Update the GEP in place if possible. 6203 if (Src->getNumOperands() == 2) { 6204 GEP.setOperand(0, Src->getOperand(0)); 6205 GEP.setOperand(1, Sum); 6206 return &GEP; 6207 } 6208 Indices.append(Src->op_begin()+1, Src->op_end()-1); 6209 Indices.push_back(Sum); 6210 Indices.append(GEP.op_begin()+2, GEP.op_end()); 6211 } else if (isa<Constant>(*GEP.idx_begin()) && 6212 cast<Constant>(*GEP.idx_begin())->isNullValue() && 6213 Src->getNumOperands() != 1) { 6214 // Otherwise we can do the fold if the first index of the GEP is a zero 6215 Indices.append(Src->op_begin()+1, Src->op_end()); 6216 Indices.append(GEP.idx_begin()+1, GEP.idx_end()); 6217 } 6218 6219 if (!Indices.empty()) 6220 return (cast<GEPOperator>(&GEP)->isInBounds() && 6221 Src->isInBounds()) ? 6222 GetElementPtrInst::CreateInBounds(Src->getOperand(0), Indices.begin(), 6223 Indices.end(), GEP.getName()) : 6224 GetElementPtrInst::Create(Src->getOperand(0), Indices.begin(), 6225 Indices.end(), GEP.getName()); 6226 } 6227 6228 // Handle gep(bitcast x) and gep(gep x, 0, 0, 0). 6229 if (Value *X = getBitCastOperand(PtrOp)) { 6230 assert(isa<PointerType>(X->getType()) && "Must be cast from pointer"); 6231 6232 // If the input bitcast is actually "bitcast(bitcast(x))", then we don't 6233 // want to change the gep until the bitcasts are eliminated. 6234 if (getBitCastOperand(X)) { 6235 Worklist.AddValue(PtrOp); 6236 return 0; 6237 } 6238 6239 bool HasZeroPointerIndex = false; 6240 if (ConstantInt *C = dyn_cast<ConstantInt>(GEP.getOperand(1))) 6241 HasZeroPointerIndex = C->isZero(); 6242 6243 // Transform: GEP (bitcast [10 x i8]* X to [0 x i8]*), i32 0, ... 6244 // into : GEP [10 x i8]* X, i32 0, ... 6245 // 6246 // Likewise, transform: GEP (bitcast i8* X to [0 x i8]*), i32 0, ... 6247 // into : GEP i8* X, ... 6248 // 6249 // This occurs when the program declares an array extern like "int X[];" 6250 if (HasZeroPointerIndex) { 6251 const PointerType *CPTy = cast<PointerType>(PtrOp->getType()); 6252 const PointerType *XTy = cast<PointerType>(X->getType()); 6253 if (const ArrayType *CATy = 6254 dyn_cast<ArrayType>(CPTy->getElementType())) { 6255 // GEP (bitcast i8* X to [0 x i8]*), i32 0, ... ? 6256 if (CATy->getElementType() == XTy->getElementType()) { 6257 // -> GEP i8* X, ... 6258 SmallVector<Value*, 8> Indices(GEP.idx_begin()+1, GEP.idx_end()); 6259 return cast<GEPOperator>(&GEP)->isInBounds() ? 6260 GetElementPtrInst::CreateInBounds(X, Indices.begin(), Indices.end(), 6261 GEP.getName()) : 6262 GetElementPtrInst::Create(X, Indices.begin(), Indices.end(), 6263 GEP.getName()); 6264 } 6265 6266 if (const ArrayType *XATy = dyn_cast<ArrayType>(XTy->getElementType())){ 6267 // GEP (bitcast [10 x i8]* X to [0 x i8]*), i32 0, ... ? 6268 if (CATy->getElementType() == XATy->getElementType()) { 6269 // -> GEP [10 x i8]* X, i32 0, ... 6270 // At this point, we know that the cast source type is a pointer 6271 // to an array of the same type as the destination pointer 6272 // array. Because the array type is never stepped over (there 6273 // is a leading zero) we can fold the cast into this GEP. 6274 GEP.setOperand(0, X); 6275 return &GEP; 6276 } 6277 } 6278 } 6279 } else if (GEP.getNumOperands() == 2) { 6280 // Transform things like: 6281 // %t = getelementptr i32* bitcast ([2 x i32]* %str to i32*), i32 %V 6282 // into: %t1 = getelementptr [2 x i32]* %str, i32 0, i32 %V; bitcast 6283 const Type *SrcElTy = cast<PointerType>(X->getType())->getElementType(); 6284 const Type *ResElTy=cast<PointerType>(PtrOp->getType())->getElementType(); 6285 if (TD && isa<ArrayType>(SrcElTy) && 6286 TD->getTypeAllocSize(cast<ArrayType>(SrcElTy)->getElementType()) == 6287 TD->getTypeAllocSize(ResElTy)) { 6288 Value *Idx[2]; 6289 Idx[0] = Constant::getNullValue(Type::getInt32Ty(GEP.getContext())); 6290 Idx[1] = GEP.getOperand(1); 6291 Value *NewGEP = cast<GEPOperator>(&GEP)->isInBounds() ? 6292 Builder->CreateInBoundsGEP(X, Idx, Idx + 2, GEP.getName()) : 6293 Builder->CreateGEP(X, Idx, Idx + 2, GEP.getName()); 6294 // V and GEP are both pointer types --> BitCast 6295 return new BitCastInst(NewGEP, GEP.getType()); 6296 } 6297 6298 // Transform things like: 6299 // getelementptr i8* bitcast ([100 x double]* X to i8*), i32 %tmp 6300 // (where tmp = 8*tmp2) into: 6301 // getelementptr [100 x double]* %arr, i32 0, i32 %tmp2; bitcast 6302 6303 if (TD && isa<ArrayType>(SrcElTy) && 6304 ResElTy == Type::getInt8Ty(GEP.getContext())) { 6305 uint64_t ArrayEltSize = 6306 TD->getTypeAllocSize(cast<ArrayType>(SrcElTy)->getElementType()); 6307 6308 // Check to see if "tmp" is a scale by a multiple of ArrayEltSize. We 6309 // allow either a mul, shift, or constant here. 6310 Value *NewIdx = 0; 6311 ConstantInt *Scale = 0; 6312 if (ArrayEltSize == 1) { 6313 NewIdx = GEP.getOperand(1); 6314 Scale = ConstantInt::get(cast<IntegerType>(NewIdx->getType()), 1); 6315 } else if (ConstantInt *CI = dyn_cast<ConstantInt>(GEP.getOperand(1))) { 6316 NewIdx = ConstantInt::get(CI->getType(), 1); 6317 Scale = CI; 6318 } else if (Instruction *Inst =dyn_cast<Instruction>(GEP.getOperand(1))){ 6319 if (Inst->getOpcode() == Instruction::Shl && 6320 isa<ConstantInt>(Inst->getOperand(1))) { 6321 ConstantInt *ShAmt = cast<ConstantInt>(Inst->getOperand(1)); 6322 uint32_t ShAmtVal = ShAmt->getLimitedValue(64); 6323 Scale = ConstantInt::get(cast<IntegerType>(Inst->getType()), 6324 1ULL << ShAmtVal); 6325 NewIdx = Inst->getOperand(0); 6326 } else if (Inst->getOpcode() == Instruction::Mul && 6327 isa<ConstantInt>(Inst->getOperand(1))) { 6328 Scale = cast<ConstantInt>(Inst->getOperand(1)); 6329 NewIdx = Inst->getOperand(0); 6330 } 6331 } 6332 6333 // If the index will be to exactly the right offset with the scale taken 6334 // out, perform the transformation. Note, we don't know whether Scale is 6335 // signed or not. We'll use unsigned version of division/modulo 6336 // operation after making sure Scale doesn't have the sign bit set. 6337 if (ArrayEltSize && Scale && Scale->getSExtValue() >= 0LL && 6338 Scale->getZExtValue() % ArrayEltSize == 0) { 6339 Scale = ConstantInt::get(Scale->getType(), 6340 Scale->getZExtValue() / ArrayEltSize); 6341 if (Scale->getZExtValue() != 1) { 6342 Constant *C = ConstantExpr::getIntegerCast(Scale, NewIdx->getType(), 6343 false /*ZExt*/); 6344 NewIdx = Builder->CreateMul(NewIdx, C, "idxscale"); 6345 } 6346 6347 // Insert the new GEP instruction. 6348 Value *Idx[2]; 6349 Idx[0] = Constant::getNullValue(Type::getInt32Ty(GEP.getContext())); 6350 Idx[1] = NewIdx; 6351 Value *NewGEP = cast<GEPOperator>(&GEP)->isInBounds() ? 6352 Builder->CreateInBoundsGEP(X, Idx, Idx + 2, GEP.getName()) : 6353 Builder->CreateGEP(X, Idx, Idx + 2, GEP.getName()); 6354 // The NewGEP must be pointer typed, so must the old one -> BitCast 6355 return new BitCastInst(NewGEP, GEP.getType()); 6356 } 6357 } 6358 } 6359 } 6360 6361 /// See if we can simplify: 6362 /// X = bitcast A* to B* 6363 /// Y = gep X, <...constant indices...> 6364 /// into a gep of the original struct. This is important for SROA and alias 6365 /// analysis of unions. If "A" is also a bitcast, wait for A/X to be merged. 6366 if (BitCastInst *BCI = dyn_cast<BitCastInst>(PtrOp)) { 6367 if (TD && 6368 !isa<BitCastInst>(BCI->getOperand(0)) && GEP.hasAllConstantIndices()) { 6369 // Determine how much the GEP moves the pointer. We are guaranteed to get 6370 // a constant back from EmitGEPOffset. 6371 ConstantInt *OffsetV = cast<ConstantInt>(EmitGEPOffset(&GEP)); 6372 int64_t Offset = OffsetV->getSExtValue(); 6373 6374 // If this GEP instruction doesn't move the pointer, just replace the GEP 6375 // with a bitcast of the real input to the dest type. 6376 if (Offset == 0) { 6377 // If the bitcast is of an allocation, and the allocation will be 6378 // converted to match the type of the cast, don't touch this. 6379 if (isa<AllocaInst>(BCI->getOperand(0)) || 6380 isMalloc(BCI->getOperand(0))) { 6381 // See if the bitcast simplifies, if so, don't nuke this GEP yet. 6382 if (Instruction *I = visitBitCast(*BCI)) { 6383 if (I != BCI) { 6384 I->takeName(BCI); 6385 BCI->getParent()->getInstList().insert(BCI, I); 6386 ReplaceInstUsesWith(*BCI, I); 6387 } 6388 return &GEP; 6389 } 6390 } 6391 return new BitCastInst(BCI->getOperand(0), GEP.getType()); 6392 } 6393 6394 // Otherwise, if the offset is non-zero, we need to find out if there is a 6395 // field at Offset in 'A's type. If so, we can pull the cast through the 6396 // GEP. 6397 SmallVector<Value*, 8> NewIndices; 6398 const Type *InTy = 6399 cast<PointerType>(BCI->getOperand(0)->getType())->getElementType(); 6400 if (FindElementAtOffset(InTy, Offset, NewIndices)) { 6401 Value *NGEP = cast<GEPOperator>(&GEP)->isInBounds() ? 6402 Builder->CreateInBoundsGEP(BCI->getOperand(0), NewIndices.begin(), 6403 NewIndices.end()) : 6404 Builder->CreateGEP(BCI->getOperand(0), NewIndices.begin(), 6405 NewIndices.end()); 6406 6407 if (NGEP->getType() == GEP.getType()) 6408 return ReplaceInstUsesWith(GEP, NGEP); 6409 NGEP->takeName(&GEP); 6410 return new BitCastInst(NGEP, GEP.getType()); 6411 } 6412 } 6413 } 6414 6415 return 0; 6416} 6417 6418Instruction *InstCombiner::visitAllocaInst(AllocaInst &AI) { 6419 // Convert: alloca Ty, C - where C is a constant != 1 into: alloca [C x Ty], 1 6420 if (AI.isArrayAllocation()) { // Check C != 1 6421 if (const ConstantInt *C = dyn_cast<ConstantInt>(AI.getArraySize())) { 6422 const Type *NewTy = 6423 ArrayType::get(AI.getAllocatedType(), C->getZExtValue()); 6424 assert(isa<AllocaInst>(AI) && "Unknown type of allocation inst!"); 6425 AllocaInst *New = Builder->CreateAlloca(NewTy, 0, AI.getName()); 6426 New->setAlignment(AI.getAlignment()); 6427 6428 // Scan to the end of the allocation instructions, to skip over a block of 6429 // allocas if possible...also skip interleaved debug info 6430 // 6431 BasicBlock::iterator It = New; 6432 while (isa<AllocaInst>(*It) || isa<DbgInfoIntrinsic>(*It)) ++It; 6433 6434 // Now that I is pointing to the first non-allocation-inst in the block, 6435 // insert our getelementptr instruction... 6436 // 6437 Value *NullIdx =Constant::getNullValue(Type::getInt32Ty(AI.getContext())); 6438 Value *Idx[2]; 6439 Idx[0] = NullIdx; 6440 Idx[1] = NullIdx; 6441 Value *V = GetElementPtrInst::CreateInBounds(New, Idx, Idx + 2, 6442 New->getName()+".sub", It); 6443 6444 // Now make everything use the getelementptr instead of the original 6445 // allocation. 6446 return ReplaceInstUsesWith(AI, V); 6447 } else if (isa<UndefValue>(AI.getArraySize())) { 6448 return ReplaceInstUsesWith(AI, Constant::getNullValue(AI.getType())); 6449 } 6450 } 6451 6452 if (TD && isa<AllocaInst>(AI) && AI.getAllocatedType()->isSized()) { 6453 // If alloca'ing a zero byte object, replace the alloca with a null pointer. 6454 // Note that we only do this for alloca's, because malloc should allocate 6455 // and return a unique pointer, even for a zero byte allocation. 6456 if (TD->getTypeAllocSize(AI.getAllocatedType()) == 0) 6457 return ReplaceInstUsesWith(AI, Constant::getNullValue(AI.getType())); 6458 6459 // If the alignment is 0 (unspecified), assign it the preferred alignment. 6460 if (AI.getAlignment() == 0) 6461 AI.setAlignment(TD->getPrefTypeAlignment(AI.getAllocatedType())); 6462 } 6463 6464 return 0; 6465} 6466 6467Instruction *InstCombiner::visitFree(Instruction &FI) { 6468 Value *Op = FI.getOperand(1); 6469 6470 // free undef -> unreachable. 6471 if (isa<UndefValue>(Op)) { 6472 // Insert a new store to null because we cannot modify the CFG here. 6473 new StoreInst(ConstantInt::getTrue(FI.getContext()), 6474 UndefValue::get(Type::getInt1PtrTy(FI.getContext())), &FI); 6475 return EraseInstFromFunction(FI); 6476 } 6477 6478 // If we have 'free null' delete the instruction. This can happen in stl code 6479 // when lots of inlining happens. 6480 if (isa<ConstantPointerNull>(Op)) 6481 return EraseInstFromFunction(FI); 6482 6483 // If we have a malloc call whose only use is a free call, delete both. 6484 if (isMalloc(Op)) { 6485 if (CallInst* CI = extractMallocCallFromBitCast(Op)) { 6486 if (Op->hasOneUse() && CI->hasOneUse()) { 6487 EraseInstFromFunction(FI); 6488 EraseInstFromFunction(*CI); 6489 return EraseInstFromFunction(*cast<Instruction>(Op)); 6490 } 6491 } else { 6492 // Op is a call to malloc 6493 if (Op->hasOneUse()) { 6494 EraseInstFromFunction(FI); 6495 return EraseInstFromFunction(*cast<Instruction>(Op)); 6496 } 6497 } 6498 } 6499 6500 return 0; 6501} 6502 6503/// InstCombineLoadCast - Fold 'load (cast P)' -> cast (load P)' when possible. 6504static Instruction *InstCombineLoadCast(InstCombiner &IC, LoadInst &LI, 6505 const TargetData *TD) { 6506 User *CI = cast<User>(LI.getOperand(0)); 6507 Value *CastOp = CI->getOperand(0); 6508 6509 const PointerType *DestTy = cast<PointerType>(CI->getType()); 6510 const Type *DestPTy = DestTy->getElementType(); 6511 if (const PointerType *SrcTy = dyn_cast<PointerType>(CastOp->getType())) { 6512 6513 // If the address spaces don't match, don't eliminate the cast. 6514 if (DestTy->getAddressSpace() != SrcTy->getAddressSpace()) 6515 return 0; 6516 6517 const Type *SrcPTy = SrcTy->getElementType(); 6518 6519 if (DestPTy->isInteger() || isa<PointerType>(DestPTy) || 6520 isa<VectorType>(DestPTy)) { 6521 // If the source is an array, the code below will not succeed. Check to 6522 // see if a trivial 'gep P, 0, 0' will help matters. Only do this for 6523 // constants. 6524 if (const ArrayType *ASrcTy = dyn_cast<ArrayType>(SrcPTy)) 6525 if (Constant *CSrc = dyn_cast<Constant>(CastOp)) 6526 if (ASrcTy->getNumElements() != 0) { 6527 Value *Idxs[2]; 6528 Idxs[0] = Constant::getNullValue(Type::getInt32Ty(LI.getContext())); 6529 Idxs[1] = Idxs[0]; 6530 CastOp = ConstantExpr::getGetElementPtr(CSrc, Idxs, 2); 6531 SrcTy = cast<PointerType>(CastOp->getType()); 6532 SrcPTy = SrcTy->getElementType(); 6533 } 6534 6535 if (IC.getTargetData() && 6536 (SrcPTy->isInteger() || isa<PointerType>(SrcPTy) || 6537 isa<VectorType>(SrcPTy)) && 6538 // Do not allow turning this into a load of an integer, which is then 6539 // casted to a pointer, this pessimizes pointer analysis a lot. 6540 (isa<PointerType>(SrcPTy) == isa<PointerType>(LI.getType())) && 6541 IC.getTargetData()->getTypeSizeInBits(SrcPTy) == 6542 IC.getTargetData()->getTypeSizeInBits(DestPTy)) { 6543 6544 // Okay, we are casting from one integer or pointer type to another of 6545 // the same size. Instead of casting the pointer before the load, cast 6546 // the result of the loaded value. 6547 Value *NewLoad = 6548 IC.Builder->CreateLoad(CastOp, LI.isVolatile(), CI->getName()); 6549 // Now cast the result of the load. 6550 return new BitCastInst(NewLoad, LI.getType()); 6551 } 6552 } 6553 } 6554 return 0; 6555} 6556 6557Instruction *InstCombiner::visitLoadInst(LoadInst &LI) { 6558 Value *Op = LI.getOperand(0); 6559 6560 // Attempt to improve the alignment. 6561 if (TD) { 6562 unsigned KnownAlign = 6563 GetOrEnforceKnownAlignment(Op, TD->getPrefTypeAlignment(LI.getType())); 6564 if (KnownAlign > 6565 (LI.getAlignment() == 0 ? TD->getABITypeAlignment(LI.getType()) : 6566 LI.getAlignment())) 6567 LI.setAlignment(KnownAlign); 6568 } 6569 6570 // load (cast X) --> cast (load X) iff safe. 6571 if (isa<CastInst>(Op)) 6572 if (Instruction *Res = InstCombineLoadCast(*this, LI, TD)) 6573 return Res; 6574 6575 // None of the following transforms are legal for volatile loads. 6576 if (LI.isVolatile()) return 0; 6577 6578 // Do really simple store-to-load forwarding and load CSE, to catch cases 6579 // where there are several consequtive memory accesses to the same location, 6580 // separated by a few arithmetic operations. 6581 BasicBlock::iterator BBI = &LI; 6582 if (Value *AvailableVal = FindAvailableLoadedValue(Op, LI.getParent(), BBI,6)) 6583 return ReplaceInstUsesWith(LI, AvailableVal); 6584 6585 // load(gep null, ...) -> unreachable 6586 if (GetElementPtrInst *GEPI = dyn_cast<GetElementPtrInst>(Op)) { 6587 const Value *GEPI0 = GEPI->getOperand(0); 6588 // TODO: Consider a target hook for valid address spaces for this xform. 6589 if (isa<ConstantPointerNull>(GEPI0) && GEPI->getPointerAddressSpace() == 0){ 6590 // Insert a new store to null instruction before the load to indicate 6591 // that this code is not reachable. We do this instead of inserting 6592 // an unreachable instruction directly because we cannot modify the 6593 // CFG. 6594 new StoreInst(UndefValue::get(LI.getType()), 6595 Constant::getNullValue(Op->getType()), &LI); 6596 return ReplaceInstUsesWith(LI, UndefValue::get(LI.getType())); 6597 } 6598 } 6599 6600 // load null/undef -> unreachable 6601 // TODO: Consider a target hook for valid address spaces for this xform. 6602 if (isa<UndefValue>(Op) || 6603 (isa<ConstantPointerNull>(Op) && LI.getPointerAddressSpace() == 0)) { 6604 // Insert a new store to null instruction before the load to indicate that 6605 // this code is not reachable. We do this instead of inserting an 6606 // unreachable instruction directly because we cannot modify the CFG. 6607 new StoreInst(UndefValue::get(LI.getType()), 6608 Constant::getNullValue(Op->getType()), &LI); 6609 return ReplaceInstUsesWith(LI, UndefValue::get(LI.getType())); 6610 } 6611 6612 // Instcombine load (constantexpr_cast global) -> cast (load global) 6613 if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Op)) 6614 if (CE->isCast()) 6615 if (Instruction *Res = InstCombineLoadCast(*this, LI, TD)) 6616 return Res; 6617 6618 if (Op->hasOneUse()) { 6619 // Change select and PHI nodes to select values instead of addresses: this 6620 // helps alias analysis out a lot, allows many others simplifications, and 6621 // exposes redundancy in the code. 6622 // 6623 // Note that we cannot do the transformation unless we know that the 6624 // introduced loads cannot trap! Something like this is valid as long as 6625 // the condition is always false: load (select bool %C, int* null, int* %G), 6626 // but it would not be valid if we transformed it to load from null 6627 // unconditionally. 6628 // 6629 if (SelectInst *SI = dyn_cast<SelectInst>(Op)) { 6630 // load (select (Cond, &V1, &V2)) --> select(Cond, load &V1, load &V2). 6631 if (isSafeToLoadUnconditionally(SI->getOperand(1), SI) && 6632 isSafeToLoadUnconditionally(SI->getOperand(2), SI)) { 6633 Value *V1 = Builder->CreateLoad(SI->getOperand(1), 6634 SI->getOperand(1)->getName()+".val"); 6635 Value *V2 = Builder->CreateLoad(SI->getOperand(2), 6636 SI->getOperand(2)->getName()+".val"); 6637 return SelectInst::Create(SI->getCondition(), V1, V2); 6638 } 6639 6640 // load (select (cond, null, P)) -> load P 6641 if (Constant *C = dyn_cast<Constant>(SI->getOperand(1))) 6642 if (C->isNullValue()) { 6643 LI.setOperand(0, SI->getOperand(2)); 6644 return &LI; 6645 } 6646 6647 // load (select (cond, P, null)) -> load P 6648 if (Constant *C = dyn_cast<Constant>(SI->getOperand(2))) 6649 if (C->isNullValue()) { 6650 LI.setOperand(0, SI->getOperand(1)); 6651 return &LI; 6652 } 6653 } 6654 } 6655 return 0; 6656} 6657 6658/// InstCombineStoreToCast - Fold store V, (cast P) -> store (cast V), P 6659/// when possible. This makes it generally easy to do alias analysis and/or 6660/// SROA/mem2reg of the memory object. 6661static Instruction *InstCombineStoreToCast(InstCombiner &IC, StoreInst &SI) { 6662 User *CI = cast<User>(SI.getOperand(1)); 6663 Value *CastOp = CI->getOperand(0); 6664 6665 const Type *DestPTy = cast<PointerType>(CI->getType())->getElementType(); 6666 const PointerType *SrcTy = dyn_cast<PointerType>(CastOp->getType()); 6667 if (SrcTy == 0) return 0; 6668 6669 const Type *SrcPTy = SrcTy->getElementType(); 6670 6671 if (!DestPTy->isInteger() && !isa<PointerType>(DestPTy)) 6672 return 0; 6673 6674 /// NewGEPIndices - If SrcPTy is an aggregate type, we can emit a "noop gep" 6675 /// to its first element. This allows us to handle things like: 6676 /// store i32 xxx, (bitcast {foo*, float}* %P to i32*) 6677 /// on 32-bit hosts. 6678 SmallVector<Value*, 4> NewGEPIndices; 6679 6680 // If the source is an array, the code below will not succeed. Check to 6681 // see if a trivial 'gep P, 0, 0' will help matters. Only do this for 6682 // constants. 6683 if (isa<ArrayType>(SrcPTy) || isa<StructType>(SrcPTy)) { 6684 // Index through pointer. 6685 Constant *Zero = Constant::getNullValue(Type::getInt32Ty(SI.getContext())); 6686 NewGEPIndices.push_back(Zero); 6687 6688 while (1) { 6689 if (const StructType *STy = dyn_cast<StructType>(SrcPTy)) { 6690 if (!STy->getNumElements()) /* Struct can be empty {} */ 6691 break; 6692 NewGEPIndices.push_back(Zero); 6693 SrcPTy = STy->getElementType(0); 6694 } else if (const ArrayType *ATy = dyn_cast<ArrayType>(SrcPTy)) { 6695 NewGEPIndices.push_back(Zero); 6696 SrcPTy = ATy->getElementType(); 6697 } else { 6698 break; 6699 } 6700 } 6701 6702 SrcTy = PointerType::get(SrcPTy, SrcTy->getAddressSpace()); 6703 } 6704 6705 if (!SrcPTy->isInteger() && !isa<PointerType>(SrcPTy)) 6706 return 0; 6707 6708 // If the pointers point into different address spaces or if they point to 6709 // values with different sizes, we can't do the transformation. 6710 if (!IC.getTargetData() || 6711 SrcTy->getAddressSpace() != 6712 cast<PointerType>(CI->getType())->getAddressSpace() || 6713 IC.getTargetData()->getTypeSizeInBits(SrcPTy) != 6714 IC.getTargetData()->getTypeSizeInBits(DestPTy)) 6715 return 0; 6716 6717 // Okay, we are casting from one integer or pointer type to another of 6718 // the same size. Instead of casting the pointer before 6719 // the store, cast the value to be stored. 6720 Value *NewCast; 6721 Value *SIOp0 = SI.getOperand(0); 6722 Instruction::CastOps opcode = Instruction::BitCast; 6723 const Type* CastSrcTy = SIOp0->getType(); 6724 const Type* CastDstTy = SrcPTy; 6725 if (isa<PointerType>(CastDstTy)) { 6726 if (CastSrcTy->isInteger()) 6727 opcode = Instruction::IntToPtr; 6728 } else if (isa<IntegerType>(CastDstTy)) { 6729 if (isa<PointerType>(SIOp0->getType())) 6730 opcode = Instruction::PtrToInt; 6731 } 6732 6733 // SIOp0 is a pointer to aggregate and this is a store to the first field, 6734 // emit a GEP to index into its first field. 6735 if (!NewGEPIndices.empty()) 6736 CastOp = IC.Builder->CreateInBoundsGEP(CastOp, NewGEPIndices.begin(), 6737 NewGEPIndices.end()); 6738 6739 NewCast = IC.Builder->CreateCast(opcode, SIOp0, CastDstTy, 6740 SIOp0->getName()+".c"); 6741 return new StoreInst(NewCast, CastOp); 6742} 6743 6744/// equivalentAddressValues - Test if A and B will obviously have the same 6745/// value. This includes recognizing that %t0 and %t1 will have the same 6746/// value in code like this: 6747/// %t0 = getelementptr \@a, 0, 3 6748/// store i32 0, i32* %t0 6749/// %t1 = getelementptr \@a, 0, 3 6750/// %t2 = load i32* %t1 6751/// 6752static bool equivalentAddressValues(Value *A, Value *B) { 6753 // Test if the values are trivially equivalent. 6754 if (A == B) return true; 6755 6756 // Test if the values come form identical arithmetic instructions. 6757 // This uses isIdenticalToWhenDefined instead of isIdenticalTo because 6758 // its only used to compare two uses within the same basic block, which 6759 // means that they'll always either have the same value or one of them 6760 // will have an undefined value. 6761 if (isa<BinaryOperator>(A) || 6762 isa<CastInst>(A) || 6763 isa<PHINode>(A) || 6764 isa<GetElementPtrInst>(A)) 6765 if (Instruction *BI = dyn_cast<Instruction>(B)) 6766 if (cast<Instruction>(A)->isIdenticalToWhenDefined(BI)) 6767 return true; 6768 6769 // Otherwise they may not be equivalent. 6770 return false; 6771} 6772 6773// If this instruction has two uses, one of which is a llvm.dbg.declare, 6774// return the llvm.dbg.declare. 6775DbgDeclareInst *InstCombiner::hasOneUsePlusDeclare(Value *V) { 6776 if (!V->hasNUses(2)) 6777 return 0; 6778 for (Value::use_iterator UI = V->use_begin(), E = V->use_end(); 6779 UI != E; ++UI) { 6780 if (DbgDeclareInst *DI = dyn_cast<DbgDeclareInst>(UI)) 6781 return DI; 6782 if (isa<BitCastInst>(UI) && UI->hasOneUse()) { 6783 if (DbgDeclareInst *DI = dyn_cast<DbgDeclareInst>(UI->use_begin())) 6784 return DI; 6785 } 6786 } 6787 return 0; 6788} 6789 6790Instruction *InstCombiner::visitStoreInst(StoreInst &SI) { 6791 Value *Val = SI.getOperand(0); 6792 Value *Ptr = SI.getOperand(1); 6793 6794 // If the RHS is an alloca with a single use, zapify the store, making the 6795 // alloca dead. 6796 // If the RHS is an alloca with a two uses, the other one being a 6797 // llvm.dbg.declare, zapify the store and the declare, making the 6798 // alloca dead. We must do this to prevent declare's from affecting 6799 // codegen. 6800 if (!SI.isVolatile()) { 6801 if (Ptr->hasOneUse()) { 6802 if (isa<AllocaInst>(Ptr)) { 6803 EraseInstFromFunction(SI); 6804 ++NumCombined; 6805 return 0; 6806 } 6807 if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(Ptr)) { 6808 if (isa<AllocaInst>(GEP->getOperand(0))) { 6809 if (GEP->getOperand(0)->hasOneUse()) { 6810 EraseInstFromFunction(SI); 6811 ++NumCombined; 6812 return 0; 6813 } 6814 if (DbgDeclareInst *DI = hasOneUsePlusDeclare(GEP->getOperand(0))) { 6815 EraseInstFromFunction(*DI); 6816 EraseInstFromFunction(SI); 6817 ++NumCombined; 6818 return 0; 6819 } 6820 } 6821 } 6822 } 6823 if (DbgDeclareInst *DI = hasOneUsePlusDeclare(Ptr)) { 6824 EraseInstFromFunction(*DI); 6825 EraseInstFromFunction(SI); 6826 ++NumCombined; 6827 return 0; 6828 } 6829 } 6830 6831 // Attempt to improve the alignment. 6832 if (TD) { 6833 unsigned KnownAlign = 6834 GetOrEnforceKnownAlignment(Ptr, TD->getPrefTypeAlignment(Val->getType())); 6835 if (KnownAlign > 6836 (SI.getAlignment() == 0 ? TD->getABITypeAlignment(Val->getType()) : 6837 SI.getAlignment())) 6838 SI.setAlignment(KnownAlign); 6839 } 6840 6841 // Do really simple DSE, to catch cases where there are several consecutive 6842 // stores to the same location, separated by a few arithmetic operations. This 6843 // situation often occurs with bitfield accesses. 6844 BasicBlock::iterator BBI = &SI; 6845 for (unsigned ScanInsts = 6; BBI != SI.getParent()->begin() && ScanInsts; 6846 --ScanInsts) { 6847 --BBI; 6848 // Don't count debug info directives, lest they affect codegen, 6849 // and we skip pointer-to-pointer bitcasts, which are NOPs. 6850 // It is necessary for correctness to skip those that feed into a 6851 // llvm.dbg.declare, as these are not present when debugging is off. 6852 if (isa<DbgInfoIntrinsic>(BBI) || 6853 (isa<BitCastInst>(BBI) && isa<PointerType>(BBI->getType()))) { 6854 ScanInsts++; 6855 continue; 6856 } 6857 6858 if (StoreInst *PrevSI = dyn_cast<StoreInst>(BBI)) { 6859 // Prev store isn't volatile, and stores to the same location? 6860 if (!PrevSI->isVolatile() &&equivalentAddressValues(PrevSI->getOperand(1), 6861 SI.getOperand(1))) { 6862 ++NumDeadStore; 6863 ++BBI; 6864 EraseInstFromFunction(*PrevSI); 6865 continue; 6866 } 6867 break; 6868 } 6869 6870 // If this is a load, we have to stop. However, if the loaded value is from 6871 // the pointer we're loading and is producing the pointer we're storing, 6872 // then *this* store is dead (X = load P; store X -> P). 6873 if (LoadInst *LI = dyn_cast<LoadInst>(BBI)) { 6874 if (LI == Val && equivalentAddressValues(LI->getOperand(0), Ptr) && 6875 !SI.isVolatile()) { 6876 EraseInstFromFunction(SI); 6877 ++NumCombined; 6878 return 0; 6879 } 6880 // Otherwise, this is a load from some other location. Stores before it 6881 // may not be dead. 6882 break; 6883 } 6884 6885 // Don't skip over loads or things that can modify memory. 6886 if (BBI->mayWriteToMemory() || BBI->mayReadFromMemory()) 6887 break; 6888 } 6889 6890 6891 if (SI.isVolatile()) return 0; // Don't hack volatile stores. 6892 6893 // store X, null -> turns into 'unreachable' in SimplifyCFG 6894 if (isa<ConstantPointerNull>(Ptr) && SI.getPointerAddressSpace() == 0) { 6895 if (!isa<UndefValue>(Val)) { 6896 SI.setOperand(0, UndefValue::get(Val->getType())); 6897 if (Instruction *U = dyn_cast<Instruction>(Val)) 6898 Worklist.Add(U); // Dropped a use. 6899 ++NumCombined; 6900 } 6901 return 0; // Do not modify these! 6902 } 6903 6904 // store undef, Ptr -> noop 6905 if (isa<UndefValue>(Val)) { 6906 EraseInstFromFunction(SI); 6907 ++NumCombined; 6908 return 0; 6909 } 6910 6911 // If the pointer destination is a cast, see if we can fold the cast into the 6912 // source instead. 6913 if (isa<CastInst>(Ptr)) 6914 if (Instruction *Res = InstCombineStoreToCast(*this, SI)) 6915 return Res; 6916 if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Ptr)) 6917 if (CE->isCast()) 6918 if (Instruction *Res = InstCombineStoreToCast(*this, SI)) 6919 return Res; 6920 6921 6922 // If this store is the last instruction in the basic block (possibly 6923 // excepting debug info instructions and the pointer bitcasts that feed 6924 // into them), and if the block ends with an unconditional branch, try 6925 // to move it to the successor block. 6926 BBI = &SI; 6927 do { 6928 ++BBI; 6929 } while (isa<DbgInfoIntrinsic>(BBI) || 6930 (isa<BitCastInst>(BBI) && isa<PointerType>(BBI->getType()))); 6931 if (BranchInst *BI = dyn_cast<BranchInst>(BBI)) 6932 if (BI->isUnconditional()) 6933 if (SimplifyStoreAtEndOfBlock(SI)) 6934 return 0; // xform done! 6935 6936 return 0; 6937} 6938 6939/// SimplifyStoreAtEndOfBlock - Turn things like: 6940/// if () { *P = v1; } else { *P = v2 } 6941/// into a phi node with a store in the successor. 6942/// 6943/// Simplify things like: 6944/// *P = v1; if () { *P = v2; } 6945/// into a phi node with a store in the successor. 6946/// 6947bool InstCombiner::SimplifyStoreAtEndOfBlock(StoreInst &SI) { 6948 BasicBlock *StoreBB = SI.getParent(); 6949 6950 // Check to see if the successor block has exactly two incoming edges. If 6951 // so, see if the other predecessor contains a store to the same location. 6952 // if so, insert a PHI node (if needed) and move the stores down. 6953 BasicBlock *DestBB = StoreBB->getTerminator()->getSuccessor(0); 6954 6955 // Determine whether Dest has exactly two predecessors and, if so, compute 6956 // the other predecessor. 6957 pred_iterator PI = pred_begin(DestBB); 6958 BasicBlock *OtherBB = 0; 6959 if (*PI != StoreBB) 6960 OtherBB = *PI; 6961 ++PI; 6962 if (PI == pred_end(DestBB)) 6963 return false; 6964 6965 if (*PI != StoreBB) { 6966 if (OtherBB) 6967 return false; 6968 OtherBB = *PI; 6969 } 6970 if (++PI != pred_end(DestBB)) 6971 return false; 6972 6973 // Bail out if all the relevant blocks aren't distinct (this can happen, 6974 // for example, if SI is in an infinite loop) 6975 if (StoreBB == DestBB || OtherBB == DestBB) 6976 return false; 6977 6978 // Verify that the other block ends in a branch and is not otherwise empty. 6979 BasicBlock::iterator BBI = OtherBB->getTerminator(); 6980 BranchInst *OtherBr = dyn_cast<BranchInst>(BBI); 6981 if (!OtherBr || BBI == OtherBB->begin()) 6982 return false; 6983 6984 // If the other block ends in an unconditional branch, check for the 'if then 6985 // else' case. there is an instruction before the branch. 6986 StoreInst *OtherStore = 0; 6987 if (OtherBr->isUnconditional()) { 6988 --BBI; 6989 // Skip over debugging info. 6990 while (isa<DbgInfoIntrinsic>(BBI) || 6991 (isa<BitCastInst>(BBI) && isa<PointerType>(BBI->getType()))) { 6992 if (BBI==OtherBB->begin()) 6993 return false; 6994 --BBI; 6995 } 6996 // If this isn't a store, isn't a store to the same location, or if the 6997 // alignments differ, bail out. 6998 OtherStore = dyn_cast<StoreInst>(BBI); 6999 if (!OtherStore || OtherStore->getOperand(1) != SI.getOperand(1) || 7000 OtherStore->getAlignment() != SI.getAlignment()) 7001 return false; 7002 } else { 7003 // Otherwise, the other block ended with a conditional branch. If one of the 7004 // destinations is StoreBB, then we have the if/then case. 7005 if (OtherBr->getSuccessor(0) != StoreBB && 7006 OtherBr->getSuccessor(1) != StoreBB) 7007 return false; 7008 7009 // Okay, we know that OtherBr now goes to Dest and StoreBB, so this is an 7010 // if/then triangle. See if there is a store to the same ptr as SI that 7011 // lives in OtherBB. 7012 for (;; --BBI) { 7013 // Check to see if we find the matching store. 7014 if ((OtherStore = dyn_cast<StoreInst>(BBI))) { 7015 if (OtherStore->getOperand(1) != SI.getOperand(1) || 7016 OtherStore->getAlignment() != SI.getAlignment()) 7017 return false; 7018 break; 7019 } 7020 // If we find something that may be using or overwriting the stored 7021 // value, or if we run out of instructions, we can't do the xform. 7022 if (BBI->mayReadFromMemory() || BBI->mayWriteToMemory() || 7023 BBI == OtherBB->begin()) 7024 return false; 7025 } 7026 7027 // In order to eliminate the store in OtherBr, we have to 7028 // make sure nothing reads or overwrites the stored value in 7029 // StoreBB. 7030 for (BasicBlock::iterator I = StoreBB->begin(); &*I != &SI; ++I) { 7031 // FIXME: This should really be AA driven. 7032 if (I->mayReadFromMemory() || I->mayWriteToMemory()) 7033 return false; 7034 } 7035 } 7036 7037 // Insert a PHI node now if we need it. 7038 Value *MergedVal = OtherStore->getOperand(0); 7039 if (MergedVal != SI.getOperand(0)) { 7040 PHINode *PN = PHINode::Create(MergedVal->getType(), "storemerge"); 7041 PN->reserveOperandSpace(2); 7042 PN->addIncoming(SI.getOperand(0), SI.getParent()); 7043 PN->addIncoming(OtherStore->getOperand(0), OtherBB); 7044 MergedVal = InsertNewInstBefore(PN, DestBB->front()); 7045 } 7046 7047 // Advance to a place where it is safe to insert the new store and 7048 // insert it. 7049 BBI = DestBB->getFirstNonPHI(); 7050 InsertNewInstBefore(new StoreInst(MergedVal, SI.getOperand(1), 7051 OtherStore->isVolatile(), 7052 SI.getAlignment()), *BBI); 7053 7054 // Nuke the old stores. 7055 EraseInstFromFunction(SI); 7056 EraseInstFromFunction(*OtherStore); 7057 ++NumCombined; 7058 return true; 7059} 7060 7061 7062Instruction *InstCombiner::visitBranchInst(BranchInst &BI) { 7063 // Change br (not X), label True, label False to: br X, label False, True 7064 Value *X = 0; 7065 BasicBlock *TrueDest; 7066 BasicBlock *FalseDest; 7067 if (match(&BI, m_Br(m_Not(m_Value(X)), TrueDest, FalseDest)) && 7068 !isa<Constant>(X)) { 7069 // Swap Destinations and condition... 7070 BI.setCondition(X); 7071 BI.setSuccessor(0, FalseDest); 7072 BI.setSuccessor(1, TrueDest); 7073 return &BI; 7074 } 7075 7076 // Cannonicalize fcmp_one -> fcmp_oeq 7077 FCmpInst::Predicate FPred; Value *Y; 7078 if (match(&BI, m_Br(m_FCmp(FPred, m_Value(X), m_Value(Y)), 7079 TrueDest, FalseDest)) && 7080 BI.getCondition()->hasOneUse()) 7081 if (FPred == FCmpInst::FCMP_ONE || FPred == FCmpInst::FCMP_OLE || 7082 FPred == FCmpInst::FCMP_OGE) { 7083 FCmpInst *Cond = cast<FCmpInst>(BI.getCondition()); 7084 Cond->setPredicate(FCmpInst::getInversePredicate(FPred)); 7085 7086 // Swap Destinations and condition. 7087 BI.setSuccessor(0, FalseDest); 7088 BI.setSuccessor(1, TrueDest); 7089 Worklist.Add(Cond); 7090 return &BI; 7091 } 7092 7093 // Cannonicalize icmp_ne -> icmp_eq 7094 ICmpInst::Predicate IPred; 7095 if (match(&BI, m_Br(m_ICmp(IPred, m_Value(X), m_Value(Y)), 7096 TrueDest, FalseDest)) && 7097 BI.getCondition()->hasOneUse()) 7098 if (IPred == ICmpInst::ICMP_NE || IPred == ICmpInst::ICMP_ULE || 7099 IPred == ICmpInst::ICMP_SLE || IPred == ICmpInst::ICMP_UGE || 7100 IPred == ICmpInst::ICMP_SGE) { 7101 ICmpInst *Cond = cast<ICmpInst>(BI.getCondition()); 7102 Cond->setPredicate(ICmpInst::getInversePredicate(IPred)); 7103 // Swap Destinations and condition. 7104 BI.setSuccessor(0, FalseDest); 7105 BI.setSuccessor(1, TrueDest); 7106 Worklist.Add(Cond); 7107 return &BI; 7108 } 7109 7110 return 0; 7111} 7112 7113Instruction *InstCombiner::visitSwitchInst(SwitchInst &SI) { 7114 Value *Cond = SI.getCondition(); 7115 if (Instruction *I = dyn_cast<Instruction>(Cond)) { 7116 if (I->getOpcode() == Instruction::Add) 7117 if (ConstantInt *AddRHS = dyn_cast<ConstantInt>(I->getOperand(1))) { 7118 // change 'switch (X+4) case 1:' into 'switch (X) case -3' 7119 for (unsigned i = 2, e = SI.getNumOperands(); i != e; i += 2) 7120 SI.setOperand(i, 7121 ConstantExpr::getSub(cast<Constant>(SI.getOperand(i)), 7122 AddRHS)); 7123 SI.setOperand(0, I->getOperand(0)); 7124 Worklist.Add(I); 7125 return &SI; 7126 } 7127 } 7128 return 0; 7129} 7130 7131Instruction *InstCombiner::visitExtractValueInst(ExtractValueInst &EV) { 7132 Value *Agg = EV.getAggregateOperand(); 7133 7134 if (!EV.hasIndices()) 7135 return ReplaceInstUsesWith(EV, Agg); 7136 7137 if (Constant *C = dyn_cast<Constant>(Agg)) { 7138 if (isa<UndefValue>(C)) 7139 return ReplaceInstUsesWith(EV, UndefValue::get(EV.getType())); 7140 7141 if (isa<ConstantAggregateZero>(C)) 7142 return ReplaceInstUsesWith(EV, Constant::getNullValue(EV.getType())); 7143 7144 if (isa<ConstantArray>(C) || isa<ConstantStruct>(C)) { 7145 // Extract the element indexed by the first index out of the constant 7146 Value *V = C->getOperand(*EV.idx_begin()); 7147 if (EV.getNumIndices() > 1) 7148 // Extract the remaining indices out of the constant indexed by the 7149 // first index 7150 return ExtractValueInst::Create(V, EV.idx_begin() + 1, EV.idx_end()); 7151 else 7152 return ReplaceInstUsesWith(EV, V); 7153 } 7154 return 0; // Can't handle other constants 7155 } 7156 if (InsertValueInst *IV = dyn_cast<InsertValueInst>(Agg)) { 7157 // We're extracting from an insertvalue instruction, compare the indices 7158 const unsigned *exti, *exte, *insi, *inse; 7159 for (exti = EV.idx_begin(), insi = IV->idx_begin(), 7160 exte = EV.idx_end(), inse = IV->idx_end(); 7161 exti != exte && insi != inse; 7162 ++exti, ++insi) { 7163 if (*insi != *exti) 7164 // The insert and extract both reference distinctly different elements. 7165 // This means the extract is not influenced by the insert, and we can 7166 // replace the aggregate operand of the extract with the aggregate 7167 // operand of the insert. i.e., replace 7168 // %I = insertvalue { i32, { i32 } } %A, { i32 } { i32 42 }, 1 7169 // %E = extractvalue { i32, { i32 } } %I, 0 7170 // with 7171 // %E = extractvalue { i32, { i32 } } %A, 0 7172 return ExtractValueInst::Create(IV->getAggregateOperand(), 7173 EV.idx_begin(), EV.idx_end()); 7174 } 7175 if (exti == exte && insi == inse) 7176 // Both iterators are at the end: Index lists are identical. Replace 7177 // %B = insertvalue { i32, { i32 } } %A, i32 42, 1, 0 7178 // %C = extractvalue { i32, { i32 } } %B, 1, 0 7179 // with "i32 42" 7180 return ReplaceInstUsesWith(EV, IV->getInsertedValueOperand()); 7181 if (exti == exte) { 7182 // The extract list is a prefix of the insert list. i.e. replace 7183 // %I = insertvalue { i32, { i32 } } %A, i32 42, 1, 0 7184 // %E = extractvalue { i32, { i32 } } %I, 1 7185 // with 7186 // %X = extractvalue { i32, { i32 } } %A, 1 7187 // %E = insertvalue { i32 } %X, i32 42, 0 7188 // by switching the order of the insert and extract (though the 7189 // insertvalue should be left in, since it may have other uses). 7190 Value *NewEV = Builder->CreateExtractValue(IV->getAggregateOperand(), 7191 EV.idx_begin(), EV.idx_end()); 7192 return InsertValueInst::Create(NewEV, IV->getInsertedValueOperand(), 7193 insi, inse); 7194 } 7195 if (insi == inse) 7196 // The insert list is a prefix of the extract list 7197 // We can simply remove the common indices from the extract and make it 7198 // operate on the inserted value instead of the insertvalue result. 7199 // i.e., replace 7200 // %I = insertvalue { i32, { i32 } } %A, { i32 } { i32 42 }, 1 7201 // %E = extractvalue { i32, { i32 } } %I, 1, 0 7202 // with 7203 // %E extractvalue { i32 } { i32 42 }, 0 7204 return ExtractValueInst::Create(IV->getInsertedValueOperand(), 7205 exti, exte); 7206 } 7207 if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(Agg)) { 7208 // We're extracting from an intrinsic, see if we're the only user, which 7209 // allows us to simplify multiple result intrinsics to simpler things that 7210 // just get one value.. 7211 if (II->hasOneUse()) { 7212 // Check if we're grabbing the overflow bit or the result of a 'with 7213 // overflow' intrinsic. If it's the latter we can remove the intrinsic 7214 // and replace it with a traditional binary instruction. 7215 switch (II->getIntrinsicID()) { 7216 case Intrinsic::uadd_with_overflow: 7217 case Intrinsic::sadd_with_overflow: 7218 if (*EV.idx_begin() == 0) { // Normal result. 7219 Value *LHS = II->getOperand(1), *RHS = II->getOperand(2); 7220 II->replaceAllUsesWith(UndefValue::get(II->getType())); 7221 EraseInstFromFunction(*II); 7222 return BinaryOperator::CreateAdd(LHS, RHS); 7223 } 7224 break; 7225 case Intrinsic::usub_with_overflow: 7226 case Intrinsic::ssub_with_overflow: 7227 if (*EV.idx_begin() == 0) { // Normal result. 7228 Value *LHS = II->getOperand(1), *RHS = II->getOperand(2); 7229 II->replaceAllUsesWith(UndefValue::get(II->getType())); 7230 EraseInstFromFunction(*II); 7231 return BinaryOperator::CreateSub(LHS, RHS); 7232 } 7233 break; 7234 case Intrinsic::umul_with_overflow: 7235 case Intrinsic::smul_with_overflow: 7236 if (*EV.idx_begin() == 0) { // Normal result. 7237 Value *LHS = II->getOperand(1), *RHS = II->getOperand(2); 7238 II->replaceAllUsesWith(UndefValue::get(II->getType())); 7239 EraseInstFromFunction(*II); 7240 return BinaryOperator::CreateMul(LHS, RHS); 7241 } 7242 break; 7243 default: 7244 break; 7245 } 7246 } 7247 } 7248 // Can't simplify extracts from other values. Note that nested extracts are 7249 // already simplified implicitely by the above (extract ( extract (insert) ) 7250 // will be translated into extract ( insert ( extract ) ) first and then just 7251 // the value inserted, if appropriate). 7252 return 0; 7253} 7254 7255 7256 7257 7258/// TryToSinkInstruction - Try to move the specified instruction from its 7259/// current block into the beginning of DestBlock, which can only happen if it's 7260/// safe to move the instruction past all of the instructions between it and the 7261/// end of its block. 7262static bool TryToSinkInstruction(Instruction *I, BasicBlock *DestBlock) { 7263 assert(I->hasOneUse() && "Invariants didn't hold!"); 7264 7265 // Cannot move control-flow-involving, volatile loads, vaarg, etc. 7266 if (isa<PHINode>(I) || I->mayHaveSideEffects() || isa<TerminatorInst>(I)) 7267 return false; 7268 7269 // Do not sink alloca instructions out of the entry block. 7270 if (isa<AllocaInst>(I) && I->getParent() == 7271 &DestBlock->getParent()->getEntryBlock()) 7272 return false; 7273 7274 // We can only sink load instructions if there is nothing between the load and 7275 // the end of block that could change the value. 7276 if (I->mayReadFromMemory()) { 7277 for (BasicBlock::iterator Scan = I, E = I->getParent()->end(); 7278 Scan != E; ++Scan) 7279 if (Scan->mayWriteToMemory()) 7280 return false; 7281 } 7282 7283 BasicBlock::iterator InsertPos = DestBlock->getFirstNonPHI(); 7284 7285 I->moveBefore(InsertPos); 7286 ++NumSunkInst; 7287 return true; 7288} 7289 7290 7291/// AddReachableCodeToWorklist - Walk the function in depth-first order, adding 7292/// all reachable code to the worklist. 7293/// 7294/// This has a couple of tricks to make the code faster and more powerful. In 7295/// particular, we constant fold and DCE instructions as we go, to avoid adding 7296/// them to the worklist (this significantly speeds up instcombine on code where 7297/// many instructions are dead or constant). Additionally, if we find a branch 7298/// whose condition is a known constant, we only visit the reachable successors. 7299/// 7300static bool AddReachableCodeToWorklist(BasicBlock *BB, 7301 SmallPtrSet<BasicBlock*, 64> &Visited, 7302 InstCombiner &IC, 7303 const TargetData *TD) { 7304 bool MadeIRChange = false; 7305 SmallVector<BasicBlock*, 256> Worklist; 7306 Worklist.push_back(BB); 7307 7308 std::vector<Instruction*> InstrsForInstCombineWorklist; 7309 InstrsForInstCombineWorklist.reserve(128); 7310 7311 SmallPtrSet<ConstantExpr*, 64> FoldedConstants; 7312 7313 while (!Worklist.empty()) { 7314 BB = Worklist.back(); 7315 Worklist.pop_back(); 7316 7317 // We have now visited this block! If we've already been here, ignore it. 7318 if (!Visited.insert(BB)) continue; 7319 7320 for (BasicBlock::iterator BBI = BB->begin(), E = BB->end(); BBI != E; ) { 7321 Instruction *Inst = BBI++; 7322 7323 // DCE instruction if trivially dead. 7324 if (isInstructionTriviallyDead(Inst)) { 7325 ++NumDeadInst; 7326 DEBUG(errs() << "IC: DCE: " << *Inst << '\n'); 7327 Inst->eraseFromParent(); 7328 continue; 7329 } 7330 7331 // ConstantProp instruction if trivially constant. 7332 if (!Inst->use_empty() && isa<Constant>(Inst->getOperand(0))) 7333 if (Constant *C = ConstantFoldInstruction(Inst, TD)) { 7334 DEBUG(errs() << "IC: ConstFold to: " << *C << " from: " 7335 << *Inst << '\n'); 7336 Inst->replaceAllUsesWith(C); 7337 ++NumConstProp; 7338 Inst->eraseFromParent(); 7339 continue; 7340 } 7341 7342 7343 7344 if (TD) { 7345 // See if we can constant fold its operands. 7346 for (User::op_iterator i = Inst->op_begin(), e = Inst->op_end(); 7347 i != e; ++i) { 7348 ConstantExpr *CE = dyn_cast<ConstantExpr>(i); 7349 if (CE == 0) continue; 7350 7351 // If we already folded this constant, don't try again. 7352 if (!FoldedConstants.insert(CE)) 7353 continue; 7354 7355 Constant *NewC = ConstantFoldConstantExpression(CE, TD); 7356 if (NewC && NewC != CE) { 7357 *i = NewC; 7358 MadeIRChange = true; 7359 } 7360 } 7361 } 7362 7363 7364 InstrsForInstCombineWorklist.push_back(Inst); 7365 } 7366 7367 // Recursively visit successors. If this is a branch or switch on a 7368 // constant, only visit the reachable successor. 7369 TerminatorInst *TI = BB->getTerminator(); 7370 if (BranchInst *BI = dyn_cast<BranchInst>(TI)) { 7371 if (BI->isConditional() && isa<ConstantInt>(BI->getCondition())) { 7372 bool CondVal = cast<ConstantInt>(BI->getCondition())->getZExtValue(); 7373 BasicBlock *ReachableBB = BI->getSuccessor(!CondVal); 7374 Worklist.push_back(ReachableBB); 7375 continue; 7376 } 7377 } else if (SwitchInst *SI = dyn_cast<SwitchInst>(TI)) { 7378 if (ConstantInt *Cond = dyn_cast<ConstantInt>(SI->getCondition())) { 7379 // See if this is an explicit destination. 7380 for (unsigned i = 1, e = SI->getNumSuccessors(); i != e; ++i) 7381 if (SI->getCaseValue(i) == Cond) { 7382 BasicBlock *ReachableBB = SI->getSuccessor(i); 7383 Worklist.push_back(ReachableBB); 7384 continue; 7385 } 7386 7387 // Otherwise it is the default destination. 7388 Worklist.push_back(SI->getSuccessor(0)); 7389 continue; 7390 } 7391 } 7392 7393 for (unsigned i = 0, e = TI->getNumSuccessors(); i != e; ++i) 7394 Worklist.push_back(TI->getSuccessor(i)); 7395 } 7396 7397 // Once we've found all of the instructions to add to instcombine's worklist, 7398 // add them in reverse order. This way instcombine will visit from the top 7399 // of the function down. This jives well with the way that it adds all uses 7400 // of instructions to the worklist after doing a transformation, thus avoiding 7401 // some N^2 behavior in pathological cases. 7402 IC.Worklist.AddInitialGroup(&InstrsForInstCombineWorklist[0], 7403 InstrsForInstCombineWorklist.size()); 7404 7405 return MadeIRChange; 7406} 7407 7408bool InstCombiner::DoOneIteration(Function &F, unsigned Iteration) { 7409 MadeIRChange = false; 7410 7411 DEBUG(errs() << "\n\nINSTCOMBINE ITERATION #" << Iteration << " on " 7412 << F.getNameStr() << "\n"); 7413 7414 { 7415 // Do a depth-first traversal of the function, populate the worklist with 7416 // the reachable instructions. Ignore blocks that are not reachable. Keep 7417 // track of which blocks we visit. 7418 SmallPtrSet<BasicBlock*, 64> Visited; 7419 MadeIRChange |= AddReachableCodeToWorklist(F.begin(), Visited, *this, TD); 7420 7421 // Do a quick scan over the function. If we find any blocks that are 7422 // unreachable, remove any instructions inside of them. This prevents 7423 // the instcombine code from having to deal with some bad special cases. 7424 for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB) 7425 if (!Visited.count(BB)) { 7426 Instruction *Term = BB->getTerminator(); 7427 while (Term != BB->begin()) { // Remove instrs bottom-up 7428 BasicBlock::iterator I = Term; --I; 7429 7430 DEBUG(errs() << "IC: DCE: " << *I << '\n'); 7431 // A debug intrinsic shouldn't force another iteration if we weren't 7432 // going to do one without it. 7433 if (!isa<DbgInfoIntrinsic>(I)) { 7434 ++NumDeadInst; 7435 MadeIRChange = true; 7436 } 7437 7438 // If I is not void type then replaceAllUsesWith undef. 7439 // This allows ValueHandlers and custom metadata to adjust itself. 7440 if (!I->getType()->isVoidTy()) 7441 I->replaceAllUsesWith(UndefValue::get(I->getType())); 7442 I->eraseFromParent(); 7443 } 7444 } 7445 } 7446 7447 while (!Worklist.isEmpty()) { 7448 Instruction *I = Worklist.RemoveOne(); 7449 if (I == 0) continue; // skip null values. 7450 7451 // Check to see if we can DCE the instruction. 7452 if (isInstructionTriviallyDead(I)) { 7453 DEBUG(errs() << "IC: DCE: " << *I << '\n'); 7454 EraseInstFromFunction(*I); 7455 ++NumDeadInst; 7456 MadeIRChange = true; 7457 continue; 7458 } 7459 7460 // Instruction isn't dead, see if we can constant propagate it. 7461 if (!I->use_empty() && isa<Constant>(I->getOperand(0))) 7462 if (Constant *C = ConstantFoldInstruction(I, TD)) { 7463 DEBUG(errs() << "IC: ConstFold to: " << *C << " from: " << *I << '\n'); 7464 7465 // Add operands to the worklist. 7466 ReplaceInstUsesWith(*I, C); 7467 ++NumConstProp; 7468 EraseInstFromFunction(*I); 7469 MadeIRChange = true; 7470 continue; 7471 } 7472 7473 // See if we can trivially sink this instruction to a successor basic block. 7474 if (I->hasOneUse()) { 7475 BasicBlock *BB = I->getParent(); 7476 Instruction *UserInst = cast<Instruction>(I->use_back()); 7477 BasicBlock *UserParent; 7478 7479 // Get the block the use occurs in. 7480 if (PHINode *PN = dyn_cast<PHINode>(UserInst)) 7481 UserParent = PN->getIncomingBlock(I->use_begin().getUse()); 7482 else 7483 UserParent = UserInst->getParent(); 7484 7485 if (UserParent != BB) { 7486 bool UserIsSuccessor = false; 7487 // See if the user is one of our successors. 7488 for (succ_iterator SI = succ_begin(BB), E = succ_end(BB); SI != E; ++SI) 7489 if (*SI == UserParent) { 7490 UserIsSuccessor = true; 7491 break; 7492 } 7493 7494 // If the user is one of our immediate successors, and if that successor 7495 // only has us as a predecessors (we'd have to split the critical edge 7496 // otherwise), we can keep going. 7497 if (UserIsSuccessor && UserParent->getSinglePredecessor()) 7498 // Okay, the CFG is simple enough, try to sink this instruction. 7499 MadeIRChange |= TryToSinkInstruction(I, UserParent); 7500 } 7501 } 7502 7503 // Now that we have an instruction, try combining it to simplify it. 7504 Builder->SetInsertPoint(I->getParent(), I); 7505 7506#ifndef NDEBUG 7507 std::string OrigI; 7508#endif 7509 DEBUG(raw_string_ostream SS(OrigI); I->print(SS); OrigI = SS.str();); 7510 DEBUG(errs() << "IC: Visiting: " << OrigI << '\n'); 7511 7512 if (Instruction *Result = visit(*I)) { 7513 ++NumCombined; 7514 // Should we replace the old instruction with a new one? 7515 if (Result != I) { 7516 DEBUG(errs() << "IC: Old = " << *I << '\n' 7517 << " New = " << *Result << '\n'); 7518 7519 // Everything uses the new instruction now. 7520 I->replaceAllUsesWith(Result); 7521 7522 // Push the new instruction and any users onto the worklist. 7523 Worklist.Add(Result); 7524 Worklist.AddUsersToWorkList(*Result); 7525 7526 // Move the name to the new instruction first. 7527 Result->takeName(I); 7528 7529 // Insert the new instruction into the basic block... 7530 BasicBlock *InstParent = I->getParent(); 7531 BasicBlock::iterator InsertPos = I; 7532 7533 if (!isa<PHINode>(Result)) // If combining a PHI, don't insert 7534 while (isa<PHINode>(InsertPos)) // middle of a block of PHIs. 7535 ++InsertPos; 7536 7537 InstParent->getInstList().insert(InsertPos, Result); 7538 7539 EraseInstFromFunction(*I); 7540 } else { 7541#ifndef NDEBUG 7542 DEBUG(errs() << "IC: Mod = " << OrigI << '\n' 7543 << " New = " << *I << '\n'); 7544#endif 7545 7546 // If the instruction was modified, it's possible that it is now dead. 7547 // if so, remove it. 7548 if (isInstructionTriviallyDead(I)) { 7549 EraseInstFromFunction(*I); 7550 } else { 7551 Worklist.Add(I); 7552 Worklist.AddUsersToWorkList(*I); 7553 } 7554 } 7555 MadeIRChange = true; 7556 } 7557 } 7558 7559 Worklist.Zap(); 7560 return MadeIRChange; 7561} 7562 7563 7564bool InstCombiner::runOnFunction(Function &F) { 7565 MustPreserveLCSSA = mustPreserveAnalysisID(LCSSAID); 7566 TD = getAnalysisIfAvailable<TargetData>(); 7567 7568 7569 /// Builder - This is an IRBuilder that automatically inserts new 7570 /// instructions into the worklist when they are created. 7571 IRBuilder<true, TargetFolder, InstCombineIRInserter> 7572 TheBuilder(F.getContext(), TargetFolder(TD), 7573 InstCombineIRInserter(Worklist)); 7574 Builder = &TheBuilder; 7575 7576 bool EverMadeChange = false; 7577 7578 // Iterate while there is work to do. 7579 unsigned Iteration = 0; 7580 while (DoOneIteration(F, Iteration++)) 7581 EverMadeChange = true; 7582 7583 Builder = 0; 7584 return EverMadeChange; 7585} 7586 7587FunctionPass *llvm::createInstructionCombiningPass() { 7588 return new InstCombiner(); 7589} 7590