Implementing missing trigonometric optimizations

[cs15btech11041]

Summary

Here we have implemented the following missing trigonometric optimizations.

1. tan(x)*cos(x)=sin(x)
2. sin(x)*cos(x) = sin(2*x)/2
3. sin(x)/tan(x)=cos(x);
4. tan(x)/sin(x)=1/cos(x);

Here is the reference to the missing optimization reported on bugzilla.

https://bugs.llvm.org/show_bug.cgi?id=35602

[asb]

As mentioned in llvm-dev, it looks like David Majnemer and Craig Topper might be appropriate reviewers for this patch (or can perhaps help to suggest other reviewers).

It looks like you've run clang-format on the entire lib/Transforms/InstCombine/InstructionCombining.cpp file. This makes it harder to review the changes you've made. Best practice is to only clang-format lines that you touch. I use the git-clang-format helper script for this, and it looks like clang-format-diff.py can help if you're using SVN:

https://github.com/llvm-mirror/clang/blob/master/tools/clang-format/git-clang-format
https://github.com/llvm-mirror/clang/blob/master/tools/clang-format/clang-format-diff.py

[fhahn]

Thanks for your patch!

Usually it is easier to review smaller patches. Splitting it up into 4 patches for the 4 different cases you implemented would make it slightly easier to reason about the 4 unrelated transformation in isolation.

[rengolin]

This may need special guard with fast-math flags (precision, etc), no?

[davide]

Meta point: It's unclear to me whether this is something profitable to implement.
Sure, you can probably take a textbook and implement all the possible identities written there, but, what's the point?

I looked and it seems other compilers (most notably, GCC) don't implement at least the first transformation you implemented (I didn't bother to check the others).
https://godbolt.org/g/kKP5PW

tl;dr: what's your motivation?

[davide]

Something else you may want to keep in mind is that these transformations may introduce dramatic rounding errors, so they need some thoughts/analysis before they can go in (cc: @scanon), even under -ffast-math.

[aprantl]

lib/Transforms/InstCombine/InstructionCombining.cpp

1431

Please remove the \brief, it is redundant.

1442

Please always use full sentences in documentation:
// Return nullptr if argument to calls are not same.

[cs15btech11041]

Updates made:

1. Made the test cases more modular as mentioned in the comments.
2. Instead of clang format on entire InstructionCombine.cpp clang-formatted only the modified/inserted code for better understanding.

3.Comments improved.

[cs15btech11041]

In D41659#965688, @asb wrote:

As mentioned in llvm-dev, it looks like David Majnemer and Craig Topper might be appropriate reviewers for this patch (or can perhaps help to suggest other reviewers).

Hi, thanks for the comment. Thanks for adding appropriate reviewers for the patch.

It looks like you've run clang-format on the entire lib/Transforms/InstCombine/InstructionCombining.cpp file. This makes it harder to review the changes you've made. Best practice is to only clang-format lines that you touch. I use the git-clang-format helper script for this, and it looks like clang-format-diff.py can help if you're using SVN:

As suggested, I have updated the diff file with clang format only on the section of code modified/inserted. Hopefully it is easier for the review. Thanks for the suggestion.

https://github.com/llvm-mirror/clang/blob/master/tools/clang-format/git-clang-format
https://github.com/llvm-mirror/clang/blob/master/tools/clang-format/clang-format-diff.py

[cs15btech11041]

In D41659#965694, @fhahn wrote:

Thanks for your patch!

Usually it is easier to review smaller patches. Splitting it up into 4 patches for the 4 different cases you implemented would make it slightly easier to reason about the 4 unrelated transformation in isolation.

Yes. Thank you for the suggestions. I have updated the diff to incorporate the changes you suggested. And submitted different test case for each optimization in isolation. Hope it has made it easier to review the patch.

[cs15btech11041]

In D41659#965696, @rengolin wrote:

This may need special guard with fast-math flags (precision, etc), no?

I have added FastMathFlagGuard Guard to the IRBuilder. And also copied the ffast-math flags of the division/multiplication instruction. To the new trigonometric/multiplication/division instruction inserted. As for precision, we are replacing two trigonometric functions with single equivalent trigonometric function with fast math flag guards. Also the type which we are specifying in CreateCall is same as that of the division/multiplication instruction. Hence would have the same type and precision. Please let me know if I did not answer your question.

[cs15btech11041]

In D41659#965699, @davide wrote:

Meta point: It's unclear to me whether this is something profitable to implement.
Sure, you can probably take a textbook and implement all the possible identities written there, but, what's the point?

I looked and it seems other compilers (most notably, GCC) don't implement at least the first transformation you implemented (I didn't bother to check the others).
https://godbolt.org/g/kKP5PW

tl;dr: what's your motivation?

Hi, thanks for the comments. the motivation for taking this up were two things.
First was missing optimization reported on bugzilla. However it mentions only the first optimization implemented. I have implemented for other similar cases as well.

https://bugs.llvm.org/show_bug.cgi?id=35602

Second, replacing two trigonometric operations with single trigonometric operation or with a mul/div instruction would save considerable clock cycles. It says trigonometric operations require almost five time the clock cycles needed by multiplication/division.Also to add we are reducing the code size. As one could see from the test cases, the number of instructions after transformations <= number of instructions before. And to that we are also saving clock cycles.

https://stackoverflow.com/questions/2479517/is-trigonometry-computationally-expensive

[cs15btech11041]

Added the right file for sin_div_tan.ll test case (incorrect was added in previous commit).

[spatel]

In D41659#965694, @fhahn wrote:

Thanks for your patch!

Usually it is easier to review smaller patches. Splitting it up into 4 patches for the 4 different cases you implemented would make it slightly easier to reason about the 4 unrelated transformation in isolation.

Strongly agree. I understand there's a common theme here, but it will save time making redundant comments if we start with a patch for just one of these transforms.

The structure of the patch is not correct. We don't need a trig helper function because it's impossible for an integer op like mul or udiv to have an FP operand like llvm.sin.
Please have a look at these patches for the correct way to match intrinsics and libcalls:
D41322
D41283
D41389

[fhahn]

In D41659#966397, @cs15btech11041 wrote:
Yes. Thank you for the suggestions. I have updated the diff to incorporate the changes you suggested. And submitted different test case for each optimization in isolation. Hope it has made it easier to review the patch.

I think I wasn't too clear, sorry. I meant splitting up the whole patch into 4 different patches and submitting them as separate reviewss, i.e. one review only including the code & test for tan(x)*cos(x)=sin(x), one for sin(x)*cos(x) = sin(2*x)/2 and so on.

This also makes it slightly easier to decide if each transform is beneficial on a case-by-case basis.

lib/Transforms/InstCombine/InstCombineInternal.h

private:
   /// demanded bits.
   bool SimplifyDemandedInstructionBits(Instruction &Inst);
 
   Value *SimplifyDemandedVectorElts(Value *V, APInt DemandedElts,
                                     APInt &UndefElts, unsigned Depth = 0);
 
   Value *SimplifyVectorOp(BinaryOperator &Inst);
 
+  Value *SimplifyTrigOp(Instruction &Inst);
 
   /// Given a binary operator, cast instruction, or select which has a PHI node
   /// as operand #0, see if we can fold the instruction into the PHI (which is
   /// only possible if all operands to the PHI are constants).
   Instruction *foldOpIntoPhi(Instruction &I, PHINode *PN);
 
   /// Given an instruction with a select as one operand and a constant as the
   /// other operand, try to fold the binary operator into the select arguments.

lib/Transforms/InstCombine/InstCombineMulDivRem.cpp

