[NFC] Methods to compare IR added in each IR subclass

[vish99]

Summary

When there is a change to IR, the comparators also need to be updated which if not done can leads to mis-compiles. The function haveSameSpecialState() in line 407 of Instruction.cpp in sync with the IR so that the comparators can call this function to compare the Instruction specific properties. The ideal thing is when IR is defined, the author should also tell how two instructions of that specific IR type can be compared. This can be done by defining a method in that subclass of IR which compares two instructions. To achieve this, a method hasSamePropertiesAs() has been added in every subclass of IR which compares the instruction specific properties of that class, like for in AllocaInst class we added the method hasSamePropertiesAs() which compares the allocated type and alignment. This can solve the following issues.

1. If we add a new instruction.

In the haveSameSpecialState() in Instruction.cpp checks have been added for every known IR subclass. If the current instructions to compare don't fit into the case of any known instructions, an llvm_unreachable() call is executed. This will lead to an error when a new instruction is added but the haveSameSpecialState() function is not updated.

2. If a new operand is added.

If a new operand is added to an IR instruction, there will be a need to do a lot of changes in the subclass of that IR instruction like changing the constructors. Along with these changes, an additional check need to be added in the hasSamePropertiesAs() method of that same subclass if the operand being added matters for comparison. This can be easily checked.

This minimizes the number of files to touch for a change in the IR while maintaining sync of IR with comparators.

[nikic]

At this point, I would recommend writing this as a switch over the instruction opcode.

[nikic]

llvm/lib/IR/Instruction.cpp

420

I don't think this belongs here, as it is comparison operands. That's handled separately, e.g. in isSameOperationAs.

423

This can be an assertion, because operand count equality implies it.

426

Similar to the return case, I don't think this belongs, as it's checking operands.

431

Same here.

447

inbounds is subclass optional data, it should not be compared here. (It is legal to drop inbounds.)

[vish99]

Added comparision for all types in haveSameSpecialState() of Instruction.cpp and changed the if-else branching to switch over the Instruction Opcode

[vish99]

In D82892#2123584, @nikic wrote:

At this point, I would recommend writing this as a switch over the instruction opcode.

I do agree that a switch over instruction opcode would make more sense. I updated the revision to do the same.

[vish99]

Added case for Freeze instruction.

[vish99]

Added hasSamePropertiesAs() method in each subclass of the IR which should say how two IR instructions of that subclass should be compared.
Changed haveSameSpecialState() method to make use of the hasSamePropertiesAs() methods.
When there is a change to IR, only the hasSamePropertiesAs() method needs of that subclass need to be updated.

[hiraditya]

llvm/lib/IR/Instruction.cpp

416

Good idea. this should ensure that any new added instruction will fail compilation unless an entry is added to this switch statement. Maybe we should put a comment here.

[tejohnson]

Is this a bug fix? If it is NFC (No Functional Change) please specify that in the title, otherwise needs a test case.

[vish99]

In D82892#2133157, @tejohnson wrote:

Is this a bug fix? If it is NFC (No Functional Change) please specify that in the title, otherwise needs a test case.

Thanks. The title has been edited :)

[vish99]

Comment added

[vish99]

@jfb @tejohnson, just reminding you of the review as the patch has been lying dormant since a week.

[tejohnson]

Why not just make hasSamePropertiesAs a pure virtual on Instruction, then you don't need any switch statement in haveSameSpecialState? You'd need to do the cast on the Instruction operand within the implementations, but that would be cleaner IMO. For the ones that currently return true, you wouldn't need the cast just an opcode comparison.

llvm/include/llvm/IR/Instructions.h

1323

Stray ';'

llvm/lib/IR/Instruction.cpp

406

Does anything similar need to be done to the above function (which appears to have been moved to its own file, lib/Transforms/Utils/FunctionComparator.cpp)?

[vish99]

In D82892#2151162, @tejohnson wrote:

Why not just make hasSamePropertiesAs a pure virtual on Instruction, then you don't need any switch statement in haveSameSpecialState? You'd need to do the cast on the Instruction operand within the implementations, but that would be cleaner IMO. For the ones that currently return true, you wouldn't need the cast just an opcode comparison.

I think adding a virtual method to Instruction class would fail a static_assert in OperandTraits which says a subclass of User shouldn't be polymorphic and if virtual methods are added to subclasses of User, it breaks use lists.

[tejohnson]

In D82892#2151280, @vish99 wrote:

In D82892#2151162, @tejohnson wrote:

Why not just make hasSamePropertiesAs a pure virtual on Instruction, then you don't need any switch statement in haveSameSpecialState? You'd need to do the cast on the Instruction operand within the implementations, but that would be cleaner IMO. For the ones that currently return true, you wouldn't need the cast just an opcode comparison.

I think adding a virtual method to Instruction class would fail a static_assert in OperandTraits which says a subclass of User shouldn't be polymorphic and if virtual methods are added to subclasses of User, it breaks use lists.

Ah got it, no wonder there are no virtual methods in Instruction.h right now. Nevermind this suggestion then!

[vish99]

Changed hasSamePropertiesAs() method in each subclass of IR to introduce total ordering between two instructions of that subclass
and modified FunctionComparator to use haveSameSpecialState() method for IR comparision.

[vish99]

Comment added

[nikic]

llvm/include/llvm/IR/InstrTypes.h

183

Now that this implements a comparison rather than an equality, the name is a bit odd. Maybe compareProperties() or so?

[vish99]

Changed named of comparator method in each subclass to compareInstSpecificProperties()

[vish99]

Changed name from haveSameSpecialState() to compareSpecialState()

[hiraditya]

Can we build and run llvm testsuite to make sure there are no miscompiles?

[vish99]

Ran the llvm test-suite. All the tests were going fine.

[vish99]

This comment was removed by vish99.

[vish99]

Quoting the observed text segment sizes for few object files in MySQL, by enabling MergeFunctions by default and comparing them with baseline.

FILENAME	Baseline	With-mergefunc	Size reduction %
none.cpp.o(ex libbinlogevents.a)	913	771	15.5%
mysqlrouter	26,811	24,454	8.7%
load_data_events.cpp.o (ex libbinlogstandalone.a)	3,459	3,171	8.3%
rows_event.cpp.o (ex libbinlogstandalone.a)	18,264	16,756	8.2%
control_events.cpp.o (ex libbinlogstandalone.a)	13,820	13,018	5.8%
iterator.cpp.o (ex libbinlogevents.a)	3,775	3,587	4.9%
mysqlrouter_passwd	56,875	54,129	4.8%
mysqld	55,329,095	52,690,049	4.7%
binlog_event.cpp.o (ex libbinlogstandalone.a)	2,525	2,430	3.7%
rows_event.cpp.o (ex libbinlogevents.a)	15,442	14,888	3.5%
control_events.cpp.o (ex libbinlogevents.a)	12,470	12,050	3.3%

[hiraditya]

@tejohnson @nikic do we have comments to be addressed?

[nikic]

Please take a look at how Instruction::clone() is implemented, using a protected cloneImpl() method on each instruction type. I would suggest to follow the same pattern, and make these type-specific methods protected (and drop the redundant doc comment on each one of them).

It would be nice to also use the HANDLE_INST pattern to avoid the long list of instructions, but I guess that might be a bit complicated by the IgnoreAlignment/IgnoreMetaData flags. Maybe you just want to keep these as flags passed down to all the functions, regardless of whether they need them or not. I'm not sure on this.

[nikic]

llvm/lib/IR/Instructions.cpp

161 ↗

