[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

424

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

427

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

430

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

435

Same here.

451

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

420

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

1311

Stray ';'

llvm/lib/IR/Instruction.cpp

403–404

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

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

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

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

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;

187

Same here on flags.

320

Ditto.

1471

Ditto.

3795

Ditto.

4012

Ditto.

llvm/lib/IR/Instructions.cpp

82

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

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

Can we do:

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

66

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());
   }
 
+  // Function to introduce total ordering between two UnaryOperator
+  // Instructions. Returns -1 (this instruction < I)
+  //         +1 (this instruction > I)
+  //          0 (this instruction = I)
+  // 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.
+  int compareInstSpecificProperties(const UnaryOperator *I) const;
+
   // 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();
 
+  // Function to introduce total ordering between two BinaryOperator
+  // Instructions. Returns -1 (this instruction < I)
+  //         +1 (this instruction > I)
+  //          0 (this instruction = I)
+  // 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.
+  int compareInstSpecificProperties(const BinaryOperator *I) const;
+
   // 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));
   }
 };
public:
   /// Determine if Pred1 implies Pred2 is true when two compares have matching
   /// operands.
   static bool isImpliedTrueByMatchingCmp(Predicate Pred1, Predicate Pred2);
 
   /// Determine if Pred1 implies Pred2 is false when two compares have matching
   /// operands.
   static bool isImpliedFalseByMatchingCmp(Predicate Pred1, Predicate Pred2);
 
+  // Function to introduce total ordering between two Cmp Instructions.
+  // Returns -1 (this instruction < I)
+  //         +1 (this instruction > I)
+  //          0 (this instruction = I)
+  // Any addition of operands in CmpInst class need to be reflected here
+  // so that the IR comparators stay in sync with the changes to IR.
+  int compareInstSpecificProperties(const CmpInst *I) const;
+
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->getOpcode() == Instruction::ICmp ||
            I->getOpcode() == Instruction::FCmp;
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }

llvm/include/llvm/IR/Instruction.h

public:
 
   /// Create a copy of 'this' instruction that is identical in all ways except
   /// the following:
   ///   * The instruction has no parent
   ///   * The instruction has no name
   ///
   Instruction *clone() const;
 
+  /// Function to introduce total ordering between two Instructions
+  /// based on their special state.
+  /// Returns -1 (this instruction < I1)
+  ///         +1 (this instruction > I1)
+  ///          0 (this instruction = I1)
+  /// This checks whether instruction specific properties for instructions
+  /// which have the same Opcode and same number of operands.
+  int compareSpecialState(const Instruction *I1, unsigned flags = 0) const;
+
   /// Return true if the specified instruction is exactly identical to the
   /// current one. This means that all operands match and any extra information
   /// (e.g. load is volatile) agree.
   bool isIdenticalTo(const Instruction *I) const;
 
   /// This is like isIdenticalTo, except that it ignores the
   /// SubclassOptionalData flags, which may specify conditions under which the
   /// instruction's result is undefined.
   bool isIdenticalToWhenDefined(const Instruction *I) const;
 
   /// When checking for operation equivalence (using isSameOperationAs) it is
   /// sometimes useful to ignore certain attributes.
   enum OperationEquivalenceFlags {
     /// Check for equivalence ignoring load/store alignment.
-    CompareIgnoringAlignment = 1<<0,
+    CompareIgnoringAlignment = 1 << 0,
+    /// Check for equivalence ignoring MetaData.
+    CompareIgnoringMetaData = 1 << 1,
     /// Check for equivalence treating a type and a vector of that type
     /// as equivalent.
-    CompareUsingScalarTypes = 1<<1
+    CompareUsingScalarTypes = 1 << 2
   };
 
   /// This function determines if the specified instruction executes the same
   /// operation as the current one. This means that the opcodes, type, operand
   /// types and any other factors affecting the operation must be the same. This
   /// is similar to isIdenticalTo except the operands themselves don't have to
   /// be identical.
   /// @returns true if the specified instruction is the same operation as

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));
   }
 
+  // Function to introduce total ordering between two Alloca Instructions.
+  // Returns -1 (this instruction < AI)
+  //         +1 (this instruction > AI)
+  //          0 (this instruction = AI)
+  // 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.
+  int compareInstSpecificProperties(const AllocaInst *AI,
+                                    bool IgnoreAlignment = false) const;
+
   // 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();
   }
 
+  // Function to introduce total ordering between two Load Instructions.
+  // Returns -1 (this instruction < LI)
+  //         +1 (this instruction > LI)
+  //          0 (this instruction = LI)
+  // 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.
+  int compareInstSpecificProperties(const LoadInst *LI,
+                                    bool IgnoreAlignment = false,
+                                    bool IgnoreMetaData = false) const;
+
   // 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();
   }
 
+  // Function to introduce total ordering between two Store Instructions.
+  // Returns -1 (this instruction < SI)
+  //         +1 (this instruction > SI)
+  //          0 (this instruction = SI)
+  // 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.
+  int compareInstSpecificProperties(const StoreInst *SI,
+                                    bool IgnoreAlignment = false) const;
+
   // 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;
   }
 
+  // Function to introduce total ordering between two Fence Instructions.
+  // Returns -1 (this instruction < FI)
+  //         +1 (this instruction > FI)
+  //          0 (this instruction = FI)
+  // 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.
+  int compareInstSpecificProperties(const FenceInst *FI) const;
+
   // 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;
     }
   }
 
+  // Function to introduce total ordering between two AtomicCmpXchg
+  // Instructions. Returns -1 (this instruction < I)
+  //         +1 (this instruction > I)
+  //          0 (this instruction = I)
+  // 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.
+  int compareInstSpecificProperties(const AtomicCmpXchgInst *I) const;
+
   // 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());
   }
 
+  // Function to introduce total ordering between two AtomicRMW Instructions.
+  // Returns -1 (this instruction < I)
+  //         +1 (this instruction > I)
+  //          0 (this instruction = I)
+  // 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.
+  int compareInstSpecificProperties(const AtomicRMWInst *I) const;
+
   // 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;
 
+  // Function to introduce total ordering between two GetElementPtr
+  // Instructions. Returns -1 (this instruction < I)
+  //         +1 (this instruction > I)
+  //          0 (this instruction = I)
+  // 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.
+  int compareInstSpecificProperties(const GetElementPtrInst *I) const;
+
   // 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
   }
 
   // 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));
   }
 };
 
 //===----------------------------------------------------------------------===//
 //                               FCmpInst Class
 //===----------------------------------------------------------------------===//
 
 /// This instruction compares its operands according to the predicate given
 /// to the constructor. It only operates on floating point values or packed

 
 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);
   }
 
+  // Function to introduce total ordering between two Call Instructions.
+  // Returns -1 (this instruction < I)
+  //         +1 (this instruction > I)
+  //          0 (this instruction = I)
+  // 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.
+  int compareInstSpecificProperties(const CallInst *I,
+                                    bool IgnoreMetaData) const;
+
   // 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());
   }
 
+  // Function to introduce total ordering between two Select Instructions.
+  // Returns -1 (this instruction < I)
+  //         +1 (this instruction > I)
+  //          0 (this instruction = I)
+  // 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.
+  int compareInstSpecificProperties(const SelectInst *I) const;
+
   // 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; }
 
+  // Function to introduce total ordering between two VAArg Instructions.
+  // Returns -1 (this instruction < I)
+  //         +1 (this instruction > I)
+  //          0 (this instruction = I)
+  // 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.
+  int compareInstSpecificProperties(const VAArgInst *I) const;
+
   // 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:
 
   VectorType *getVectorOperandType() const {
     return cast<VectorType>(getVectorOperand()->getType());
   }
 
   /// Transparently provide more efficient getOperand methods.
   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
 
+  // Function to introduce total ordering between two ExtractElement
+  // Instructions. Returns -1 (this instruction < I)
+  //         +1 (this instruction > I)
+  //          0 (this instruction = I)
+  // 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.
+  int compareInstSpecificProperties(const ExtractElementInst *I) const;
+
   // 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) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 };
public:
   ///
   VectorType *getType() const {
     return cast<VectorType>(Instruction::getType());
   }
 
   /// Transparently provide more efficient getOperand methods.
   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
 
+  // Function to introduce total ordering between two InsertElement
+  // Instructions. Returns -1 (this instruction < I)
+  //         +1 (this instruction > I)
+  //          0 (this instruction = I)
+  // 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.
+  int compareInstSpecificProperties(const InsertElementInst *I) const;
+
   // 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) {
     return isa<Instruction>(V) && classof(cast<Instruction>(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");
     }
   }
 
+  // Function to introduce total ordering between two ShuffleVector
+  // Instructions. Returns -1 (this instruction < I)
+  //         +1 (this instruction > I)
+  //          0 (this instruction = I)
+  // 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.
+  int compareInstSpecificProperties(const ShuffleVectorInst *I) const;
+
   // 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:
   ArrayRef<unsigned> getIndices() const {
     return Indices;
   }
 
   unsigned getNumIndices() const {
     return (unsigned)Indices.size();
   }
 
-  bool hasIndices() const {
-    return true;
-  }
+  bool hasIndices() const { return true; }
+
+  // Function to introduce total ordering between two ExtractValue Instructions.
+  // Returns -1 (this instruction < I)
+  //         +1 (this instruction > I)
+  //          0 (this instruction = I)
+  // 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.
+  int compareInstSpecificProperties(const ExtractValueInst *I) const;
 
   // 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:
   ArrayRef<unsigned> getIndices() const {
     return Indices;
   }
 
   unsigned getNumIndices() const {
     return (unsigned)Indices.size();
   }
 
-  bool hasIndices() const {
-    return true;
-  }
+  bool hasIndices() const { return true; }
+
+  // Function to introduce total ordering between two InsertValue Instructions.
+  // Returns -1 (this instruction < I)
+  //         +1 (this instruction > I)
+  //          0 (this instruction = I)
+  // 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.
+  int compareInstSpecificProperties(const InsertValueInst *I) const;
 
   // 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;
 
+  // Function to introduce total ordering between two PHI Instructions.
+  // Returns -1 (this instruction < I)
+  //         +1 (this instruction > I)
+  //          0 (this instruction = I)
+  // 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.
+  int compareInstSpecificProperties(const PHINode *I) const;
+
   /// 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); }
 
+  // Function to introduce total ordering between two LandingPad Instructions.
+  // Returns -1 (this instruction < I)
+  //         +1 (this instruction > I)
+  //          0 (this instruction = I)
+  // 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.
+  int compareInstSpecificProperties(const LandingPadInst *I) const;
+
   // 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; }
 
+  // Function to introduce total ordering between two Return Instructions.
+  // Returns -1 (this instruction < I)
+  //         +1 (this instruction > I)
+  //          0 (this instruction = I)
+  // 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.
+  int compareInstSpecificProperties(const ReturnInst *I) const;
+
   // 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()));
   }
 
+  // Function to introduce total ordering between two Branch Instructions.
+  // Returns -1 (this instruction < I)
+  //         +1 (this instruction > I)
+  //          0 (this instruction = I)
+  // 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.
+  int compareInstSpecificProperties(const BranchInst *I) const;
+
   // 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);
   }
 
+  // Function to introduce total ordering between two Switch Instructions.
+  // Returns -1 (this instruction < I)
+  //         +1 (this instruction > I)
+  //          0 (this instruction = I)
+  // 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.
+  int compareInstSpecificProperties(const SwitchInst *I) const;
+
   // 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()));
   }
 
+  // Function to introduce total ordering between two IndirectBr Instructions.
+  // Returns -1 (this instruction < I)
+  //         +1 (this instruction > I)
+  //          0 (this instruction = I)
+  // 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.
+  int compareInstSpecificProperties(const IndirectBrInst *I) const;
+
   // 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; }
 
+  // Function to introduce total ordering between two Invoke Instructions.
+  // Returns -1 (this instruction < I)
+  //         +1 (this instruction > I)
+  //          0 (this instruction = I)
+  // 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.
+  int compareInstSpecificProperties(const InvokeInst *I,
+                                    bool IgnoreMetaData = false) const;
+
   // 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; }
 
+  // Function to introduce total ordering between two CallBr Instructions.
+  // Returns -1 (this instruction < I)
+  //         +1 (this instruction > I)
+  //          0 (this instruction = I)
+  // 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.
+  int compareInstSpecificProperties(const CallBrInst *I,
+                                    bool IgnoreMetaData = false) const;
+
   // 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; }
 
+  // Function to introduce total ordering between two Resume Instructions.
+  // Returns -1 (this instruction < I)
+  //         +1 (this instruction > I)
+  //          0 (this instruction = I)
+  // 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.
+  int compareInstSpecificProperties(const ResumeInst *I) const;
+
   // 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);
   }
 
+  // Function to introduce total ordering between two CatchSwitch Instructions.
+  // Returns -1 (this instruction < I)
+  //         +1 (this instruction > I)
+  //          0 (this instruction = I)
+  // 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.
+  int compareInstSpecificProperties(const CatchSwitchInst *I) const;
+
   // 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);
   }
 
+  // Function to introduce total ordering between two CleanupPad Instructions.
+  // Returns -1 (this instruction < I)
+  //         +1 (this instruction > I)
+  //          0 (this instruction = I)
+  // 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.
+  int compareInstSpecificProperties(const CleanupPadInst *I) const;
+
   /// 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;
   }
 