bool InstCombiner::willNotOverflowSignedMul(const Value *LHS,
   }
   return false;
 }
 
 Instruction *InstCombiner::visitMul(BinaryOperator &I) {
   bool Changed = SimplifyAssociativeOrCommutative(I);
   Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
 
+  if (Value *V = SimplifyTrigOp(I))
+    return replaceInstUsesWith(I, V);
+
   if (Value *V = SimplifyVectorOp(I))
     return replaceInstUsesWith(I, V);
 
   if (Value *V = SimplifyMulInst(Op0, Op1, SQ.getWithInstruction(&I)))
     return replaceInstUsesWith(I, V);
 
   if (Value *V = SimplifyUsingDistributiveLaws(I))
     return replaceInstUsesWith(I, V);
Value *InstCombiner::foldFMulConst(Instruction *FMulOrDiv, Constant *C,
 
   return R;
 }
 
 Instruction *InstCombiner::visitFMul(BinaryOperator &I) {
   bool Changed = SimplifyAssociativeOrCommutative(I);
   Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
 
+  if (Value *V = SimplifyTrigOp(I))
+    return replaceInstUsesWith(I, V);
+
   if (Value *V = SimplifyVectorOp(I))
     return replaceInstUsesWith(I, V);
 
   if (isa<Constant>(Op0))
     std::swap(Op0, Op1);
 
   if (Value *V = SimplifyFMulInst(Op0, Op1, I.getFastMathFlags(),
                                   SQ.getWithInstruction(&I)))
static Instruction *narrowUDivURem(BinaryOperator &I,
   }
 
   return nullptr;
 }
 
 Instruction *InstCombiner::visitUDiv(BinaryOperator &I) {
   Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
 
+  if (Value *V = SimplifyTrigOp(I))
+    return replaceInstUsesWith(I, V);
+
   if (Value *V = SimplifyVectorOp(I))
     return replaceInstUsesWith(I, V);
 
   if (Value *V = SimplifyUDivInst(Op0, Op1, SQ.getWithInstruction(&I)))
     return replaceInstUsesWith(I, V);
 
   // Handle the integer div common cases
   if (Instruction *Common = commonIDivTransforms(I))
if (visitUDivOperand(Op0, Op1, I, UDivActions))
     }
 
   return nullptr;
 }
 
 Instruction *InstCombiner::visitSDiv(BinaryOperator &I) {
   Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
 
+  if (Value *V = SimplifyTrigOp(I))
+    return replaceInstUsesWith(I, V);
+
   if (Value *V = SimplifyVectorOp(I))
     return replaceInstUsesWith(I, V);
 
   if (Value *V = SimplifySDivInst(Op0, Op1, SQ.getWithInstruction(&I)))
     return replaceInstUsesWith(I, V);
 
   // Handle the integer div common cases
   if (Instruction *Common = commonIDivTransforms(I))
static Instruction *CvtFDivConstToReciprocal(Value *Dividend, Constant *Divisor,
   ConstantFP *R;
   R = ConstantFP::get(Dividend->getType()->getContext(), Reciprocal);
   return BinaryOperator::CreateFMul(Dividend, R);
 }
 
 Instruction *InstCombiner::visitFDiv(BinaryOperator &I) {
   Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
 
+  if (Value *V = SimplifyTrigOp(I))
+    return replaceInstUsesWith(I, V);
+
   if (Value *V = SimplifyVectorOp(I))
     return replaceInstUsesWith(I, V);
 
   if (Value *V = SimplifyFDivInst(Op0, Op1, I.getFastMathFlags(),
                                   SQ.getWithInstruction(&I)))
     return replaceInstUsesWith(I, V);
 
   if (isa<Constant>(Op0))

lib/Transforms/InstCombine/InstructionCombining.cpp

 #include <string>
 #include <utility>
 
 using namespace llvm;
 using namespace llvm::PatternMatch;
 
 #define DEBUG_TYPE "instcombine"
 
-STATISTIC(NumCombined , "Number of insts combined");
+STATISTIC(NumCombined, "Number of insts combined");
 STATISTIC(NumConstProp, "Number of constant folds");
-STATISTIC(NumDeadInst , "Number of dead inst eliminated");
-STATISTIC(NumSunkInst , "Number of instructions sunk");
-STATISTIC(NumExpand,    "Number of expansions");
-STATISTIC(NumFactor   , "Number of factorizations");
-STATISTIC(NumReassoc  , "Number of reassociations");
+STATISTIC(NumDeadInst, "Number of dead inst eliminated");
+STATISTIC(NumSunkInst, "Number of instructions sunk");
+STATISTIC(NumExpand, "Number of expansions");
+STATISTIC(NumFactor, "Number of factorizations");
+STATISTIC(NumReassoc, "Number of reassociations");
 DEBUG_COUNTER(VisitCounter, "instcombine-visit",
               "Controls which instructions are visited");
 
 static cl::opt<bool>
     EnableExpensiveCombines("expensive-combines",
                             cl::desc("Enable expensive instruction combines"));
 
-static cl::opt<unsigned>
-MaxArraySize("instcombine-maxarray-size", cl::init(1024),
-             cl::desc("Maximum array size considered when doing a combine"));
+static cl::opt<unsigned> MaxArraySize(
+    "instcombine-maxarray-size", cl::init(1024),
 
 // FIXME: Remove this flag when it is no longer necessary to convert
 // llvm.dbg.declare to avoid inaccurate debug info. Setting this to false
 // increases variable availability at the cost of accuracy. Variables that
 // cannot be promoted by mem2reg or SROA will be described as living in memory
 // for their entire lifetime. However, passes like DSE and instcombine can
 // delete stores to the alloca, leading to misleading and inaccurate debug
 // information. This flag can be removed when those passes are fixed.

 bool InstCombiner::SimplifyAssociativeOrCommutative(BinaryOperator &I) {
   Instruction::BinaryOps Opcode = I.getOpcode();
   bool Changed = false;
 
   do {
     // Order operands such that they are listed from right (least complex) to
     // left (most complex).  This puts constants before unary operators before
     // binary operators.
-    if (I.isCommutative() && getComplexity(I.getOperand(0)) <
-        getComplexity(I.getOperand(1)))
+    if (I.isCommutative() &&
+        getComplexity(I.getOperand(0)) < getComplexity(I.getOperand(1)))
       Changed = !I.swapOperands();
 
     BinaryOperator *Op0 = dyn_cast<BinaryOperator>(I.getOperand(0));
     BinaryOperator *Op1 = dyn_cast<BinaryOperator>(I.getOperand(1));
 
     if (I.isAssociative()) {
       // Transform: "(A op B) op C" ==> "A op (B op C)" if "B op C" simplifies.
       if (Op0 && Op0->getOpcode() == Opcode) {
if (I.isAssociative() && I.isCommutative()) {
           Changed = true;
           ++NumReassoc;
           continue;
         }
       }
 
       // Transform: "(A op C1) op (B op C2)" ==> "(A op B) op (C1 op C2)"
       // if C1 and C2 are constants.
-      if (Op0 && Op1 &&
-          Op0->getOpcode() == Opcode && Op1->getOpcode() == Opcode &&
-          isa<Constant>(Op0->getOperand(1)) &&
-          isa<Constant>(Op1->getOperand(1)) &&
-          Op0->hasOneUse() && Op1->hasOneUse()) {
+      if (Op0 && Op1 && Op0->getOpcode() == Opcode &&
+          Op1->getOpcode() == Opcode && isa<Constant>(Op0->getOperand(1)) &&
+          isa<Constant>(Op1->getOperand(1)) && Op0->hasOneUse() &&
+          Op1->hasOneUse()) {
         Value *A = Op0->getOperand(0);
         Constant *C1 = cast<Constant>(Op0->getOperand(1));
         Value *B = Op1->getOperand(0);
         Constant *C2 = cast<Constant>(Op1->getOperand(1));
 
         Constant *Folded = ConstantExpr::get(Opcode, C1, C2);
         BinaryOperator *New = BinaryOperator::Create(Opcode, A, B);
         if (isa<FPMathOperator>(New)) {
Instruction::BinaryOps TopLevelOpcode = I.getOpcode();
     if (Op0 && Op1 && LHSOpcode == RHSOpcode)
       if (Value *V = tryFactorization(I, LHSOpcode, A, B, C, D))
         return V;
 
     // The instruction has the form "(A op' B) op (C)".  Try to factorize common
     // term.
     if (Op0)
       if (Value *Ident = getIdentityValue(LHSOpcode, RHS))
-        if (Value *V =
-                tryFactorization(I, LHSOpcode, A, B, RHS, Ident))
+        if (Value *V = tryFactorization(I, LHSOpcode, A, B, RHS, Ident))
           return V;
 
     // The instruction has the form "(B) op (C op' D)".  Try to factorize common
     // term.
     if (Op1)
       if (Value *Ident = getIdentityValue(RHSOpcode, LHS))
-        if (Value *V =
-                tryFactorization(I, RHSOpcode, LHS, Ident, C, D))
+        if (Value *V = tryFactorization(I, RHSOpcode, LHS, Ident, C, D))
           return V;
   }
 
   // Expansion.
   if (Op0 && RightDistributesOverLeft(Op0->getOpcode(), TopLevelOpcode)) {
     // The instruction has the form "(A op' B) op C".  See if expanding it out
     // to "(A op C) op' (B op C)" results in simplifications.
     Value *A = Op0->getOperand(0), *B = Op0->getOperand(1), *C = RHS;
if (auto *SOC = dyn_cast<Constant>(SO)) {
     return ConstantExpr::get(I.getOpcode(), ConstOperand, SOC);
   }
 
   Value *Op0 = SO, *Op1 = ConstOperand;
   if (!ConstIsRHS)
     std::swap(Op0, Op1);
 
   auto *BO = cast<BinaryOperator>(&I);
-  Value *RI = Builder.CreateBinOp(BO->getOpcode(), Op0, Op1,
-                                  SO->getName() + ".op");
+  Value *RI =
+      Builder.CreateBinOp(BO->getOpcode(), Op0, Op1, SO->getName() + ".op");
   auto *FPInst = dyn_cast<Instruction>(RI);
   if (FPInst && isa<FPMathOperator>(FPInst))
     FPInst->copyFastMathFlags(BO);
   return RI;
 }
 
 Instruction *InstCombiner::FoldOpIntoSelect(Instruction &Op, SelectInst *SI) {
   // Don't modify shared select instructions.
Instruction *InstCombiner::foldOpIntoPhi(Instruction &I, PHINode *PN) {
   // bail out.  We don't do arbitrary constant expressions here because moving
   // their computation can be expensive without a cost model.
   BasicBlock *NonConstBB = nullptr;
   for (unsigned i = 0; i != NumPHIValues; ++i) {
     Value *InVal = PN->getIncomingValue(i);
     if (isa<Constant>(InVal) && !isa<ConstantExpr>(InVal))
       continue;
 
-    if (isa<PHINode>(InVal)) return nullptr;  // Itself a phi.
-    if (NonConstBB) return nullptr;  // More than one non-const value.
+    if (isa<PHINode>(InVal))
+      return nullptr; // Itself a phi.
+    if (NonConstBB)
+      return nullptr; // More than one non-const value.
 
     NonConstBB = PN->getIncomingBlock(i);
 
     // If the InVal is an invoke at the end of the pred block, then we can't
     // insert a computation after it without breaking the edge.
     if (InvokeInst *II = dyn_cast<InvokeInst>(InVal))
       if (II->getParent() == NonConstBB)
         return nullptr;
 
     // If the incoming non-constant value is in I's block, we will remove one
     // instruction, but insert another equivalent one, leading to infinite
     // instcombine.
     if (isPotentiallyReachable(I.getParent(), NonConstBB, &DT, LI))
       return nullptr;
   }
 
   // If there is exactly one non-constant value, we can insert a copy of the
   // operation in that block.  However, if this is a critical edge, we would be
   // inserting the computation on some other paths (e.g. inside a loop).  Only
   // do this if the pred block is unconditionally branching into the phi block.
   if (NonConstBB != nullptr) {
     BranchInst *BI = dyn_cast<BranchInst>(NonConstBB->getTerminator());
-    if (!BI || !BI->isUnconditional()) return nullptr;
+    if (!BI || !BI->isUnconditional())
+      return nullptr;
   }
 
   // Okay, we can do the transformation: create the new PHI node.
   PHINode *NewPN = PHINode::Create(I.getType(), PN->getNumIncomingValues());
   InsertNewInstBefore(NewPN, *PN);
   NewPN->takeName(PN);
 
   // If we are going to have to insert a new computation, do so right before the
if (SelectInst *SI = dyn_cast<SelectInst>(&I)) {
     }
   } else if (CmpInst *CI = dyn_cast<CmpInst>(&I)) {
     Constant *C = cast<Constant>(I.getOperand(1));
     for (unsigned i = 0; i != NumPHIValues; ++i) {
       Value *InV = nullptr;
       if (Constant *InC = dyn_cast<Constant>(PN->getIncomingValue(i)))
         InV = ConstantExpr::getCompare(CI->getPredicate(), InC, C);
       else if (isa<ICmpInst>(CI))
-        InV = Builder.CreateICmp(CI->getPredicate(), PN->getIncomingValue(i),
-                                 C, "phitmp");
+        InV = Builder.CreateICmp(CI->getPredicate(), PN->getIncomingValue(i), C,
+                                 "phitmp");
       else
-        InV = Builder.CreateFCmp(CI->getPredicate(), PN->getIncomingValue(i),
-                                 C, "phitmp");
+        InV = Builder.CreateFCmp(CI->getPredicate(), PN->getIncomingValue(i), C,
+                                 "phitmp");
       NewPN->addIncoming(InV, PN->getIncomingBlock(i));
     }
   } else if (auto *BO = dyn_cast<BinaryOperator>(&I)) {
     for (unsigned i = 0; i != NumPHIValues; ++i) {
-      Value *InV = foldOperationIntoPhiValue(BO, PN->getIncomingValue(i),
-                                             Builder);
+      Value *InV =
+          foldOperationIntoPhiValue(BO, PN->getIncomingValue(i), Builder);
       NewPN->addIncoming(InV, PN->getIncomingBlock(i));
     }
   } else {
     CastInst *CI = cast<CastInst>(&I);
     Type *RetTy = CI->getType();
     for (unsigned i = 0; i != NumPHIValues; ++i) {
       Value *InV;
       if (Constant *InC = dyn_cast<Constant>(PN->getIncomingValue(i)))
         InV = ConstantExpr::getCast(CI->getOpcode(), InC, RetTy);
       else
         InV = Builder.CreateCast(CI->getOpcode(), PN->getIncomingValue(i),
                                  I.getType(), "phitmp");
       NewPN->addIncoming(InV, PN->getIncomingBlock(i));
     }
   }
 
   for (auto UI = PN->user_begin(), E = PN->user_end(); UI != E;) {
     Instruction *User = cast<Instruction>(*UI++);
-    if (User == &I) continue;
+    if (User == &I)
+      continue;
     replaceInstUsesWith(*User, NewPN);
     eraseInstFromFunction(*User);
   }
   return replaceInstUsesWith(I, NewPN);
 }
 
 Instruction *InstCombiner::foldOpWithConstantIntoOperand(BinaryOperator &I) {
   assert(isa<Constant>(I.getOperand(1)) && "Unexpected operand type");
if (!Ty->isSized())
     return nullptr;
 
   // Start with the index over the outer type.  Note that the type size
   // might be zero (even if the offset isn't zero) if the indexed type
   // is something like [0 x {int, int}]
   Type *IntPtrTy = DL.getIntPtrType(PtrTy);
   int64_t FirstIdx = 0;
   if (int64_t TySize = DL.getTypeAllocSize(Ty)) {
-    FirstIdx = Offset/TySize;
-    Offset -= FirstIdx*TySize;
+    FirstIdx = Offset / TySize;
+    Offset -= FirstIdx * TySize;
 
     // Handle hosts where % returns negative instead of values [0..TySize).
     if (Offset < 0) {
       --FirstIdx;
       Offset += TySize;
       assert(Offset >= 0);
     }
     assert((uint64_t)Offset < (uint64_t)TySize && "Out of range offset");
   }
 
   NewIndices.push_back(ConstantInt::get(IntPtrTy, FirstIdx));
 
   // Index into the types.  If we fail, set OrigBase to null.
   while (Offset) {
     // Indexing into tail padding between struct/array elements.
     if (uint64_t(Offset * 8) >= DL.getTypeSizeInBits(Ty))
       return nullptr;
 
     if (StructType *STy = dyn_cast<StructType>(Ty)) {
       const StructLayout *SL = DL.getStructLayout(STy);
       assert(Offset < (int64_t)SL->getSizeInBytes() &&
              "Offset must stay within the indexed type");
 
       unsigned Elt = SL->getElementContainingOffset(Offset);
-      NewIndices.push_back(ConstantInt::get(Type::getInt32Ty(Ty->getContext()),
-                                            Elt));
+      NewIndices.push_back(
+          ConstantInt::get(Type::getInt32Ty(Ty->getContext()), Elt));
 
       Offset -= SL->getElementOffset(Elt);
       Ty = STy->getElementType(Elt);
     } else if (ArrayType *AT = dyn_cast<ArrayType>(Ty)) {
       uint64_t EltSize = DL.getTypeAllocSize(AT->getElementType());
       assert(EltSize && "Cannot index into a zero-sized array");
-      NewIndices.push_back(ConstantInt::get(IntPtrTy,Offset/EltSize));
+      NewIndices.push_back(ConstantInt::get(IntPtrTy, Offset / EltSize));
       Offset %= EltSize;
       Ty = AT->getElementType();
     } else {
       // Otherwise, we can't index into the middle of this atomic type, bail.
       return nullptr;
     }
   }
 
   return Ty;
 }
 
 static bool shouldMergeGEPs(GEPOperator &GEP, GEPOperator &Src) {
   // If this GEP has only 0 indices, it is the same pointer as
   // Src. If Src is not a trivial GEP too, don't combine
   // the indices.
-  if (GEP.hasAllZeroIndices() && !Src.hasAllZeroIndices() &&
-      !Src.hasOneUse())
+  if (GEP.hasAllZeroIndices() && !Src.hasAllZeroIndices() && !Src.hasOneUse())
     return false;
   return true;
 }
 
 /// Return a value X such that Val = X * Scale, or null if none.
 /// If the multiplication is known not to overflow, then NoSignedWrap is set.
 Value *InstCombiner::Descale(Value *Val, APInt Scale, bool &NoSignedWrap) {
   assert(isa<IntegerType>(Val->getType()) && "Can only descale integers!");
   assert(cast<IntegerType>(Val->getType())->getBitWidth() ==
-         Scale.getBitWidth() && "Scale not compatible with value!");
+             Scale.getBitWidth() &&
+         "Scale not compatible with value!");
 
   // If Val is zero or Scale is one then Val = Val * Scale.
   if (match(Val, m_Zero()) || Scale == 1) {
     NoSignedWrap = true;
     return Val;
   }
 
   // If Scale is zero then it does not divide Val.
if (BinaryOperator *BO = dyn_cast<BinaryOperator>(Op)) {
       if (logScale > 0 && BO->getOpcode() == Instruction::Shl &&
           isa<ConstantInt>(BO->getOperand(1))) {
         // Multiplication by a power of 2.
         NoSignedWrap = BO->hasNoSignedWrap();
         if (RequireNoSignedWrap && !NoSignedWrap)
           return nullptr;
 
         Value *LHS = BO->getOperand(0);
-        int32_t Amt = cast<ConstantInt>(BO->getOperand(1))->
-          getLimitedValue(Scale.getBitWidth());
+        int32_t Amt = cast<ConstantInt>(BO->getOperand(1))
+                          ->getLimitedValue(Scale.getBitWidth());
         // Op = LHS << Amt.
 
         if (Amt == logScale) {
           // Multiplication by exactly the scale, replace the multiplication
           // by its left-hand side in the parent.
           Op = LHS;
           break;
         }
static Value *CreateBinOpAsGiven(BinaryOperator &Inst, Value *LHS, Value *RHS,
                                  InstCombiner::BuilderTy &B) {
   Value *BO = B.CreateBinOp(Inst.getOpcode(), LHS, RHS);
   // If LHS and RHS are constant, BO won't be a binary operator.
   if (BinaryOperator *NewBO = dyn_cast<BinaryOperator>(BO))
     NewBO->copyIRFlags(&Inst);
   return BO;
 }
 
+static bool isTrigLibCall(CallInst *CI) {
+  // We can only hope to do anything useful if we can ignore things like errno
+  // and floating-point exceptions.
+  // We already checked the prototype.
+  return CI->hasFnAttr(Attribute::NoUnwind) &&
+         CI->hasFnAttr(Attribute::ReadNone);
+}
+
+/// \brief Replaces the division or multiplication operations on trigonometric
+/// functions to equivalent trigonometric operation
+
+Value *InstCombiner::SimplifyTrigOp(Instruction &I) {
+
+  if (((I.getOpcode() == Instruction::FMul) ||
+       (I.getOpcode() == Instruction::Mul))) {
+    if (isa<CallInst>(I.getOperand(0)) && isa<CallInst>(I.getOperand(1))) {
+      CallInst *call1 = dyn_cast<CallInst>(I.getOperand(0));
+      CallInst *call2 = dyn_cast<CallInst>(I.getOperand(1));
+
+      // return nullptr if argument to calls are not same
+      if (!(call1->getOperand(0) == call2->getOperand(0)))
+        return nullptr;
+
+      // tan(x)*cos(x)=sin(x);
+
+      Value *Op1 = call1->getArgOperand(1);
+      Value *Op2 = call2->getArgOperand(1);
+
+      if ((isTrigLibCall(call1) &&
+           ((Op1->getName() == "tan") || (Op1->getName() == "tanf") ||
+            (Op1->getName() == "tanf")) &&
+           (Op2->getName().startswith("llvm.cos"))) ||
+          (isTrigLibCall(call2) && (Op1->getName().startswith("llvm.cos")) &&
+           ((Op2->getName() == "tan") || (Op2->getName() == "tanf") ||
+            (Op2->getName() == "tanl")))) {
+        IRBuilder<>::FastMathFlagGuard Guard(Builder);
+        Builder.setFastMathFlags(I.getFastMathFlags());
+        Function *fun = Intrinsic::getDeclaration(I.getModule(), Intrinsic::sin,
+                                                  I.getType());
+        CallInst *SinCall = Builder.CreateCall(fun, call2->getOperand(0));
+
+        SinCall->takeName(&I);
+        SinCall->copyFastMathFlags(&I);
+
+        return SinCall;
+      }
+
+      // sin(x)*cos(x)=sin(2x)*0.5
+
+      else if (((call1->getOperand(1)->getName().startswith("llvm.sin")) &&
+                (call2->getOperand(1)->getName().startswith("llvm.cos"))) ||
+               ((call1->getOperand(1)->getName().startswith("llvm.cos")) &&
+                (call2->getOperand(1)->getName().startswith("llvm.sin")))) {
+        IRBuilder<>::FastMathFlagGuard Guard(Builder);
+        Builder.setFastMathFlags(I.getFastMathFlags());
+        Function *fun = Intrinsic::getDeclaration(I.getModule(), Intrinsic::sin,
+                                                  I.getType());
+
+        Constant *ConstFloatTwo =
+            ConstantFP::get(Type::getDoubleTy(I.getContext()), 2.0);
+        Instruction *MulIns = dyn_cast<Instruction>(
+            Builder.CreateFMul(ConstFloatTwo, call1->getOperand(0)));
+        CallInst *SinCall = Builder.CreateCall(fun, MulIns);
+        Instruction *DivIns =
+            dyn_cast<Instruction>(Builder.CreateFDiv(SinCall, ConstFloatTwo));
+        DivIns->takeName(&I);
+        DivIns->copyFastMathFlags(&I);
+
+        return DivIns;
+      }
+    }
+  }
+
+  else if ((I.getOpcode() == Instruction::FDiv) ||
+           (I.getOpcode() == Instruction::SDiv) ||
+           (I.getOpcode() == Instruction::UDiv)) {
+    if (isa<CallInst>(I.getOperand(0)) && isa<CallInst>(I.getOperand(1))) {
+      CallInst *call1 = dyn_cast<CallInst>(I.getOperand(0));
+      CallInst *call2 = dyn_cast<CallInst>(I.getOperand(1));
+
+      // return nullptr if argument to calls are not same
+
+      if (!(call1->getOperand(0) == call2->getOperand(0)))
+        return nullptr;
+
+      Value *Op1 = call1->getArgOperand(1);
+      Value *Op2 = call2->getArgOperand(1);
+
+      // sin/tan=cos;
+      if ((Op1->getName().startswith("llvm.sin")) &&
+
+          (isTrigLibCall(call2) &&
+           ((Op2->getName() == "tan") || (Op2->getName() == "tanf") ||
+            (Op2->getName() == "tanl")))) {
+        IRBuilder<>::FastMathFlagGuard Guard(Builder);
+        Builder.setFastMathFlags(I.getFastMathFlags());
+        Function *fun = Intrinsic::getDeclaration(I.getModule(), Intrinsic::cos,
+                                                  I.getType());
+        CallInst *CosCall = Builder.CreateCall(fun, call1->getOperand(0));
+        CosCall->takeName(&I);
+        CosCall->copyFastMathFlags(&I);
+        return CosCall;
+      }
+
+      // tan/sin=1/cos;
+      else if ((Op2->getName().startswith("llvm.sin")) &&
+
+               (isTrigLibCall(call1) &&
+                ((Op1->getName() == "tan") || (Op1->getName() == "tanf") ||
+                 (Op1->getName() == "tanl")))) {
+        IRBuilder<>::FastMathFlagGuard Guard(Builder);
+        Builder.setFastMathFlags(I.getFastMathFlags());
+        Function *fun = Intrinsic::getDeclaration(I.getModule(), Intrinsic::cos,
+                                                  I.getType());
+        CallInst *CosCall = Builder.CreateCall(fun, call1->getOperand(0));
+        Constant *ConstFloatOne =
+            ConstantFP::get(Type::getDoubleTy(I.getContext()), 1.0);
+
+        Instruction *DivIns =
+            dyn_cast<Instruction>(Builder.CreateFDiv(ConstFloatOne, CosCall));
+        DivIns->takeName(&I);
+        DivIns->copyFastMathFlags(&I);
+
+        return DivIns;
+      }
+    }
+  }
+
+  return nullptr;
+}
+
 /// \brief Makes transformation of binary operation specific for vector types.
 /// \param Inst Binary operator to transform.
 /// \return Pointer to node that must replace the original binary operator, or
 ///         null pointer if no transformation was made.
 Value *InstCombiner::SimplifyVectorOp(BinaryOperator &Inst) {
-  if (!Inst.getType()->isVectorTy()) return nullptr;
+  if (!Inst.getType()->isVectorTy())
+    return nullptr;
 
   // It may not be safe to reorder shuffles and things like div, urem, etc.
   // because we may trap when executing those ops on unknown vector elements.
   // See PR20059.
   if (!isSafeToSpeculativelyExecute(&Inst))
     return nullptr;
 
   unsigned VWidth = cast<VectorType>(Inst.getType())->getNumElements();
   Value *LHS = Inst.getOperand(0), *RHS = Inst.getOperand(1);
   assert(cast<VectorType>(LHS->getType())->getNumElements() == VWidth);
   assert(cast<VectorType>(RHS->getType())->getNumElements() == VWidth);
 
   // If both arguments of the binary operation are shuffles that use the same
   // mask and shuffle within a single vector, move the shuffle after the binop:
   //   Op(shuffle(v1, m), shuffle(v2, m)) -> shuffle(Op(v1, v2), m)
   auto *LShuf = dyn_cast<ShuffleVectorInst>(LHS);
   auto *RShuf = dyn_cast<ShuffleVectorInst>(RHS);
   if (LShuf && RShuf && LShuf->getMask() == RShuf->getMask() &&
       isa<UndefValue>(LShuf->getOperand(1)) &&
       isa<UndefValue>(RShuf->getOperand(1)) &&
       LShuf->getOperand(0)->getType() == RShuf->getOperand(0)->getType()) {
     Value *NewBO = CreateBinOpAsGiven(Inst, LShuf->getOperand(0),
                                       RShuf->getOperand(0), Builder);
-    return Builder.CreateShuffleVector(
-        NewBO, UndefValue::get(NewBO->getType()), LShuf->getMask());
+    return Builder.CreateShuffleVector(NewBO, UndefValue::get(NewBO->getType()),
+                                       LShuf->getMask());
   }
 
   // If one argument is a shuffle within one vector, the other is a constant,
   // try moving the shuffle after the binary operation.
   ShuffleVectorInst *Shuffle = nullptr;
   Constant *C1 = nullptr;
-  if (isa<ShuffleVectorInst>(LHS)) Shuffle = cast<ShuffleVectorInst>(LHS);
-  if (isa<ShuffleVectorInst>(RHS)) Shuffle = cast<ShuffleVectorInst>(RHS);
-  if (isa<Constant>(LHS)) C1 = cast<Constant>(LHS);
-  if (isa<Constant>(RHS)) C1 = cast<Constant>(RHS);
+  if (isa<ShuffleVectorInst>(LHS))
+    Shuffle = cast<ShuffleVectorInst>(LHS);
+  if (isa<ShuffleVectorInst>(RHS))
+    Shuffle = cast<ShuffleVectorInst>(RHS);
+  if (isa<Constant>(LHS))
+    C1 = cast<Constant>(LHS);
+  if (isa<Constant>(RHS))
+    C1 = cast<Constant>(RHS);
   if (Shuffle && C1 &&
       (isa<ConstantVector>(C1) || isa<ConstantDataVector>(C1)) &&
       isa<UndefValue>(Shuffle->getOperand(1)) &&
       Shuffle->getType() == Shuffle->getOperand(0)->getType()) {
     SmallVector<int, 16> ShMask = Shuffle->getShuffleMask();
     // Find constant C2 that has property:
     //   shuffle(C2, ShMask) = C1
     // If such constant does not exist (example: ShMask=<0,0> and C1=<1,2>)
     // reorder is not possible.
-    SmallVector<Constant*, 16> C2M(VWidth,
-                               UndefValue::get(C1->getType()->getScalarType()));
+    SmallVector<Constant *, 16> C2M(
+        VWidth, UndefValue::get(C1->getType()->getScalarType()));
     bool MayChange = true;
     for (unsigned I = 0; I < VWidth; ++I) {
       if (ShMask[I] >= 0) {
         assert(ShMask[I] < (int)VWidth);
         if (!isa<UndefValue>(C2M[ShMask[I]])) {
           MayChange = false;
           break;
         }
         C2M[ShMask[I]] = C1->getAggregateElement(I);
       }
     }
     if (MayChange) {
       Constant *C2 = ConstantVector::get(C2M);
       Value *NewLHS = isa<Constant>(LHS) ? C2 : Shuffle->getOperand(0);
       Value *NewRHS = isa<Constant>(LHS) ? Shuffle->getOperand(0) : C2;
       Value *NewBO = CreateBinOpAsGiven(Inst, NewLHS, NewRHS, Builder);
-      return Builder.CreateShuffleVector(NewBO,
-          UndefValue::get(Inst.getType()), Shuffle->getMask());
+      return Builder.CreateShuffleVector(NewBO, UndefValue::get(Inst.getType()),
+                                         Shuffle->getMask());
     }
   }
 
   return nullptr;
 }
 
 Instruction *InstCombiner::visitGetElementPtrInst(GetElementPtrInst &GEP) {
-  SmallVector<Value*, 8> Ops(GEP.op_begin(), GEP.op_end());
+  SmallVector<Value *, 8> Ops(GEP.op_begin(), GEP.op_end());
 
   if (Value *V = SimplifyGEPInst(GEP.getSourceElementType(), Ops,
                                  SQ.getWithInstruction(&GEP)))
     return replaceInstUsesWith(GEP, V);
 
   Value *PtrOp = GEP.getOperand(0);
 
   // Eliminate unneeded casts for indices, and replace indices which displace
   // by multiples of a zero size type with zero.
   bool MadeChange = false;
   Type *IntPtrTy =
       DL.getIntPtrType(GEP.getPointerOperandType()->getScalarType());
 
   gep_type_iterator GTI = gep_type_begin(GEP);
   for (User::op_iterator I = GEP.op_begin() + 1, E = GEP.op_end(); I != E;
        ++I, ++GTI) {
     // Skip indices into struct types.
     if (GTI.isStruct())
       continue;
 
     // Index type should have the same width as IntPtr
     Type *IndexTy = (*I)->getType();
-    Type *NewIndexType = IndexTy->isVectorTy() ?
-      VectorType::get(IntPtrTy, IndexTy->getVectorNumElements()) : IntPtrTy;
+    Type *NewIndexType =
+        IndexTy->isVectorTy()
+            ? VectorType::get(IntPtrTy, IndexTy->getVectorNumElements())
+            : IntPtrTy;
 
     // If the element type has zero size then any index over it is equivalent
     // to an index of zero, so replace it with zero if it is not zero already.
     Type *EltTy = GTI.getIndexedType();
     if (EltTy->isSized() && DL.getTypeAllocSize(EltTy) == 0)
       if (!isa<Constant>(*I) || !cast<Constant>(*I)->isNullValue()) {
         *I = Constant::getNullValue(NewIndexType);
         MadeChange = true;
if (PHINode *PN = dyn_cast<PHINode>(PtrOp)) {
     // thus requiring an additional register variable to be live, but not
     // actually achieving anything (the GEP still needs to be executed once per
     // loop iteration).
     if (Op1 == &GEP)
       return nullptr;
 
     int DI = -1;
 
-    for (auto I = PN->op_begin()+1, E = PN->op_end(); I !=E; ++I) {
+    for (auto I = PN->op_begin() + 1, E = PN->op_end(); I != E; ++I) {
       GetElementPtrInst *Op2 = dyn_cast<GetElementPtrInst>(*I);
       if (!Op2 || Op1->getNumOperands() != Op2->getNumOperands())
         return nullptr;
 
       // As for Op1 above, don't try to fold a GEP into itself.
       if (Op2 == &GEP)
         return nullptr;
 
Instruction *InstCombiner::visitGetElementPtrInst(GetElementPtrInst &GEP) {
   // getelementptr instructions into a single instruction.
   if (GEPOperator *Src = dyn_cast<GEPOperator>(PtrOp)) {
     if (!shouldMergeGEPs(*cast<GEPOperator>(&GEP), *Src))
       return nullptr;
 
     // Note that if our source is a gep chain itself then we wait for that
     // chain to be resolved before we perform this transformation.  This
     // avoids us creating a TON of code in some cases.
-    if (GEPOperator *SrcGEP =
-          dyn_cast<GEPOperator>(Src->getOperand(0)))
+    if (GEPOperator *SrcGEP = dyn_cast<GEPOperator>(Src->getOperand(0)))
       if (SrcGEP->getNumOperands() == 2 && shouldMergeGEPs(*Src, *SrcGEP))
-        return nullptr;   // Wait until our source is folded to completion.
+        return nullptr; // Wait until our source is folded to completion.
 
-    SmallVector<Value*, 8> Indices;
+    SmallVector<Value *, 8> Indices;
 
     // Find out whether the last index in the source GEP is a sequential idx.
     bool EndsWithSequential = false;
     for (gep_type_iterator I = gep_type_begin(*Src), E = gep_type_end(*Src);
          I != E; ++I)
       EndsWithSequential = I.isSequential();
 
     // Can we combine the two pointer arithmetics offsets?
     if (EndsWithSequential) {
       // Replace: gep (gep %P, long B), long A, ...
       // With:    T = long A+B; gep %P, T, ...
-      Value *SO1 = Src->getOperand(Src->getNumOperands()-1);
+      Value *SO1 = Src->getOperand(Src->getNumOperands() - 1);
       Value *GO1 = GEP.getOperand(1);
 
       // If they aren't the same type, then the input hasn't been processed
       // by the loop above yet (which canonicalizes sequential index types to
       // intptr_t).  Just avoid transforming this until the input has been
       // normalized.
       if (SO1->getType() != GO1->getType())
         return nullptr;
 
       Value *Sum =
           SimplifyAddInst(GO1, SO1, false, false, SQ.getWithInstruction(&GEP));
       // Only do the combine when we are sure the cost after the
       // merge is never more than that before the merge.
       if (Sum == nullptr)
         return nullptr;
 
       // Update the GEP in place if possible.
       if (Src->getNumOperands() == 2) {
         GEP.setOperand(0, Src->getOperand(0));
         GEP.setOperand(1, Sum);
         return &GEP;
       }
-      Indices.append(Src->op_begin()+1, Src->op_end()-1);
+      Indices.append(Src->op_begin() + 1, Src->op_end() - 1);
       Indices.push_back(Sum);
-      Indices.append(GEP.op_begin()+2, GEP.op_end());
+      Indices.append(GEP.op_begin() + 2, GEP.op_end());
     } else if (isa<Constant>(*GEP.idx_begin()) &&
                cast<Constant>(*GEP.idx_begin())->isNullValue() &&
                Src->getNumOperands() != 1) {
       // Otherwise we can do the fold if the first index of the GEP is a zero
-      Indices.append(Src->op_begin()+1, Src->op_end());
-      Indices.append(GEP.idx_begin()+1, GEP.idx_end());
+      Indices.append(Src->op_begin() + 1, Src->op_end());
+      Indices.append(GEP.idx_begin() + 1, GEP.idx_end());
     }
 
     if (!Indices.empty())
       return GEP.isInBounds() && Src->isInBounds()
                  ? GetElementPtrInst::CreateInBounds(
                        Src->getSourceElementType(), Src->getOperand(0), Indices,
                        GEP.getName())
                  : GetElementPtrInst::Create(Src->getSourceElementType(),
if (StrippedPtr != PtrOp) {
     // Transform: GEP (bitcast [10 x i8]* X to [0 x i8]*), i32 0, ...
     // into     : GEP [10 x i8]* X, i32 0, ...
     //
     // Likewise, transform: GEP (bitcast i8* X to [0 x i8]*), i32 0, ...
     //           into     : GEP i8* X, ...
     //
     // This occurs when the program declares an array extern like "int X[];"
     if (HasZeroPointerIndex) {
-      if (ArrayType *CATy =
-          dyn_cast<ArrayType>(GEP.getSourceElementType())) {
+      if (ArrayType *CATy = dyn_cast<ArrayType>(GEP.getSourceElementType())) {
         // GEP (bitcast i8* X to [0 x i8]*), i32 0, ... ?
         if (CATy->getElementType() == StrippedPtrTy->getElementType()) {
           // -> GEP i8* X, ...
-          SmallVector<Value*, 8> Idx(GEP.idx_begin()+1, GEP.idx_end());
+          SmallVector<Value *, 8> Idx(GEP.idx_begin() + 1, GEP.idx_end());
           GetElementPtrInst *Res = GetElementPtrInst::Create(
               StrippedPtrTy->getElementType(), StrippedPtr, Idx, GEP.getName());
           Res->setIsInBounds(GEP.isInBounds());
           if (StrippedPtrTy->getAddressSpace() == GEP.getAddressSpace())
             return Res;
           // Insert Res, and create an addrspacecast.
           // e.g.,
           // GEP (addrspacecast i8 addrspace(1)* X to [0 x i8]*), i32 0, ...
           // ->
           // %0 = GEP i8 addrspace(1)* X, ...
           // addrspacecast i8 addrspace(1)* %0 to i8*
           return new AddrSpaceCastInst(Builder.Insert(Res), GEP.getType());
         }
 
         if (ArrayType *XATy =
-              dyn_cast<ArrayType>(StrippedPtrTy->getElementType())){
+                dyn_cast<ArrayType>(StrippedPtrTy->getElementType())) {
           // GEP (bitcast [10 x i8]* X to [0 x i8]*), i32 0, ... ?
           if (CATy->getElementType() == XATy->getElementType()) {
             // -> GEP [10 x i8]* X, i32 0, ...
             // At this point, we know that the cast source type is a pointer
             // to an array of the same type as the destination pointer
             // array.  Because the array type is never stepped over (there
             // is a leading zero) we can fold the cast into this GEP.
             if (StrippedPtrTy->getAddressSpace() == GEP.getAddressSpace()) {
               GEP.setOperand(0, StrippedPtr);
               GEP.setSourceElementType(XATy);
               return &GEP;
             }
             // Cannot replace the base pointer directly because StrippedPtr's
             // address space is different. Instead, create a new GEP followed by
             // an addrspacecast.
             // e.g.,
             // GEP (addrspacecast [10 x i8] addrspace(1)* X to [0 x i8]*),
             //   i32 0, ...
             // ->
             // %0 = GEP [10 x i8] addrspace(1)* X, ...
             // addrspacecast i8 addrspace(1)* %0 to i8*
-            SmallVector<Value*, 8> Idx(GEP.idx_begin(), GEP.idx_end());
+            SmallVector<Value *, 8> Idx(GEP.idx_begin(), GEP.idx_end());
             Value *NewGEP = GEP.isInBounds()
                                 ? Builder.CreateInBoundsGEP(
                                       nullptr, StrippedPtr, Idx, GEP.getName())
                                 : Builder.CreateGEP(nullptr, StrippedPtr, Idx,
                                                     GEP.getName());
             return new AddrSpaceCastInst(NewGEP, GEP.getType());
           }
         }
       }
     } else if (GEP.getNumOperands() == 2) {
       // Transform things like:
       // %t = getelementptr i32* bitcast ([2 x i32]* %str to i32*), i32 %V
       // into:  %t1 = getelementptr [2 x i32]* %str, i32 0, i32 %V; bitcast
       Type *SrcElTy = StrippedPtrTy->getElementType();
       Type *ResElTy = GEP.getSourceElementType();
       if (SrcElTy->isArrayTy() &&
           DL.getTypeAllocSize(SrcElTy->getArrayElementType()) ==
               DL.getTypeAllocSize(ResElTy)) {
         Type *IdxType = DL.getIntPtrType(GEP.getType());
-        Value *Idx[2] = { Constant::getNullValue(IdxType), GEP.getOperand(1) };
+        Value *Idx[2] = {Constant::getNullValue(IdxType), GEP.getOperand(1)};
         Value *NewGEP =
             GEP.isInBounds()
                 ? Builder.CreateInBoundsGEP(nullptr, StrippedPtr, Idx,
                                             GEP.getName())
                 : Builder.CreateGEP(nullptr, StrippedPtr, Idx, GEP.getName());
 
         // V and GEP are both pointer types --> BitCast
         return CastInst::CreatePointerBitCastOrAddrSpaceCast(NewGEP,
if (!isa<BitCastInst>(Operand) &&
               I->takeName(BCI);
               BCI->getParent()->getInstList().insert(BCI->getIterator(), I);
               replaceInstUsesWith(*BCI, I);
             }
             return &GEP;
           }
         }
 
-        if (Operand->getType()->getPointerAddressSpace() != GEP.getAddressSpace())
+        if (Operand->getType()->getPointerAddressSpace() !=
+            GEP.getAddressSpace())
           return new AddrSpaceCastInst(Operand, GEP.getType());
         return new BitCastInst(Operand, GEP.getType());
       }
 
       // Otherwise, if the offset is non-zero, we need to find out if there is a
       // field at Offset in 'A's type.  If so, we can pull the cast through the
       // GEP.
-      SmallVector<Value*, 8> NewIndices;
+      SmallVector<Value *, 8> NewIndices;
       if (FindElementAtOffset(OpType, Offset.getSExtValue(), NewIndices)) {
         Value *NGEP =
             GEP.isInBounds()
                 ? Builder.CreateInBoundsGEP(nullptr, Operand, NewIndices)
                 : Builder.CreateGEP(nullptr, Operand, NewIndices);
 
         if (NGEP->getType() == GEP.getType())
           return replaceInstUsesWith(GEP, NGEP);
         NGEP->takeName(&GEP);
 
         if (NGEP->getType()->getPointerAddressSpace() != GEP.getAddressSpace())
           return new AddrSpaceCastInst(NGEP, GEP.getType());
         return new BitCastInst(NGEP, GEP.getType());
       }
     }
   }
 
   if (!GEP.isInBounds()) {
     unsigned PtrWidth =
         DL.getPointerSizeInBits(PtrOp->getType()->getPointerAddressSpace());
     APInt BasePtrOffset(PtrWidth, 0);
     Value *UnderlyingPtrOp =
-            PtrOp->stripAndAccumulateInBoundsConstantOffsets(DL,
-                                                             BasePtrOffset);
+        PtrOp->stripAndAccumulateInBoundsConstantOffsets(DL, BasePtrOffset);
     if (auto *AI = dyn_cast<AllocaInst>(UnderlyingPtrOp)) {
       if (GEP.accumulateConstantOffset(DL, BasePtrOffset) &&
           BasePtrOffset.isNonNegative()) {
         APInt AllocSize(PtrWidth, DL.getTypeAllocSize(AI->getAllocatedType()));
         if (BasePtrOffset.ule(AllocSize)) {
           return GetElementPtrInst::CreateInBounds(
               PtrOp, makeArrayRef(Ops).slice(1), GEP.getName());
         }
static bool isNeverEqualToUnescapedAlloc(Value *V, const TargetLibraryInfo *TLI,
   // the result statement below to be true, even when AI and V (ex:
   // i8* ->i32* ->i8* of AI) are the same allocations.
   return isAllocLikeFn(V, TLI) && V != AI;
 }
 
 static bool isAllocSiteRemovable(Instruction *AI,
                                  SmallVectorImpl<WeakTrackingVH> &Users,
                                  const TargetLibraryInfo *TLI) {
-  SmallVector<Instruction*, 4> Worklist;
+  SmallVector<Instruction *, 4> Worklist;
   Worklist.push_back(AI);
 
   do {
     Instruction *PI = Worklist.pop_back_val();
     for (User *U : PI->users()) {
       Instruction *I = cast<Instruction>(U);
       switch (I->getOpcode()) {
       default:
if (isa<AllocaInst>(MI)) {
     DIB.reset(new DIBuilder(*MI.getModule(), /*AllowUnresolved=*/false));
   }
 
   if (isAllocSiteRemovable(&MI, Users, &TLI)) {
     for (unsigned i = 0, e = Users.size(); i != e; ++i) {
       // Lowering all @llvm.objectsize calls first because they may
       // use a bitcast/GEP of the alloca we are removing.
       if (!Users[i])
         continue;
 
       Instruction *I = cast<Instruction>(&*Users[i]);
 
       if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(I)) {
         if (II->getIntrinsicID() == Intrinsic::objectsize) {
           ConstantInt *Result = lowerObjectSizeCall(II, DL, &TLI,
                                                     /*MustSucceed=*/true);
           replaceInstUsesWith(*I, Result);
for (unsigned i = 0, e = Users.size(); i != e; ++i) {
       }
       eraseInstFromFunction(*I);
     }
 
     if (InvokeInst *II = dyn_cast<InvokeInst>(&MI)) {
       // Replace invoke with a NOP intrinsic to maintain the original CFG
       Module *M = II->getModule();
       Function *F = Intrinsic::getDeclaration(M, Intrinsic::donothing);
-      InvokeInst::Create(F, II->getNormalDest(), II->getUnwindDest(),
-                         None, "", II->getParent());
+      InvokeInst::Create(F, II->getNormalDest(), II->getUnwindDest(), None, "",
+                         II->getParent());
     }
 
     for (auto *DII : DIIs)
       eraseInstFromFunction(*DII);
 
     return eraseInstFromFunction(MI);
   }
   return nullptr;

 /// will be removed, i.e.:
 /// 1. it has only one predecessor P, and P has two successors
 /// 2. it contains the call and an unconditional branch
 /// 3. its successor is the same as its predecessor's successor
 ///
 /// The profitability is out-of concern here and this function should
 /// be called only if the caller knows this transformation would be
 /// profitable (e.g., for code size).
-static Instruction *
-tryToMoveFreeBeforeNullTest(CallInst &FI) {
+static Instruction *tryToMoveFreeBeforeNullTest(CallInst &FI) {
   Value *Op = FI.getArgOperand(0);
   BasicBlock *FreeInstrBB = FI.getParent();
   BasicBlock *PredBB = FreeInstrBB->getSinglePredecessor();
 
   // Validate part of constraint #1: Only one predecessor
   // FIXME: We can extend the number of predecessor, but in that case, we
   //        would duplicate the call to free in each predecessor and it may
   //        not be profitable even for code size.
Instruction *InstCombiner::visitSwitchInst(SwitchInst &SI) {
   // TODO: A better way to determine this would use ComputeNumSignBits().
   for (auto &C : SI.cases()) {
     LeadingKnownZeros = std::min(
         LeadingKnownZeros, C.getCaseValue()->getValue().countLeadingZeros());
     LeadingKnownOnes = std::min(
         LeadingKnownOnes, C.getCaseValue()->getValue().countLeadingOnes());
   }
 
-  unsigned NewWidth = Known.getBitWidth() - std::max(LeadingKnownZeros, LeadingKnownOnes);
+  unsigned NewWidth =
+      Known.getBitWidth() - std::max(LeadingKnownZeros, LeadingKnownOnes);
 
   // Shrink the condition operand if the new type is smaller than the old type.
   // This may produce a non-standard type for the switch, but that's ok because
   // the backend should extend back to a legal type for the target.
   if (NewWidth > 0 && NewWidth < Known.getBitWidth()) {
     IntegerType *Ty = IntegerType::get(SI.getContext(), NewWidth);
     Builder.SetInsertPoint(&SI);
     Value *NewCond = Builder.CreateTrunc(Cond, Ty, "trunc");
Instruction *InstCombiner::visitExtractValueInst(ExtractValueInst &EV) {
 
   if (Value *V = SimplifyExtractValueInst(Agg, EV.getIndices(),
                                           SQ.getWithInstruction(&EV)))
     return replaceInstUsesWith(EV, V);
 
   if (InsertValueInst *IV = dyn_cast<InsertValueInst>(Agg)) {
     // We're extracting from an insertvalue instruction, compare the indices
     const unsigned *exti, *exte, *insi, *inse;
-    for (exti = EV.idx_begin(), insi = IV->idx_begin(),
-         exte = EV.idx_end(), inse = IV->idx_end();
-         exti != exte && insi != inse;
-         ++exti, ++insi) {
+    for (exti = EV.idx_begin(), insi = IV->idx_begin(), exte = EV.idx_end(),
+        inse = IV->idx_end();
+         exti != exte && insi != inse; ++exti, ++insi) {
       if (*insi != *exti)
         // The insert and extract both reference distinctly different elements.
         // This means the extract is not influenced by the insert, and we can
         // replace the aggregate operand of the extract with the aggregate
         // operand of the insert. i.e., replace
         // %I = insertvalue { i32, { i32 } } %A, { i32 } { i32 42 }, 1
         // %E = extractvalue { i32, { i32 } } %I, 0
         // with
if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(Agg)) {
     // just get one value.
     if (II->hasOneUse()) {
       // Check if we're grabbing the overflow bit or the result of a 'with
       // overflow' intrinsic.  If it's the latter we can remove the intrinsic
       // and replace it with a traditional binary instruction.
       switch (II->getIntrinsicID()) {
       case Intrinsic::uadd_with_overflow:
       case Intrinsic::sadd_with_overflow:
-        if (*EV.idx_begin() == 0) {  // Normal result.
+        if (*EV.idx_begin() == 0) { // Normal result.
           Value *LHS = II->getArgOperand(0), *RHS = II->getArgOperand(1);
           replaceInstUsesWith(*II, UndefValue::get(II->getType()));
           eraseInstFromFunction(*II);
           return BinaryOperator::CreateAdd(LHS, RHS);
         }
 
         // If the normal result of the add is dead, and the RHS is a constant,
         // we can transform this into a range comparison.
         // overflow = uadd a, -4  -->  overflow = icmp ugt a, 3
         if (II->getIntrinsicID() == Intrinsic::uadd_with_overflow)
           if (ConstantInt *CI = dyn_cast<ConstantInt>(II->getArgOperand(1)))
             return new ICmpInst(ICmpInst::ICMP_UGT, II->getArgOperand(0),
                                 ConstantExpr::getNot(CI));
         break;
       case Intrinsic::usub_with_overflow:
       case Intrinsic::ssub_with_overflow:
-        if (*EV.idx_begin() == 0) {  // Normal result.
+        if (*EV.idx_begin() == 0) { // Normal result.
           Value *LHS = II->getArgOperand(0), *RHS = II->getArgOperand(1);
           replaceInstUsesWith(*II, UndefValue::get(II->getType()));
           eraseInstFromFunction(*II);
           return BinaryOperator::CreateSub(LHS, RHS);
         }
         break;
       case Intrinsic::umul_with_overflow:
       case Intrinsic::smul_with_overflow:
-        if (*EV.idx_begin() == 0) {  // Normal result.
+        if (*EV.idx_begin() == 0) { // Normal result.
           Value *LHS = II->getArgOperand(0), *RHS = II->getArgOperand(1);
           replaceInstUsesWith(*II, UndefValue::get(II->getType()));
           eraseInstFromFunction(*II);
           return BinaryOperator::CreateMul(LHS, RHS);
         }
         break;
       default:
         break;
       }
     }
   }
   if (LoadInst *L = dyn_cast<LoadInst>(Agg))
     // If the (non-volatile) load only has one use, we can rewrite this to a
     // load from a GEP. This reduces the size of the load. If a load is used
     // only by extractvalue instructions then this either must have been
     // optimized before, or it is a struct with padding, in which case we
     // don't want to do the transformation as it loses padding knowledge.
     if (L->isSimple() && L->hasOneUse()) {
       // extractvalue has integer indices, getelementptr has Value*s. Convert.
-      SmallVector<Value*, 4> Indices;
+      SmallVector<Value *, 4> Indices;
       // Prefix an i32 0 since we need the first element.
       Indices.push_back(Builder.getInt32(0));
       for (ExtractValueInst::idx_iterator I = EV.idx_begin(), E = EV.idx_end();
-            I != E; ++I)
         Indices.push_back(Builder.getInt32(*I));
 
       // We need to insert these at the location of the old load, not at that of
       // the extractvalue.
       Builder.SetInsertPoint(L);
       Value *GEP = Builder.CreateInBoundsGEP(L->getType(),
                                              L->getPointerOperand(), Indices);
       Instruction *NL = Builder.CreateLoad(GEP);
static bool isCatchAll(EHPersonality Personality, Constant *TypeInfo) {
   case EHPersonality::MSVC_CXX:
   case EHPersonality::CoreCLR:
     return TypeInfo->isNullValue();
   }
   llvm_unreachable("invalid enum");
 }
 
 static bool shorter_filter(const Value *LHS, const Value *RHS) {
-  return
-    cast<ArrayType>(LHS->getType())->getNumElements()
-  <
+  return cast<ArrayType>(LHS->getType())->getNumElements() <
          cast<ArrayType>(RHS->getType())->getNumElements();
 }
 
 Instruction *InstCombiner::visitLandingPadInst(LandingPadInst &LI) {
   // The logic here should be correct for any real-world personality function.
   // However if that turns out not to be true, the offending logic can always
   // be conditioned on the personality function, like the catch-all logic is.
   EHPersonality Personality =
       classifyEHPersonality(LI.getParent()->getParent()->getPersonalityFn());
 
   // Simplify the list of clauses, eg by removing repeated catch clauses
   // (these are often created by inlining).
   bool MakeNewInstruction = false; // If true, recreate using the following:
   SmallVector<Constant *, 16> NewClauses; // - Clauses for the new instruction;
-  bool CleanupFlag = LI.isCleanup();   // - The new instruction is a cleanup.
+  bool CleanupFlag = LI.isCleanup();      // - The new instruction is a cleanup.
 
   SmallPtrSet<Value *, 16> AlreadyCaught; // Typeinfos known caught already.
   for (unsigned i = 0, e = LI.getNumClauses(); i != e; ++i) {
     bool isLastClause = i + 1 == e;
     if (LI.isCatch(i)) {
       // A catch clause.
       Constant *CatchClause = LI.getClause(i);
       Constant *TypeInfo = CatchClause->stripPointerCasts();
if (LI.isCatch(i)) {
       if (!NumTypeInfos) {
         NewClauses.push_back(FilterClause);
         if (!isLastClause)
           MakeNewInstruction = true;
         CleanupFlag = false;
         break;
       }
 
-      bool MakeNewFilter = false; // If true, make a new filter.
+      bool MakeNewFilter = false;                // If true, make a new filter.
       SmallVector<Constant *, 16> NewFilterElts; // New elements.
       if (isa<ConstantAggregateZero>(FilterClause)) {
         // Not an empty filter - it contains at least one null typeinfo.
         assert(NumTypeInfos > 0 && "Should have handled empty filter already!");
         Constant *TypeInfo =
             Constant::getNullValue(FilterType->getElementType());
         // If this typeinfo is a catch-all then the filter can never match.
         if (isCatchAll(Personality, TypeInfo)) {
           // Throw the filter away.
           MakeNewInstruction = true;
           continue;
         }
 
         // There is no point in having multiple copies of this typeinfo, so
if (LI.isCatch(i)) {
           continue;
         }
 
         // If we dropped something from the filter, make a new one.
         if (NewFilterElts.size() < NumTypeInfos)
           MakeNewFilter = true;
       }
       if (MakeNewFilter) {
-        FilterType = ArrayType::get(FilterType->getElementType(),
-                                    NewFilterElts.size());
+        FilterType =
+            ArrayType::get(FilterType->getElementType(), NewFilterElts.size());
         FilterClause = ConstantArray::get(FilterType, NewFilterElts);
         MakeNewInstruction = true;
       }
 
       NewClauses.push_back(FilterClause);
 
       // If the new filter is empty then it will catch everything so there is
       // no point in keeping any following clauses or marking the landingpad
       // as having a cleanup.  The case of the original filter being empty was
       // already handled above.
       if (MakeNewFilter && !NewFilterElts.size()) {
         assert(MakeNewInstruction && "New filter but not a new instruction!");
         CleanupFlag = false;
         break;
       }
     }
   }
 
   // If several filters occur in a row then reorder them so that the shortest
   // filters come first (those with the smallest number of elements).  This is
   // advantageous because shorter filters are more likely to match, speeding up
   // unwinding, but mostly because it increases the effectiveness of the other
   // filter optimizations below.
-  for (unsigned i = 0, e = NewClauses.size(); i + 1 < e; ) {
+  for (unsigned i = 0, e = NewClauses.size(); i + 1 < e;) {
     unsigned j;
     // Find the maximal 'j' s.t. the range [i, j) consists entirely of filters.
     for (j = i; j != e; ++j)
       if (!isa<ArrayType>(NewClauses[j]->getType()))
         break;
 
     // Check whether the filters are already sorted by length.  We need to know
     // if sorting them is actually going to do anything so that we only make a
     // new landingpad instruction if it does.
     for (unsigned k = i; k + 1 < j; ++k)
-      if (shorter_filter(NewClauses[k+1], NewClauses[k])) {
+      if (shorter_filter(NewClauses[k + 1], NewClauses[k])) {
         // Not sorted, so sort the filters now.  Doing an unstable sort would be
         // correct too but reordering filters pointlessly might confuse users.
         std::stable_sort(NewClauses.begin() + i, NewClauses.begin() + j,
                          shorter_filter);
         MakeNewInstruction = true;
         break;
       }
 
for (unsigned j = NewClauses.size() - 1; j != i; --j) {
       }
       // Move on to the next filter.
     }
   }
 
   // If we changed any of the clauses, replace the old landingpad instruction
   // with a new one.
   if (MakeNewInstruction) {
-    LandingPadInst *NLI = LandingPadInst::Create(LI.getType(),
-                                                 NewClauses.size());
+    LandingPadInst *NLI =
+        LandingPadInst::Create(LI.getType(), NewClauses.size());
     for (unsigned i = 0, e = NewClauses.size(); i != e; ++i)
       NLI->addClause(NewClauses[i]);
     // A landing pad with no clauses must have the cleanup flag set.  It is
     // theoretically possible, though highly unlikely, that we eliminated all
     // clauses.  If so, force the cleanup flag to true.
     if (NewClauses.empty())
       CleanupFlag = true;
     NLI->setCleanup(CleanupFlag);
static bool TryToSinkInstruction(Instruction *I, BasicBlock *DestBlock) {
   assert(I->hasOneUse() && "Invariants didn't hold!");
 
   // Cannot move control-flow-involving, volatile loads, vaarg, etc.
   if (isa<PHINode>(I) || I->isEHPad() || I->mayHaveSideEffects() ||
       isa<TerminatorInst>(I))
     return false;
 
   // Do not sink alloca instructions out of the entry block.
-  if (isa<AllocaInst>(I) && I->getParent() ==
-        &DestBlock->getParent()->getEntryBlock())
+  if (isa<AllocaInst>(I) &&
+      I->getParent() == &DestBlock->getParent()->getEntryBlock())
     return false;
 
   // Do not sink into catchswitch blocks.
   if (isa<CatchSwitchInst>(DestBlock->getTerminator()))
     return false;
 
   // Do not sink convergent call instructions.
   if (auto *CI = dyn_cast<CallInst>(I)) {
static bool TryToSinkInstruction(Instruction *I, BasicBlock *DestBlock) {
   I->moveBefore(&*InsertPos);
   ++NumSunkInst;
   return true;
 }
 
 bool InstCombiner::run() {
   while (!Worklist.isEmpty()) {
     Instruction *I = Worklist.RemoveOne();
-    if (I == nullptr) continue;  // skip null values.
+    if (I == nullptr)
+      continue; // skip null values.
 
     // Check to see if we can DCE the instruction.
     if (isInstructionTriviallyDead(I, &TLI)) {
       DEBUG(dbgs() << "IC: DCE: " << *I << '\n');
       eraseInstFromFunction(*I);
       ++NumDeadInst;
       MadeIRChange = true;
       continue;
if (!I->use_empty() &&
         continue;
       }
     }
 
     // In general, it is possible for computeKnownBits to determine all bits in
     // a value even when the operands are not all constants.
     Type *Ty = I->getType();
     if (ExpensiveCombines && !I->use_empty() && Ty->isIntOrIntVectorTy()) {
-      KnownBits Known = computeKnownBits(I, /*Depth*/0, I);
+      KnownBits Known = computeKnownBits(I, /*Depth*/ 0, I);
       if (Known.isConstant()) {
         Constant *C = ConstantInt::get(Ty, Known.getConstant());
-        DEBUG(dbgs() << "IC: ConstFold (all bits known) to: " << *C <<
-                        " from: " << *I << '\n');
+        DEBUG(dbgs() << "IC: ConstFold (all bits known) to: " << *C
+                     << " from: " << *I << '\n');
 
         // Add operands to the worklist.
         replaceInstUsesWith(*I, C);
         ++NumConstProp;
         if (isInstructionTriviallyDead(I, &TLI))
           eraseInstFromFunction(*I);
         MadeIRChange = true;
         continue;

 /// them to the worklist (this significantly speeds up instcombine on code where
 /// many instructions are dead or constant).  Additionally, if we find a branch
 /// whose condition is a known constant, we only visit the reachable successors.
 static bool AddReachableCodeToWorklist(BasicBlock *BB, const DataLayout &DL,
                                        SmallPtrSetImpl<BasicBlock *> &Visited,
                                        InstCombineWorklist &ICWorklist,
                                        const TargetLibraryInfo *TLI) {
   bool MadeIRChange = false;
-  SmallVector<BasicBlock*, 256> Worklist;
+  SmallVector<BasicBlock *, 256> Worklist;
   Worklist.push_back(BB);
 
-  SmallVector<Instruction*, 128> InstrsForInstCombineWorklist;
+  SmallVector<Instruction *, 128> InstrsForInstCombineWorklist;
   DenseMap<Constant *, Constant *> FoldedConstants;
 
   do {
     BB = Worklist.pop_back_val();
 
     // We have now visited this block!  If we've already been here, ignore it.
     if (!Visited.insert(BB).second)
       continue;
 
-    for (BasicBlock::iterator BBI = BB->begin(), E = BB->end(); BBI != E; ) {
+    for (BasicBlock::iterator BBI = BB->begin(), E = BB->end(); BBI != E;) {
       Instruction *Inst = &*BBI++;
 
       // DCE instruction if trivially dead.
       if (isInstructionTriviallyDead(Inst, TLI)) {
         ++NumDeadInst;
         DEBUG(dbgs() << "IC: DCE: " << *Inst << '\n');
         salvageDebugInfo(*Inst);
         Inst->eraseFromParent();
         MadeIRChange = true;
         continue;
       }
 
       // ConstantProp instruction if trivially constant.
       if (!Inst->use_empty() &&
           (Inst->getNumOperands() == 0 || isa<Constant>(Inst->getOperand(0))))
         if (Constant *C = ConstantFoldInstruction(Inst, DL, TLI)) {
-          DEBUG(dbgs() << "IC: ConstFold to: " << *C << " from: "
-                       << *Inst << '\n');
+          DEBUG(dbgs() << "IC: ConstFold to: " << *C << " from: " << *Inst
+                       << '\n');
           Inst->replaceAllUsesWith(C);
           ++NumConstProp;
           if (isInstructionTriviallyDead(Inst, TLI))
             Inst->eraseFromParent();
           MadeIRChange = true;
           continue;
         }
 
       // See if we can constant fold its operands.
       for (Use &U : Inst->operands()) {
         if (!isa<ConstantVector>(U) && !isa<ConstantExpr>(U))
           continue;
 
         auto *C = cast<Constant>(U);
         Constant *&FoldRes = FoldedConstants[C];
         if (!FoldRes)
           FoldRes = ConstantFoldConstant(C, DL, TLI);
         if (!FoldRes)
           FoldRes = C;
 
         if (FoldRes != C) {
           DEBUG(dbgs() << "IC: ConstFold operand of: " << *Inst
-                       << "\n    Old = " << *C
-                       << "\n    New = " << *FoldRes << '\n');
+                       << "\n    Old = " << *C << "\n    New = " << *FoldRes
+                       << '\n');
           U = FoldRes;
           MadeIRChange = true;
         }
       }
 
-      // Skip processing debug intrinsics in InstCombine. Processing these call instructions
-      // consumes non-trivial amount of time and provides no value for the optimization.
+      // Skip processing debug intrinsics in InstCombine. Processing these call
+      // instructions consumes non-trivial amount of time and provides no value
+      // for the optimization.
       if (!isa<DbgInfoIntrinsic>(Inst))
         InstrsForInstCombineWorklist.push_back(Inst);
     }
 
     // Recursively visit successors.  If this is a branch or switch on a
     // constant, only visit the reachable successor.
     TerminatorInst *TI = BB->getTerminator();
     if (BranchInst *BI = dyn_cast<BranchInst>(TI)) {

test/Transforms/InstCombine/trigonometric-optimizations.ll

+; RUN: opt < %s -instcombine -S | FileCheck %s
+
+declare double @tan(double)
+declare double @llvm.cos.f64(double)
+declare double @llvm.sin.f64(double)
+
+define double @_Z11tan_mul_cosd(double)  {
+  %2 = call fast double @tan(double %0) #8
+  %3 = call fast double @llvm.cos.f64(double %0)
+  %4 = fmul fast double %2, %3
+  ret double %4
+
+; CHECK-LABEL:@_Z11tan_mul_cosd(
+; CHECK-NEXT: %2 = call fast double @llvm.sin.f64(double %0)
+; CHECK-NEXT: ret double %2
+
+}
+
+define double @_Z11sin_mul_cosd(double)  {
+  %2 = call fast double @llvm.sin.f64(double %0)
+  %3 = call fast double @llvm.cos.f64(double %0)
+  %4 = fmul fast double %2, %3
+  ret double %4
+
+; CHECK-LABEL: @_Z11sin_mul_cosd(
+; CHECK-NEXT:  %2 = fmul fast double %0, 2.000000e+00
+; CHECK-NEXT:  %3 = call fast double @llvm.sin.f64(double %2)
+; CHECK-NEXT:  %4 = fmul fast double %3, 5.000000e-01
+; CHECK-NEXT:  ret double %4
+}
+
+define double @_Z11sin_div_tand(double)  {
+  %2 = call fast double @llvm.sin.f64(double %0)
+  %3 = call fast double @tan(double %0) #8
+  %4 = fdiv fast double %2, %3
+  ret double %4
+
+; CHECK-LABEL: @_Z11sin_div_tand(
+; CHECK-NEXT:  %2 = call fast double @llvm.cos.f64(double %0)
+; CHECK-NEXT:  ret double %2
+}
+
+define double @_Z11tan_div_sind(double)  {
+  %2 = call fast double @tan(double %0) #8
+  %3 = call fast double @llvm.sin.f64(double %0)
+  %4 = fdiv fast double %2, %3
+  ret double %4
+
+; CHECK-LABEL: @_Z11tan_div_sind(
+; CHECK-NEXT:  %2 = call fast double @llvm.cos.f64(double %0)
+; CHECK-NEXT:  %3 = fdiv fast double 1.000000e+00, %2
+; CHECK-NEXT:  ret double %3
+}
+
+define double @_Z8combinedd(double)  {
+  %2 = call fast double @llvm.sin.f64(double %0)
+  %3 = call fast double @tan(double %0) #8
+  %4 = fdiv fast double %2, %3
+  %5 = call fast double @tan(double %0) #8
+  %6 = call fast double @llvm.cos.f64(double %0)
+  %7 = fmul fast double %5, %6
+  %8 = fmul fast double %4, %7
+  ret double %8
+
+; CHECK-LABEL: @_Z8combinedd(
+; CHECK-NEXT:  %2 = fmul fast double %0, 2.000000e+00
+; CHECK-NEXT:  %3 = call fast double @llvm.sin.f64(double %2)
+; CHECK-NEXT:  %4 = fmul fast double %3, 5.000000e-01
+; CHECK-NEXT:  ret double %4
+}
+
+define double @_Z19different_argumentsdd(double, double)  {
+  %3 = call fast double @llvm.sin.f64(double %0)
+  %4 = call fast double @tan(double %0) #8
+  %5 = fdiv fast double %3, %4
+  %6 = call fast double @tan(double %1) #8
+  %7 = call fast double @llvm.cos.f64(double %1)
+  %8 = fmul fast double %6, %7
+  %9 = fmul fast double %5, %8
+  ret double %9
+
+; CHECK-LABEL: @_Z19different_argumentsdd(
+; CHECK-NEXT:  %3 = call fast double @llvm.cos.f64(double %0)
+; CHECK-NEXT:  %4 = call fast double @llvm.sin.f64(double %1)
+; CHECK-NEXT:  %5 = fmul fast double %3, %4
+; CHECK-NEXT:  ret double %5
+}
+
+attributes #8 = { nounwind readnone }