(On Diff #280039)

The compareTypes() function looks a bit problematic to me. The issue is that MergeFunctions considers integer types and all pointer types of the same size equal. Other places in LLVM require that the type must be exactly identical. The function as implemented here seems to go some middle way, where pointers are not considered equal to integers, but all pointer types are the same. That's in the spirit of opaque pointers, but we're not there yet.

[hiraditya]

llvm/lib/IR/Instructions.cpp

161 ↗

(On Diff #280039)

Other places in LLVM require that the type must be exactly identical

Could you provide an instance where this is required. That will help formulate the right check here. The current check is replicating what MergeFunction did. If there's a bug, it'll be good to fix it.

[vish99]

Changed compareInstSpecificProperies() methods to protected and added comparision of elemnet types of pointers in compareTypes()

[hiraditya]

llvm/lib/IR/Instructions.cpp

176 ↗

(On Diff #282929)

s/i/I
s/e/E
Same for other clang-tidy warnings as well.

[jfb]

I didn't check that all of these compare all the required state for all opcodes.

That being said, this still seems somewhat brittle, if less so than before. Are there sufficient tests to find future divergences?

llvm/include/llvm/IR/Instruction.h

655 ↗

(On Diff #282929)

Can you document flags?

llvm/include/llvm/IR/Instructions.h

69

I prefer having an enum class instead of bool parameters. i.e.

enum class IgnoreAlignment { No, Yes };
int compareInstSpecificProperties(const AllocaInst *AI,
                                    IgnoreAlignment ignoreAlignment = IgnoreAlignment::No) const;

188

Same here on flags.

323

Ditto.

1500

Ditto.

3822

Ditto.

4040

Ditto.

llvm/lib/IR/Instructions.cpp

82 ↗

(On Diff #282929)

Is it expected that APInts with different bit width but the same value won't be equal?

[vish99]

Changed IgnoreAlignment and IgnoreMetaData to enum class instead of bool type and fixed clang-tidy warnings.

[vish99]

In D82892#2208245, @jfb wrote:

I didn't check that all of these compare all the required state for all opcodes.

That being said, this still seems somewhat brittle, if less so than before. Are there sufficient tests to find future divergences?

When a new instruction has been added and the compareSpecialState() method has not been updated, it leads to failure. But when there is an addition of a new operand, it's the responsibility of the author to change the compareInstSpecificProperties() method of that method(which can be done easily as it'll be in the same file) and this can update all the comparators. Currently, I don't think there are enough tests.

llvm/lib/IR/Instructions.cpp

161 ↗

(On Diff #280039)

How about we also compare the element types of the pointers through a recursive call to compareTypes() along with the Address space comparison?

[vish99]

Added TestCases

[hiraditya]

llvm/lib/IR/Instructions.cpp

58 ↗

(On Diff #285661)

Can we do:

if (L==R)
  return 0;
if (L)
  return 1;
return -1;

66 ↗

(On Diff #285661)

SInce AtomicOrdering is unsinged. We should be able to just return their difference.

[vish99]

cmpAPInts fix

[hiraditya]

please run clang-format

[vish99]

Clang-format fix

[vish99]

Comment Added

[vish99]

Are they any more improvements needed?

llvm/include/llvm/IR/InstrTypes.h

static UnaryOperator *CreateFNegFMF(Value *Op, Instruction *FMFSource,
     return CreateWithCopiedFlags(Instruction::FNeg, Op, FMFSource, Name,
                                  InsertBefore);
   }
 
   UnaryOps getOpcode() const {
     return static_cast<UnaryOps>(Instruction::getOpcode());
   }
 
+  // Returns true if the UnaryOperator I has same special properties as the
+  // current instruction. Any addition of operands in UnaryOperator class need
+  // to be reflected here so that the IR comparators stay in sync with the
+  // changes to IR. Currently returning true because UnaryOperator has no
+  // special properties to compare.
+  bool hasSamePropertiesAs(const UnaryOperator *I) const { return true; }
+
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->isUnaryOp();
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 };
#undef DEFINE_HELPERS
 
   /// Exchange the two operands to this instruction.
   /// This instruction is safe to use on any binary instruction and
   /// does not modify the semantics of the instruction.  If the instruction
   /// cannot be reversed (ie, it's a Div), then return true.
   ///
   bool swapOperands();
 
+  // Returns true if the BinaryOperator I has same special properties as the
+  // current instruction. Any addition of operands in BinaryOperator class need
+  // to be reflected here so that the IR comparators stay in sync with the
+  // changes to IR. Currently returning true because BinaryOperator has no
+  // special properties to compare.
+  bool hasSamePropertiesAs(const BinaryOperator *I) const { return true; }
+
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->isBinaryOp();
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 };

llvm/include/llvm/IR/Instructions.h

 
 protected:
   // Note: Instruction needs to be a friend here to call cloneImpl.
   friend class Instruction;
 
   AllocaInst *cloneImpl() const;
 
 public:
   explicit AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize,
                       const Twine &Name, Instruction *InsertBefore);
   AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize,
              const Twine &Name, BasicBlock *InsertAtEnd);
 
   AllocaInst(Type *Ty, unsigned AddrSpace, const Twine &Name,
              Instruction *InsertBefore);
   AllocaInst(Type *Ty, unsigned AddrSpace,
              const Twine &Name, BasicBlock *InsertAtEnd);
public:
   }
 
   /// Specify whether this alloca is used to represent a swifterror.
   void setSwiftError(bool V) {
     setInstructionSubclassData((getSubclassDataFromInstruction() & ~64) |
                                (V ? 64 : 0));
   }
 
+  // Returns true if the AllocaInst AI has same special properties as the
+  // current instruction. Any addition of operands in AllocaInst class need to
+  // be reflected here so that the IR comparators stay in sync with the changes
+  // to IR.
+  bool hasSamePropertiesAs(const AllocaInst *AI,
+                           bool IgnoreAlignment = false) const {
+    return getAllocatedType() == AI->getAllocatedType() &&
+           (getAlignment() == AI->getAlignment() || IgnoreAlignment);
+  }
+
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return (I->getOpcode() == Instruction::Alloca);
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 

 protected:
   // Note: Instruction needs to be a friend here to call cloneImpl.
   friend class Instruction;
 
   LoadInst *cloneImpl() const;
 
 public:
   LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr,
            Instruction *InsertBefore);
   LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, BasicBlock *InsertAtEnd);
   LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
            Instruction *InsertBefore);
   LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
            BasicBlock *InsertAtEnd);
   LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
            Align Align, Instruction *InsertBefore = nullptr);
   LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
public:
   static unsigned getPointerOperandIndex() { return 0U; }
   Type *getPointerOperandType() const { return getPointerOperand()->getType(); }
 
   /// Returns the address space of the pointer operand.
   unsigned getPointerAddressSpace() const {
     return getPointerOperandType()->getPointerAddressSpace();
   }
 