+  // Function to introduce total ordering between two CatchPad Instructions.
+  // Returns -1 (this instruction < I)
+  //         +1 (this instruction > I)
+  //          0 (this instruction = I)
+  // 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 compareInstSpecificProperties(const CatchPadInst *I) const;
+
   /// 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();
   }
 
+  // Function to introduce total ordering between two CatchReturn Instructions.
+  // Returns -1 (this instruction < I)
+  //         +1 (this instruction > I)
+  //          0 (this instruction = I)
+  // 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.
+  int compareInstSpecificProperties(const CatchReturnInst *I) const;
+
   // 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;
   }
 
+  // Function to introduce total ordering between two CleanupReturn
+  // Instructions. Returns -1 (this instruction < I)
+  //         +1 (this instruction > I)
+  //          0 (this instruction = I)
+  // 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.
+  int compareInstSpecificProperties(const CleanupReturnInst *I) const;
+
   // 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; }
 
+  // Function to introduce total ordering between two Unreachable Instructions.
+  // Returns -1 (this instruction < I)
+  //         +1 (this instruction > I)
+  //          0 (this instruction = I)
+  // 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.
+  int compareInstSpecificProperties(const UnreachableInst *I) const;
+
   // 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));
   }
 
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
     Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
   );
 
   /// 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
+      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
   );
 
+  // Function to introduce total ordering between two Trunc Instructions.
+  // Returns -1 (this instruction < I)
+  //         +1 (this instruction > I)
+  //          0 (this instruction = I)
+  // 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.
+  int compareInstSpecificProperties(const TruncInst *I) const;
+
   /// 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:
   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
     Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
   );
 
   /// 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
+  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
   );
 
+  // Function to introduce total ordering between two ZExt Instructions.
+  // Returns -1 (this instruction < I)
+  //         +1 (this instruction > I)
+  //          0 (this instruction = I)
+  // 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.
+  int compareInstSpecificProperties(const ZExtInst *I) const;
+
   /// 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:
   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
     Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
   );
 
   /// 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
+  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
   );
 
+  // Function to introduce total ordering between two SExt Instructions.
+  // Returns -1 (this instruction < I)
+  //         +1 (this instruction > I)
+  //          0 (this instruction = I)
+  // 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.
+  int compareInstSpecificProperties(const SExtInst *I) const;
+
   /// 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));
   }
 };
FPTruncInst(
     Value *S,                           ///< The value to be truncated
     Type *Ty,                           ///< The type to truncate to
     const Twine &NameStr = "",          ///< A name for the new instruction
     Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
   );
 
   /// 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
+      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
   );
 
+  // Function to introduce total ordering between two FPTrunc Instructions.
+  // Returns -1 (this instruction < I)
+  //         +1 (this instruction > I)
+  //          0 (this instruction = I)
+  // 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.
+  int compareInstSpecificProperties(const FPTruncInst *I) const;
+
   /// 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));
   }
 };
FPExtInst(
     Value *S,                           ///< The value to be extended
     Type *Ty,                           ///< The type to extend to
     const Twine &NameStr = "",          ///< A name for the new instruction
     Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
   );
 
   /// 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
+      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
   );
 
+  // Function to introduce total ordering between two FPExt Instructions.
+  // Returns -1 (this instruction < I)
+  //         +1 (this instruction > I)
+  //          0 (this instruction = I)
+  // 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.
+  int compareInstSpecificProperties(const FPExtInst *I) const;
+
   /// 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));
   }
 };
UIToFPInst(
     Value *S,                           ///< The value to be converted
     Type *Ty,                           ///< The type to convert to
     const Twine &NameStr = "",          ///< A name for the new instruction
     Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
   );
 
   /// 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
+      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
   );
 
+  // Function to introduce total ordering between two UIToFP Instructions.
+  // Returns -1 (this instruction < I)
+  //         +1 (this instruction > I)
+  //          0 (this instruction = I)
+  // 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.
+  int compareInstSpecificProperties(const UIToFPInst *I) const;
+
   /// 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));
   }
 };
SIToFPInst(
     Value *S,                           ///< The value to be converted
     Type *Ty,                           ///< The type to convert to
     const Twine &NameStr = "",          ///< A name for the new instruction
     Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
   );
 
   /// 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
+      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
   );
 
+  // Function to introduce total ordering between two SIToFP Instructions.
+  // Returns -1 (this instruction < I)
+  //         +1 (this instruction > I)
+  //          0 (this instruction = I)
+  // 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.
+  int compareInstSpecificProperties(const SIToFPInst *I) const;
+
   /// 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:
   FPToUIInst(
     Value *S,                           ///< The value to be converted
     Type *Ty,                           ///< The type to convert to
     const Twine &NameStr = "",          ///< A name for the new instruction
     Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
   );
 
   /// 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
+  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
   );
 
+  // Function to introduce total ordering between two FPToUI Instructions.
+  // Returns -1 (this instruction < I)
+  //         +1 (this instruction > I)
+  //          0 (this instruction = I)
+  // 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.
+  int compareInstSpecificProperties(const FPToUIInst *I) const;
+
   /// 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));
   }
 };
FPToSIInst(
     Value *S,                           ///< The value to be converted
     Type *Ty,                           ///< The type to convert to
     const Twine &NameStr = "",          ///< A name for the new instruction
     Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
   );
 
   /// 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
+      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
   );
 
+  // Function to introduce total ordering between two FPToSI Instructions.
+  // Returns -1 (this instruction < I)
+  //         +1 (this instruction > I)
+  //          0 (this instruction = I)
+  // 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.
+  int compareInstSpecificProperties(const FPToSIInst *I) const;
+
   /// 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();
   }
 
+  // Function to introduce total ordering between two IntToPtr Instructions.
+  // Returns -1 (this instruction < I)
+  //         +1 (this instruction > I)
+  //          0 (this instruction = I)
+  // 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.
+  int compareInstSpecificProperties(const IntToPtrInst *I) const;
+
   // 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();
   }
 
+  // Function to introduce total ordering between two PtrToInt Instructions.
+  // Returns -1 (this instruction < I)
+  //         +1 (this instruction > I)
+  //          0 (this instruction = I)
+  // 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.
+  int compareInstSpecificProperties(const PtrToIntInst *I) const;
+
   // 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));
   }
 };
BitCastInst(
     Value *S,                           ///< The value to be casted
     Type *Ty,                           ///< The type to casted to
     const Twine &NameStr = "",          ///< A name for the new instruction
     Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
   );
 
   /// 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
+      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
   );
 
+  // Function to introduce total ordering between two BitCast Instructions.
+  // Returns -1 (this instruction < I)
+  //         +1 (this instruction > I)
+  //          0 (this instruction = I)
+  // 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.
+  int compareInstSpecificProperties(const BitCastInst *I) const;
+
   // 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));
   }
 };
AddrSpaceCastInst(
     Value *S,                           ///< The value to be casted
     Type *Ty,                           ///< The type to casted to
     const Twine &NameStr = "",          ///< A name for the new instruction
     Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
   );
 
   /// 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
+      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
   );
 
+  // Function to introduce total ordering between two AddrSpaceCast
+  // Instructions. Returns -1 (this instruction < I)
+  //         +1 (this instruction > I)
+  //          0 (this instruction = I)
+  // 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.
+  int compareInstSpecificProperties(const AddrSpaceCastInst *I) const;
+
   // 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);
 
+  // Function to introduce total ordering between two Freeze Instructions.
+  // Returns -1 (this instruction < I)
+  //         +1 (this instruction > I)
+  //          0 (this instruction = I)
+  // 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.
+  int compareInstSpecificProperties(const FreezeInst *I) const;
+
   // 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 InsertValue:    return "insertvalue";
   case LandingPad:     return "landingpad";
   case CleanupPad:     return "cleanuppad";
   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() &&
+/// Function to introduce total ordering between two Instructions
+/// based on the special state.
+/// Returns -1 (this instruction < I)
+///         +1 (this instruction > I)
+///          0 (this instruction = I)
+/// This is used by FunctionComparator::cmpOperations in
+/// lib/Transforms/Utils/FunctionComparator.cpp.
+int Instruction::compareSpecialState(const Instruction *I1,
+                                     unsigned flags) const {
+  assert(getOpcode() == I2->getOpcode() &&
          "Can not compare special state of different instructions");
+  assert(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();
+  bool IgnoreAlignment = flags & CompareIgnoringAlignment;
+  bool IgnoreMetaData = flags & CompareIgnoringMetaData;
 
-  return true;
+  switch (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>(this);
+    return AI->compareInstSpecificProperties(cast<AllocaInst>(I1),
+                                             IgnoreAlignment);
+  }
+  case Instruction::Load: {
+    const LoadInst *LI = cast<LoadInst>(this);
+    return LI->compareInstSpecificProperties(cast<LoadInst>(I1),
+                                             IgnoreAlignment, IgnoreMetaData);
+  }
+  case Instruction::Store: {
+    const StoreInst *SI = cast<StoreInst>(this);
+    return SI->compareInstSpecificProperties(cast<StoreInst>(I1),
+                                             IgnoreAlignment);
+  }
+  case Instruction::ICmp:
+  case Instruction::FCmp: {
+    const CmpInst *C = cast<CmpInst>(this);
+    return C->compareInstSpecificProperties(cast<CmpInst>(I1));
+  }
+  case Instruction::Call: {
+    const CallInst *CI = cast<CallInst>(this);
+    return CI->compareInstSpecificProperties(cast<CallInst>(I1),
+                                             IgnoreMetaData);
+  }
+  case Instruction::Invoke: {
+    const InvokeInst *II = cast<InvokeInst>(this);
+    return II->compareInstSpecificProperties(cast<InvokeInst>(I1),
+                                             IgnoreMetaData);
+  }
+  case Instruction::CallBr: {
+    const CallBrInst *CBI = cast<CallBrInst>(this);
+    return CBI->compareInstSpecificProperties(cast<CallBrInst>(I1),
+                                              IgnoreMetaData);
+  }
+  case Instruction::InsertValue: {
+    const InsertValueInst *IVI = cast<InsertValueInst>(this);
+    return IVI->compareInstSpecificProperties(cast<InsertValueInst>(I1));
+  }
+  case Instruction::ExtractValue: {
+    const ExtractValueInst *EVI = cast<ExtractValueInst>(this);
+    return EVI->compareInstSpecificProperties(cast<ExtractValueInst>(I1));
+  }
+  case Instruction::Fence: {
+    const FenceInst *FI = cast<FenceInst>(this);
+    return FI->compareInstSpecificProperties(cast<FenceInst>(I1));
+  }
+  case Instruction::AtomicCmpXchg: {
+    const AtomicCmpXchgInst *CXI = cast<AtomicCmpXchgInst>(this);
+    return CXI->compareInstSpecificProperties(cast<AtomicCmpXchgInst>(I1));
+  }
+  case Instruction::AtomicRMW: {
+    const AtomicRMWInst *RMWI = cast<AtomicRMWInst>(this);
+    return RMWI->compareInstSpecificProperties(cast<AtomicRMWInst>(I1));
+  }
+  case Instruction::ShuffleVector: {
+    const ShuffleVectorInst *SVI = cast<ShuffleVectorInst>(this);
+    return SVI->compareInstSpecificProperties(cast<ShuffleVectorInst>(I1));
+  }
+  case Instruction::Ret: {
+    const ReturnInst *RI = cast<ReturnInst>(this);
+    return RI->compareInstSpecificProperties(cast<ReturnInst>(I1));
+  }
+  case Instruction::Br: {
+    const BranchInst *BI = cast<BranchInst>(this);
+    return BI->compareInstSpecificProperties(cast<BranchInst>(I1));
+  }
+  case Instruction::Switch: {
+    const SwitchInst *SI = cast<SwitchInst>(this);
+    return SI->compareInstSpecificProperties(cast<SwitchInst>(I1));
+  }
+  case Instruction::IndirectBr: {
+    const IndirectBrInst *IBI = cast<IndirectBrInst>(this);
+    return IBI->compareInstSpecificProperties(cast<IndirectBrInst>(I1));
+  }
+  case Instruction::Resume: {
+    const ResumeInst *RI = cast<ResumeInst>(this);
+    return RI->compareInstSpecificProperties(cast<ResumeInst>(I1));
+  }
+  case Instruction::CatchSwitch: {
+    const CatchSwitchInst *CSI = cast<CatchSwitchInst>(this);
+    return CSI->compareInstSpecificProperties(cast<CatchSwitchInst>(I1));
+  }
+  case Instruction::CatchRet: {
+    const CatchReturnInst *CRI = cast<CatchReturnInst>(this);
+    return CRI->compareInstSpecificProperties(cast<CatchReturnInst>(I1));
+  }
+  case Instruction::CleanupRet: {
+    const CleanupReturnInst *CRI = cast<CleanupReturnInst>(this);
+    return CRI->compareInstSpecificProperties(cast<CleanupReturnInst>(I1));
+  }
+  case Instruction::Unreachable: {
+    const UnreachableInst *UI = cast<UnreachableInst>(this);
+    return UI->compareInstSpecificProperties(cast<UnreachableInst>(I1));
+  }
+  case Instruction::FNeg: {
+    const UnaryOperator *UOP = cast<UnaryOperator>(this);
+    return UOP->compareInstSpecificProperties(cast<UnaryOperator>(I1));
+  }
+  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>(this);
+    return BOP->compareInstSpecificProperties(cast<BinaryOperator>(I1));
+  }
+  case Instruction::GetElementPtr: {
+    const GetElementPtrInst *GEP = cast<GetElementPtrInst>(this);
+    return GEP->compareInstSpecificProperties(cast<GetElementPtrInst>(I1));
+  }
+  case Instruction::Trunc: {
+    const TruncInst *TI = cast<TruncInst>(this);
+    return TI->compareInstSpecificProperties(cast<TruncInst>(I1));
+  }
+  case Instruction::ZExt: {
+    const ZExtInst *ZEI = cast<ZExtInst>(this);
+    return ZEI->compareInstSpecificProperties(cast<ZExtInst>(I1));
+  }
+  case Instruction::SExt: {
+    const SExtInst *SEI = cast<SExtInst>(this);
+    return SEI->compareInstSpecificProperties(cast<SExtInst>(I1));
+  }
+  case Instruction::FPToUI: {
+    const FPToUIInst *FUI = cast<FPToUIInst>(this);
+    return FUI->compareInstSpecificProperties(cast<FPToUIInst>(I1));
+  }
+  case Instruction::FPToSI: {
+    const FPToSIInst *FSI = cast<FPToSIInst>(this);
+    return FSI->compareInstSpecificProperties(cast<FPToSIInst>(I1));
+  }
+  case Instruction::UIToFP: {
+    const UIToFPInst *UFI = cast<UIToFPInst>(this);
+    return UFI->compareInstSpecificProperties(cast<UIToFPInst>(I1));
+  }
+  case Instruction::SIToFP: {
+    const SIToFPInst *SFI = cast<SIToFPInst>(this);
+    return SFI->compareInstSpecificProperties(cast<SIToFPInst>(I1));
+  }
+  case Instruction::FPTrunc: {
+    const FPTruncInst *FTI = cast<FPTruncInst>(this);
+    return FTI->compareInstSpecificProperties(cast<FPTruncInst>(I1));
+  }
+  case Instruction::FPExt: {
+    const FPExtInst *FEI = cast<FPExtInst>(this);
+    return FEI->compareInstSpecificProperties(cast<FPExtInst>(I1));
+  }
+  case Instruction::PtrToInt: {
+    const PtrToIntInst *PII = cast<PtrToIntInst>(this);
+    return PII->compareInstSpecificProperties(cast<PtrToIntInst>(I1));
+  }
+  case Instruction::IntToPtr: {
+    const IntToPtrInst *IPI = cast<IntToPtrInst>(this);
+    return IPI->compareInstSpecificProperties(cast<IntToPtrInst>(I1));
+  }
+  case Instruction::BitCast: {
+    const BitCastInst *BI = cast<BitCastInst>(this);
+    return BI->compareInstSpecificProperties(cast<BitCastInst>(I1));
+  }
+  case Instruction::AddrSpaceCast: {
+    const AddrSpaceCastInst *ACI = cast<AddrSpaceCastInst>(this);
+    return ACI->compareInstSpecificProperties(cast<AddrSpaceCastInst>(I1));
+  }
+  case Instruction::CleanupPad: {
+    const CleanupPadInst *CPI = cast<CleanupPadInst>(this);
+    return CPI->compareInstSpecificProperties(cast<CleanupPadInst>(I1));
+  }
+  case Instruction::CatchPad: {
+    const CatchPadInst *CPI = cast<CatchPadInst>(this);
+    return CPI->compareInstSpecificProperties(cast<CatchPadInst>(I1));
+  }
+  case Instruction::PHI: {
+    const PHINode *PI = cast<PHINode>(this);
+    return PI->compareInstSpecificProperties(cast<PHINode>(I1));
+  }
+  case Instruction::Select: {
+    const SelectInst *SI = cast<SelectInst>(this);
+    return SI->compareInstSpecificProperties(cast<SelectInst>(I1));
+  }
+  case Instruction::VAArg: {
+    const VAArgInst *VAI = cast<VAArgInst>(this);
+    return VAI->compareInstSpecificProperties(cast<VAArgInst>(I1));
+  }
+  case Instruction::ExtractElement: {
+    const ExtractElementInst *EEI = cast<ExtractElementInst>(this);
+    return EEI->compareInstSpecificProperties(cast<ExtractElementInst>(I1));
+  }
+  case Instruction::InsertElement: {
+    const InsertElementInst *IEI = cast<InsertElementInst>(this);
+    return IEI->compareInstSpecificProperties(cast<InsertElementInst>(I1));
+  }
+  case Instruction::LandingPad: {
+    const LandingPadInst *LPI = cast<LandingPadInst>(this);
+    return LPI->compareInstSpecificProperties(cast<LandingPadInst>(I1));
+  }
+  case Instruction::Freeze: {
+    const FreezeInst *FI = cast<FreezeInst>(this);
+    return FI->compareInstSpecificProperties(cast<FreezeInst>(I1));
+  }
+  }
 }
 
 bool Instruction::isIdenticalTo(const Instruction *I) const {
   return isIdenticalToWhenDefined(I) &&
          SubclassOptionalData == I->SubclassOptionalData;
 }
 
 bool Instruction::isIdenticalToWhenDefined(const Instruction *I) const {
   if (getOpcode() != I->getOpcode() ||
-      getNumOperands() != I->getNumOperands() ||
-      getType() != I->getType())
+      getNumOperands() != I->getNumOperands() || getType() != I->getType())
     return false;
 
   // If both instructions have no operands, they are identical.
   if (getNumOperands() == 0 && I->getNumOperands() == 0)
