diff --git a/llvm/lib/IR/Instruction.cpp b/llvm/lib/IR/Instruction.cpp
--- a/llvm/lib/IR/Instruction.cpp
+++ b/llvm/lib/IR/Instruction.cpp
@@ -408,46 +408,71 @@
                                  bool IgnoreAlignment = false) {
   assert(I1->getOpcode() == I2->getOpcode() &&
          "Can not compare special state of different instructions");
+  assert(I1->getNumOperands() == I2->getNumOperands() &&
+         "Can not compare special state of instructions with different number "
+         "of operands");
 
-  if (const AllocaInst *AI = dyn_cast<AllocaInst>(I1))
+  switch (I1->getOpcode()) {
+  default:
+    llvm_unreachable("Instructions to compare are unknown");
+  case Instruction::Alloca: {
+    const AllocaInst *AI = cast<AllocaInst>(I1);
     return AI->getAllocatedType() == cast<AllocaInst>(I2)->getAllocatedType() &&
            (AI->getAlignment() == cast<AllocaInst>(I2)->getAlignment() ||
             IgnoreAlignment);
-  if (const LoadInst *LI = dyn_cast<LoadInst>(I1))
+  }
+  case Instruction::Load: {
+    const LoadInst *LI = cast<LoadInst>(I1);
     return LI->isVolatile() == cast<LoadInst>(I2)->isVolatile() &&
            (LI->getAlignment() == cast<LoadInst>(I2)->getAlignment() ||
             IgnoreAlignment) &&
            LI->getOrdering() == cast<LoadInst>(I2)->getOrdering() &&
            LI->getSyncScopeID() == cast<LoadInst>(I2)->getSyncScopeID();
-  if (const StoreInst *SI = dyn_cast<StoreInst>(I1))
+  }
+  case Instruction::Store: {
+    const StoreInst *SI = cast<StoreInst>(I1);
     return SI->isVolatile() == cast<StoreInst>(I2)->isVolatile() &&
            (SI->getAlignment() == cast<StoreInst>(I2)->getAlignment() ||
             IgnoreAlignment) &&
            SI->getOrdering() == cast<StoreInst>(I2)->getOrdering() &&
            SI->getSyncScopeID() == cast<StoreInst>(I2)->getSyncScopeID();
-  if (const CmpInst *CI = dyn_cast<CmpInst>(I1))
-    return CI->getPredicate() == cast<CmpInst>(I2)->getPredicate();
-  if (const CallInst *CI = dyn_cast<CallInst>(I1))
+  }
+  case Instruction::ICmp:
+  case Instruction::FCmp:
+    return cast<CmpInst>(I1)->getPredicate() ==
+           cast<CmpInst>(I2)->getPredicate();
+  case Instruction::Call: {
+    const CallInst *CI = cast<CallInst>(I1);
     return CI->isTailCall() == cast<CallInst>(I2)->isTailCall() &&
            CI->getCallingConv() == cast<CallInst>(I2)->getCallingConv() &&
            CI->getAttributes() == cast<CallInst>(I2)->getAttributes() &&
            CI->hasIdenticalOperandBundleSchema(*cast<CallInst>(I2));
-  if (const InvokeInst *CI = dyn_cast<InvokeInst>(I1))
-    return CI->getCallingConv() == cast<InvokeInst>(I2)->getCallingConv() &&
-           CI->getAttributes() == cast<InvokeInst>(I2)->getAttributes() &&
-           CI->hasIdenticalOperandBundleSchema(*cast<InvokeInst>(I2));
-  if (const CallBrInst *CI = dyn_cast<CallBrInst>(I1))
-    return CI->getCallingConv() == cast<CallBrInst>(I2)->getCallingConv() &&
-           CI->getAttributes() == cast<CallBrInst>(I2)->getAttributes() &&
-           CI->hasIdenticalOperandBundleSchema(*cast<CallBrInst>(I2));
-  if (const InsertValueInst *IVI = dyn_cast<InsertValueInst>(I1))
-    return IVI->getIndices() == cast<InsertValueInst>(I2)->getIndices();
-  if (const ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(I1))
-    return EVI->getIndices() == cast<ExtractValueInst>(I2)->getIndices();
-  if (const FenceInst *FI = dyn_cast<FenceInst>(I1))
+  }
+  case Instruction::Invoke: {
+    const InvokeInst *II = cast<InvokeInst>(I1);
+    return II->getCallingConv() == cast<InvokeInst>(I2)->getCallingConv() &&
+           II->getAttributes() == cast<InvokeInst>(I2)->getAttributes() &&
+           II->hasIdenticalOperandBundleSchema(*cast<InvokeInst>(I2));
+  }
+  case Instruction::CallBr: {
+    const CallBrInst *CBI = cast<CallBrInst>(I1);
+    return CBI->getCallingConv() == cast<CallBrInst>(I2)->getCallingConv() &&
+           CBI->getAttributes() == cast<CallBrInst>(I2)->getAttributes() &&
+           CBI->hasIdenticalOperandBundleSchema(*cast<CallBrInst>(I2));
+  }
+  case Instruction::InsertValue:
+    return cast<InsertValueInst>(I1)->getIndices() ==
+           cast<InsertValueInst>(I2)->getIndices();
+  case Instruction::ExtractValue:
+    return cast<ExtractValueInst>(I1)->getIndices() ==
+           cast<ExtractValueInst>(I2)->getIndices();
+  case Instruction::Fence: {
+    const FenceInst *FI = cast<FenceInst>(I1);
     return FI->getOrdering() == cast<FenceInst>(I2)->getOrdering() &&
            FI->getSyncScopeID() == cast<FenceInst>(I2)->getSyncScopeID();
-  if (const AtomicCmpXchgInst *CXI = dyn_cast<AtomicCmpXchgInst>(I1))
+  }
+  case Instruction::AtomicCmpXchg: {
+    const AtomicCmpXchgInst *CXI = cast<AtomicCmpXchgInst>(I1);
     return CXI->isVolatile() == cast<AtomicCmpXchgInst>(I2)->isVolatile() &&
            CXI->isWeak() == cast<AtomicCmpXchgInst>(I2)->isWeak() &&
            CXI->getSuccessOrdering() ==
@@ -456,16 +481,95 @@
                cast<AtomicCmpXchgInst>(I2)->getFailureOrdering() &&
            CXI->getSyncScopeID() ==
                cast<AtomicCmpXchgInst>(I2)->getSyncScopeID();
-  if (const AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(I1))
+  }
+  case Instruction::AtomicRMW: {
+    const AtomicRMWInst *RMWI = cast<AtomicRMWInst>(I1);
     return RMWI->getOperation() == cast<AtomicRMWInst>(I2)->getOperation() &&
            RMWI->isVolatile() == cast<AtomicRMWInst>(I2)->isVolatile() &&
            RMWI->getOrdering() == cast<AtomicRMWInst>(I2)->getOrdering() &&
            RMWI->getSyncScopeID() == cast<AtomicRMWInst>(I2)->getSyncScopeID();
-  if (const ShuffleVectorInst *SVI = dyn_cast<ShuffleVectorInst>(I1))
-    return SVI->getShuffleMask() ==
+  }
+  case Instruction::ShuffleVector:
+    return cast<ShuffleVectorInst>(I1)->getShuffleMask() ==
            cast<ShuffleVectorInst>(I2)->getShuffleMask();
-
-  return true;
+  case Instruction::Ret:
+    return true;
+  case Instruction::Br:
+    return true;
+  case Instruction::Switch:
+    return true;
+  case Instruction::IndirectBr:
+    return true;
+  case Instruction::Resume:
+    return true;
+  case Instruction::CatchSwitch:
+    return cast<CatchSwitchInst>(I1)->unwindsToCaller() ==
+           cast<CatchSwitchInst>(I2)->unwindsToCaller();
+  case Instruction::CatchRet:
+    return true;
+  case Instruction::CleanupRet:
+    return cast<CleanupReturnInst>(I1)->unwindsToCaller() ==
+           cast<CleanupReturnInst>(I2)->unwindsToCaller();
+  case Instruction::Unreachable:
+    return true;
+  case Instruction::FNeg:
+    return true;
+  case Instruction::Add:
+  case Instruction::FAdd:
+  case Instruction::Sub:
+  case Instruction::FSub:
+  case Instruction::Mul:
+  case Instruction::FMul:
+  case Instruction::UDiv:
+  case Instruction::SDiv:
+  case Instruction::FDiv:
+  case Instruction::URem:
+  case Instruction::SRem:
+  case Instruction::FRem:
+  case Instruction::Shl:
+  case Instruction::LShr:
+  case Instruction::AShr:
+  case Instruction::And:
+  case Instruction::Or:
+  case Instruction::Xor:
+    return true;
+  case Instruction::GetElementPtr:
+    return true;
+  case Instruction::Trunc:
+  case Instruction::ZExt:
+  case Instruction::SExt:
+  case Instruction::FPToUI:
+  case Instruction::FPToSI:
+  case Instruction::UIToFP:
+  case Instruction::SIToFP:
+  case Instruction::FPTrunc:
+  case Instruction::FPExt:
+  case Instruction::PtrToInt:
+  case Instruction::IntToPtr:
+  case Instruction::BitCast:
+  case Instruction::AddrSpaceCast:
+    return true;
+  case Instruction::CleanupPad:
+    return true;
+  case Instruction::CatchPad:
+    return haveSameSpecialState(cast<CatchPadInst>(I1)->getCatchSwitch(),
+                                cast<CatchPadInst>(I2)->getCatchSwitch());
+  case Instruction::PHI:
+    return true;
+  case Instruction::Select:
+    return true;
+  case Instruction::VAArg:
+    return true;
+  case Instruction::ExtractElement:
+    return true;
+  case Instruction::InsertElement:
+    return true;
+  case Instruction::LandingPad:
+    return cast<LandingPadInst>(I1)->isCleanup() ==
+           cast<LandingPadInst>(I2)->isCleanup();
+  case Instruction::Freeze:
+    return true;
+  }
 }
 
 bool Instruction::isIdenticalTo(const Instruction *I) const {