+  // Returns true if the LoadInst LI has same special properties as the current
+  // instruction. Any addition of operands in LoadInst class need to be
+  // reflected here so that the IR comparators stay in sync with the changes to
+  // IR.
+  bool hasSamePropertiesAs(const LoadInst *LI,
+                           bool IgnoreAlignment = false) const {
+    return isVolatile() == LI->isVolatile() &&
+           (getAlignment() == LI->getAlignment() || IgnoreAlignment) &&
+           getOrdering() == LI->getOrdering() &&
+           getSyncScopeID() == LI->getSyncScopeID();
+  }
+
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->getOpcode() == Instruction::Load;
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 

 
 protected:
   // Note: Instruction needs to be a friend here to call cloneImpl.
   friend class Instruction;
 
   StoreInst *cloneImpl() const;
 
 public:
   StoreInst(Value *Val, Value *Ptr, Instruction *InsertBefore);
   StoreInst(Value *Val, Value *Ptr, BasicBlock *InsertAtEnd);
   StoreInst(Value *Val, Value *Ptr, bool isVolatile, Instruction *InsertBefore);
   StoreInst(Value *Val, Value *Ptr, bool isVolatile, BasicBlock *InsertAtEnd);
   StoreInst(Value *Val, Value *Ptr, bool isVolatile, Align Align,
             Instruction *InsertBefore = nullptr);
   StoreInst(Value *Val, Value *Ptr, bool isVolatile, Align Align,
             BasicBlock *InsertAtEnd);
   StoreInst(Value *Val, Value *Ptr, bool isVolatile, Align Align,
public:
   static unsigned getPointerOperandIndex() { return 1U; }
   Type *getPointerOperandType() const { return getPointerOperand()->getType(); }
 
   /// Returns the address space of the pointer operand.
   unsigned getPointerAddressSpace() const {
     return getPointerOperandType()->getPointerAddressSpace();
   }
 
+  // Returns true if the StoreInst SI has same special properties as the current
+  // instruction. Any addition of operands in StoreInst class need to be
+  // reflected here so that the IR comparators stay in sync with the changes to
+  // IR.
+  bool hasSamePropertiesAs(const StoreInst *SI,
+                           bool IgnoreAlignment = false) const {
+    return isVolatile() == SI->isVolatile() &&
+           (getAlignment() == SI->getAlignment() || IgnoreAlignment) &&
+           getOrdering() == SI->getOrdering() &&
+           getSyncScopeID() == SI->getSyncScopeID();
+  }
+
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->getOpcode() == Instruction::Store;
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 
SyncScope::ID getSyncScopeID() const {
     return SSID;
   }
 
   /// Sets the synchronization scope ID of this fence instruction.
   void setSyncScopeID(SyncScope::ID SSID) {
     this->SSID = SSID;
   }
 
+  // Returns true if the FenceInst FI has same special properties as the current
+  // instruction. Any addition of operands in FenceInst class need to be
+  // reflected here so that the IR comparators stay in sync with the changes to
+  // IR.
+  bool hasSamePropertiesAs(const FenceInst *FI) const {
+    return getOrdering() == FI->getOrdering() &&
+           getSyncScopeID() == FI->getSyncScopeID();
+  }
+
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->getOpcode() == Instruction::Fence;
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 
getStrongestFailureOrdering(AtomicOrdering SuccessOrdering) {
     case AtomicOrdering::AcquireRelease:
     case AtomicOrdering::Acquire:
       return AtomicOrdering::Acquire;
     case AtomicOrdering::SequentiallyConsistent:
       return AtomicOrdering::SequentiallyConsistent;
     }
   }
 
+  // Returns true if the AtomicCmpXchgInst I has same special properties as the
+  // current instruction. Any addition of operands in AtomicCmpXchgInst class
+  // need to be reflected here so that the IR comparators stay in sync with the
+  // changes to IR.
+  bool hasSamePropertiesAs(const AtomicCmpXchgInst *I) const {
+    return isVolatile() == I->isVolatile() && isWeak() == I->isWeak() &&
+           getSuccessOrdering() == I->getSuccessOrdering() &&
+           getFailureOrdering() == I->getFailureOrdering() &&
+           getSyncScopeID() == I->getSyncScopeID();
+  }
+
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->getOpcode() == Instruction::AtomicCmpXchg;
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 
public:
   unsigned getPointerAddressSpace() const {
     return getPointerOperand()->getType()->getPointerAddressSpace();
   }
 
   bool isFloatingPointOperation() const {
     return isFPOperation(getOperation());
   }
 
+  // Returns true if the AtomicRMWInst I has same special properties as the
+  // current instruction. Any addition of operands in AtomicRMWInst class need
+  // to be reflected here so that the IR comparators stay in sync with the
+  // changes to IR.
+  bool hasSamePropertiesAs(const AtomicRMWInst *I) const {
+    return getOperation() == I->getOperation() &&
+           isVolatile() == I->isVolatile() &&
+           getOrdering() == I->getOrdering() &&
+           getSyncScopeID() == I->getSyncScopeID();
+  }
+
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->getOpcode() == Instruction::AtomicRMW;
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 
public:
   /// This routine accepts an APInt into which it will accumulate the constant
   /// offset of this GEP if the GEP is in fact constant. If the GEP is not
   /// all-constant, it returns false and the value of the offset APInt is
   /// undefined (it is *not* preserved!). The APInt passed into this routine
   /// must be at least as wide as the IntPtr type for the address space of
   /// the base GEP pointer.
   bool accumulateConstantOffset(const DataLayout &DL, APInt &Offset) const;
 
+  // Returns true if the GetElementPtrInst I has same special properties as the
+  // current instruction. Any addition of operands in GetElementPtrInst class
+  // need to be reflected here so that the IR comparators stay in sync with the
+  // changes to IR. Currently returning true because GetElementPtr has no
+  // special properties to compare.
+  bool hasSamePropertiesAs(const GetElementPtrInst *I) const { return true; }
+
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return (I->getOpcode() == Instruction::GetElementPtr);
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 };
#endif
   /// changed to retain the same result if the predicate is order dependent
   /// (e.g. ult).
   /// Swap operands and adjust predicate.
   void swapOperands() {
     setPredicate(getSwappedPredicate());
     Op<0>().swap(Op<1>());
   }
 
+  // Returns true if the ICmpInst I has same special properties as the current
+  // instruction. Any addition of operands in ICmpInst class need to be
+  // reflected here so that the IR comparators stay in sync with the changes to
+  // IR.
+  bool hasSamePropertiesAs(const ICmpInst *I) const {
+    return getPredicate() == I->getPredicate();
+    ;
+  }
+
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->getOpcode() == Instruction::ICmp;
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 };
public:
   /// changed to retain the same result if the predicate is order dependent
   /// (e.g. ult).
   /// Swap operands and adjust predicate.
   void swapOperands() {
     setPredicate(getSwappedPredicate());
     Op<0>().swap(Op<1>());
   }
 
+  // Returns true if the FCmpInst I has same special properties as the current
+  // instruction. Any addition of operands in FCmpInst class need to be
+  // reflected here so that the IR comparators stay in sync with the changes to
+  // IR.
+  bool hasSamePropertiesAs(const FCmpInst *I) const {
+    return getPredicate() == I->getPredicate();
+  }
+
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->getOpcode() == Instruction::FCmp;
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 };

 
 protected:
   // Note: Instruction needs to be a friend here to call cloneImpl.
   friend class Instruction;
 
   CallInst *cloneImpl() const;
 
 public:
   static CallInst *Create(FunctionType *Ty, Value *F, const Twine &NameStr = "",
                           Instruction *InsertBefore = nullptr) {
     return new (ComputeNumOperands(0)) CallInst(Ty, F, NameStr, InsertBefore);
   }
 
   static CallInst *Create(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
                           const Twine &NameStr,
                           Instruction *InsertBefore = nullptr) {
     return new (ComputeNumOperands(Args.size()))
public:
   }
 
   /// Return true if the call can return twice
   bool canReturnTwice() const { return hasFnAttr(Attribute::ReturnsTwice); }
   void setCanReturnTwice() {
     addAttribute(AttributeList::FunctionIndex, Attribute::ReturnsTwice);
   }
 
+  // Returns true if the CallInst I has same special properties as the current
+  // instruction. Any addition of operands in CallInst class need to be
+  // reflected here so that the IR comparators stay in sync with the changes to
+  // IR.
+  bool hasSamePropertiesAs(const CallInst *I) const {
+    return isTailCall() == I->isTailCall() &&
+           getCallingConv() == I->getCallingConv() &&
+           getAttributes() == I->getAttributes() &&
+           hasIdenticalOperandBundleSchema(*I);
+  }
+
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->getOpcode() == Instruction::Call;
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 
public:
 
   /// Transparently provide more efficient getOperand methods.
   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
 
   OtherOps getOpcode() const {
     return static_cast<OtherOps>(Instruction::getOpcode());
   }
 