-    return haveSameSpecialState(this, I);
+    return compareSpecialState(I, CompareIgnoringMetaData) == 0;
 
   // We have two instructions of identical opcode and #operands.  Check to see
   // if all operands are the same.
   if (!std::equal(op_begin(), op_end(), I->op_begin()))
     return false;
 
   if (const PHINode *thisPHI = dyn_cast<PHINode>(this)) {
     const PHINode *otherPHI = cast<PHINode>(I);
     return std::equal(thisPHI->block_begin(), thisPHI->block_end(),
                       otherPHI->block_begin());
   }
 
-  return haveSameSpecialState(this, I);
+  return compareSpecialState(I, CompareIgnoringMetaData) == 0;
 }
 
 // Keep this in sync with FunctionComparator::cmpOperations in
 // lib/Transforms/IPO/MergeFunctions.cpp.
 bool Instruction::isSameOperationAs(const Instruction *I,
                                     unsigned flags) const {
-  bool IgnoreAlignment = flags & CompareIgnoringAlignment;
   bool UseScalarTypes  = flags & CompareUsingScalarTypes;
 
   if (getOpcode() != I->getOpcode() ||
       getNumOperands() != I->getNumOperands() ||
       (UseScalarTypes ?
        getType()->getScalarType() != I->getType()->getScalarType() :
        getType() != I->getType()))
     return false;
 
   // We have two instructions of identical opcode and #operands.  Check to see
   // if all operands are the same type
   for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
-    if (UseScalarTypes ?
-        getOperand(i)->getType()->getScalarType() !=
-          I->getOperand(i)->getType()->getScalarType() :
-        getOperand(i)->getType() != I->getOperand(i)->getType())
+    if (UseScalarTypes
+            ? getOperand(i)->getType()->getScalarType() !=
+                  I->getOperand(i)->getType()->getScalarType()
+            : getOperand(i)->getType() != I->getOperand(i)->getType())
       return false;
 
-  return haveSameSpecialState(this, I, IgnoreAlignment);
+  return compareSpecialState(I, flags | CompareIgnoringMetaData) == 0;
 }
 
 bool Instruction::isUsedOutsideOfBlock(const BasicBlock *BB) const {
   for (const Use &U : uses()) {
     // PHI nodes uses values in the corresponding predecessor block.  For other
     // instructions, just check to see whether the parent of the use matches up.
     const Instruction *I = cast<Instruction>(U.getUser());
     const PHINode *PN = dyn_cast<PHINode>(I);

llvm/lib/IR/Instructions.cpp

 #include "llvm/Support/TypeSize.h"
 #include <algorithm>
 #include <cassert>
 #include <cstdint>
 #include <vector>
 
 using namespace llvm;
 
+// Functions for comparision of basic types used for
+// introducing total ordering between IR instructions.
+static int compareIntegers(uint64_t L, uint64_t R) {
+  if (L < R)
+    return -1;
+  if (L > R)
+    return 1;
+  return 0;
+}
+
+static int compareBools(bool L, bool R) {
+  if ((int)L < (int)R)
+    return -1;
+  if ((int)L > (int)R)
+    return 1;
+  return 0;
+}
+
+static int compareOrderings(AtomicOrdering L, AtomicOrdering R) {
+  if ((int)L < (int)R)
+    return -1;
+  if ((int)L > (int)R)
+    return 1;
+  return 0;
+}
+
+static int compareAPInts(const APInt &L, const APInt &R) {
+  if (int Res = compareIntegers(L.getBitWidth(), R.getBitWidth()))
+    return Res;
+  if (L.ugt(R))
+    return 1;
+  if (R.ugt(L))
+    return -1;
+  return 0;
+}
+
+static int compareRangeMetadata(const MDNode *L, const MDNode *R) {
+  if (L == R)
+    return 0;
+  if (!L)
+    return -1;
+  if (!R)
+    return 1;
+  // Range metadata is a sequence of numbers. Make sure they are the same
+  // sequence.
+  // TODO: Note that as this is metadata, it is possible to drop and/or merge
+  // this data when considering functions to merge. Thus this comparison would
+  // return 0 (i.e. equivalent), but merging would become more complicated
+  // because the ranges would need to be unioned. It is not likely that
+  // functions differ ONLY in this metadata if they are actually the same
+  // function semantically.
+  if (int Res = compareIntegers(L->getNumOperands(), R->getNumOperands()))
+    return Res;
+  for (size_t I = 0; I < L->getNumOperands(); ++I) {
+    ConstantInt *LLow = mdconst::extract<ConstantInt>(L->getOperand(I));
+    ConstantInt *RLow = mdconst::extract<ConstantInt>(R->getOperand(I));
+    if (int Res = compareAPInts(LLow->getValue(), RLow->getValue()))
+      return Res;
+  }
+  return 0;
+}
+
+static int compareOperandBundlesSchema(const CallBase &LCS,
+                                       const CallBase &RCS) {
+  assert(LCS.getOpcode() == RCS.getOpcode() && "Can't compare otherwise!");
+
+  if (int Res = compareIntegers(LCS.getNumOperandBundles(),
+                                RCS.getNumOperandBundles()))
+    return Res;
+
+  for (unsigned I = 0, E = LCS.getNumOperandBundles(); I != E; ++I) {
+    auto OBL = LCS.getOperandBundleAt(I);
+    auto OBR = RCS.getOperandBundleAt(I);
+
+    if (int Res = OBL.getTagName().compare(OBR.getTagName()))
+      return Res;
+
+    if (int Res = compareIntegers(OBL.Inputs.size(), OBR.Inputs.size()))
+      return Res;
+  }
+
+  return 0;
+}
+
+static int compareTypes(Type *TyL, Type *TyR) {
+  PointerType *PTyL = dyn_cast<PointerType>(TyL);
+  PointerType *PTyR = dyn_cast<PointerType>(TyR);
+
+  if (TyL == TyR)
+    return 0;
+
+  if (int Res = compareIntegers(TyL->getTypeID(), TyR->getTypeID()))
+    return Res;
+
+  switch (TyL->getTypeID()) {
+  default:
+    llvm_unreachable("Unknown type!");
+  case Type::IntegerTyID:
+    return compareIntegers(cast<IntegerType>(TyL)->getBitWidth(),
+                           cast<IntegerType>(TyR)->getBitWidth());
+  // TyL == TyR would have returned true earlier, because types are uniqued.
+  case Type::VoidTyID:
+  case Type::FloatTyID:
+  case Type::DoubleTyID:
+  case Type::X86_FP80TyID:
+  case Type::FP128TyID:
+  case Type::PPC_FP128TyID:
+  case Type::LabelTyID:
+  case Type::MetadataTyID:
+  case Type::TokenTyID:
+    return 0;
+
+  case Type::PointerTyID:
+    assert(PTyL && PTyR && "Both types must be pointers here.");
+    return compareIntegers(PTyL->getAddressSpace(), PTyR->getAddressSpace());
+
+  case Type::StructTyID: {
+    StructType *STyL = cast<StructType>(TyL);
+    StructType *STyR = cast<StructType>(TyR);
+    if (STyL->getNumElements() != STyR->getNumElements())
+      return compareIntegers(STyL->getNumElements(), STyR->getNumElements());
+
+    if (STyL->isPacked() != STyR->isPacked())
+      return compareIntegers(STyL->isPacked(), STyR->isPacked());
+
+    for (unsigned i = 0, e = STyL->getNumElements(); i != e; ++i) {
+      if (int Res =
+              compareTypes(STyL->getElementType(i), STyR->getElementType(i)))
+        return Res;
+    }
+    return 0;
+  }
+
+  case Type::FunctionTyID: {
+    FunctionType *FTyL = cast<FunctionType>(TyL);
+    FunctionType *FTyR = cast<FunctionType>(TyR);
+    if (FTyL->getNumParams() != FTyR->getNumParams())
+      return compareIntegers(FTyL->getNumParams(), FTyR->getNumParams());
+
+    if (FTyL->isVarArg() != FTyR->isVarArg())
+      return compareIntegers(FTyL->isVarArg(), FTyR->isVarArg());
+
+    if (int Res = compareTypes(FTyL->getReturnType(), FTyR->getReturnType()))
+      return Res;
+
+    for (unsigned i = 0, e = FTyL->getNumParams(); i != e; ++i) {
+      if (int Res = compareTypes(FTyL->getParamType(i), FTyR->getParamType(i)))
+        return Res;
+    }
+    return 0;
+  }
+
+  case Type::ArrayTyID: {
+    auto *STyL = cast<ArrayType>(TyL);
+    auto *STyR = cast<ArrayType>(TyR);
+    if (STyL->getNumElements() != STyR->getNumElements())
+      return compareIntegers(STyL->getNumElements(), STyR->getNumElements());
+    return compareTypes(STyL->getElementType(), STyR->getElementType());
+  }
+  case Type::FixedVectorTyID:
+  case Type::ScalableVectorTyID: {
+    auto *STyL = cast<VectorType>(TyL);
+    auto *STyR = cast<VectorType>(TyR);
+    if (STyL->getElementCount().Scalable != STyR->getElementCount().Scalable)
+      return compareIntegers(STyL->getElementCount().Scalable,
+                             STyR->getElementCount().Scalable);
+    if (STyL->getElementCount().Min != STyR->getElementCount().Min)
+      return compareIntegers(STyL->getElementCount().Min,
+                             STyR->getElementCount().Min);
+    return compareTypes(STyL->getElementType(), STyR->getElementType());
+  }
+  }
+}
+
+int compareAttrs(const AttributeList L, const AttributeList R) {
+  if (int Res = compareIntegers(L.getNumAttrSets(), R.getNumAttrSets()))
+    return Res;
+
+  for (unsigned i = L.index_begin(), e = L.index_end(); i != e; ++i) {
+    AttributeSet LAS = L.getAttributes(i);
+    AttributeSet RAS = R.getAttributes(i);
+    AttributeSet::iterator LI = LAS.begin(), LE = LAS.end();
+    AttributeSet::iterator RI = RAS.begin(), RE = RAS.end();
+    for (; LI != LE && RI != RE; ++LI, ++RI) {
+      Attribute LA = *LI;
+      Attribute RA = *RI;
+      if (LA.isTypeAttribute() && RA.isTypeAttribute()) {
+        if (LA.getKindAsEnum() != RA.getKindAsEnum())
+          return compareIntegers(LA.getKindAsEnum(), RA.getKindAsEnum());
+
+        Type *TyL = LA.getValueAsType();
+        Type *TyR = RA.getValueAsType();
+        if (TyL && TyR)
+          return compareTypes(TyL, TyR);
+
+        // Two pointers, at least one null, so the comparison result is
+        // independent of the value of a real pointer.
+        return compareIntegers((uint64_t)TyL, (uint64_t)TyR);
+      }
+      if (LA < RA)
+        return -1;
+      if (RA < LA)
+        return 1;
+    }
+    if (LI != LE)
+      return 1;
+    if (RI != RE)
+      return -1;
+  }
+  return 0;
+}
+
 //===----------------------------------------------------------------------===//
 //                            AllocaInst Class
 //===----------------------------------------------------------------------===//
 
 Optional<uint64_t>
 AllocaInst::getAllocationSizeInBits(const DataLayout &DL) const {
   uint64_t Size = DL.getTypeAllocSizeInBits(getAllocatedType());
   if (isArrayAllocation()) {
if (ET->getNumElements() != VT->getNumElements())
       return "vector select requires selected vectors to have "
                    "the same vector length as select condition";
   } else if (Op0->getType() != Type::getInt1Ty(Op0->getContext())) {
     return "select condition must be i1 or <n x i1>";
   }
   return nullptr;
 }
 
+// Function to introduce total ordering between two Select Instructions.
+// Returns -1 (this instruction < I)
+//         +1 (this instruction > I)
+//          0 (this instruction = I)
+// 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.
+int SelectInst::compareInstSpecificProperties(const SelectInst *I) const {
+  return 0;
+}
+
 //===----------------------------------------------------------------------===//
 //                               PHINode Class
 //===----------------------------------------------------------------------===//
 
 PHINode::PHINode(const PHINode &PN)
     : Instruction(PN.getType(), Instruction::PHI, nullptr, PN.getNumOperands()),
       ReservedSpace(PN.getNumOperands()) {
   allocHungoffUses(PN.getNumOperands());
if (Incoming != this && !isa<UndefValue>(Incoming)) {
       if (ConstantValue && ConstantValue != Incoming)
         return false;
       ConstantValue = Incoming;
     }
   }
   return true;
 }
 
+// Function to introduce total ordering between two PHI Instructions.
+// Returns -1 (this instruction < I)
+//         +1 (this instruction > I)
+//          0 (this instruction = I)
+// 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.
+int PHINode::compareInstSpecificProperties(const PHINode *I) const { return 0; }
+
 //===----------------------------------------------------------------------===//
 //                       LandingPadInst Implementation
 //===----------------------------------------------------------------------===//
 
 LandingPadInst::LandingPadInst(Type *RetTy, unsigned NumReservedValues,
                                const Twine &NameStr, Instruction *InsertBefore)
     : Instruction(RetTy, Instruction::LandingPad, nullptr, 0, InsertBefore) {
   init(NumReservedValues, NameStr);

 void LandingPadInst::addClause(Constant *Val) {
   unsigned OpNo = getNumOperands();
   growOperands(1);
   assert(OpNo < ReservedSpace && "Growing didn't work!");
   setNumHungOffUseOperands(getNumOperands() + 1);
   getOperandList()[OpNo] = Val;
 }
 
+// Function to introduce total ordering between two LandingPad Instructions.
+// Returns -1 (this instruction < I)
+//         +1 (this instruction > I)
+//          0 (this instruction = I)
+// 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.
+int LandingPadInst::compareInstSpecificProperties(
+    const LandingPadInst *I) const {
+  return compareBools(isCleanup(), I->isCleanup());
+}
+
 //===----------------------------------------------------------------------===//
 //                        CallBase Implementation
 //===----------------------------------------------------------------------===//
 
 Function *CallBase::getCaller() { return getParent()->getParent(); }
 
 unsigned CallBase::getNumSubclassExtraOperandsDynamic() const {
   assert(getOpcode() == Instruction::CallBr && "Unexpected opcode!");

 Instruction *CallInst::CreateFree(Value *Source,
                                   ArrayRef<OperandBundleDef> Bundles,
                                   BasicBlock *InsertAtEnd) {
   Instruction *FreeCall = createFree(Source, Bundles, nullptr, InsertAtEnd);
   assert(FreeCall && "CreateFree did not create a CallInst");
   return FreeCall;
 }
 
+// Function to introduce total ordering between two Call Instructions.
+// Returns -1 (this instruction < I)
+//         +1 (this instruction > I)
+//          0 (this instruction = I)
+// 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.
+int CallInst::compareInstSpecificProperties(const CallInst *I,
+                                            bool IgnoreMetaData) const {
+  if (int Res = compareIntegers(getCallingConv(), I->getCallingConv()))
+    return Res;
+  if (int Res = compareAttrs(getAttributes(), I->getAttributes()))
+    return Res;
+  if (int Res = compareOperandBundlesSchema(*this, *I))
+    return Res;
+  if (!IgnoreMetaData)
+    if (int Res = compareRangeMetadata(getMetadata(LLVMContext::MD_range),
+                                       I->getMetadata(LLVMContext::MD_range)))
+      return Res;
+  return compareIntegers(getTailCallKind(), I->getTailCallKind());
+}
+
 //===----------------------------------------------------------------------===//
 //                        InvokeInst Implementation
 //===----------------------------------------------------------------------===//
 
 void InvokeInst::init(FunctionType *FTy, Value *Fn, BasicBlock *IfNormal,
                       BasicBlock *IfException, ArrayRef<Value *> Args,
                       ArrayRef<OperandBundleDef> Bundles,
                       const Twine &NameStr) {
auto *NewII = InvokeInst::Create(
       II->getUnwindDest(), Args, OpB, II->getName(), InsertPt);
   NewII->setCallingConv(II->getCallingConv());
   NewII->SubclassOptionalData = II->SubclassOptionalData;
   NewII->setAttributes(II->getAttributes());
   NewII->setDebugLoc(II->getDebugLoc());
   return NewII;
 }
 
-
 LandingPadInst *InvokeInst::getLandingPadInst() const {
   return cast<LandingPadInst>(getUnwindDest()->getFirstNonPHI());
 }
 
+// Function to introduce total ordering between two Invoke Instructions.
+// Returns -1 (this instruction < I)
+//         +1 (this instruction > I)
+//          0 (this instruction = I)
+// 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.
+int InvokeInst::compareInstSpecificProperties(const InvokeInst *I,
+                                              bool IgnoreMetaData) const {
+  if (int Res = compareIntegers(getCallingConv(), I->getCallingConv()))
+    return Res;
+  if (int Res = compareAttrs(getAttributes(), I->getAttributes()))
+    return Res;
+  if (!IgnoreMetaData)
+    if (int Res = compareRangeMetadata(getMetadata(LLVMContext::MD_range),
+                                       I->getMetadata(LLVMContext::MD_range)))
+      return Res;
+  return compareOperandBundlesSchema(*this, *I);
+}
+
 //===----------------------------------------------------------------------===//
 //                        CallBrInst Implementation
 //===----------------------------------------------------------------------===//
 
 void CallBrInst::init(FunctionType *FTy, Value *Fn, BasicBlock *Fallthrough,
                       ArrayRef<BasicBlock *> IndirectDests,
                       ArrayRef<Value *> Args,
                       ArrayRef<OperandBundleDef> Bundles,
CallBrInst *CallBrInst::Create(CallBrInst *CBI, ArrayRef<OperandBundleDef> OpB,
   NewCBI->setCallingConv(CBI->getCallingConv());
   NewCBI->SubclassOptionalData = CBI->SubclassOptionalData;
   NewCBI->setAttributes(CBI->getAttributes());
   NewCBI->setDebugLoc(CBI->getDebugLoc());
   NewCBI->NumIndirectDests = CBI->NumIndirectDests;
   return NewCBI;
 }
 
+// Function to introduce total ordering between two CallBr Instructions.
+// Returns -1 (this instruction < I)
+//         +1 (this instruction > I)
+//          0 (this instruction = I)
+// 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.
+int CallBrInst::compareInstSpecificProperties(const CallBrInst *I,
+                                              bool IgnoreMetaData) const {
+  if (int Res = compareIntegers(getCallingConv(), I->getCallingConv()))
+    return Res;
+  if (int Res = compareAttrs(getAttributes(), I->getAttributes()))
+    return Res;
+  if (!IgnoreMetaData)
+    if (int Res = compareRangeMetadata(getMetadata(LLVMContext::MD_range),
+                                       I->getMetadata(LLVMContext::MD_range)))
+      return Res;
+  return compareOperandBundlesSchema(*this, *I);
+}
+
 //===----------------------------------------------------------------------===//
 //                        ReturnInst Implementation
 //===----------------------------------------------------------------------===//
 
 ReturnInst::ReturnInst(const ReturnInst &RI)
     : Instruction(Type::getVoidTy(RI.getContext()), Instruction::Ret,
                   OperandTraits<ReturnInst>::op_end(this) - RI.getNumOperands(),
                   RI.getNumOperands()) {
ReturnInst::ReturnInst(LLVMContext &C, Value *retVal, BasicBlock *InsertAtEnd)
   if (retVal)
     Op<0>() = retVal;
 }
 
 ReturnInst::ReturnInst(LLVMContext &Context, BasicBlock *InsertAtEnd)
     : Instruction(Type::getVoidTy(Context), Instruction::Ret,
                   OperandTraits<ReturnInst>::op_end(this), 0, InsertAtEnd) {}
 
+// Function to introduce total ordering between two Return Instructions.
+// Returns -1 (this instruction < I)
+//         +1 (this instruction > I)
+//          0 (this instruction = I)
+// 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.
+int ReturnInst::compareInstSpecificProperties(const ReturnInst *I) const {
+  return 0;
+}
+
 //===----------------------------------------------------------------------===//
 //                        ResumeInst Implementation
 //===----------------------------------------------------------------------===//
 
 ResumeInst::ResumeInst(const ResumeInst &RI)
     : Instruction(Type::getVoidTy(RI.getContext()), Instruction::Resume,
                   OperandTraits<ResumeInst>::op_begin(this), 1) {
   Op<0>() = RI.Op<0>();
 }
 
 ResumeInst::ResumeInst(Value *Exn, Instruction *InsertBefore)
     : Instruction(Type::getVoidTy(Exn->getContext()), Instruction::Resume,
                   OperandTraits<ResumeInst>::op_begin(this), 1, InsertBefore) {
   Op<0>() = Exn;
 }
 
 ResumeInst::ResumeInst(Value *Exn, BasicBlock *InsertAtEnd)
     : Instruction(Type::getVoidTy(Exn->getContext()), Instruction::Resume,
                   OperandTraits<ResumeInst>::op_begin(this), 1, InsertAtEnd) {
   Op<0>() = Exn;
 }
 
+// Function to introduce total ordering between two Resume Instructions.
+// Returns -1 (this instruction < I)
+//         +1 (this instruction > I)
+//          0 (this instruction = I)
+// 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.
+int ResumeInst::compareInstSpecificProperties(const ResumeInst *I) const {
+  return 0;
+}
+
 //===----------------------------------------------------------------------===//
 //                        CleanupReturnInst Implementation
 //===----------------------------------------------------------------------===//
 
 CleanupReturnInst::CleanupReturnInst(const CleanupReturnInst &CRI)
     : Instruction(CRI.getType(), Instruction::CleanupRet,
                   OperandTraits<CleanupReturnInst>::op_end(this) -
                       CRI.getNumOperands(),
CleanupReturnInst::CleanupReturnInst(Value *CleanupPad, BasicBlock *UnwindBB,
                                      unsigned Values, BasicBlock *InsertAtEnd)
     : Instruction(Type::getVoidTy(CleanupPad->getContext()),
                   Instruction::CleanupRet,
                   OperandTraits<CleanupReturnInst>::op_end(this) - Values,
                   Values, InsertAtEnd) {
   init(CleanupPad, UnwindBB);
 }
 
+// Function to introduce total ordering between two CleanupReturn Instructions.
+// Returns -1 (this instruction < I)
+//         +1 (this instruction > I)
+//          0 (this instruction = I)
+// 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.
+int CleanupReturnInst::compareInstSpecificProperties(
+    const CleanupReturnInst *I) const {
+  return compareBools(unwindsToCaller(), I->unwindsToCaller());
+}
+
 //===----------------------------------------------------------------------===//
 //                        CatchReturnInst Implementation
 //===----------------------------------------------------------------------===//
 void CatchReturnInst::init(Value *CatchPad, BasicBlock *BB) {
   Op<0>() = CatchPad;
   Op<1>() = BB;
 }
 

 CatchReturnInst::CatchReturnInst(Value *CatchPad, BasicBlock *BB,
                                  BasicBlock *InsertAtEnd)
     : Instruction(Type::getVoidTy(BB->getContext()), Instruction::CatchRet,
                   OperandTraits<CatchReturnInst>::op_begin(this), 2,
                   InsertAtEnd) {
   init(CatchPad, BB);
 }
 
+// Function to introduce total ordering between two CatchReturn Instructions.
+// Returns -1 (this instruction < I)
+//         +1 (this instruction > I)
+//          0 (this instruction = I)
+// 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.
+int CatchReturnInst::compareInstSpecificProperties(
+    const CatchReturnInst *I) const {
+  return 0;
+}
+
 //===----------------------------------------------------------------------===//
 //                       CatchSwitchInst Implementation
 //===----------------------------------------------------------------------===//
 
 CatchSwitchInst::CatchSwitchInst(Value *ParentPad, BasicBlock *UnwindDest,
                                  unsigned NumReservedValues,
                                  const Twine &NameStr,
                                  Instruction *InsertBefore)
void CatchSwitchInst::removeHandler(handler_iterator HI) {
   for (Use *CurDst = HI.getCurrent(); CurDst != EndDst; ++CurDst)
     *CurDst = *(CurDst + 1);
   // Null out the last handler use.
   *EndDst = nullptr;
 
   setNumHungOffUseOperands(getNumOperands() - 1);
 }
 
+// Function to introduce total ordering between two CatchSwitch Instructions.
+// Returns -1 (this instruction < I)
+//         +1 (this instruction > I)
+//          0 (this instruction = I)
+// 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.
+int CatchSwitchInst::compareInstSpecificProperties(
+    const CatchSwitchInst *I) const {
+  return compareBools(unwindsToCaller(), I->unwindsToCaller());
+}
+
 //===----------------------------------------------------------------------===//
 //                        FuncletPadInst Implementation
 //===----------------------------------------------------------------------===//
 void FuncletPadInst::init(Value *ParentPad, ArrayRef<Value *> Args,
                           const Twine &NameStr) {
   assert(getNumOperands() == 1 + Args.size() && "NumOperands not set up?");
   llvm::copy(Args, op_begin());
   setParentPad(ParentPad);

 UnreachableInst::UnreachableInst(LLVMContext &Context,
                                  Instruction *InsertBefore)
     : Instruction(Type::getVoidTy(Context), Instruction::Unreachable, nullptr,
                   0, InsertBefore) {}
 UnreachableInst::UnreachableInst(LLVMContext &Context, BasicBlock *InsertAtEnd)
     : Instruction(Type::getVoidTy(Context), Instruction::Unreachable, nullptr,
                   0, InsertAtEnd) {}
 
+// Function to introduce total ordering between two Unreachable Instructions.
+// Returns -1 (this instruction < I)
+//         +1 (this instruction > I)
+//          0 (this instruction = I)
+// 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.
+int UnreachableInst::compareInstSpecificProperties(
+    const UnreachableInst *I) const {
+  return 0;
+}
+
 //===----------------------------------------------------------------------===//
 //                        BranchInst Implementation
 //===----------------------------------------------------------------------===//
 
 void BranchInst::AssertOK() {
   if (isConditional())
     assert(getCondition()->getType()->isIntegerTy(1) &&
            "May only branch on boolean predicates!");
assert(isConditional() &&
          "Cannot swap successors of an unconditional branch");
   Op<-1>().swap(Op<-2>());
 
   // Update profile metadata if present and it matches our structural
   // expectations.
   swapProfMetadata();
 }
 
+// Function to introduce total ordering between two Branch Instructions.
+// Returns -1 (this instruction < I)
+//         +1 (this instruction > I)
+//          0 (this instruction = I)
+// 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.
+int BranchInst::compareInstSpecificProperties(const BranchInst *I) const {
+  return 0;
+}
+
 //===----------------------------------------------------------------------===//
 //                        AllocaInst Implementation
 //===----------------------------------------------------------------------===//
 
 static Value *getAISize(LLVMContext &Context, Value *Amt) {
   if (!Amt)
     Amt = ConstantInt::get(Type::getInt32Ty(Context), 1);
   else {
bool AllocaInst::isArrayAllocation() const {
   return true;
 }
 
 /// isStaticAlloca - Return true if this alloca is in the entry block of the
 /// function and is a constant size.  If so, the code generator will fold it
 /// into the prolog/epilog code, so it is basically free.
 bool AllocaInst::isStaticAlloca() const {
   // Must be constant size.
-  if (!isa<ConstantInt>(getArraySize())) return false;
+  if (!isa<ConstantInt>(getArraySize()))
+    return false;
 
   // Must be in the entry block.
   const BasicBlock *Parent = getParent();
   return Parent == &Parent->getParent()->front() && !isUsedWithInAlloca();
 }
 
+// Function to introduce total ordering between two Alloca Instructions.
+// Returns -1 (this instruction < AI)
+//         +1 (this instruction > AI)
+//          0 (this instruction = AI)
+// 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.
+int AllocaInst::compareInstSpecificProperties(const AllocaInst *AI,
+                                              bool IgnoreAlignment) const {
+  if (!IgnoreAlignment)
+    if (int Res = compareIntegers(getAlignment(), AI->getAlignment()))
+      return Res;
+  return compareTypes(getAllocatedType(), AI->getAllocatedType());
+}
+
 //===----------------------------------------------------------------------===//
 //                           LoadInst Implementation
 //===----------------------------------------------------------------------===//
 
 void LoadInst::AssertOK() {
   assert(getOperand(0)->getType()->isPointerTy() &&
          "Ptr must have pointer type.");
   assert(!(isAtomic() && getAlignment() == 0) &&

 void LoadInst::setAlignment(Align Align) {
   assert(Align <= MaximumAlignment &&
          "Alignment is greater than MaximumAlignment!");
   setInstructionSubclassData((getSubclassDataFromInstruction() & ~(31 << 1)) |
                              (encode(Align) << 1));
   assert(getAlign() == Align && "Alignment representation error!");
 }
 
+// Function to introduce total ordering between two Load Instructions.
+// Returns -1 (this instruction < LI)
+//         +1 (this instruction > LI)
+//          0 (this instruction = LI)
+// 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.
+int LoadInst::compareInstSpecificProperties(const LoadInst *LI,
+                                            bool IgnoreAlignment,
+                                            bool IgnoreMetaData) const {
+  if (int Res = compareIntegers(isVolatile(), LI->isVolatile()))
+    return Res;
+  if (!IgnoreAlignment)
+    if (int Res = compareIntegers(getAlignment(), LI->getAlignment()))
+      return Res;
+  if (int Res = compareOrderings(getOrdering(), LI->getOrdering()))
+    return Res;
+  if (!IgnoreMetaData)
+    if (int Res = compareRangeMetadata(getMetadata(LLVMContext::MD_range),
+                                       LI->getMetadata(LLVMContext::MD_range)))
+      return Res;
+  return compareIntegers(getSyncScopeID(), LI->getSyncScopeID());
+}
+
 //===----------------------------------------------------------------------===//
 //                           StoreInst Implementation
 //===----------------------------------------------------------------------===//
 
 void StoreInst::AssertOK() {
   assert(getOperand(0) && getOperand(1) && "Both operands must be non-null!");
   assert(getOperand(1)->getType()->isPointerTy() &&
          "Ptr must have pointer type!");

 void StoreInst::setAlignment(Align Alignment) {
   assert(Alignment <= MaximumAlignment &&
          "Alignment is greater than MaximumAlignment!");
   setInstructionSubclassData((getSubclassDataFromInstruction() & ~(31 << 1)) |
                              (encode(Alignment) << 1));
   assert(getAlign() == Alignment && "Alignment representation error!");
 }
 
+// Function to introduce total ordering between two Store Instructions.
+// Returns -1 (this instruction < SI)
+//         +1 (this instruction > SI)
+//          0 (this instruction = SI)
+// 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.
+int StoreInst::compareInstSpecificProperties(const StoreInst *SI,
+                                             bool IgnoreAlignment) const {
+  if (int Res = compareIntegers(isVolatile(), SI->isVolatile()))
+    return Res;
+  if (!IgnoreAlignment)
+    if (int Res = compareIntegers(getAlignment(), SI->getAlignment()))
+      return Res;
+  if (int Res = compareOrderings(getOrdering(), SI->getOrdering()))
+    return Res;
+  return compareIntegers(getSyncScopeID(), SI->getSyncScopeID());
+}
+
 //===----------------------------------------------------------------------===//
 //                       AtomicCmpXchgInst Implementation
 //===----------------------------------------------------------------------===//
 
 void AtomicCmpXchgInst::Init(Value *Ptr, Value *Cmp, Value *NewVal,
                              AtomicOrdering SuccessOrdering,
                              AtomicOrdering FailureOrdering,
                              SyncScope::ID SSID) {
AtomicCmpXchgInst::AtomicCmpXchgInst(Value *Ptr, Value *Cmp, Value *NewVal,
                                      BasicBlock *InsertAtEnd)
     : Instruction(
           StructType::get(Cmp->getType(), Type::getInt1Ty(Cmp->getContext())),
           AtomicCmpXchg, OperandTraits<AtomicCmpXchgInst>::op_begin(this),
           OperandTraits<AtomicCmpXchgInst>::operands(this), InsertAtEnd) {
   Init(Ptr, Cmp, NewVal, SuccessOrdering, FailureOrdering, SSID);
 }
 
+// Function to introduce total ordering between two AtomicCmpXchg Instructions.
+// Returns -1 (this instruction < I)
+//         +1 (this instruction > I)
+//          0 (this instruction = I)
+// 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.
+int AtomicCmpXchgInst::compareInstSpecificProperties(
+    const AtomicCmpXchgInst *I) const {
+  if (int Res = compareIntegers(isVolatile(), I->isVolatile()))
+    return Res;
+  if (int Res = compareIntegers(isWeak(), I->isWeak()))
+    return Res;
+  if (int Res = compareOrderings(getSuccessOrdering(), I->getSuccessOrdering()))
+    return Res;
+  if (int Res = compareOrderings(getFailureOrdering(), I->getFailureOrdering()))
+    return Res;
+  return compareIntegers(getSyncScopeID(), I->getSyncScopeID());
+}
+
 //===----------------------------------------------------------------------===//
 //                       AtomicRMWInst Implementation
 //===----------------------------------------------------------------------===//
 
 void AtomicRMWInst::Init(BinOp Operation, Value *Ptr, Value *Val,
                          AtomicOrdering Ordering,
                          SyncScope::ID SSID) {
   Op<0>() = Ptr;
case AtomicRMWInst::FSub:
     return "fsub";
   case AtomicRMWInst::BAD_BINOP:
     return "<invalid operation>";
   }
 
   llvm_unreachable("invalid atomicrmw operation");
 }
 
+// Function to introduce total ordering between two AtomicRMW Instructions.
+// Returns -1 (this instruction < I)
+//         +1 (this instruction > I)
+//          0 (this instruction = I)
+// 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.
+int AtomicRMWInst::compareInstSpecificProperties(const AtomicRMWInst *I) const {
+  if (int Res = compareIntegers(getOperation(), I->getOperation()))
+    return Res;
+  if (int Res = compareIntegers(isVolatile(), I->isVolatile()))
+    return Res;
+  if (int Res = compareOrderings(getOrdering(), I->getOrdering()))
+    return Res;
+  return compareIntegers(getSyncScopeID(), I->getSyncScopeID());
+}
+
 //===----------------------------------------------------------------------===//
 //                       FenceInst Implementation
 //===----------------------------------------------------------------------===//
 
 FenceInst::FenceInst(LLVMContext &C, AtomicOrdering Ordering,
-                     SyncScope::ID SSID,
-                     Instruction *InsertBefore)
+                     SyncScope::ID SSID, Instruction *InsertBefore)
     : Instruction(Type::getVoidTy(C), Fence, nullptr, 0, InsertBefore) {
   setOrdering(Ordering);
   setSyncScopeID(SSID);
 }
 
 FenceInst::FenceInst(LLVMContext &C, AtomicOrdering Ordering,
-                     SyncScope::ID SSID,
-                     BasicBlock *InsertAtEnd)
+                     SyncScope::ID SSID, BasicBlock *InsertAtEnd)
     : Instruction(Type::getVoidTy(C), Fence, nullptr, 0, InsertAtEnd) {
   setOrdering(Ordering);
   setSyncScopeID(SSID);
 }
 
+// Function to introduce total ordering between two Fence Instructions.
+// Returns -1 (this instruction < FI)
+//         +1 (this instruction > FI)
+//          0 (this instruction = FI)
+// 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.
+int FenceInst::compareInstSpecificProperties(const FenceInst *FI) const {
+  if (int Res = compareOrderings(getOrdering(), FI->getOrdering()))
+    return Res;
+  return compareIntegers(getSyncScopeID(), FI->getSyncScopeID());
+}
+
 //===----------------------------------------------------------------------===//
 //                       GetElementPtrInst Implementation
 //===----------------------------------------------------------------------===//
 
 void GetElementPtrInst::init(Value *Ptr, ArrayRef<Value *> IdxList,
                              const Twine &Name) {
   assert(getNumOperands() == 1 + IdxList.size() &&
          "NumOperands not initialized?");

 }
 
 bool GetElementPtrInst::accumulateConstantOffset(const DataLayout &DL,
                                                  APInt &Offset) const {
   // Delegate to the generic GEPOperator implementation.
   return cast<GEPOperator>(this)->accumulateConstantOffset(DL, Offset);
 }
 
+// Function to introduce total ordering between two GetElementPtr Instructions.
+// Returns -1 (this instruction < I)
+//         +1 (this instruction > I)
+//          0 (this instruction = I)
+// 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.
+int GetElementPtrInst::compareInstSpecificProperties(
+    const GetElementPtrInst *I) const {
+  return 0;
+}
+
 //===----------------------------------------------------------------------===//
 //                           ExtractElementInst Implementation
 //===----------------------------------------------------------------------===//
 
 ExtractElementInst::ExtractElementInst(Value *Val, Value *Index,
                                        const Twine &Name,
                                        Instruction *InsertBef)
   : Instruction(cast<VectorType>(Val->getType())->getElementType(),
                 ExtractElement,
                 OperandTraits<ExtractElementInst>::op_begin(this),
                 2, InsertBef) {
   assert(isValidOperands(Val, Index) &&
          "Invalid extractelement instruction operands!");
   Op<0>() = Val;
   Op<1>() = Index;
   setName(Name);
 }
 
 ExtractElementInst::ExtractElementInst(Value *Val, Value *Index,
-                                       const Twine &Name,
-                                       BasicBlock *InsertAE)
-  : Instruction(cast<VectorType>(Val->getType())->getElementType(),
-                ExtractElement,
-                OperandTraits<ExtractElementInst>::op_begin(this),
-                2, InsertAE) {
+                                       const Twine &Name, BasicBlock *InsertAE)
+    : Instruction(
+          cast<VectorType>(Val->getType())->getElementType(), ExtractElement,
+          OperandTraits<ExtractElementInst>::op_begin(this), 2, InsertAE) {
   assert(isValidOperands(Val, Index) &&
          "Invalid extractelement instruction operands!");
 
   Op<0>() = Val;
   Op<1>() = Index;
   setName(Name);
 }
 
 bool ExtractElementInst::isValidOperands(const Value *Val, const Value *Index) {
   if (!Val->getType()->isVectorTy() || !Index->getType()->isIntegerTy())
     return false;
   return true;
 }
 
+// Function to introduce total ordering between two ExtractElement Instructions.
+// Returns -1 (this instruction < I)
+//         +1 (this instruction > I)
+//          0 (this instruction = I)
+// 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.
+int ExtractElementInst::compareInstSpecificProperties(
+    const ExtractElementInst *I) const {
+  return 0;
+}
+
 //===----------------------------------------------------------------------===//
 //                           InsertElementInst Implementation
 //===----------------------------------------------------------------------===//
 
 InsertElementInst::InsertElementInst(Value *Vec, Value *Elt, Value *Index,
                                      const Twine &Name,
                                      Instruction *InsertBef)
   : Instruction(Vec->getType(), InsertElement,
InsertElementInst::InsertElementInst(Value *Vec, Value *Elt, Value *Index,
   Op<1>() = Elt;
   Op<2>() = Index;
   setName(Name);
 }
 
 bool InsertElementInst::isValidOperands(const Value *Vec, const Value *Elt,
                                         const Value *Index) {
   if (!Vec->getType()->isVectorTy())
-    return false;   // First operand of insertelement must be vector type.
+    return false; // First operand of insertelement must be vector type.
 
   if (Elt->getType() != cast<VectorType>(Vec->getType())->getElementType())
     return false;// Second operand of insertelement must be vector element type.
 
   if (!Index->getType()->isIntegerTy())
     return false;  // Third operand of insertelement must be i32.
   return true;
 }
 
+// Function to introduce total ordering between two InsertElement Instructions.
+// Returns -1 (this instruction < I)
+//         +1 (this instruction > I)
+//          0 (this instruction = I)
+// 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.
+int InsertElementInst::compareInstSpecificProperties(
+    const InsertElementInst *I) const {
+  return 0;
+}
+
 //===----------------------------------------------------------------------===//
 //                      ShuffleVectorInst Implementation
 //===----------------------------------------------------------------------===//
 
 ShuffleVectorInst::ShuffleVectorInst(Value *V1, Value *V2, Value *Mask,
                                      const Twine &Name,
                                      Instruction *InsertBefore)
     : Instruction(
bool ShuffleVectorInst::isConcat() const {
 
   // Use the mask length rather than the operands' vector lengths here. We
   // already know that the shuffle returns a vector twice as long as the inputs,
   // and neither of the inputs are undef vectors. If the mask picks consecutive
   // elements from both inputs, then this is a concatenation of the inputs.
   return isIdentityMaskImpl(getShuffleMask(), NumMaskElts);
 }
 
+// Function to introduce total ordering between two ShuffleVector Instructions.
+// Returns -1 (this instruction < I)
+//         +1 (this instruction > I)
+//          0 (this instruction = I)
+// 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.
+int ShuffleVectorInst::compareInstSpecificProperties(
+    const ShuffleVectorInst *I) const {
+  ArrayRef<int> LMask = getShuffleMask();
+  ArrayRef<int> RMask = I->getShuffleMask();
+  if (int Res = compareIntegers(LMask.size(), RMask.size()))
+    return Res;
+  for (size_t i = 0, e = LMask.size(); i != e; ++i) {
+    if (int Res = compareIntegers(LMask[i], RMask[i]))
+      return Res;
+  }
+  return 0;
+}
+
 //===----------------------------------------------------------------------===//
 //                             InsertValueInst Class
 //===----------------------------------------------------------------------===//
 
 void InsertValueInst::init(Value *Agg, Value *Val, ArrayRef<unsigned> Idxs,
                            const Twine &Name) {
   assert(getNumOperands() == 2 && "NumOperands not initialized?");
 
   // There's no fundamental reason why we require at least one index
   // (other than weirdness with &*IdxBegin being invalid; see
   // getelementptr's init routine for example). But there's no
   // present need to support it.
   assert(!Idxs.empty() && "InsertValueInst must have at least one index");
 
   assert(ExtractValueInst::getIndexedType(Agg->getType(), Idxs) ==
-         Val->getType() && "Inserted value must match indexed type!");
+             Val->getType() &&
+         "Inserted value must match indexed type!");
   Op<0>() = Agg;
   Op<1>() = Val;
 
   Indices.append(Idxs.begin(), Idxs.end());
   setName(Name);
 }
 
 InsertValueInst::InsertValueInst(const InsertValueInst &IVI)
     : Instruction(IVI.getType(), InsertValue,
                   OperandTraits<InsertValueInst>::op_begin(this), 2),
       Indices(IVI.Indices) {
   Op<0>() = IVI.getOperand(0);
   Op<1>() = IVI.getOperand(1);
   SubclassOptionalData = IVI.SubclassOptionalData;
 }
 
+// Function to introduce total ordering between two InsertValue Instructions.
+// Returns -1 (this instruction < I)
+//         +1 (this instruction > I)
+//          0 (this instruction = I)
+// 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.
+int InsertValueInst::compareInstSpecificProperties(
+    const InsertValueInst *I) const {
+  ArrayRef<unsigned> LIndices = getIndices();
+  ArrayRef<unsigned> RIndices = I->getIndices();
+  if (int Res = compareIntegers(LIndices.size(), RIndices.size()))
+    return Res;
+  for (size_t i = 0, e = LIndices.size(); i != e; ++i) {
+    if (int Res = compareIntegers(LIndices[i], RIndices[i]))
+      return Res;
+  }
+  return 0;
+}
+
 //===----------------------------------------------------------------------===//
 //                             ExtractValueInst Class
 //===----------------------------------------------------------------------===//
 
 void ExtractValueInst::init(ArrayRef<unsigned> Idxs, const Twine &Name) {
   assert(getNumOperands() == 1 && "NumOperands not initialized?");
 
   // There's no fundamental reason why we require at least one index.
if (ArrayType *AT = dyn_cast<ArrayType>(Agg)) {
       if (Index >= ST->getNumElements())
         return nullptr;
       Agg = ST->getElementType(Index);
     } else {
       // Not a valid type to index into.
       return nullptr;
     }
   }
-  return const_cast<Type*>(Agg);
+  return const_cast<Type *>(Agg);
 }
 
+// Function to introduce total ordering between two ExtractValue Instructions.
+// Returns -1 (this instruction < I)
+//         +1 (this instruction > I)
+//          0 (this instruction = I)
+// 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.
+int ExtractValueInst::compareInstSpecificProperties(
+    const ExtractValueInst *I) const {
+  ArrayRef<unsigned> LIndices = getIndices();
+  ArrayRef<unsigned> RIndices = I->getIndices();
+  if (int Res = compareIntegers(LIndices.size(), RIndices.size()))
+    return Res;
+  for (size_t i = 0, e = LIndices.size(); i != e; ++i) {
+    if (int Res = compareIntegers(LIndices[i], RIndices[i]))
+      return Res;
+  }
+  return 0;
+}
+
 //===----------------------------------------------------------------------===//
 //                             UnaryOperator Class
 //===----------------------------------------------------------------------===//
 
 UnaryOperator::UnaryOperator(UnaryOps iType, Value *S,
                              Type *Ty, const Twine &Name,
                              Instruction *InsertBefore)
   : UnaryInstruction(Ty, iType, S, InsertBefore) {
assert(getType()->isFPOrFPVectorTy() &&
            "Tried to create a floating-point operation on a "
            "non-floating-point type!");
     break;
   default: llvm_unreachable("Invalid opcode provided");
   }
 #endif
 }
 
+// Function to introduce total ordering between two UnaryOperator Instructions.
+// Returns -1 (this instruction < I)
+//         +1 (this instruction > I)
+//          0 (this instruction = I)
+// 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.
+int UnaryOperator::compareInstSpecificProperties(const UnaryOperator *I) const {
+  return 0;
+}
+
 //===----------------------------------------------------------------------===//
 //                             BinaryOperator Class
 //===----------------------------------------------------------------------===//
 
 BinaryOperator::BinaryOperator(BinaryOps iType, Value *S1, Value *S2,
                                Type *Ty, const Twine &Name,
                                Instruction *InsertBefore)
   : Instruction(Ty, iType,
BinaryOperator *BinaryOperator::CreateNUWNeg(Value *Op, const Twine &Name,
                                              BasicBlock *InsertAtEnd) {
   Value *zero = ConstantFP::getZeroValueForNegation(Op->getType());
   return BinaryOperator::CreateNUWSub(zero, Op, Name, InsertAtEnd);
 }
 
 BinaryOperator *BinaryOperator::CreateNot(Value *Op, const Twine &Name,
                                           Instruction *InsertBefore) {
   Constant *C = Constant::getAllOnesValue(Op->getType());
-  return new BinaryOperator(Instruction::Xor, Op, C,
-                            Op->getType(), Name, InsertBefore);
+  return new BinaryOperator(Instruction::Xor, Op, C, Op->getType(), Name,
+                            InsertBefore);
 }
 
 BinaryOperator *BinaryOperator::CreateNot(Value *Op, const Twine &Name,
                                           BasicBlock *InsertAtEnd) {
   Constant *AllOnes = Constant::getAllOnesValue(Op->getType());
-  return new BinaryOperator(Instruction::Xor, Op, AllOnes,
-                            Op->getType(), Name, InsertAtEnd);
+  return new BinaryOperator(Instruction::Xor, Op, AllOnes, Op->getType(), Name,
+                            InsertAtEnd);
 }
 
 // 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 is order-dependent (SetLT f.e.), the opcode
 // is changed.
 bool BinaryOperator::swapOperands() {
   if (!isCommutative())
     return true; // Can't commute operands
   Op<0>().swap(Op<1>());
   return false;
 }
 
+// Function to introduce total ordering between two BinaryOperator Instructions.
+// Returns -1 (this instruction < I)
+//         +1 (this instruction > I)
+//          0 (this instruction = I)
+// 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.
+int BinaryOperator::compareInstSpecificProperties(
+    const BinaryOperator *I) const {
+  return 0;
+}
+
 //===----------------------------------------------------------------------===//
 //                             FPMathOperator Class
 //===----------------------------------------------------------------------===//
 
 float FPMathOperator::getFPAccuracy() const {
   const MDNode *MD =
       cast<Instruction>(this)->getMetadata(LLVMContext::MD_fpmath);
   if (!MD)

 }
 
 TruncInst::TruncInst(
   Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
 ) : CastInst(Ty, Trunc, S, Name, InsertAtEnd) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal Trunc");
 }
 
+// Function to introduce total ordering between two Trunc Instructions.
+// Returns -1 (this instruction < I)
+//         +1 (this instruction > I)
+//          0 (this instruction = I)
+// 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.
+int TruncInst::compareInstSpecificProperties(const TruncInst *I) const {
+  return 0;
+}
+
 ZExtInst::ZExtInst(
   Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
 )  : CastInst(Ty, ZExt, S, Name, InsertBefore) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal ZExt");
 }
 
-ZExtInst::ZExtInst(
-  Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
-)  : CastInst(Ty, ZExt, S, Name, InsertAtEnd) {
+ZExtInst::ZExtInst(Value *S, Type *Ty, const Twine &Name,
+                   BasicBlock *InsertAtEnd)
+    : CastInst(Ty, ZExt, S, Name, InsertAtEnd) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal ZExt");
 }
+
+// Function to introduce total ordering between two ZExt Instructions.
+// Returns -1 (this instruction < I)
+//         +1 (this instruction > I)
+//          0 (this instruction = I)
+// 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.
+int ZExtInst::compareInstSpecificProperties(const ZExtInst *I) const {
+  return 0;
+}
+
 SExtInst::SExtInst(
   Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
 ) : CastInst(Ty, SExt, S, Name, InsertBefore) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal SExt");
 }
 
-SExtInst::SExtInst(
-  Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
-)  : CastInst(Ty, SExt, S, Name, InsertAtEnd) {
+SExtInst::SExtInst(Value *S, Type *Ty, const Twine &Name,
+                   BasicBlock *InsertAtEnd)
+    : CastInst(Ty, SExt, S, Name, InsertAtEnd) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal SExt");
 }
 
+// Function to introduce total ordering between two SExt Instructions.
+// Returns -1 (this instruction < I)
+//         +1 (this instruction > I)
+//          0 (this instruction = I)
+// 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.
+int SExtInst::compareInstSpecificProperties(const SExtInst *I) const {
+  return 0;
+}
+
 FPTruncInst::FPTruncInst(
   Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
 ) : CastInst(Ty, FPTrunc, S, Name, InsertBefore) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPTrunc");
 }
 
-FPTruncInst::FPTruncInst(
-  Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
-) : CastInst(Ty, FPTrunc, S, Name, InsertAtEnd) {
+FPTruncInst::FPTruncInst(Value *S, Type *Ty, const Twine &Name,
+                         BasicBlock *InsertAtEnd)
+    : CastInst(Ty, FPTrunc, S, Name, InsertAtEnd) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPTrunc");
 }
 
-FPExtInst::FPExtInst(
-  Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
-) : CastInst(Ty, FPExt, S, Name, InsertBefore) {
+// Function to introduce total ordering between two FPTrunc Instructions.
+// Returns -1 (this instruction < I)
+//         +1 (this instruction > I)
+//          0 (this instruction = I)
+// 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.
+int FPTruncInst::compareInstSpecificProperties(const FPTruncInst *I) const {
+  return 0;
+}
+
+FPExtInst::FPExtInst(Value *S, Type *Ty, const Twine &Name,
+                     Instruction *InsertBefore)
+    : CastInst(Ty, FPExt, S, Name, InsertBefore) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPExt");
 }
 
-FPExtInst::FPExtInst(
-  Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
-) : CastInst(Ty, FPExt, S, Name, InsertAtEnd) {
+FPExtInst::FPExtInst(Value *S, Type *Ty, const Twine &Name,
+                     BasicBlock *InsertAtEnd)
+    : CastInst(Ty, FPExt, S, Name, InsertAtEnd) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPExt");
 }
 
-UIToFPInst::UIToFPInst(
-  Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
-) : CastInst(Ty, UIToFP, S, Name, InsertBefore) {
+// Function to introduce total ordering between two FPExt Instructions.
+// Returns -1 (this instruction < I)
+//         +1 (this instruction > I)
+//          0 (this instruction = I)
+// 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.
+int FPExtInst::compareInstSpecificProperties(const FPExtInst *I) const {
+  return 0;
+}
+
+UIToFPInst::UIToFPInst(Value *S, Type *Ty, const Twine &Name,
+                       Instruction *InsertBefore)
+    : CastInst(Ty, UIToFP, S, Name, InsertBefore) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal UIToFP");
 }
 
-UIToFPInst::UIToFPInst(
-  Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
-) : CastInst(Ty, UIToFP, S, Name, InsertAtEnd) {
+UIToFPInst::UIToFPInst(Value *S, Type *Ty, const Twine &Name,
+                       BasicBlock *InsertAtEnd)
+    : CastInst(Ty, UIToFP, S, Name, InsertAtEnd) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal UIToFP");
 }
 
-SIToFPInst::SIToFPInst(
-  Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
-) : CastInst(Ty, SIToFP, S, Name, InsertBefore) {
+// Function to introduce total ordering between two UIToFP Instructions.
+// Returns -1 (this instruction < I)
+//         +1 (this instruction > I)
+//          0 (this instruction = I)
+// 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.
+int UIToFPInst::compareInstSpecificProperties(const UIToFPInst *I) const {
+  return 0;
+}
+
+SIToFPInst::SIToFPInst(Value *S, Type *Ty, const Twine &Name,
+                       Instruction *InsertBefore)
+    : CastInst(Ty, SIToFP, S, Name, InsertBefore) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal SIToFP");
 }
 
 SIToFPInst::SIToFPInst(
   Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
 ) : CastInst(Ty, SIToFP, S, Name, InsertAtEnd) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal SIToFP");
 }
 
-FPToUIInst::FPToUIInst(
-  Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
-) : CastInst(Ty, FPToUI, S, Name, InsertBefore) {
+// Function to introduce total ordering between two SIToFP Instructions.
+// Returns -1 (this instruction < I)
+//         +1 (this instruction > I)
+//          0 (this instruction = I)
+// 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.
+int SIToFPInst::compareInstSpecificProperties(const SIToFPInst *I) const {
+  return 0;
+}
+
+FPToUIInst::FPToUIInst(Value *S, Type *Ty, const Twine &Name,
+                       Instruction *InsertBefore)
+    : CastInst(Ty, FPToUI, S, Name, InsertBefore) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPToUI");
 }
 
 FPToUIInst::FPToUIInst(
   Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
 ) : CastInst(Ty, FPToUI, S, Name, InsertAtEnd) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPToUI");
 }
 
-FPToSIInst::FPToSIInst(
-  Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
-) : CastInst(Ty, FPToSI, S, Name, InsertBefore) {
+// Function to introduce total ordering between two FPToUI Instructions.
+// Returns -1 (this instruction < I)
+//         +1 (this instruction > I)
+//          0 (this instruction = I)
+// 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.
+int FPToUIInst::compareInstSpecificProperties(const FPToUIInst *I) const {
+  return 0;
+}
+
+FPToSIInst::FPToSIInst(Value *S, Type *Ty, const Twine &Name,
+                       Instruction *InsertBefore)
+    : CastInst(Ty, FPToSI, S, Name, InsertBefore) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPToSI");
 }
 
 FPToSIInst::FPToSIInst(
   Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
 ) : CastInst(Ty, FPToSI, S, Name, InsertAtEnd) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPToSI");
 }
 
+// Function to introduce total ordering between two FPToSI Instructions.
+// Returns -1 (this instruction < I)
+//         +1 (this instruction > I)
+//          0 (this instruction = I)
+// 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.
+int FPToSIInst::compareInstSpecificProperties(const FPToSIInst *I) const {
+  return 0;
+}
+
 PtrToIntInst::PtrToIntInst(
   Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
 ) : CastInst(Ty, PtrToInt, S, Name, InsertBefore) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal PtrToInt");
 }
 
 PtrToIntInst::PtrToIntInst(
   Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
 ) : CastInst(Ty, PtrToInt, S, Name, InsertAtEnd) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal PtrToInt");
 }
 