+  // Returns true if the SelectInst I has same special properties as the current
+  // instruction. Any addition of operands in SelectInst class need to be
+  // reflected here so that the IR comparators stay in sync with the changes to
+  // IR. Currently returning true because SelectInst has no special properties
+  // to compare.
+  bool hasSamePropertiesAs(const SelectInst *I) const { return true; }
+
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->getOpcode() == Instruction::Select;
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 };
VAArgInst(Value *List, Type *Ty, const Twine &NameStr,
     : UnaryInstruction(Ty, VAArg, List, InsertAtEnd) {
     setName(NameStr);
   }
 
   Value *getPointerOperand() { return getOperand(0); }
   const Value *getPointerOperand() const { return getOperand(0); }
   static unsigned getPointerOperandIndex() { return 0U; }
 
+  // Returns true if the VAArgInst I has same special properties as the current
+  // instruction. Any addition of operands in VAArgInst class need to be
+  // reflected here so that the IR comparators stay in sync with the changes to
+  // IR. Currently returning true because VAArgInst has no special properties to
+  // compare.
+  bool hasSamePropertiesAs(const VAArgInst *I) const { return true; }
+
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->getOpcode() == VAArg;
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 };
public:
   Value *getIndexOperand() { return Op<1>(); }
   const Value *getVectorOperand() const { return Op<0>(); }
   const Value *getIndexOperand() const { return Op<1>(); }
 
   VectorType *getVectorOperandType() const {
     return cast<VectorType>(getVectorOperand()->getType());
   }
 
+  // Returns true if the ExtractElementInst I has same special properties as the
+  // current instruction. Any addition of operands in ExtractElementInst class
+  // need to be reflected here so that the IR comparators stay in sync with the
+  // changes to IR. Currently returning true because ExtractElementInst has no
+  // special properties to compare.
+  bool hasSamePropertiesAs(const ExtractElementInst *I) const { return true; }
+
   /// Transparently provide more efficient getOperand methods.
   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->getOpcode() == Instruction::ExtractElement;
   }
   static bool classof(const Value *V) {
static bool isValidOperands(const Value *Vec, const Value *NewElt,
                               const Value *Idx);
 
   /// Overload to return most specific vector type.
   ///
   VectorType *getType() const {
     return cast<VectorType>(Instruction::getType());
   }
 
+  // Returns true if the InsertElementInst I has same special properties as the
+  // current instruction. Any addition of operands in InsertElementInst class
+  // need to be reflected here so that the IR comparators stay in sync with the
+  // changes to IR. Currently returning true because InsertElementInst has no
+  // special properties to compare.
+  bool hasSamePropertiesAs(const InsertElementInst *I) const { return true; }
+
   /// Transparently provide more efficient getOperand methods.
   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->getOpcode() == Instruction::InsertElement;
   }
   static bool classof(const Value *V) {
for (int &Idx : Mask) {
       if (Idx == -1)
         continue;
       Idx = Idx < (int)InVecNumElts ? Idx + InVecNumElts : Idx - InVecNumElts;
       assert(Idx >= 0 && Idx < (int)InVecNumElts * 2 &&
              "shufflevector mask index out of range");
     }
   }
 
+  // Returns true if the ShuffleVectorInst I has same special properties as the
+  // current instruction. Any addition of operands in ShuffleVectorInst class
+  // need to be reflected here so that the IR comparators stay in sync with the
+  // changes to IR.
+  bool hasSamePropertiesAs(const ShuffleVectorInst *I) const {
+    return getShuffleMask() == I->getShuffleMask();
+  }
+
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->getOpcode() == Instruction::ShuffleVector;
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 };
public:
   unsigned getNumIndices() const {
     return (unsigned)Indices.size();
   }
 
   bool hasIndices() const {
     return true;
   }
 
+  // Returns true if the ExtractValueInst I has same special properties as the
+  // current instruction. Any addition of operands in ExtractValueInst class
+  // need to be reflected here so that the IR comparators stay in sync with the
+  // changes to IR.
+  bool hasSamePropertiesAs(const ExtractValueInst *I) const {
+    return getIndices() == I->getIndices();
+  }
+
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->getOpcode() == Instruction::ExtractValue;
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 };
public:
   unsigned getNumIndices() const {
     return (unsigned)Indices.size();
   }
 
   bool hasIndices() const {
     return true;
   }
 
+  // Returns true if the InsertValueInst I has same special properties as the
+  // current instruction. Any addition of operands in InsertValueInst class need
+  // to be reflected here so that the IR comparators stay in sync with the
+  // changes to IR.
+  bool hasSamePropertiesAs(const InsertValueInst *I) const {
+    return getIndices() == I->getIndices();
+  }
+
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->getOpcode() == Instruction::InsertValue;
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 };
public:
   /// same value, return the value, otherwise return null.
   Value *hasConstantValue() const;
 
   /// Whether the specified PHI node always merges
   /// together the same value, assuming undefs are equal to a unique
   /// non-undef value.
   bool hasConstantOrUndefValue() const;
 
+  // Returns true if the PHINode I has same special properties as the current
+  // instruction. Any addition of operands in PHINode class need to be reflected
+  // here so that the IR comparators stay in sync with the changes to IR.
+  // Currently returning true because PHINode has no special properties to
+  // compare.
+  bool hasSamePropertiesAs(const PHINode *I) const { return true; }
+
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->getOpcode() == Instruction::PHI;
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 
public:
 
   /// Get the number of clauses for this landing pad.
   unsigned getNumClauses() const { return getNumOperands(); }
 
   /// Grow the size of the operand list to accommodate the new
   /// number of clauses.
   void reserveClauses(unsigned Size) { growOperands(Size); }
 
+  // Returns true if the LandingPadInst I has same special properties as the
+  // current instruction. Any addition of operands in LandingPadInst class need
+  // to be reflected here so that the IR comparators stay in sync with the
+  // changes to IR.
+  bool hasSamePropertiesAs(const LandingPadInst *I) const {
+    return isCleanup() == I->isCleanup();
+    ;
+  }
+
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->getOpcode() == Instruction::LandingPad;
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 };
public:
 
   /// Convenience accessor. Returns null if there is no return value.
   Value *getReturnValue() const {
     return getNumOperands() != 0 ? getOperand(0) : nullptr;
   }
 
   unsigned getNumSuccessors() const { return 0; }
 
+  // Returns true if the ReturnInst I has same special properties as the current
+  // instruction. Any addition of operands in ReturnInst class need to be
+  // reflected here so that the IR comparators stay in sync with the changes to
+  // IR. Currently returning true because ReturnInst has no special properties
+  // to compare.
+  bool hasSamePropertiesAs(const ReturnInst *I) const { return true; }
+
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return (I->getOpcode() == Instruction::Ret);
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 
public:
   }
 
   iterator_range<const_succ_op_iterator> successors() const {
     return make_range(const_succ_op_iterator(
                           std::next(value_op_begin(), isConditional() ? 1 : 0)),
                       const_succ_op_iterator(value_op_end()));
   }
 
+  // Returns true if the BranchInst I has same special properties as the current
+  // instruction. Any addition of operands in BranchInst class need to be
+  // reflected here so that the IR comparators stay in sync with the changes to
+  // IR. Currently returning true because BranchInst has no special properties
+  // to compare.
+  bool hasSamePropertiesAs(const BranchInst *I) const { return true; }
+
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return (I->getOpcode() == Instruction::Br);
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 };
BasicBlock *getSuccessor(unsigned idx) const {
     assert(idx < getNumSuccessors() &&"Successor idx out of range for switch!");
     return cast<BasicBlock>(getOperand(idx*2+1));
   }
   void setSuccessor(unsigned idx, BasicBlock *NewSucc) {
     assert(idx < getNumSuccessors() && "Successor # out of range for switch!");
     setOperand(idx * 2 + 1, NewSucc);
   }
 
+  // Returns true if the SwitchInst I has same special properties as the current
+  // instruction. Any addition of operands in SwitchInst class need to be
+  // reflected here so that the IR comparators stay in sync with the changes to
+  // IR. Currently returning true because SwitchInst has no special properties
+  // to compare.
+  bool hasSamePropertiesAs(const SwitchInst *I) const { return true; }
+
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->getOpcode() == Instruction::Switch;
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 };
return make_range(succ_op_iterator(std::next(value_op_begin())),
                       succ_op_iterator(value_op_end()));
   }
 
   iterator_range<const_succ_op_iterator> successors() const {
     return make_range(const_succ_op_iterator(std::next(value_op_begin())),
                       const_succ_op_iterator(value_op_end()));
   }
 
+  // Returns true if the IndirectBrInst I has same special properties as the
+  // current instruction. Any addition of operands in IndirectBrInst class need
+  // to be reflected here so that the IR comparators stay in sync with the
+  // changes to IR. Currently returning true because IndirectBrInst has no
+  // special properties to compare.
+  bool hasSamePropertiesAs(const IndirectBrInst *I) const { return true; }
+
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->getOpcode() == Instruction::IndirectBr;
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 };

 
 protected:
   // Note: Instruction needs to be a friend here to call cloneImpl.
   friend class Instruction;
 
   InvokeInst *cloneImpl() const;
 
 public:
   static InvokeInst *Create(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
                             BasicBlock *IfException, ArrayRef<Value *> Args,
                             const Twine &NameStr,
                             Instruction *InsertBefore = nullptr) {
     int NumOperands = ComputeNumOperands(Args.size());
     return new (NumOperands)
         InvokeInst(Ty, Func, IfNormal, IfException, Args, None, NumOperands,
                    NameStr, InsertBefore);
   }
void setSuccessor(unsigned i, BasicBlock *NewSucc) {
     if (i == 0)
       setNormalDest(NewSucc);
     else
       setUnwindDest(NewSucc);
   }
 
   unsigned getNumSuccessors() const { return 2; }
 
+  // Returns true if the InvokeInst I has same special properties as the current
+  // instruction. Any addition of operands in InvokeInst class need to be
+  // reflected here so that the IR comparators stay in sync with the changes to
+  // IR.
+  bool hasSamePropertiesAs(const InvokeInst *I) const {
+    return getCallingConv() == I->getCallingConv() &&
+           getAttributes() == I->getAttributes() &&
+           hasIdenticalOperandBundleSchema(*I);
+  }
+
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return (I->getOpcode() == Instruction::Invoke);
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 

 
 protected:
   // Note: Instruction needs to be a friend here to call cloneImpl.
   friend class Instruction;
 
   CallBrInst *cloneImpl() const;
 
 public:
   static CallBrInst *Create(FunctionType *Ty, Value *Func,
                             BasicBlock *DefaultDest,
                             ArrayRef<BasicBlock *> IndirectDests,
                             ArrayRef<Value *> Args, const Twine &NameStr,
                             Instruction *InsertBefore = nullptr) {
     int NumOperands = ComputeNumOperands(Args.size(), IndirectDests.size());
     return new (NumOperands)
         CallBrInst(Ty, Func, DefaultDest, IndirectDests, Args, None,
                    NumOperands, NameStr, InsertBefore);
public:
   void setSuccessor(unsigned i, BasicBlock *NewSucc) {
     assert(i < getNumIndirectDests() + 1 &&
            "Successor # out of range for callbr!");
     return i == 0 ? setDefaultDest(NewSucc) : setIndirectDest(i - 1, NewSucc);
   }
 
   unsigned getNumSuccessors() const { return getNumIndirectDests() + 1; }
 
+  // Returns true if the CallBrInst I has same special properties as the current
+  // instruction. Any addition of operands in CallBrInst class need to be
+  // reflected here so that the IR comparators stay in sync with the changes to
+  // IR.
+  bool hasSamePropertiesAs(const CallBrInst *I) const {
+    return getCallingConv() == I->getCallingConv() &&
+           getAttributes() == I->getAttributes() &&
+           hasIdenticalOperandBundleSchema(*I);
+  }
+
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return (I->getOpcode() == Instruction::CallBr);
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 
public:
   /// Provide fast operand accessors
   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
 
   /// Convenience accessor.
   Value *getValue() const { return Op<0>(); }
 
   unsigned getNumSuccessors() const { return 0; }
 
+  // Returns true if the ResumeInst I has same special properties as the current
+  // instruction. Any addition of operands in ResumeInst class need to be
+  // reflected here so that the IR comparators stay in sync with the changes to
+  // IR. Currently returning true because ResumeInst has no special properties
+  // to compare.
+  bool hasSamePropertiesAs(const ResumeInst *I) const { return true; }
+
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->getOpcode() == Instruction::Resume;
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 
BasicBlock *getSuccessor(unsigned Idx) const {
     return cast<BasicBlock>(getOperand(Idx + 1));
   }
   void setSuccessor(unsigned Idx, BasicBlock *NewSucc) {
     assert(Idx < getNumSuccessors() &&
            "Successor # out of range for catchswitch!");
     setOperand(Idx + 1, NewSucc);
   }
 
+  // Returns true if the CatchSwitchInst I has same special properties as the
+  // current instruction. Any addition of operands in CatchSwitchInst class need
+  // to be reflected here so that the IR comparators stay in sync with the
+  // changes to IR.
+  bool hasSamePropertiesAs(const CatchSwitchInst *I) const {
+    return unwindsToCaller() == I->unwindsToCaller();
+  }
+
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->getOpcode() == Instruction::CatchSwitch;
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 };
public:
 
   static CleanupPadInst *Create(Value *ParentPad, ArrayRef<Value *> Args,
                                 const Twine &NameStr, BasicBlock *InsertAtEnd) {
     unsigned Values = 1 + Args.size();
     return new (Values)
         CleanupPadInst(ParentPad, Args, Values, NameStr, InsertAtEnd);
   }
 
+  // Returns true if the CleanupPadInst I has same special properties as the
+  // current instruction. Any addition of operands in CleanupPadInst class need
+  // to be reflected here so that the IR comparators stay in sync with the
+  // changes to IR. Currently returning true because CleanupPadInst has no
+  // special properties to compare.
+  bool hasSamePropertiesAs(const CleanupPadInst *I) const { return true; }
+
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->getOpcode() == Instruction::CleanupPad;
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 };
public:
   CatchSwitchInst *getCatchSwitch() const {
     return cast<CatchSwitchInst>(Op<-1>());
   }
   void setCatchSwitch(Value *CatchSwitch) {
     assert(CatchSwitch);
     Op<-1>() = CatchSwitch;
   }
 
+  // Returns true if the CatchPadInst I has same special properties as the
+  // current instruction. Any addition of operands in CatchPadInst class need to
+  // be reflected here so that the IR comparators stay in sync with the changes
+  // to IR.
+  bool hasSamePropertiesAs(const CatchPadInst *I) const {
+    const CatchSwitchInst *CSI = getCatchSwitch();
+    return CSI->hasSamePropertiesAs(I->getCatchSwitch());
+  }
+
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->getOpcode() == Instruction::CatchPad;
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 };
public:
   unsigned getNumSuccessors() const { return 1; }
 
   /// Get the parentPad of this catchret's catchpad's catchswitch.
   /// The successor block is implicitly a member of this funclet.
   Value *getCatchSwitchParentPad() const {
     return getCatchPad()->getCatchSwitch()->getParentPad();
   }
 
+  // Returns true if the CatchReturnInst I has same special properties as the
+  // current instruction. Any addition of operands in CatchReturnInst class need
+  // to be reflected here so that the IR comparators stay in sync with the
+  // changes to IR. Currently returning true because CatchReturnInst has no
+  // special properties to compare.
+  bool hasSamePropertiesAs(const CatchReturnInst *I) const { return true; }
+
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return (I->getOpcode() == Instruction::CatchRet);
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 
BasicBlock *getUnwindDest() const {
     return hasUnwindDest() ? cast<BasicBlock>(Op<1>()) : nullptr;
   }
   void setUnwindDest(BasicBlock *NewDest) {
     assert(NewDest);
     assert(hasUnwindDest());
     Op<1>() = NewDest;
   }
 