+// Function to introduce total ordering between two PtrToInt Instructions.
+// Returns -1 (this instruction < I)
+//         +1 (this instruction > I)
+//          0 (this instruction = I)
+// 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.
+int PtrToIntInst::compareInstSpecificProperties(const PtrToIntInst *I) const {
+  return 0;
+}
+
 IntToPtrInst::IntToPtrInst(
   Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
 ) : CastInst(Ty, IntToPtr, S, Name, InsertBefore) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal IntToPtr");
 }
 
 IntToPtrInst::IntToPtrInst(
   Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
 ) : CastInst(Ty, IntToPtr, S, Name, InsertAtEnd) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal IntToPtr");
 }
 
+// Function to introduce total ordering between two IntToPtr Instructions.
+// Returns -1 (this instruction < I)
+//         +1 (this instruction > I)
+//          0 (this instruction = I)
+// 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.
+int IntToPtrInst::compareInstSpecificProperties(const IntToPtrInst *I) const {
+  return 0;
+}
+
 BitCastInst::BitCastInst(
   Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
 ) : CastInst(Ty, BitCast, S, Name, InsertBefore) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal BitCast");
 }
 
 BitCastInst::BitCastInst(
   Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
 ) : CastInst(Ty, BitCast, S, Name, InsertAtEnd) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal BitCast");
 }
 