+  // Returns true if the CleanupReturnInst I has same special properties as the
+  // current instruction. Any addition of operands in CleanupReturnInst class
+  // need to be reflected here so that the IR comparators stay in sync with the
+  // changes to IR.
+  bool hasSamePropertiesAs(const CleanupReturnInst *I) const {
+    return unwindsToCaller() == I->unwindsToCaller();
+  }
+
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return (I->getOpcode() == Instruction::CleanupRet);
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 
public:
 
   // allocate space for exactly zero operands
   void *operator new(size_t s) {
     return User::operator new(s, 0);
   }
 
   unsigned getNumSuccessors() const { return 0; }
 
+  // Returns true if the UnreachableInst I has same special properties as the
+  // current instruction. Any addition of operands in UnreachableInst class need
+  // to be reflected here so that the IR comparators stay in sync with the
+  // changes to IR. Currently returning true because UnreachableInst has no
+  // special properties to compare.
+  bool hasSamePropertiesAs(const UnreachableInst *I) const { return true; }
+
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->getOpcode() == Instruction::Unreachable;
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 
public:
   /// Constructor with insert-at-end-of-block semantics
   TruncInst(
     Value *S,                     ///< The value to be truncated
     Type *Ty,                     ///< The (smaller) type to truncate to
     const Twine &NameStr,         ///< A name for the new instruction
     BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
   );
 
+  // Returns true if the TruncInst I has same special properties as the current
+  // instruction. Any addition of operands in TruncInst class need to be
+  // reflected here so that the IR comparators stay in sync with the changes to
+  // IR. Currently returning true because TruncInst has no special properties to
+  // compare.
+  bool hasSamePropertiesAs(const TruncInst *I) const { return true; }
+
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->getOpcode() == Trunc;
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 };
public:
   /// Constructor with insert-at-end semantics.
   ZExtInst(
     Value *S,                     ///< The value to be zero extended
     Type *Ty,                     ///< The type to zero extend to
     const Twine &NameStr,         ///< A name for the new instruction
     BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
   );
 
+  // Returns true if the ZExtInst I has same special properties as the current
+  // instruction. Any addition of operands in ZExtInst class need to be
+  // reflected here so that the IR comparators stay in sync with the changes to
+  // IR. Currently returning true because ZExtInst has no special properties to
+  // compare.
+  bool hasSamePropertiesAs(const ZExtInst *I) const { return true; }
+
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->getOpcode() == ZExt;
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 };
public:
   /// Constructor with insert-at-end-of-block semantics
   SExtInst(
     Value *S,                     ///< The value to be sign extended
     Type *Ty,                     ///< The type to sign extend to
     const Twine &NameStr,         ///< A name for the new instruction
     BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
   );
 
+  // Returns true if the SExtInst I has same special properties as the current
+  // instruction. Any addition of operands in SExtInst class need to be
+  // reflected here so that the IR comparators stay in sync with the changes to
+  // IR. Currently returning true because SExtInst has no special properties to
+  // compare.
+  bool hasSamePropertiesAs(const SExtInst *I) const { return true; }
+
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->getOpcode() == SExt;
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 };
public:
   /// Constructor with insert-before-instruction semantics
   FPTruncInst(
     Value *S,                     ///< The value to be truncated
     Type *Ty,                     ///< The type to truncate to
     const Twine &NameStr,         ///< A name for the new instruction
     BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
   );
 
+  // Returns true if the FPTruncInst I has same special properties as the
+  // current instruction. Any addition of operands in FPTruncInst class need to
+  // be reflected here so that the IR comparators stay in sync with the changes
+  // to IR. Currently returning true because FPTruncInst has no special
+  // properties to compare.
+  bool hasSamePropertiesAs(const FPTruncInst *I) const { return true; }
+
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->getOpcode() == FPTrunc;
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 };
public:
   /// Constructor with insert-at-end-of-block semantics
   FPExtInst(
     Value *S,                     ///< The value to be extended
     Type *Ty,                     ///< The type to extend to
     const Twine &NameStr,         ///< A name for the new instruction
     BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
   );
 
+  // Returns true if the FPExtInst I has same special properties as the current
+  // instruction. Any addition of operands in FPExtInst class need to be
+  // reflected here so that the IR comparators stay in sync with the changes to
+  // IR. Currently returning true because FPExtInst has no special properties to
+  // compare.
+  bool hasSamePropertiesAs(const FPExtInst *I) const { return true; }
+
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->getOpcode() == FPExt;
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 };
public:
   /// Constructor with insert-at-end-of-block semantics
   UIToFPInst(
     Value *S,                     ///< The value to be converted
     Type *Ty,                     ///< The type to convert to
     const Twine &NameStr,         ///< A name for the new instruction
     BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
   );
 
+  // Returns true if the UIToFPInst I has same special properties as the current
+  // instruction. Any addition of operands in UIToFPInst class need to be
+  // reflected here so that the IR comparators stay in sync with the changes to
+  // IR. Currently returning true because UIToFPInst has no special properties
+  // to compare.
+  bool hasSamePropertiesAs(const UIToFPInst *I) const { return true; }
+
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->getOpcode() == UIToFP;
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 };
public:
   /// Constructor with insert-at-end-of-block semantics
   SIToFPInst(
     Value *S,                     ///< The value to be converted
     Type *Ty,                     ///< The type to convert to
     const Twine &NameStr,         ///< A name for the new instruction
     BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
   );
 
+  // Returns true if the SIToFPInst I has same special properties as the current
+  // instruction. Any addition of operands in SIToFPInst class need to be
+  // reflected here so that the IR comparators stay in sync with the changes to
+  // IR. Currently returning true because SIToFPInst has no special properties
+  // to compare.
+  bool hasSamePropertiesAs(const SIToFPInst *I) const { return true; }
+
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->getOpcode() == SIToFP;
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 };
public:
   /// Constructor with insert-at-end-of-block semantics
   FPToUIInst(
     Value *S,                     ///< The value to be converted
     Type *Ty,                     ///< The type to convert to
     const Twine &NameStr,         ///< A name for the new instruction
     BasicBlock *InsertAtEnd       ///< Where to insert the new instruction
   );
 
+  // Returns true if the FPToUIInst I has same special properties as the current
+  // instruction. Any addition of operands in FPToUIInst class need to be
+  // reflected here so that the IR comparators stay in sync with the changes to
+  // IR. Currently returning true because FPToUIInst has no special properties
+  // to compare.
+  bool hasSamePropertiesAs(const FPToUIInst *I) const { return true; }
+
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->getOpcode() == FPToUI;
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 };
public:
   /// Constructor with insert-at-end-of-block semantics
   FPToSIInst(
     Value *S,                     ///< The value to be converted
     Type *Ty,                     ///< The type to convert to
     const Twine &NameStr,         ///< A name for the new instruction
     BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
   );
 
+  // Returns true if the FPToSIInst I has same special properties as the current
+  // instruction. Any addition of operands in FPToSIInst class need to be
+  // reflected here so that the IR comparators stay in sync with the changes to
+  // IR. Currently returning true because FPToSIInst has no special properties
+  // to compare.
+  bool hasSamePropertiesAs(const FPToSIInst *I) const { return true; }
+
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->getOpcode() == FPToSI;
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 };
public:
   /// Clone an identical IntToPtrInst.
   IntToPtrInst *cloneImpl() const;
 
   /// Returns the address space of this instruction's pointer type.
   unsigned getAddressSpace() const {
     return getType()->getPointerAddressSpace();
   }
 