+// Function to introduce total ordering between two BitCast Instructions.
+// Returns -1 (this instruction < I)
+//         +1 (this instruction > I)
+//          0 (this instruction = I)
+// 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.
+int BitCastInst::compareInstSpecificProperties(const BitCastInst *I) const {
+  return 0;
+}
+
 AddrSpaceCastInst::AddrSpaceCastInst(
   Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
 ) : CastInst(Ty, AddrSpaceCast, S, Name, InsertBefore) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal AddrSpaceCast");
 }
 
 AddrSpaceCastInst::AddrSpaceCastInst(
   Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
 ) : CastInst(Ty, AddrSpaceCast, S, Name, InsertAtEnd) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal AddrSpaceCast");
 }
 
+// Function to introduce total ordering between two AddrSpaceCast Instructions.
+// Returns -1 (this instruction < I)
+//         +1 (this instruction > I)
+//          0 (this instruction = I)
+// 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.
+int AddrSpaceCastInst::compareInstSpecificProperties(
+    const AddrSpaceCastInst *I) const {
+  return 0;
+}
+
 //===----------------------------------------------------------------------===//
 //                               CmpInst Classes
 //===----------------------------------------------------------------------===//
 
 CmpInst::CmpInst(Type *ty, OtherOps op, Predicate predicate, Value *LHS,
                  Value *RHS, const Twine &Name, Instruction *InsertBefore,
                  Instruction *FlagsSource)
   : Instruction(ty, op,
switch (predicate) {
     default: return false;
     case FCmpInst::FCMP_UEQ: case FCmpInst::FCMP_UNE: case FCmpInst::FCMP_UGT:
     case FCmpInst::FCMP_ULT: case FCmpInst::FCMP_UGE: case FCmpInst::FCMP_ULE:
     case FCmpInst::FCMP_UNO: return true;
   }
 }
 
 bool CmpInst::isTrueWhenEqual(Predicate predicate) {
-  switch(predicate) {
-    default: return false;
-    case ICMP_EQ:   case ICMP_UGE: case ICMP_ULE: case ICMP_SGE: case ICMP_SLE:
-    case FCMP_TRUE: case FCMP_UEQ: case FCMP_UGE: case FCMP_ULE: return true;
+  switch (predicate) {
+  default:
+    return false;
+  case ICMP_EQ:
+  case ICMP_UGE:
+  case ICMP_ULE:
+  case ICMP_SGE:
+  case ICMP_SLE:
+  case FCMP_TRUE:
+  case FCMP_UEQ:
+  case FCMP_UGE:
+  case FCMP_ULE:
+    return true;
   }
 }
 
 bool CmpInst::isFalseWhenEqual(Predicate predicate) {
   switch(predicate) {
   case ICMP_NE:    case ICMP_UGT: case ICMP_ULT: case ICMP_SGT: case ICMP_SLT:
   case FCMP_FALSE: case FCMP_ONE: case FCMP_OGT: case FCMP_OLT: return true;
   default: return false;
bool CmpInst::isImpliedTrueByMatchingCmp(Predicate Pred1, Predicate Pred2) {
   }
   return false;
 }
 
 bool CmpInst::isImpliedFalseByMatchingCmp(Predicate Pred1, Predicate Pred2) {
   return isImpliedTrueByMatchingCmp(Pred1, getInversePredicate(Pred2));
 }
 
+// Function to introduce total ordering between two Cmp Instructions.
+// Returns -1 (this instruction < I)
+//         +1 (this instruction > I)
+//          0 (this instruction = I)
+// Any addition of operands in CmpInst class need to be reflected here
+// so that the IR comparators stay in sync with the changes to IR.
+int CmpInst::compareInstSpecificProperties(const CmpInst *I) const {
+  return compareIntegers(getPredicate(), I->getPredicate());
+}
+
 //===----------------------------------------------------------------------===//
 //                        SwitchInst Implementation
 //===----------------------------------------------------------------------===//
 
 void SwitchInst::init(Value *Value, BasicBlock *Default, unsigned NumReserved) {
   assert(Value && Default && NumReserved);
   ReservedSpace = NumReserved;
   setNumHungOffUseOperands(2);
if (MDNode *ProfileData = getProfBranchWeightsMD(SI))
     if (ProfileData->getNumOperands() == SI.getNumSuccessors() + 1)
       return mdconst::extract<ConstantInt>(ProfileData->getOperand(idx + 1))
           ->getValue()
           .getZExtValue();
 
   return None;
 }
 
+// Function to introduce total ordering between two Switch Instructions.
+// Returns -1 (this instruction < I)
+//         +1 (this instruction > I)
+//          0 (this instruction = I)
+// 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.
+int SwitchInst::compareInstSpecificProperties(const SwitchInst *I) const {
+  return 0;
+}
+
 //===----------------------------------------------------------------------===//
 //                        IndirectBrInst Implementation
 //===----------------------------------------------------------------------===//
 
 void IndirectBrInst::init(Value *Address, unsigned NumDests) {
   assert(Address && Address->getType()->isPointerTy() &&
          "Address of indirectbr must be a pointer");
   ReservedSpace = 1+NumDests;
IndirectBrInst::IndirectBrInst(const IndirectBrInst &IBI)
   SubclassOptionalData = IBI.SubclassOptionalData;
 }
 
 /// addDestination - Add a destination.
 ///
 void IndirectBrInst::addDestination(BasicBlock *DestBB) {
   unsigned OpNo = getNumOperands();
   if (OpNo+1 > ReservedSpace)
-    growOperands();  // Get more space!
+    growOperands(); // Get more space!
   // Initialize some new operands.
   assert(OpNo < ReservedSpace && "Growing didn't work!");
-  setNumHungOffUseOperands(OpNo+1);
+  setNumHungOffUseOperands(OpNo + 1);
   getOperandList()[OpNo] = DestBB;
 }
 
 /// removeDestination - This method removes the specified successor from the
 /// indirectbr instruction.
 void IndirectBrInst::removeDestination(unsigned idx) {
-  assert(idx < getNumOperands()-1 && "Successor index out of range!");
+  assert(idx < getNumOperands() - 1 && "Successor index out of range!");
 
   unsigned NumOps = getNumOperands();
   Use *OL = getOperandList();
 
   // Replace this value with the last one.
-  OL[idx+1] = OL[NumOps-1];
+  OL[idx + 1] = OL[NumOps - 1];
 
   // Nuke the last value.
-  OL[NumOps-1].set(nullptr);
-  setNumHungOffUseOperands(NumOps-1);
+  OL[NumOps - 1].set(nullptr);
+  setNumHungOffUseOperands(NumOps - 1);
 }
 
+// Function to introduce total ordering between two IndirectBr Instructions.
+// Returns -1 (this instruction < I)
+//         +1 (this instruction > I)
+//          0 (this instruction = I)
+// 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.
+int IndirectBrInst::compareInstSpecificProperties(
+    const IndirectBrInst *I) const {
+  return 0;
+}
+
 //===----------------------------------------------------------------------===//
 //                            FreezeInst Implementation
 //===----------------------------------------------------------------------===//
 
-FreezeInst::FreezeInst(Value *S,
-                       const Twine &Name, Instruction *InsertBefore)
+FreezeInst::FreezeInst(Value *S, const Twine &Name, Instruction *InsertBefore)
     : UnaryInstruction(S->getType(), Freeze, S, InsertBefore) {
   setName(Name);
 }
 
-FreezeInst::FreezeInst(Value *S,
-                       const Twine &Name, BasicBlock *InsertAtEnd)
+FreezeInst::FreezeInst(Value *S, const Twine &Name, BasicBlock *InsertAtEnd)
     : UnaryInstruction(S->getType(), Freeze, S, InsertAtEnd) {
   setName(Name);
 }
 
+// Function to introduce total ordering between two Freeze Instructions.
+// Returns -1 (this instruction < I)
+//         +1 (this instruction > I)
+//          0 (this instruction = I)
+// 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.
+int FreezeInst::compareInstSpecificProperties(const FreezeInst *I) const {
+  return 0;
+}
+
+//===----------------------------------------------------------------------===//
+//                            VAArgInst class
+//===----------------------------------------------------------------------===//
+
+// Function to introduce total ordering between two VAArg Instructions.
+// Returns -1 (this instruction < I)
+//         +1 (this instruction > I)
+//          0 (this instruction = I)
+// 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.
+int VAArgInst::compareInstSpecificProperties(const VAArgInst *I) const {
+  return 0;
+}
+
+//===----------------------------------------------------------------------===//
+//                            CleanupPadInst class
+//===----------------------------------------------------------------------===//
+
+// Function to introduce total ordering between two CleanupPad Instructions.
+// Returns -1 (this instruction < I)
+//         +1 (this instruction > I)
+//          0 (this instruction = I)
+// 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.
+int CleanupPadInst::compareInstSpecificProperties(
+    const CleanupPadInst *I) const {
+  return 0;
+}
+
+//===----------------------------------------------------------------------===//
+//                            CatchPadInst class
+//===----------------------------------------------------------------------===//
+
+// Function to introduce total ordering between two CatchPad Instructions.
+// Returns -1 (this instruction < I)
+//         +1 (this instruction > I)
+//          0 (this instruction = I)
+// 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 CatchPadInst::compareInstSpecificProperties(const CatchPadInst *I) const {
+  const CatchSwitchInst *CSI = getCatchSwitch();
+  return CSI->compareInstSpecificProperties(I->getCatchSwitch());
+}
+
 //===----------------------------------------------------------------------===//
 //                           cloneImpl() implementations
 //===----------------------------------------------------------------------===//
 
 // Define these methods here so vtables don't get emitted into every translation
 // unit that uses these classes.
 
 GetElementPtrInst *GetElementPtrInst::cloneImpl() const {

llvm/lib/Transforms/Utils/FunctionComparator.cpp

int FunctionComparator::cmpOperations(const Instruction *L,
   // if all operands are the same type
   for (unsigned i = 0, e = L->getNumOperands(); i != e; ++i) {
     if (int Res =
             cmpTypes(L->getOperand(i)->getType(), R->getOperand(i)->getType()))
       return Res;
   }
 
   // Check special state that is a part of some instructions.
-  if (const AllocaInst *AI = dyn_cast<AllocaInst>(L)) {
-    if (int Res = cmpTypes(AI->getAllocatedType(),
-                           cast<AllocaInst>(R)->getAllocatedType()))
-      return Res;
-    return cmpNumbers(AI->getAlignment(), cast<AllocaInst>(R)->getAlignment());
-  }
-  if (const LoadInst *LI = dyn_cast<LoadInst>(L)) {
-    if (int Res = cmpNumbers(LI->isVolatile(), cast<LoadInst>(R)->isVolatile()))
-      return Res;
-    if (int Res =
-            cmpNumbers(LI->getAlignment(), cast<LoadInst>(R)->getAlignment()))
-      return Res;
-    if (int Res =
-            cmpOrderings(LI->getOrdering(), cast<LoadInst>(R)->getOrdering()))
-      return Res;
-    if (int Res = cmpNumbers(LI->getSyncScopeID(),
-                             cast<LoadInst>(R)->getSyncScopeID()))
-      return Res;
-    return cmpRangeMetadata(
-        LI->getMetadata(LLVMContext::MD_range),
-        cast<LoadInst>(R)->getMetadata(LLVMContext::MD_range));
-  }
-  if (const StoreInst *SI = dyn_cast<StoreInst>(L)) {
-    if (int Res =
-            cmpNumbers(SI->isVolatile(), cast<StoreInst>(R)->isVolatile()))
-      return Res;
-    if (int Res =
-            cmpNumbers(SI->getAlignment(), cast<StoreInst>(R)->getAlignment()))
-      return Res;
-    if (int Res =
-            cmpOrderings(SI->getOrdering(), cast<StoreInst>(R)->getOrdering()))
-      return Res;
-    return cmpNumbers(SI->getSyncScopeID(),
-                      cast<StoreInst>(R)->getSyncScopeID());
-  }
-  if (const CmpInst *CI = dyn_cast<CmpInst>(L))
-    return cmpNumbers(CI->getPredicate(), cast<CmpInst>(R)->getPredicate());
-  if (auto *CBL = dyn_cast<CallBase>(L)) {
-    auto *CBR = cast<CallBase>(R);
-    if (int Res = cmpNumbers(CBL->getCallingConv(), CBR->getCallingConv()))
-      return Res;
-    if (int Res = cmpAttrs(CBL->getAttributes(), CBR->getAttributes()))
-      return Res;
-    if (int Res = cmpOperandBundlesSchema(*CBL, *CBR))
-      return Res;
-    if (const CallInst *CI = dyn_cast<CallInst>(L))
-      if (int Res = cmpNumbers(CI->getTailCallKind(),
-                               cast<CallInst>(R)->getTailCallKind()))
-        return Res;
-    return cmpRangeMetadata(L->getMetadata(LLVMContext::MD_range),
-                            R->getMetadata(LLVMContext::MD_range));
-  }
-  if (const InsertValueInst *IVI = dyn_cast<InsertValueInst>(L)) {
-    ArrayRef<unsigned> LIndices = IVI->getIndices();
-    ArrayRef<unsigned> RIndices = cast<InsertValueInst>(R)->getIndices();
-    if (int Res = cmpNumbers(LIndices.size(), RIndices.size()))
-      return Res;
-    for (size_t i = 0, e = LIndices.size(); i != e; ++i) {
-      if (int Res = cmpNumbers(LIndices[i], RIndices[i]))
-        return Res;
-    }
-    return 0;
-  }
-  if (const ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(L)) {
-    ArrayRef<unsigned> LIndices = EVI->getIndices();
-    ArrayRef<unsigned> RIndices = cast<ExtractValueInst>(R)->getIndices();
-    if (int Res = cmpNumbers(LIndices.size(), RIndices.size()))
-      return Res;
-    for (size_t i = 0, e = LIndices.size(); i != e; ++i) {
-      if (int Res = cmpNumbers(LIndices[i], RIndices[i]))
-        return Res;
-    }
-  }
-  if (const FenceInst *FI = dyn_cast<FenceInst>(L)) {
-    if (int Res =
-            cmpOrderings(FI->getOrdering(), cast<FenceInst>(R)->getOrdering()))
-      return Res;
-    return cmpNumbers(FI->getSyncScopeID(),
-                      cast<FenceInst>(R)->getSyncScopeID());
-  }
-  if (const AtomicCmpXchgInst *CXI = dyn_cast<AtomicCmpXchgInst>(L)) {
-    if (int Res = cmpNumbers(CXI->isVolatile(),
-                             cast<AtomicCmpXchgInst>(R)->isVolatile()))
-      return Res;
-    if (int Res =
-            cmpNumbers(CXI->isWeak(), cast<AtomicCmpXchgInst>(R)->isWeak()))
-      return Res;
-    if (int Res =
-            cmpOrderings(CXI->getSuccessOrdering(),
-                         cast<AtomicCmpXchgInst>(R)->getSuccessOrdering()))
-      return Res;
-    if (int Res =
-            cmpOrderings(CXI->getFailureOrdering(),
-                         cast<AtomicCmpXchgInst>(R)->getFailureOrdering()))
-      return Res;
-    return cmpNumbers(CXI->getSyncScopeID(),
-                      cast<AtomicCmpXchgInst>(R)->getSyncScopeID());
-  }
-  if (const AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(L)) {
-    if (int Res = cmpNumbers(RMWI->getOperation(),
-                             cast<AtomicRMWInst>(R)->getOperation()))
-      return Res;
-    if (int Res = cmpNumbers(RMWI->isVolatile(),
-                             cast<AtomicRMWInst>(R)->isVolatile()))
-      return Res;
-    if (int Res = cmpOrderings(RMWI->getOrdering(),
-                               cast<AtomicRMWInst>(R)->getOrdering()))
-      return Res;
-    return cmpNumbers(RMWI->getSyncScopeID(),
-                      cast<AtomicRMWInst>(R)->getSyncScopeID());
-  }
-  if (const ShuffleVectorInst *SVI = dyn_cast<ShuffleVectorInst>(L)) {
-    ArrayRef<int> LMask = SVI->getShuffleMask();
-    ArrayRef<int> RMask = cast<ShuffleVectorInst>(R)->getShuffleMask();
-    if (int Res = cmpNumbers(LMask.size(), RMask.size()))
-      return Res;
-    for (size_t i = 0, e = LMask.size(); i != e; ++i) {
-      if (int Res = cmpNumbers(LMask[i], RMask[i]))
-        return Res;
-    }
-  }
   if (const PHINode *PNL = dyn_cast<PHINode>(L)) {
     const PHINode *PNR = cast<PHINode>(R);
     // Ensure that in addition to the incoming values being identical
     // (checked by the caller of this function), the incoming blocks
     // are also identical.
     for (unsigned i = 0, e = PNL->getNumIncomingValues(); i != e; ++i) {
       if (int Res =
               cmpValues(PNL->getIncomingBlock(i), PNR->getIncomingBlock(i)))
         return Res;
     }
   }
-  return 0;
+  return L->compareSpecialState(R);
 }
 
 // Determine whether two GEP operations perform the same underlying arithmetic.
 // Read method declaration comments for more details.
 int FunctionComparator::cmpGEPs(const GEPOperator *GEPL,
                                 const GEPOperator *GEPR) const {
   unsigned int ASL = GEPL->getPointerAddressSpace();
   unsigned int ASR = GEPR->getPointerAddressSpace();