+  // Returns true if the IntToPtrInst I has same special properties as the
+  // current instruction. Any addition of operands in IntToPtrInst class need to
+  // be reflected here so that the IR comparators stay in sync with the changes
+  // to IR. Currently returning true because IntToPtrInst has no special
+  // properties to compare.
+  bool hasSamePropertiesAs(const IntToPtrInst *I) const { return true; }
+
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->getOpcode() == IntToPtr;
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 };
public:
   /// Gets the operand index of the pointer operand.
   static unsigned getPointerOperandIndex() { return 0U; }
 
   /// Returns the address space of the pointer operand.
   unsigned getPointerAddressSpace() const {
     return getPointerOperand()->getType()->getPointerAddressSpace();
   }
 
+  // Returns true if the PtrToIntInst I has same special properties as the
+  // current instruction. Any addition of operands in PtrToIntInst class need to
+  // be reflected here so that the IR comparators stay in sync with the changes
+  // to IR. Currently returning true because PtrToIntInst has no special
+  // properties to compare.
+  bool hasSamePropertiesAs(const PtrToIntInst *I) const { return true; }
+
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->getOpcode() == PtrToInt;
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 };
public:
   /// Constructor with insert-at-end-of-block semantics
   BitCastInst(
     Value *S,                     ///< The value to be casted
     Type *Ty,                     ///< The type to casted to
     const Twine &NameStr,         ///< A name for the new instruction
     BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
   );
 
+  // Returns true if the BitCastInst I has same special properties as the
+  // current instruction. Any addition of operands in BitCastInst class need to
+  // be reflected here so that the IR comparators stay in sync with the changes
+  // to IR. Currently returning true because BitCastInst has no special
+  // properties to compare.
+  bool hasSamePropertiesAs(const BitCastInst *I) const { return true; }
+
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->getOpcode() == BitCast;
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 };
public:
   /// Constructor with insert-at-end-of-block semantics
   AddrSpaceCastInst(
     Value *S,                     ///< The value to be casted
     Type *Ty,                     ///< The type to casted to
     const Twine &NameStr,         ///< A name for the new instruction
     BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
   );
 
+  // Returns true if the AddrSpaceCastInst I has same special properties as the
+  // current instruction. Any addition of operands in AddrSpaceCastInst class
+  // need to be reflected here so that the IR comparators stay in sync with the
+  // changes to IR. Currently returning true because AddrSpaceCastInst has no
+  // special properties to compare.
+  bool hasSamePropertiesAs(const AddrSpaceCastInst *I) const { return true; }
+
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->getOpcode() == AddrSpaceCast;
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 
protected:
   FreezeInst *cloneImpl() const;
 
 public:
   explicit FreezeInst(Value *S,
                       const Twine &NameStr = "",
                       Instruction *InsertBefore = nullptr);
   FreezeInst(Value *S, const Twine &NameStr, BasicBlock *InsertAtEnd);
 
+  // Returns true if the FreezeInst I has same special properties as the current
+  // instruction. Any addition of operands in FreezeInst class need to be
+  // reflected here so that the IR comparators stay in sync with the changes to
+  // IR. Currently returning true because FreezeInst has no special properties
+  // to compare.
+  bool hasSamePropertiesAs(const FreezeInst *I) const { return true; }
+
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const Instruction *I) {
     return I->getOpcode() == Freeze;
   }
   static inline bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_IR_INSTRUCTIONS_H

llvm/lib/IR/Instruction.cpp

const char *Instruction::getOpcodeName(unsigned OpCode) {
   case Freeze:         return "freeze";
 
   default: return "<Invalid operator> ";
   }
 }
 
 /// Return true if both instructions have the same special state. This must be
 /// kept in sync with FunctionComparator::cmpOperations in
 /// lib/Transforms/IPO/MergeFunctions.cpp.
 static bool haveSameSpecialState(const Instruction *I1, const Instruction *I2,
                                  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))
-    return AI->getAllocatedType() == cast<AllocaInst>(I2)->getAllocatedType() &&
-           (AI->getAlignment() == cast<AllocaInst>(I2)->getAlignment() ||
-            IgnoreAlignment);
-  if (const LoadInst *LI = dyn_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))
-    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))
-    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))
-    return FI->getOrdering() == cast<FenceInst>(I2)->getOrdering() &&
-           FI->getSyncScopeID() == cast<FenceInst>(I2)->getSyncScopeID();
-  if (const AtomicCmpXchgInst *CXI = dyn_cast<AtomicCmpXchgInst>(I1))
-    return CXI->isVolatile() == cast<AtomicCmpXchgInst>(I2)->isVolatile() &&
-           CXI->isWeak() == cast<AtomicCmpXchgInst>(I2)->isWeak() &&
-           CXI->getSuccessOrdering() ==
-               cast<AtomicCmpXchgInst>(I2)->getSuccessOrdering() &&
-           CXI->getFailureOrdering() ==
-               cast<AtomicCmpXchgInst>(I2)->getFailureOrdering() &&
-           CXI->getSyncScopeID() ==
-               cast<AtomicCmpXchgInst>(I2)->getSyncScopeID();
-  if (const AtomicRMWInst *RMWI = dyn_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() ==
-           cast<ShuffleVectorInst>(I2)->getShuffleMask();
-
-  return true;
+  switch (I1->getOpcode()) {
+  default:
+    // Trying to compare an instruction whose Opcode is unknown to this
+    // function. This leads to failure when new instructions are added
+    // but this function is not updated.
+    llvm_unreachable("Instruction to compare are unknown");
+  case Instruction::Alloca: {
+    const AllocaInst *AI = cast<AllocaInst>(I1);
+    return AI->hasSamePropertiesAs(cast<AllocaInst>(I2), IgnoreAlignment);
+  }
+  case Instruction::Load: {
+    const LoadInst *LI = cast<LoadInst>(I1);
+    return LI->hasSamePropertiesAs(cast<LoadInst>(I2), IgnoreAlignment);
+  }
+  case Instruction::Store: {
+    const StoreInst *SI = cast<StoreInst>(I1);
+    return SI->hasSamePropertiesAs(cast<StoreInst>(I2), IgnoreAlignment);
+  }
+  case Instruction::ICmp: {
+    const ICmpInst *IC = cast<ICmpInst>(I1);
+    return IC->hasSamePropertiesAs(cast<ICmpInst>(I2));
+  }
+  case Instruction::FCmp: {
+    const FCmpInst *FC = cast<FCmpInst>(I1);
+    return FC->hasSamePropertiesAs(cast<FCmpInst>(I2));
+  }
+  case Instruction::Call: {
+    const CallInst *CI = cast<CallInst>(I1);
+    return CI->hasSamePropertiesAs(cast<CallInst>(I2));
+  }
+  case Instruction::Invoke: {
+    const InvokeInst *II = cast<InvokeInst>(I1);
+    return II->hasSamePropertiesAs(cast<InvokeInst>(I2));
+  }
+  case Instruction::CallBr: {
+    const CallBrInst *CBI = cast<CallBrInst>(I1);
+    return CBI->hasSamePropertiesAs(cast<CallBrInst>(I2));
+  }
+  case Instruction::InsertValue: {
+    const InsertValueInst *IVI = cast<InsertValueInst>(I1);
+    return IVI->hasSamePropertiesAs(cast<InsertValueInst>(I2));
+  }
+  case Instruction::ExtractValue: {
+    const ExtractValueInst *EVI = cast<ExtractValueInst>(I1);
+    return EVI->hasSamePropertiesAs(cast<ExtractValueInst>(I2));
+  }
+  case Instruction::Fence: {
+    const FenceInst *FI = cast<FenceInst>(I1);
+    return FI->hasSamePropertiesAs(cast<FenceInst>(I2));
+  }
+  case Instruction::AtomicCmpXchg: {
+    const AtomicCmpXchgInst *CXI = cast<AtomicCmpXchgInst>(I1);
+    return CXI->hasSamePropertiesAs(cast<AtomicCmpXchgInst>(I2));
+  }
+  case Instruction::AtomicRMW: {
+    const AtomicRMWInst *RMWI = cast<AtomicRMWInst>(I1);
+    return RMWI->hasSamePropertiesAs(cast<AtomicRMWInst>(I2));
+  }
+  case Instruction::ShuffleVector: {
+    const ShuffleVectorInst *SVI = cast<ShuffleVectorInst>(I1);
+    return SVI->hasSamePropertiesAs(cast<ShuffleVectorInst>(I2));
+  }
+  case Instruction::Ret: {
+    const ReturnInst *RI = cast<ReturnInst>(I1);
+    return RI->hasSamePropertiesAs(cast<ReturnInst>(I2));
+  }
+  case Instruction::Br: {
+    const BranchInst *BI = cast<BranchInst>(I1);
+    return BI->hasSamePropertiesAs(cast<BranchInst>(I2));
+  }
+  case Instruction::Switch: {
+    const SwitchInst *SI = cast<SwitchInst>(I1);
+    return SI->hasSamePropertiesAs(cast<SwitchInst>(I2));
+  }
+  case Instruction::IndirectBr: {
+    const IndirectBrInst *IBI = cast<IndirectBrInst>(I1);
+    return IBI->hasSamePropertiesAs(cast<IndirectBrInst>(I2));
+  }
+  case Instruction::Resume: {
+    const ResumeInst *RI = cast<ResumeInst>(I1);
+    return RI->hasSamePropertiesAs(cast<ResumeInst>(I2));
+  }
+  case Instruction::CatchSwitch: {
+    const CatchSwitchInst *CSI = cast<CatchSwitchInst>(I1);
+    return CSI->hasSamePropertiesAs(cast<CatchSwitchInst>(I2));
+  }
+  case Instruction::CatchRet: {
+    const CatchReturnInst *CRI = cast<CatchReturnInst>(I1);
+    return CRI->hasSamePropertiesAs(cast<CatchReturnInst>(I2));
+  }
+  case Instruction::CleanupRet: {
+    const CleanupReturnInst *CRI = cast<CleanupReturnInst>(I1);
+    return CRI->hasSamePropertiesAs(cast<CleanupReturnInst>(I2));
+  }
+  case Instruction::Unreachable: {
+    const UnreachableInst *UI = cast<UnreachableInst>(I1);
+    return UI->hasSamePropertiesAs(cast<UnreachableInst>(I2));
+  }
+  case Instruction::FNeg: {
+    const UnaryOperator *UOP = cast<UnaryOperator>(I1);
+    return UOP->hasSamePropertiesAs(cast<UnaryOperator>(I2));
+  }
+  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: {
+    const BinaryOperator *BOP = cast<BinaryOperator>(I1);
+    return BOP->hasSamePropertiesAs(cast<BinaryOperator>(I2));
+  }
+  case Instruction::GetElementPtr: {
+    const GetElementPtrInst *GEP = cast<GetElementPtrInst>(I1);
+    return GEP->hasSamePropertiesAs(cast<GetElementPtrInst>(I2));
+  }
+  case Instruction::Trunc: {
+    const TruncInst *TI = cast<TruncInst>(I1);
+    return TI->hasSamePropertiesAs(cast<TruncInst>(I2));
+  }
+  case Instruction::ZExt: {
+    const ZExtInst *ZEI = cast<ZExtInst>(I1);
+    return ZEI->hasSamePropertiesAs(cast<ZExtInst>(I2));
+  }
+  case Instruction::SExt: {
+    const SExtInst *SEI = cast<SExtInst>(I1);
+    return SEI->hasSamePropertiesAs(cast<SExtInst>(I2));
+  }
+  case Instruction::FPToUI: {
+    const FPToUIInst *FUI = cast<FPToUIInst>(I1);
+    return FUI->hasSamePropertiesAs(cast<FPToUIInst>(I2));
+  }
+  case Instruction::FPToSI: {
+    const FPToSIInst *FSI = cast<FPToSIInst>(I1);
+    return FSI->hasSamePropertiesAs(cast<FPToSIInst>(I2));
+  }
+  case Instruction::UIToFP: {
+    const UIToFPInst *UFI = cast<UIToFPInst>(I1);
+    return UFI->hasSamePropertiesAs(cast<UIToFPInst>(I2));
+  }
+  case Instruction::SIToFP: {
+    const SIToFPInst *SFI = cast<SIToFPInst>(I1);
+    return SFI->hasSamePropertiesAs(cast<SIToFPInst>(I2));
+  }
+  case Instruction::FPTrunc: {
+    const FPTruncInst *FTI = cast<FPTruncInst>(I1);
+    return FTI->hasSamePropertiesAs(cast<FPTruncInst>(I2));
+  }
+  case Instruction::FPExt: {
+    const FPExtInst *FEI = cast<FPExtInst>(I1);
+    return FEI->hasSamePropertiesAs(cast<FPExtInst>(I2));
+  }
+  case Instruction::PtrToInt: {
+    const PtrToIntInst *PII = cast<PtrToIntInst>(I1);
+    return PII->hasSamePropertiesAs(cast<PtrToIntInst>(I2));
+  }
+  case Instruction::IntToPtr: {
+    const IntToPtrInst *IPI = cast<IntToPtrInst>(I1);
+    return IPI->hasSamePropertiesAs(cast<IntToPtrInst>(I2));
+  }
+  case Instruction::BitCast: {
+    const BitCastInst *BI = cast<BitCastInst>(I1);
+    return BI->hasSamePropertiesAs(cast<BitCastInst>(I2));
+  }
+  case Instruction::AddrSpaceCast: {
+    const AddrSpaceCastInst *ACI = cast<AddrSpaceCastInst>(I1);
+    return ACI->hasSamePropertiesAs(cast<AddrSpaceCastInst>(I2));
+  }
+  case Instruction::CleanupPad: {
+    const CleanupPadInst *CPI = cast<CleanupPadInst>(I1);
+    return CPI->hasSamePropertiesAs(cast<CleanupPadInst>(I2));
+  }
+  case Instruction::CatchPad: {
+    const CatchPadInst *CPI = cast<CatchPadInst>(I1);
+    return CPI->hasSamePropertiesAs(cast<CatchPadInst>(I2));
+  }
+  case Instruction::PHI: {
+    const PHINode *PI = cast<PHINode>(I1);
+    return PI->hasSamePropertiesAs(cast<PHINode>(I2));
+  }
+  case Instruction::Select: {
+    const SelectInst *SI = cast<SelectInst>(I1);
+    return SI->hasSamePropertiesAs(cast<SelectInst>(I2));
+  }
+  case Instruction::VAArg: {
+    const VAArgInst *VAI = cast<VAArgInst>(I1);
+    return VAI->hasSamePropertiesAs(cast<VAArgInst>(I2));
+  }
+  case Instruction::ExtractElement: {
+    const ExtractElementInst *EEI = cast<ExtractElementInst>(I1);
+    return EEI->hasSamePropertiesAs(cast<ExtractElementInst>(I2));
+  }
+  case Instruction::InsertElement: {
+    const InsertElementInst *IEI = cast<InsertElementInst>(I1);
+    return IEI->hasSamePropertiesAs(cast<InsertElementInst>(I2));
+  }
+  case Instruction::LandingPad: {
+    const LandingPadInst *LPI = cast<LandingPadInst>(I1);
+    return LPI->hasSamePropertiesAs(cast<LandingPadInst>(I2));
+  }
+  case Instruction::Freeze: {
+    const FreezeInst *FI = cast<FreezeInst>(I1);
+    return FI->hasSamePropertiesAs(cast<FreezeInst>(I2));
+  }
+  }
 }
 
 bool Instruction::isIdenticalTo(const Instruction *I) const {
   return isIdenticalToWhenDefined(I) &&
          SubclassOptionalData == I->SubclassOptionalData;
 }
 
 bool Instruction::isIdenticalToWhenDefined(const Instruction *I) const {