[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

426

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

429

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

432

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

437

Same here.

453

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

422

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

1282

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

186

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

73

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.

316

Ditto.

1443

Ditto.

3698

Ditto.

3911

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

class UnaryOperator : public UnaryInstruction {
   void AssertOK();
 
 protected:
   UnaryOperator(UnaryOps iType, Value *S, Type *Ty,
                 const Twine &Name, Instruction *InsertBefore);
   UnaryOperator(UnaryOps iType, Value *S, Type *Ty,
                 const Twine &Name, BasicBlock *InsertAtEnd);
 
-  // Note: Instruction needs to be a friend here to call cloneImpl.
+  // Note: Instruction needs to be a friend here to call cloneImpl and
+  // compareInstSpecificProperties.
   friend class Instruction;
 
   UnaryOperator *cloneImpl() const;
 
+  int compareInstSpecificProperties(const UnaryOperator *I) const;
+
 public:
 
   /// Construct a unary instruction, given the opcode and an operand.
   /// Optionally (if InstBefore is specified) insert the instruction
   /// into a BasicBlock right before the specified instruction.  The specified
   /// Instruction is allowed to be a dereferenced end iterator.
   ///
   static UnaryOperator *Create(UnaryOps Op, Value *S,
#include "llvm/IR/Instruction.def"
   }
 
   // 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));
   }
 };
 
 //===----------------------------------------------------------------------===//
 //                           BinaryOperator Class
 //===----------------------------------------------------------------------===//
 
 class BinaryOperator : public Instruction {
   void AssertOK();
 
 protected:
   BinaryOperator(BinaryOps iType, Value *S1, Value *S2, Type *Ty,
                  const Twine &Name, Instruction *InsertBefore);
   BinaryOperator(BinaryOps iType, Value *S1, Value *S2, Type *Ty,
                  const Twine &Name, BasicBlock *InsertAtEnd);
 
-  // Note: Instruction needs to be a friend here to call cloneImpl.
+  // Note: Instruction needs to be a friend here to call cloneImpl and
+  // compareInstSpecificProperties.
   friend class Instruction;
 
   BinaryOperator *cloneImpl() const;
 
+  int compareInstSpecificProperties(const BinaryOperator *I) const;
+
 public:
   // allocate space for exactly two operands
   void *operator new(size_t s) {
     return User::operator new(s, 2);
   }
 
   /// Transparently provide more efficient getOperand methods.
   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
CmpInst(Type *ty, Instruction::OtherOps op, Predicate pred,
           Value *LHS, Value *RHS, const Twine &Name = "",
           Instruction *InsertBefore = nullptr,
           Instruction *FlagsSource = nullptr);
 
   CmpInst(Type *ty, Instruction::OtherOps op, Predicate pred,
           Value *LHS, Value *RHS, const Twine &Name,
           BasicBlock *InsertAtEnd);
 
+  // Note: Instruction needs to be a friend here to call
+  // compareInstSpecificProperties.
+  friend class Instruction;
+
+  int compareInstSpecificProperties(const CmpInst *I) const;
+
 public:
   // allocate space for exactly two operands
   void *operator new(size_t s) {
     return User::operator new(s, 2);
   }
 
   /// Construct a compare instruction, given the opcode, the predicate and
   /// the two operands.  Optionally (if InstBefore is specified) insert the

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.
+  /// Flags are used for switching on/off consideration of Alignment and
+  /// MetaData during IR comparison.
+  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

 
 namespace llvm {
 
 class APInt;
 class ConstantInt;
 class DataLayout;
 class LLVMContext;
 
+enum class IgnoreAlignment { No, Yes };
+enum class IgnoreMetaData { No, Yes };
+
 //===----------------------------------------------------------------------===//
 //                                AllocaInst Class
 //===----------------------------------------------------------------------===//
 
 /// an instruction to allocate memory on the stack
 class AllocaInst : public UnaryInstruction {
   Type *AllocatedType;
 
 protected:
-  // Note: Instruction needs to be a friend here to call cloneImpl.
+  // Note: Instruction needs to be a friend here to call cloneImpl and
+  // compareInstSpecificProperties.
   friend class Instruction;
 
   AllocaInst *cloneImpl() const;
 
+  int compareInstSpecificProperties(
+      const AllocaInst *AI,
+      IgnoreAlignment CmpIgnoringAlignment = IgnoreAlignment::No) 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);

 //===----------------------------------------------------------------------===//
 
 /// An instruction for reading from memory. This uses the SubclassData field in
 /// Value to store whether or not the load is volatile.
 class LoadInst : public UnaryInstruction {
   void AssertOK();
 
 protected:
-  // Note: Instruction needs to be a friend here to call cloneImpl.
+  // Note: Instruction needs to be a friend here to call cloneImpl and
+  // compareInstSpecificProperties.
   friend class Instruction;
 
   LoadInst *cloneImpl() const;
 
+  int compareInstSpecificProperties(
+      const LoadInst *LI,
+      IgnoreAlignment CmpIgnoringAlignment = IgnoreAlignment::No,
+      IgnoreMetaData CmpIgnoringMetaData = IgnoreMetaData::No) 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);

 //                                StoreInst Class
 //===----------------------------------------------------------------------===//
 
 /// An instruction for storing to memory.
 class StoreInst : public Instruction {
   void AssertOK();
 
 protected:
-  // Note: Instruction needs to be a friend here to call cloneImpl.
+  // Note: Instruction needs to be a friend here to call cloneImpl and
+  // compareInstSpecificProperties.
   friend class Instruction;
 
   StoreInst *cloneImpl() const;
 
+  int compareInstSpecificProperties(
+      const StoreInst *SI,
+      IgnoreAlignment CmpIgnoringAlignment = IgnoreAlignment::No) 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,

 //                                FenceInst Class
 //===----------------------------------------------------------------------===//
 
 /// An instruction for ordering other memory operations.
 class FenceInst : public Instruction {
   void Init(AtomicOrdering Ordering, SyncScope::ID SSID);
 
 protected:
-  // Note: Instruction needs to be a friend here to call cloneImpl.
+  // Note: Instruction needs to be a friend here to call cloneImpl and
+  // compareInstSpecificProperties.
   friend class Instruction;
 
   FenceInst *cloneImpl() const;
 
+  int compareInstSpecificProperties(const FenceInst *FI) const;
+
 public:
   // Ordering may only be Acquire, Release, AcquireRelease, or
   // SequentiallyConsistent.
   FenceInst(LLVMContext &C, AtomicOrdering Ordering,
             SyncScope::ID SSID = SyncScope::System,
             Instruction *InsertBefore = nullptr);
   FenceInst(LLVMContext &C, AtomicOrdering Ordering, SyncScope::ID SSID,
             BasicBlock *InsertAtEnd);

 /// failure (false) as second element.
 ///
 class AtomicCmpXchgInst : public Instruction {
   void Init(Value *Ptr, Value *Cmp, Value *NewVal,
             AtomicOrdering SuccessOrdering, AtomicOrdering FailureOrdering,
             SyncScope::ID SSID);
 
 protected:
-  // Note: Instruction needs to be a friend here to call cloneImpl.
+  // Note: Instruction needs to be a friend here to call cloneImpl and
+  // compareInstSpecificProperties.
   friend class Instruction;
 
   AtomicCmpXchgInst *cloneImpl() const;
 
+  int compareInstSpecificProperties(const AtomicCmpXchgInst *I) const;
+
 public:
   AtomicCmpXchgInst(Value *Ptr, Value *Cmp, Value *NewVal,
                     AtomicOrdering SuccessOrdering,
                     AtomicOrdering FailureOrdering,
                     SyncScope::ID SSID, Instruction *InsertBefore = nullptr);
   AtomicCmpXchgInst(Value *Ptr, Value *Cmp, Value *NewVal,
                     AtomicOrdering SuccessOrdering,
                     AtomicOrdering FailureOrdering,

 //===----------------------------------------------------------------------===//
 
 /// an instruction that atomically reads a memory location,
 /// combines it with another value, and then stores the result back.  Returns
 /// the old value.
 ///
 class AtomicRMWInst : public Instruction {
 protected:
-  // Note: Instruction needs to be a friend here to call cloneImpl.
+  // Note: Instruction needs to be a friend here to call cloneImpl and
+  // compareInstSpecificProperties.
   friend class Instruction;
 
   AtomicRMWInst *cloneImpl() const;
 
+  int compareInstSpecificProperties(const AtomicRMWInst *I) const;
+
 public:
   /// This enumeration lists the possible modifications atomicrmw can make.  In
   /// the descriptions, 'p' is the pointer to the instruction's memory location,
   /// 'old' is the initial value of *p, and 'v' is the other value passed to the
   /// instruction.  These instructions always return 'old'.
   enum BinOp {
     /// *p = v
     Xchg,
inline GetElementPtrInst(Type *PointeeType, Value *Ptr,
                            const Twine &NameStr, Instruction *InsertBefore);
   inline GetElementPtrInst(Type *PointeeType, Value *Ptr,
                            ArrayRef<Value *> IdxList, unsigned Values,
                            const Twine &NameStr, BasicBlock *InsertAtEnd);
 
   void init(Value *Ptr, ArrayRef<Value *> IdxList, const Twine &NameStr);
 
 protected:
-  // Note: Instruction needs to be a friend here to call cloneImpl.
+  // Note: Instruction needs to be a friend here to call cloneImpl and
+  // compareInstSpecificProperties.
   friend class Instruction;
 
   GetElementPtrInst *cloneImpl() const;
 
+  int compareInstSpecificProperties(const GetElementPtrInst *I) const;
+
 public:
   static GetElementPtrInst *Create(Type *PointeeType, Value *Ptr,
                                    ArrayRef<Value *> IdxList,
                                    const Twine &NameStr = "",
                                    Instruction *InsertBefore = nullptr) {
     unsigned Values = 1 + unsigned(IdxList.size());
     if (!PointeeType)
       PointeeType =
#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
class CallInst : public CallBase {
   /// Compute the number of operands to allocate.
   static int ComputeNumOperands(int NumArgs, int NumBundleInputs = 0) {
     // We need one operand for the called function, plus the input operand
     // counts provided.
     return 1 + NumArgs + NumBundleInputs;
   }
 
 protected:
-  // Note: Instruction needs to be a friend here to call cloneImpl.
+  // Note: Instruction needs to be a friend here to call cloneImpl and
+  // compareInstSpecificProperties.
   friend class Instruction;
 
   CallInst *cloneImpl() const;
 
+  int compareInstSpecificProperties(
+      const CallInst *I,
+      IgnoreMetaData CmpIgnoringMetaData = IgnoreMetaData::No) 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,
class SelectInst : public Instruction {
   void init(Value *C, Value *S1, Value *S2) {
     assert(!areInvalidOperands(C, S1, S2) && "Invalid operands for select");
     Op<0>() = C;
     Op<1>() = S1;
     Op<2>() = S2;
   }
 
 protected:
-  // Note: Instruction needs to be a friend here to call cloneImpl.
+  // Note: Instruction needs to be a friend here to call cloneImpl and
+  // compareInstSpecificProperties.
   friend class Instruction;
 
   SelectInst *cloneImpl() const;
 
+  int compareInstSpecificProperties(const SelectInst *I) const;
+
 public:
   static SelectInst *Create(Value *C, Value *S1, Value *S2,
                             const Twine &NameStr = "",
                             Instruction *InsertBefore = nullptr,
                             Instruction *MDFrom = nullptr) {
     SelectInst *Sel = new(3) SelectInst(C, S1, S2, NameStr, InsertBefore);
     if (MDFrom)
       Sel->copyMetadata(*MDFrom);

 //                                VAArgInst Class
 //===----------------------------------------------------------------------===//
 
 /// This class represents the va_arg llvm instruction, which returns
 /// an argument of the specified type given a va_list and increments that list
 ///
 class VAArgInst : public UnaryInstruction {
 protected:
-  // Note: Instruction needs to be a friend here to call cloneImpl.
+  // Note: Instruction needs to be a friend here to call cloneImpl and
+  // compareInstSpecificProperties.
   friend class Instruction;
 
   VAArgInst *cloneImpl() const;
 
+  int compareInstSpecificProperties(const VAArgInst *I) const;
+
 public:
   VAArgInst(Value *List, Type *Ty, const Twine &NameStr = "",
              Instruction *InsertBefore = nullptr)
     : UnaryInstruction(Ty, VAArg, List, InsertBefore) {
     setName(NameStr);
   }
 
   VAArgInst(Value *List, Type *Ty, const Twine &NameStr,

 ///
 class ExtractElementInst : public Instruction {
   ExtractElementInst(Value *Vec, Value *Idx, const Twine &NameStr = "",
                      Instruction *InsertBefore = nullptr);
   ExtractElementInst(Value *Vec, Value *Idx, const Twine &NameStr,
                      BasicBlock *InsertAtEnd);
 
 protected:
-  // Note: Instruction needs to be a friend here to call cloneImpl.
+  // Note: Instruction needs to be a friend here to call cloneImpl and
+  // compareInstSpecificProperties.
   friend class Instruction;
 
   ExtractElementInst *cloneImpl() const;
 
+  int compareInstSpecificProperties(const ExtractElementInst *I) const;
+
 public:
   static ExtractElementInst *Create(Value *Vec, Value *Idx,
                                    const Twine &NameStr = "",
                                    Instruction *InsertBefore = nullptr) {
     return new(2) ExtractElementInst(Vec, Idx, NameStr, InsertBefore);
   }
 
   static ExtractElementInst *Create(Value *Vec, Value *Idx,

 class InsertElementInst : public Instruction {
   InsertElementInst(Value *Vec, Value *NewElt, Value *Idx,
                     const Twine &NameStr = "",
                     Instruction *InsertBefore = nullptr);
   InsertElementInst(Value *Vec, Value *NewElt, Value *Idx, const Twine &NameStr,
                     BasicBlock *InsertAtEnd);
 
 protected:
-  // Note: Instruction needs to be a friend here to call cloneImpl.
+  // Note: Instruction needs to be a friend here to call cloneImpl and
+  // compareInstSpecificProperties.
   friend class Instruction;
 
   InsertElementInst *cloneImpl() const;
 
+  int compareInstSpecificProperties(const InsertElementInst *I) const;
+
 public:
   static InsertElementInst *Create(Value *Vec, Value *NewElt, Value *Idx,
                                    const Twine &NameStr = "",
                                    Instruction *InsertBefore = nullptr) {
     return new(3) InsertElementInst(Vec, NewElt, Idx, NameStr, InsertBefore);
   }
 
   static InsertElementInst *Create(Value *Vec, Value *NewElt, Value *Idx,

 ///
 /// For scalable vectors, all the elements of the mask must be 0 or -1. This
 /// requirement may be relaxed in the future.
 class ShuffleVectorInst : public Instruction {
   SmallVector<int, 4> ShuffleMask;
   Constant *ShuffleMaskForBitcode;
 
 protected:
-  // Note: Instruction needs to be a friend here to call cloneImpl.
+  // Note: Instruction needs to be a friend here to call cloneImpl and
+  // compareInstSpecificProperties.
   friend class Instruction;
 
   ShuffleVectorInst *cloneImpl() const;
 
+  int compareInstSpecificProperties(const ShuffleVectorInst *I) const;
+
 public:
   ShuffleVectorInst(Value *V1, Value *V2, Value *Mask,
                     const Twine &NameStr = "",
                     Instruction *InsertBefor = nullptr);
   ShuffleVectorInst(Value *V1, Value *V2, Value *Mask,
                     const Twine &NameStr, BasicBlock *InsertAtEnd);
   ShuffleVectorInst(Value *V1, Value *V2, ArrayRef<int> Mask,
                     const Twine &NameStr = "",
inline ExtractValueInst(Value *Agg,
                           Instruction *InsertBefore);
   inline ExtractValueInst(Value *Agg,
                           ArrayRef<unsigned> Idxs,
                           const Twine &NameStr, BasicBlock *InsertAtEnd);
 
   void init(ArrayRef<unsigned> Idxs, const Twine &NameStr);
 
 protected:
-  // Note: Instruction needs to be a friend here to call cloneImpl.
+  // Note: Instruction needs to be a friend here to call cloneImpl and
+  // compareInstSpecificProperties.
   friend class Instruction;
 
   ExtractValueInst *cloneImpl() const;
 
+  int compareInstSpecificProperties(const ExtractValueInst *I) const;
+
 public:
   static ExtractValueInst *Create(Value *Agg,
                                   ArrayRef<unsigned> Idxs,
                                   const Twine &NameStr = "",
                                   Instruction *InsertBefore = nullptr) {
     return new
       ExtractValueInst(Agg, Idxs, NameStr, InsertBefore);
   }
public:
   ArrayRef<unsigned> getIndices() const {
     return Indices;
   }
 
   unsigned getNumIndices() const {
     return (unsigned)Indices.size();
   }
 
-  bool hasIndices() const {
-    return true;
-  }
+  bool hasIndices() const { return true; }
 
   // 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));
   }
InsertValueInst(Value *Agg, Value *Val, unsigned Idx,
                   Instruction *InsertBefore = nullptr);
   InsertValueInst(Value *Agg, Value *Val, unsigned Idx, const Twine &NameStr,
                   BasicBlock *InsertAtEnd);
 
   void init(Value *Agg, Value *Val, ArrayRef<unsigned> Idxs,
             const Twine &NameStr);
 
 protected:
-  // Note: Instruction needs to be a friend here to call cloneImpl.
+  // Note: Instruction needs to be a friend here to call cloneImpl and
+  // compareInstSpecificProperties.
   friend class Instruction;
 
   InsertValueInst *cloneImpl() const;
 
+  int compareInstSpecificProperties(const InsertValueInst *I) const;
+
 public:
   // allocate space for exactly two operands
   void *operator new(size_t s) {
     return User::operator new(s, 2);
   }
 
   static InsertValueInst *Create(Value *Agg, Value *Val,
                                  ArrayRef<unsigned> Idxs,
public:
   ArrayRef<unsigned> getIndices() const {
     return Indices;
   }
 
   unsigned getNumIndices() const {
     return (unsigned)Indices.size();
   }
 
-  bool hasIndices() const {
-    return true;
-  }
+  bool hasIndices() const { return true; }
 
   // 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));
   }
PHINode(Type *Ty, unsigned NumReservedValues, const Twine &NameStr,
           BasicBlock *InsertAtEnd)
     : Instruction(Ty, Instruction::PHI, nullptr, 0, InsertAtEnd),
       ReservedSpace(NumReservedValues) {
     setName(NameStr);
     allocHungoffUses(ReservedSpace);
   }
 
 protected:
-  // Note: Instruction needs to be a friend here to call cloneImpl.
+  // Note: Instruction needs to be a friend here to call cloneImpl and
+  // compareInstSpecificProperties.
   friend class Instruction;
 
   PHINode *cloneImpl() const;
 
+  int compareInstSpecificProperties(const PHINode *I) const;
+
   // allocHungoffUses - this is more complicated than the generic
   // User::allocHungoffUses, because we have to allocate Uses for the incoming
   // values and pointers to the incoming blocks, all in one allocation.
   void allocHungoffUses(unsigned N) {
     User::allocHungoffUses(N, /* IsPhi */ true);
   }
 
 public:
private:
   void *operator new(size_t s) {
     return User::operator new(s);
   }
 
   void growOperands(unsigned Size);
   void init(unsigned NumReservedValues, const Twine &NameStr);
 
 protected:
-  // Note: Instruction needs to be a friend here to call cloneImpl.
+  // Note: Instruction needs to be a friend here to call cloneImpl and
+  // compareInstSpecificProperties.
   friend class Instruction;
 
   LandingPadInst *cloneImpl() const;
 
+  int compareInstSpecificProperties(const LandingPadInst *I) const;
+
 public:
   /// Constructors - NumReservedClauses is a hint for the number of incoming
   /// clauses that this landingpad will have (use 0 if you really have no idea).
   static LandingPadInst *Create(Type *RetTy, unsigned NumReservedClauses,
                                 const Twine &NameStr = "",
                                 Instruction *InsertBefore = nullptr);
   static LandingPadInst *Create(Type *RetTy, unsigned NumReservedClauses,
                                 const Twine &NameStr, BasicBlock *InsertAtEnd);
private:
   // NOTE: If the Value* passed is of type void then the constructor behaves as
   // if it was passed NULL.
   explicit ReturnInst(LLVMContext &C, Value *retVal = nullptr,
                       Instruction *InsertBefore = nullptr);
   ReturnInst(LLVMContext &C, Value *retVal, BasicBlock *InsertAtEnd);
   explicit ReturnInst(LLVMContext &C, BasicBlock *InsertAtEnd);
 
 protected:
-  // Note: Instruction needs to be a friend here to call cloneImpl.
+  // Note: Instruction needs to be a friend here to call cloneImpl and
+  // compareInstSpecificProperties.
   friend class Instruction;
 
   ReturnInst *cloneImpl() const;
 
+  int compareInstSpecificProperties(const ReturnInst *I) const;
+
 public:
   static ReturnInst* Create(LLVMContext &C, Value *retVal = nullptr,
                             Instruction *InsertBefore = nullptr) {
     return new(!!retVal) ReturnInst(C, retVal, InsertBefore);
   }
 
   static ReturnInst* Create(LLVMContext &C, Value *retVal,
                             BasicBlock *InsertAtEnd) {
BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond,
              Instruction *InsertBefore = nullptr);
   BranchInst(BasicBlock *IfTrue, BasicBlock *InsertAtEnd);
   BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond,
              BasicBlock *InsertAtEnd);
 
   void AssertOK();
 
 protected:
-  // Note: Instruction needs to be a friend here to call cloneImpl.
+  // Note: Instruction needs to be a friend here to call cloneImpl and
+  // compareInstSpecificProperties.
   friend class Instruction;
 
   BranchInst *cloneImpl() const;
 
+  int compareInstSpecificProperties(const BranchInst *I) const;
+
 public:
   /// Iterator type that casts an operand to a basic block.
   ///
   /// This only makes sense because the successors are stored as adjacent
   /// operands for branch instructions.
   struct succ_op_iterator
       : iterator_adaptor_base<succ_op_iterator, value_op_iterator,
                               std::random_access_iterator_tag, BasicBlock *,
class SwitchInst : public Instruction {
   void *operator new(size_t s) {
     return User::operator new(s);
   }
 
   void init(Value *Value, BasicBlock *Default, unsigned NumReserved);
   void growOperands();
 
 protected:
-  // Note: Instruction needs to be a friend here to call cloneImpl.
+  // Note: Instruction needs to be a friend here to call cloneImpl and
+  // compareInstSpecificProperties.
   friend class Instruction;
 
   SwitchInst *cloneImpl() const;
 
+  int compareInstSpecificProperties(const SwitchInst *I) const;
+
 public:
   // -2
   static const unsigned DefaultPseudoIndex = static_cast<unsigned>(~0L-1);
 
   template <typename CaseHandleT> class CaseIteratorImpl;
 
   /// A handle to a particular switch case. It exposes a convenient interface
   /// to both the case value and the successor block.
class IndirectBrInst : public Instruction {
   void *operator new(size_t s) {
     return User::operator new(s);
   }
 
   void init(Value *Address, unsigned NumDests);
   void growOperands();
 
 protected:
-  // Note: Instruction needs to be a friend here to call cloneImpl.
+  // Note: Instruction needs to be a friend here to call cloneImpl and
+  // compareInstSpecificProperties.
   friend class Instruction;
 
   IndirectBrInst *cloneImpl() const;
 
+  int compareInstSpecificProperties(const IndirectBrInst *I) const;
+
 public:
   /// Iterator type that casts an operand to a basic block.
   ///
   /// This only makes sense because the successors are stored as adjacent
   /// operands for indirectbr instructions.
   struct succ_op_iterator
       : iterator_adaptor_base<succ_op_iterator, value_op_iterator,
                               std::random_access_iterator_tag, BasicBlock *,
class InvokeInst : public CallBase {
   /// Compute the number of operands to allocate.
   static int ComputeNumOperands(int NumArgs, int NumBundleInputs = 0) {
     // We need one operand for the called function, plus our extra operands and
     // the input operand counts provided.
     return 1 + NumExtraOperands + NumArgs + NumBundleInputs;
   }
 
 protected:
-  // Note: Instruction needs to be a friend here to call cloneImpl.
+  // Note: Instruction needs to be a friend here to call cloneImpl and
+  // compareInstSpecificProperties.
   friend class Instruction;
 
   InvokeInst *cloneImpl() const;
 
+  int compareInstSpecificProperties(
+      const InvokeInst *I,
+      IgnoreMetaData CmpIgnoringMetaData = IgnoreMetaData::No) 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,
class CallBrInst : public CallBase {
   static int ComputeNumOperands(int NumArgs, int NumIndirectDests,
                                 int NumBundleInputs = 0) {
     // We need one operand for the called function, plus our extra operands and
     // the input operand counts provided.
     return 2 + NumIndirectDests + NumArgs + NumBundleInputs;
   }
 
 protected:
-  // Note: Instruction needs to be a friend here to call cloneImpl.
+  // Note: Instruction needs to be a friend here to call cloneImpl and
+  // compareInstSpecificProperties.
   friend class Instruction;
 
   CallBrInst *cloneImpl() const;
 
+  int compareInstSpecificProperties(
+      const CallBrInst *I,
+      IgnoreMetaData CmpIgnoringMetaData = IgnoreMetaData::No) 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)

 ///
 class ResumeInst : public Instruction {
   ResumeInst(const ResumeInst &RI);
 
   explicit ResumeInst(Value *Exn, Instruction *InsertBefore=nullptr);
   ResumeInst(Value *Exn, BasicBlock *InsertAtEnd);
 
 protected:
-  // Note: Instruction needs to be a friend here to call cloneImpl.
+  // Note: Instruction needs to be a friend here to call cloneImpl and
+  // compareInstSpecificProperties.
   friend class Instruction;
 
   ResumeInst *cloneImpl() const;
 
+  int compareInstSpecificProperties(const ResumeInst *I) const;
+
 public:
   static ResumeInst *Create(Value *Exn, Instruction *InsertBefore = nullptr) {
     return new(1) ResumeInst(Exn, InsertBefore);
   }
 
   static ResumeInst *Create(Value *Exn, BasicBlock *InsertAtEnd) {
     return new(1) ResumeInst(Exn, InsertAtEnd);
   }
class CatchSwitchInst : public Instruction {
 
   // allocate space for exactly zero operands
   void *operator new(size_t s) { return User::operator new(s); }
 
   void init(Value *ParentPad, BasicBlock *UnwindDest, unsigned NumReserved);
   void growOperands(unsigned Size);
 
 protected:
-  // Note: Instruction needs to be a friend here to call cloneImpl.
+  // Note: Instruction needs to be a friend here to call cloneImpl and
+  // compareInstSpecificProperties.
   friend class Instruction;
 
+  // CatchPadInst needs to be a friend because compareInstSpecificProperties
+  // accesses a protected method in CatchPadInst class.
+  friend class CatchPadInst;
+
   CatchSwitchInst *cloneImpl() const;
 
+  int compareInstSpecificProperties(const CatchSwitchInst *I) const;
+
 public:
   static CatchSwitchInst *Create(Value *ParentPad, BasicBlock *UnwindDest,
                                  unsigned NumHandlers,
                                  const Twine &NameStr = "",
                                  Instruction *InsertBefore = nullptr) {
     return new CatchSwitchInst(ParentPad, UnwindDest, NumHandlers, NameStr,
                                InsertBefore);
   }

 struct OperandTraits<CatchSwitchInst> : public HungoffOperandTraits<2> {};
 
 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CatchSwitchInst, Value)
 
 //===----------------------------------------------------------------------===//
 //                               CleanupPadInst Class
 //===----------------------------------------------------------------------===//
 class CleanupPadInst : public FuncletPadInst {
+protected:
+  // Note: Instruction needs to be a friend here to call
+  // compareInstSpecificProperties.
+  friend class Instruction;
+
+  int compareInstSpecificProperties(const CleanupPadInst *I) const;
+
 private:
   explicit CleanupPadInst(Value *ParentPad, ArrayRef<Value *> Args,
                           unsigned Values, const Twine &NameStr,
                           Instruction *InsertBefore)
       : FuncletPadInst(Instruction::CleanupPad, ParentPad, Args, Values,
                        NameStr, InsertBefore) {}
   explicit CleanupPadInst(Value *ParentPad, ArrayRef<Value *> Args,
                           unsigned Values, const Twine &NameStr,
static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 };
 
 //===----------------------------------------------------------------------===//
 //                               CatchPadInst Class
 //===----------------------------------------------------------------------===//
 class CatchPadInst : public FuncletPadInst {
+protected:
+  // Note: Instruction needs to be a friend here to call
+  // compareInstSpecificProperties.
+  friend class Instruction;
+
+  bool compareInstSpecificProperties(const CatchPadInst *I) const;
+
 private:
   explicit CatchPadInst(Value *CatchSwitch, ArrayRef<Value *> Args,
                         unsigned Values, const Twine &NameStr,
                         Instruction *InsertBefore)
       : FuncletPadInst(Instruction::CatchPad, CatchSwitch, Args, Values,
                        NameStr, InsertBefore) {}
   explicit CatchPadInst(Value *CatchSwitch, ArrayRef<Value *> Args,
                         unsigned Values, const Twine &NameStr,

 class CatchReturnInst : public Instruction {
   CatchReturnInst(const CatchReturnInst &RI);
   CatchReturnInst(Value *CatchPad, BasicBlock *BB, Instruction *InsertBefore);
   CatchReturnInst(Value *CatchPad, BasicBlock *BB, BasicBlock *InsertAtEnd);
 
   void init(Value *CatchPad, BasicBlock *BB);
 
 protected:
-  // Note: Instruction needs to be a friend here to call cloneImpl.
+  // Note: Instruction needs to be a friend here to call cloneImpl and
+  // compareInstSpecificProperties.
   friend class Instruction;
 
   CatchReturnInst *cloneImpl() const;
 
+  int compareInstSpecificProperties(const CatchReturnInst *I) const;
+
 public:
   static CatchReturnInst *Create(Value *CatchPad, BasicBlock *BB,
                                  Instruction *InsertBefore = nullptr) {
     assert(CatchPad);
     assert(BB);
     return new (2) CatchReturnInst(CatchPad, BB, InsertBefore);
   }
 
private:
   CleanupReturnInst(Value *CleanupPad, BasicBlock *UnwindBB, unsigned Values,
                     Instruction *InsertBefore = nullptr);
   CleanupReturnInst(Value *CleanupPad, BasicBlock *UnwindBB, unsigned Values,
                     BasicBlock *InsertAtEnd);
 
   void init(Value *CleanupPad, BasicBlock *UnwindBB);
 
 protected:
-  // Note: Instruction needs to be a friend here to call cloneImpl.
+  // Note: Instruction needs to be a friend here to call cloneImpl and
+  // compareInstSpecificProperties.
   friend class Instruction;
 
   CleanupReturnInst *cloneImpl() const;
 
+  int compareInstSpecificProperties(const CleanupReturnInst *I) const;
+
 public:
   static CleanupReturnInst *Create(Value *CleanupPad,
                                    BasicBlock *UnwindBB = nullptr,
                                    Instruction *InsertBefore = nullptr) {
     assert(CleanupPad);
     unsigned Values = 1;
     if (UnwindBB)
       ++Values;

 
 //===---------------------------------------------------------------------------
 /// This function has undefined behavior.  In particular, the
 /// presence of this instruction indicates some higher level knowledge that the
 /// end of the block cannot be reached.
 ///
 class UnreachableInst : public Instruction {
 protected:
-  // Note: Instruction needs to be a friend here to call cloneImpl.
+  // Note: Instruction needs to be a friend here to call cloneImpl and
+  // compareInstSpecificProperties.
   friend class Instruction;
 
   UnreachableInst *cloneImpl() const;
 
+  int compareInstSpecificProperties(const UnreachableInst *I) const;
+
 public:
   explicit UnreachableInst(LLVMContext &C, Instruction *InsertBefore = nullptr);
   explicit UnreachableInst(LLVMContext &C, BasicBlock *InsertAtEnd);
 
   // allocate space for exactly zero operands
   void *operator new(size_t s) {
     return User::operator new(s, 0);
   }

 
 //===----------------------------------------------------------------------===//
 //                                 TruncInst Class
 //===----------------------------------------------------------------------===//
 
 /// This class represents a truncation of integer types.
 class TruncInst : public CastInst {
 protected:
-  // Note: Instruction needs to be a friend here to call cloneImpl.
+  // Note: Instruction needs to be a friend here to call cloneImpl and
+  // compareInstSpecificProperties.
   friend class Instruction;
 
   /// Clone an identical TruncInst
   TruncInst *cloneImpl() const;
 
+  int compareInstSpecificProperties(const TruncInst *I) const;
+
 public:
   /// Constructor with insert-before-instruction 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
     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
   );
 
   /// 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));
   }
 };
 
 //===----------------------------------------------------------------------===//
 //                                 ZExtInst Class
 //===----------------------------------------------------------------------===//
 
 /// This class represents zero extension of integer types.
 class ZExtInst : public CastInst {
 protected:
-  // Note: Instruction needs to be a friend here to call cloneImpl.
+  // Note: Instruction needs to be a friend here to call cloneImpl and
+  // compareInstSpecificProperties.
   friend class Instruction;
 
   /// Clone an identical ZExtInst
   ZExtInst *cloneImpl() const;
 
+  int compareInstSpecificProperties(const ZExtInst *I) const;
+
 public:
   /// Constructor with insert-before-instruction 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
     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
   );
 
   /// 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));
   }
 };
 
 //===----------------------------------------------------------------------===//
 //                                 SExtInst Class
 //===----------------------------------------------------------------------===//
 
 /// This class represents a sign extension of integer types.
 class SExtInst : public CastInst {
 protected:
-  // Note: Instruction needs to be a friend here to call cloneImpl.
+  // Note: Instruction needs to be a friend here to call cloneImpl and
+  // compareInstSpecificProperties.
   friend class Instruction;
 
   /// Clone an identical SExtInst
   SExtInst *cloneImpl() const;
 
+  int compareInstSpecificProperties(const SExtInst *I) const;
+
 public:
   /// Constructor with insert-before-instruction 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
     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
   );
 
   /// 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 Class
 //===----------------------------------------------------------------------===//
 
 /// This class represents a truncation of floating point types.
 class FPTruncInst : public CastInst {
 protected:
-  // Note: Instruction needs to be a friend here to call cloneImpl.
+  // Note: Instruction needs to be a friend here to call cloneImpl and
+  // compareInstSpecificProperties.
   friend class Instruction;
 
   /// Clone an identical FPTruncInst
   FPTruncInst *cloneImpl() const;
 
+  int compareInstSpecificProperties(const FPTruncInst *I) const;
+
 public:
   /// Constructor with insert-before-instruction semantics
   FPTruncInst(
     Value *S,                           ///< The value to be truncated
     Type *Ty,                           ///< The type to truncate to
     const Twine &NameStr = "",          ///< A name for the new instruction
     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
   );
 
   /// 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 Class
 //===----------------------------------------------------------------------===//
 
 /// This class represents an extension of floating point types.
 class FPExtInst : public CastInst {
 protected:
-  // Note: Instruction needs to be a friend here to call cloneImpl.
+  // Note: Instruction needs to be a friend here to call cloneImpl and
+  // compareInstSpecificProperties.
   friend class Instruction;
 
   /// Clone an identical FPExtInst
   FPExtInst *cloneImpl() const;
 
+  int compareInstSpecificProperties(const FPExtInst *I) const;
+
 public:
   /// Constructor with insert-before-instruction 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
     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
   );
 
   /// 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 Class
 //===----------------------------------------------------------------------===//
 
 /// This class represents a cast unsigned integer to floating point.
 class UIToFPInst : public CastInst {
 protected:
-  // Note: Instruction needs to be a friend here to call cloneImpl.
+  // Note: Instruction needs to be a friend here to call cloneImpl and
+  // compareInstSpecificProperties.
   friend class Instruction;
 
   /// Clone an identical UIToFPInst
   UIToFPInst *cloneImpl() const;
 
+  int compareInstSpecificProperties(const UIToFPInst *I) const;
+
 public:
   /// Constructor with insert-before-instruction 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
     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
   );
 
   /// 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 Class
 //===----------------------------------------------------------------------===//
 
 /// This class represents a cast from signed integer to floating point.
 class SIToFPInst : public CastInst {
 protected:
-  // Note: Instruction needs to be a friend here to call cloneImpl.
+  // Note: Instruction needs to be a friend here to call cloneImpl and
+  // compareInstSpecificProperties.
   friend class Instruction;
 
   /// Clone an identical SIToFPInst
   SIToFPInst *cloneImpl() const;
 
+  int compareInstSpecificProperties(const SIToFPInst *I) const;
+
 public:
   /// Constructor with insert-before-instruction 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
     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
   );
 
   /// 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));
   }
 };
 
 //===----------------------------------------------------------------------===//
 //                                 FPToUIInst Class
 //===----------------------------------------------------------------------===//
 
 /// This class represents a cast from floating point to unsigned integer
 class FPToUIInst  : public CastInst {
 protected:
-  // Note: Instruction needs to be a friend here to call cloneImpl.
+  // Note: Instruction needs to be a friend here to call cloneImpl and
+  // compareInstSpecificProperties.
   friend class Instruction;
 
   /// Clone an identical FPToUIInst
   FPToUIInst *cloneImpl() const;
 
+  int compareInstSpecificProperties(const FPToUIInst *I) const;
+
 public:
   /// Constructor with insert-before-instruction 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
     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
   );
 
   /// 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 Class
 //===----------------------------------------------------------------------===//
 
 /// This class represents a cast from floating point to signed integer.
 class FPToSIInst  : public CastInst {
 protected:
-  // Note: Instruction needs to be a friend here to call cloneImpl.
+  // Note: Instruction needs to be a friend here to call cloneImpl and
+  // compareInstSpecificProperties.
   friend class Instruction;
 
   /// Clone an identical FPToSIInst
   FPToSIInst *cloneImpl() const;
 
+  int compareInstSpecificProperties(const FPToSIInst *I) const;
+
 public:
   /// Constructor with insert-before-instruction 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
     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
   );
 
   /// 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));
   }
 };
 
 //===----------------------------------------------------------------------===//
 //                                 IntToPtrInst Class
 //===----------------------------------------------------------------------===//
 
 /// This class represents a cast from an integer to a pointer.
 class IntToPtrInst : public CastInst {
+protected:
+  // Note: Instruction needs to be a friend here to call
+  // compareInstSpecificProperties.
+  friend class Instruction;
+
+  int compareInstSpecificProperties(const IntToPtrInst *I) const;
+
 public:
   // Note: Instruction needs to be a friend here to call cloneImpl.
   friend class Instruction;
 
   /// Constructor with insert-before-instruction semantics
   IntToPtrInst(
     Value *S,                           ///< The value to be converted
     Type *Ty,                           ///< The type to convert to

 
 //===----------------------------------------------------------------------===//
 //                                 PtrToIntInst Class
 //===----------------------------------------------------------------------===//
 
 /// This class represents a cast from a pointer to an integer.
 class PtrToIntInst : public CastInst {
 protected:
-  // Note: Instruction needs to be a friend here to call cloneImpl.
+  // Note: Instruction needs to be a friend here to call cloneImpl and
+  // compareInstSpecificProperties.
   friend class Instruction;
 
   /// Clone an identical PtrToIntInst.
   PtrToIntInst *cloneImpl() const;
 
+  int compareInstSpecificProperties(const PtrToIntInst *I) const;
+
 public:
   /// Constructor with insert-before-instruction semantics
   PtrToIntInst(
     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
   );

 
 //===----------------------------------------------------------------------===//
 //                             BitCastInst Class
 //===----------------------------------------------------------------------===//
 
 /// This class represents a no-op cast from one type to another.
 class BitCastInst : public CastInst {
 protected:
-  // Note: Instruction needs to be a friend here to call cloneImpl.
+  // Note: Instruction needs to be a friend here to call cloneImpl and
+  // compareInstSpecificProperties.
   friend class Instruction;
 
   /// Clone an identical BitCastInst.
   BitCastInst *cloneImpl() const;
 
+  int compareInstSpecificProperties(const BitCastInst *I) const;
+
 public:
   /// Constructor with insert-before-instruction 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
     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
   );
 
   // 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 Class
 //===----------------------------------------------------------------------===//
 
 /// This class represents a conversion between pointers from one address space
 /// to another.
 class AddrSpaceCastInst : public CastInst {
 protected:
-  // Note: Instruction needs to be a friend here to call cloneImpl.
+  // Note: Instruction needs to be a friend here to call cloneImpl and
+  // compareInstSpecificProperties.
   friend class Instruction;
 
   /// Clone an identical AddrSpaceCastInst.
   AddrSpaceCastInst *cloneImpl() const;
 
+  int compareInstSpecificProperties(const AddrSpaceCastInst *I) const;
+
 public:
   /// Constructor with insert-before-instruction 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
     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
   );
 
   // 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));

 //===----------------------------------------------------------------------===//
 //                              FreezeInst Class
 //===----------------------------------------------------------------------===//
 
 /// This class represents a freeze function that returns random concrete
 /// value if an operand is either a poison value or an undef value
 class FreezeInst : public UnaryInstruction {
 protected:
-  // Note: Instruction needs to be a friend here to call cloneImpl.
+  // Note: Instruction needs to be a friend here to call cloneImpl and
+  // compareInstSpecificProperties.
   friend class Instruction;
 
   /// Clone an identical FreezeInst
   FreezeInst *cloneImpl() const;
 
+  int compareInstSpecificProperties(const FreezeInst *I) const;
+
 public:
   explicit FreezeInst(Value *S,
                       const Twine &NameStr = "",
                       Instruction *InsertBefore = nullptr);
   FreezeInst(Value *S, const Twine &NameStr, BasicBlock *InsertAtEnd);
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const Instruction *I) {

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.
+/// Flags can be used to switch on/off consideration of
+/// Alignment and MetaData in comparison.
+int Instruction::compareSpecialState(const Instruction *I1,
+                                     unsigned Flags) const {
+  assert(getOpcode() == I1->getOpcode() &&
          "Can not compare special state of different instructions");
+  assert(getNumOperands() == I1->getNumOperands() &&
+         "Can not compare special state of instructions with different number "
+         "of operands");
+
+  IgnoreAlignment CmpIgnoringAlignment = (Flags & CompareIgnoringAlignment) != 0
+                                             ? IgnoreAlignment::Yes
+                                             : IgnoreAlignment::No;
+  IgnoreMetaData CmpIgnoringMetaData = (Flags & CompareIgnoringMetaData) != 0
+                                           ? IgnoreMetaData::Yes
+                                           : IgnoreMetaData::No;
 
-  if (const AllocaInst *AI = dyn_cast<AllocaInst>(I1))
-    return AI->getAllocatedType() == cast<AllocaInst>(I2)->getAllocatedType() &&
-           (AI->getAlignment() == cast<AllocaInst>(I2)->getAlignment() ||
-            IgnoreAlignment);
-  if (const LoadInst *LI = dyn_cast<LoadInst>(I1))
-    return LI->isVolatile() == cast<LoadInst>(I2)->isVolatile() &&
-           (LI->getAlignment() == cast<LoadInst>(I2)->getAlignment() ||
-            IgnoreAlignment) &&
-           LI->getOrdering() == cast<LoadInst>(I2)->getOrdering() &&
-           LI->getSyncScopeID() == cast<LoadInst>(I2)->getSyncScopeID();
-  if (const StoreInst *SI = dyn_cast<StoreInst>(I1))
-    return SI->isVolatile() == cast<StoreInst>(I2)->isVolatile() &&
-           (SI->getAlignment() == cast<StoreInst>(I2)->getAlignment() ||
-            IgnoreAlignment) &&
-           SI->getOrdering() == cast<StoreInst>(I2)->getOrdering() &&
-           SI->getSyncScopeID() == cast<StoreInst>(I2)->getSyncScopeID();
-  if (const CmpInst *CI = dyn_cast<CmpInst>(I1))
-    return CI->getPredicate() == cast<CmpInst>(I2)->getPredicate();
-  if (const CallInst *CI = dyn_cast<CallInst>(I1))
-    return CI->isTailCall() == cast<CallInst>(I2)->isTailCall() &&
-           CI->getCallingConv() == cast<CallInst>(I2)->getCallingConv() &&
-           CI->getAttributes() == cast<CallInst>(I2)->getAttributes() &&
-           CI->hasIdenticalOperandBundleSchema(*cast<CallInst>(I2));
-  if (const InvokeInst *CI = dyn_cast<InvokeInst>(I1))
-    return CI->getCallingConv() == cast<InvokeInst>(I2)->getCallingConv() &&
-           CI->getAttributes() == cast<InvokeInst>(I2)->getAttributes() &&
-           CI->hasIdenticalOperandBundleSchema(*cast<InvokeInst>(I2));
-  if (const CallBrInst *CI = dyn_cast<CallBrInst>(I1))
-    return CI->getCallingConv() == cast<CallBrInst>(I2)->getCallingConv() &&
-           CI->getAttributes() == cast<CallBrInst>(I2)->getAttributes() &&
-           CI->hasIdenticalOperandBundleSchema(*cast<CallBrInst>(I2));
-  if (const InsertValueInst *IVI = dyn_cast<InsertValueInst>(I1))
-    return IVI->getIndices() == cast<InsertValueInst>(I2)->getIndices();
-  if (const ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(I1))
-    return EVI->getIndices() == cast<ExtractValueInst>(I2)->getIndices();
-  if (const FenceInst *FI = dyn_cast<FenceInst>(I1))
-    return FI->getOrdering() == cast<FenceInst>(I2)->getOrdering() &&
-           FI->getSyncScopeID() == cast<FenceInst>(I2)->getSyncScopeID();
-  if (const AtomicCmpXchgInst *CXI = dyn_cast<AtomicCmpXchgInst>(I1))
-    return CXI->isVolatile() == cast<AtomicCmpXchgInst>(I2)->isVolatile() &&
-           CXI->isWeak() == cast<AtomicCmpXchgInst>(I2)->isWeak() &&
-           CXI->getSuccessOrdering() ==
-               cast<AtomicCmpXchgInst>(I2)->getSuccessOrdering() &&
-           CXI->getFailureOrdering() ==
-               cast<AtomicCmpXchgInst>(I2)->getFailureOrdering() &&
-           CXI->getSyncScopeID() ==
-               cast<AtomicCmpXchgInst>(I2)->getSyncScopeID();
-  if (const AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(I1))
-    return RMWI->getOperation() == cast<AtomicRMWInst>(I2)->getOperation() &&
-           RMWI->isVolatile() == cast<AtomicRMWInst>(I2)->isVolatile() &&
-           RMWI->getOrdering() == cast<AtomicRMWInst>(I2)->getOrdering() &&
-           RMWI->getSyncScopeID() == cast<AtomicRMWInst>(I2)->getSyncScopeID();
-  if (const ShuffleVectorInst *SVI = dyn_cast<ShuffleVectorInst>(I1))
-    return SVI->getShuffleMask() ==
-           cast<ShuffleVectorInst>(I2)->getShuffleMask();
-
-  return true;
+  switch (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("Instructions to compare are unknown");
+  case Instruction::Alloca: {
+    const AllocaInst *AI = cast<AllocaInst>(this);
+    return AI->compareInstSpecificProperties(cast<AllocaInst>(I1),
+                                             CmpIgnoringAlignment);
+  }
+  case Instruction::Load: {
+    const LoadInst *LI = cast<LoadInst>(this);
+    return LI->compareInstSpecificProperties(
+        cast<LoadInst>(I1), CmpIgnoringAlignment, CmpIgnoringMetaData);
+  }
+  case Instruction::Store: {
+    const StoreInst *SI = cast<StoreInst>(this);
+    return SI->compareInstSpecificProperties(cast<StoreInst>(I1),
+                                             CmpIgnoringAlignment);
+  }
+  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),
+                                             CmpIgnoringMetaData);
+  }
+  case Instruction::Invoke: {
+    const InvokeInst *II = cast<InvokeInst>(this);
+    return II->compareInstSpecificProperties(cast<InvokeInst>(I1),
+                                             CmpIgnoringMetaData);
+  }
+  case Instruction::CallBr: {
+    const CallBrInst *CBI = cast<CallBrInst>(this);
+    return CBI->compareInstSpecificProperties(cast<CallBrInst>(I1),
+                                              CmpIgnoringMetaData);
+  }
+  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 (L == R)
+    return 0;
+  if (L)
+    return 1;
+  return -1;
+}
+
+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 (L.getBitWidth() == R.getBitWidth()) {
+    if (L.ugt(R))
+      return 1;
+    if (R.ugt(L))
+      return -1;
+    return 0;
+  } else if (L.getBitWidth() > R.getBitWidth()) {
+    if (L.ugt(R.zext(L.getBitWidth())))
+      return 1;
+    if (R.zext(L.getBitWidth()).ugt(L))
+      return -1;
+    return 0;
+  } else {
+    if (L.zext(R.getBitWidth()).ugt(R))
+      return 1;
+    if (R.ugt(L.zext(L.getBitWidth())))
+      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) {
+  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: {
+    PointerType *PTyL = dyn_cast<PointerType>(TyL);
+    PointerType *PTyR = dyn_cast<PointerType>(TyR);
+    assert(PTyL && PTyR && "Both types must be pointers here.");
+    if (PTyL->getAddressSpace() != PTyR->getAddressSpace())
+      return compareIntegers(PTyL->getAddressSpace(), PTyR->getAddressSpace());
+    // Comparing the element types of both the pointers.
+    return compareTypes(PTyL->getElementType(), PTyR->getElementType());
+  }
+
+  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, IgnoreMetaData CmpIgnoringMetaData) 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 (CmpIgnoringMetaData == IgnoreMetaData::No)
+    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, IgnoreMetaData CmpIgnoringMetaData) const {
+  if (int Res = compareIntegers(getCallingConv(), I->getCallingConv()))
+    return Res;
+  if (int Res = compareAttrs(getAttributes(), I->getAttributes()))
+    return Res;
+  if (CmpIgnoringMetaData == IgnoreMetaData::No)
+    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, IgnoreMetaData CmpIgnoringMetaData) const {
+  if (int Res = compareIntegers(getCallingConv(), I->getCallingConv()))
+    return Res;
+  if (int Res = compareAttrs(getAttributes(), I->getAttributes()))
+    return Res;
+  if (CmpIgnoringMetaData == IgnoreMetaData::No)
+    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, IgnoreAlignment CmpIgnoringAlignment) const {
+  if (CmpIgnoringAlignment == IgnoreAlignment::No)
+    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, IgnoreAlignment CmpIgnoringAlignment,
+    IgnoreMetaData CmpIgnoringMetaData) const {
+  if (int Res = compareIntegers(isVolatile(), LI->isVolatile()))
+    return Res;
+  if (CmpIgnoringAlignment == IgnoreAlignment::No)
+    if (int Res = compareIntegers(getAlignment(), LI->getAlignment()))
+      return Res;
+  if (int Res = compareOrderings(getOrdering(), LI->getOrdering()))
+    return Res;
+  if (CmpIgnoringMetaData == IgnoreMetaData::No)
+    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, IgnoreAlignment CmpIgnoringAlignment) const {
+  if (int Res = compareIntegers(isVolatile(), SI->isVolatile()))
+    return Res;
+  if (CmpIgnoringAlignment == IgnoreAlignment::No)
+    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");
 }
 
-ZExtInst::ZExtInst(
-  Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
-)  : CastInst(Ty, ZExt, S, Name, InsertBefore) {
+// 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");
 }
-SExtInst::SExtInst(
-  Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
-) : CastInst(Ty, SExt, S, Name, InsertBefore) {
+
+// 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");
 }
 
-FPTruncInst::FPTruncInst(
-  Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
-) : CastInst(Ty, FPTrunc, S, Name, InsertBefore) {
+// 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");
 }
 
-PtrToIntInst::PtrToIntInst(
-  Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
-) : CastInst(Ty, PtrToInt, S, Name, InsertBefore) {
+// 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");
 }
 
-IntToPtrInst::IntToPtrInst(
-  Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
-) : CastInst(Ty, IntToPtr, S, Name, InsertBefore) {
+// 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");
 }
 
-BitCastInst::BitCastInst(
-  Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
-) : CastInst(Ty, BitCast, S, Name, InsertBefore) {
+// 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");
 }
 
-AddrSpaceCastInst::AddrSpaceCastInst(
-  Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
-) : CastInst(Ty, AddrSpaceCast, S, Name, InsertBefore) {
+// 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;
for (unsigned i = 0, E = IBI.getNumOperands(); i != E; ++i)
     OL[i] = InOL[i];
   SubclassOptionalData = IBI.SubclassOptionalData;
 }
 
 /// addDestination - Add a destination.
 ///
 void IndirectBrInst::addDestination(BasicBlock *DestBB) {
   unsigned OpNo = getNumOperands();
-  if (OpNo+1 > ReservedSpace)
-    growOperands();  // Get more space!
+  if (OpNo + 1 > ReservedSpace)
+    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,
   // We have two instructions of identical opcode and #operands.  Check to see
   // 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.
+  // Check special state of some instructions which need a different treatment
+  // compared to that specified in their compareInstSpecificProperties() method.
   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;
-    }
+            cmpNumbers(AI->getAlignment(), cast<AllocaInst>(R)->getAlignment()))
+    // The cmpTypes function differs from that used by
+    // compareInstSpecificProperties() method.
+    return cmpTypes(AI->getAllocatedType(),
+                    cast<AllocaInst>(R)->getAllocatedType());
   }
   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();

llvm/test/Transforms/MergeFunc/gep-base-type.ll

; CHECK-NEXT: ret
   %2 = getelementptr inbounds %"struct2", %"struct2"* %P, i64 %i
   %3 = getelementptr inbounds %"struct2", %"struct2"* %P, i64 %i
   %4 = getelementptr inbounds %"struct2", %"struct2"* %P, i64 %i
   %5 = getelementptr inbounds %"struct2", %"struct2"* %P, i64 %i
   %6 = getelementptr inbounds %"struct2", %"struct2"* %P, i64 %i
   ret %struct2* %6
 }
 
-
 define internal %struct1* @Gfunc(%struct1* %P, i64 %i) {
 ; CHECK-LABEL: @Gfunc(
 ; CHECK-NEXT: getelementptr
 ; CHECK-NEXT: getelementptr
 ; CHECK-NEXT: getelementptr
 ; CHECK-NEXT: getelementptr
 ; CHECK-NEXT: getelementptr
 ; CHECK-NEXT: getelementptr
 ; CHECK-NEXT: ret
   %1 = getelementptr inbounds %"struct1", %"struct1"* %P, i64 %i
   %2 = getelementptr inbounds %"struct1", %"struct1"* %P, i64 %i
   %3 = getelementptr inbounds %"struct1", %"struct1"* %P, i64 %i
   %4 = getelementptr inbounds %"struct1", %"struct1"* %P, i64 %i
   %5 = getelementptr inbounds %"struct1", %"struct1"* %P, i64 %i
   %6 = getelementptr inbounds %"struct1", %"struct1"* %P, i64 %i
   ret %struct1* %6
 }
-

llvm/test/Transforms/MergeFunc/ir-cmp-alloca1.ll

+; RUN: opt -mergefunc -S < %s | FileCheck %s
+
+;; Make sure that two different allocas are not treated as equal.
+
+target datalayout = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32"
+
+%kv1 = type { i32, i32* }
+%kv2 = type { i8 }
+%kv3 = type { i64, i64* }
+
+; Size difference.
+
+; CHECK-LABEL: define void @size1
+; CHECK-NOT: call void @
+define void @size1(i8 *%f) {
+  %v = alloca %kv1, align 8
+  %f_2 = bitcast i8* %f to void (%kv1 *)*
+  call void %f_2(%kv1 * %v)
+  call void %f_2(%kv1 * %v)
+  call void %f_2(%kv1 * %v)
+  call void %f_2(%kv1 * %v)
+  ret void
+}
+
+; CHECK-LABEL: define void @size2
+; CHECK-NOT: call void @
+define void @size2(i8 *%f) {
+  %v = alloca %kv2, align 8
+  %f_2 = bitcast i8* %f to void (%kv2 *)*
+  call void %f_2(%kv2 * %v)
+  call void %f_2(%kv2 * %v)
+  call void %f_2(%kv2 * %v)
+  call void %f_2(%kv2 * %v)
+  ret void
+}
+
+; Alignment difference.
+
+; CHECK-LABEL: define void @align1
+; CHECK-NOT: call void @
+define void @align1(i8 *%f) {
+  %v = alloca %kv3, align 8
+  %f_2 = bitcast i8* %f to void (%kv3 *)*
+  call void %f_2(%kv3 * %v)
+  call void %f_2(%kv3 * %v)
+  call void %f_2(%kv3 * %v)
+  call void %f_2(%kv3 * %v)
+  ret void
+}
+
+; CHECK-LABEL: define void @align2
+; CHECK-NOT: call void @
+define void @align2(i8 *%f) {
+  %v = alloca %kv3, align 16
+  %f_2 = bitcast i8* %f to void (%kv3 *)*
+  call void %f_2(%kv3 * %v)
+  call void %f_2(%kv3 * %v)
+  call void %f_2(%kv3 * %v)
+  call void %f_2(%kv3 * %v)
+  ret void
+}

llvm/test/Transforms/MergeFunc/ir-cmp-alloca2.ll

+; RUN: opt -mergefunc -S < %s | FileCheck %s
+
+;; Make sure that two same allocas are treated as equal.
+
+target datalayout = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32"
+
+%kv1 = type {i8*, i32*}
+%kv2 = type {i64*, float*}
+%kv3 = type {i64}
+
+;; Checks if pointer types of different element types, bitwidth of integer types and alignment are considered equal by
+;; MergeFunctions and merges both functions
+
+; CHECK-LABEL: define void @size1
+; CHECK-NOT: call void @
+define void @size1(i8 *%f) {
+  %v = alloca %kv1, align 8
+  %f_2 = bitcast i8* %f to void (%kv1 *)*
+  call void %f_2(%kv1 * %v)
+  %u = alloca %kv3, align 16
+  %f_3 = bitcast i8* %f to void (%kv3 *)*
+  call void %f_3(%kv3 * %u)
+  ret void
+}
+
+; CHECK-LABEL: define void @size2
+; CHECK: call void @
+define void @size2(i8 *%f) {
+  %v = alloca %kv2, align 8
+  %f_2 = bitcast i8* %f to void (%kv2 *)*
+  call void %f_2(%kv2 * %v)
+  %u = alloca %kv3, align 16
+  %f_3 = bitcast i8* %f to void (%kv3 *)*
+  call void %f_3(%kv3 * %u)
+  ret void
+}

llvm/test/Transforms/MergeFunc/ir-cmp-atomicrmw1.ll

+; RUN: opt -mergefunc -S < %s | FileCheck %s
+
+;; Make sure that two different AtomicRMW Insts are not treated as equal.
+
+target datalayout = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32"
+
+;; Operation difference
+
+; CHECK-LABEL: define void @f1
+; CHECK-NOT: call void @
+define void @f1(i32*) {
+  %old = atomicrmw add i32* %0, i32 1 acquire
+  %inc = add nsw i32 %old, 1
+  %val = load i32, i32* %0, align 4
+  %eq = icmp eq i32 %inc, %val
+  ret void
+}
+
+; CHECK-LABEL: define void @f2
+; CHECK-NOT: call void @
+define void @f2(i32*) {
+  %old = atomicrmw sub i32* %0, i32 1 acquire
+  %inc = add nsw i32 %old, 1
+  %val = load i32, i32* %0, align 4
+  %eq = icmp eq i32 %inc, %val
+  ret void
+}
+
+;; Volatile difference
+
+; CHECK-LABEL: define void @f3
+; CHECK-NOT: call void @
+define void @f3(i32*) {
+  %old = atomicrmw volatile add i32* %0, i32 1 monotonic
+  %inc = add nsw i32 %old, 1
+  %val = load i32, i32* %0, align 4
+  %eq = icmp eq i32 %inc, %val
+  ret void
+}
+
+; CHECK-LABEL: define void @f4
+; CHECK-NOT: call void @
+define void @f4(i32*) {
+  %old = atomicrmw add i32* %0, i32 1 monotonic
+  %inc = add nsw i32 %old, 1
+  %val = load i32, i32* %0, align 4
+  %eq = icmp eq i32 %inc, %val
+  ret void
+}
+
+;; Ordering difference
+
+; CHECK-LABEL: define void @f5
+; CHECK-NOT: call void @
+define void @f5(i32*) {
+  %old = atomicrmw sub i32* %0, i32 1 acquire
+  %dec = sub nsw i32 %old, 1
+  %val = load i32, i32* %0, align 4
+  %eq = icmp eq i32 %dec, %val
+  ret void
+}
+
+; CHECK-LABEL: define void @f6
+; CHECK-NOT: call void @
+define void @f6(i32*) {
+  %old = atomicrmw sub i32* %0, i32 1 release
+  %dec = sub nsw i32 %old, 1
+  %val = load i32, i32* %0, align 4
+  %eq = icmp eq i32 %dec, %val
+  ret void
+}
+
+;; SyncScopeID difference
+
+; CHECK-LABEL: define void @f7
+; CHECK-NOT: call void @
+define void @f7(i32*) {
+  %old = atomicrmw add i32* %0, i32 1 syncscope("<target-scope>") acquire
+  %inc = add nsw i32 %old, 1
+  %val = load i32, i32* %0, align 4
+  %eq = icmp eq i32 %inc, %val
+  ret void
+}
+
+; CHECK-LABEL: define void @f8
+; CHECK-NOT: call void @
+define void @f8(i32*) {
+  %old = atomicrmw add i32* %0, i32 1 syncscope("singlethread") acquire
+  %inc = add nsw i32 %old, 1
+  %val = load i32, i32* %0, align 4
+  %eq = icmp eq i32 %inc, %val
+  ret void
+}

llvm/test/Transforms/MergeFunc/ir-cmp-atomicrmw2.ll

+; RUN: opt -mergefunc -S < %s | FileCheck %s
+
+;; Make sure that two same AtomicRMW Insts are treated as equal.
+
+target datalayout = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32"
+
+;; Operation, Volatility, Ordering, SyncScopeID are considered during comparison
+
+; CHECK-LABEL: define void @f1
+; CHECK-NOT: call void @
+define void @f1(i32*) {
+  %old = atomicrmw volatile add i32* %0, i32 1 syncscope("<target-scope>") acquire
+  %inc = add nsw i32 %old, 1
+  %val = load i32, i32* %0, align 4
+  %eq = icmp eq i32 %inc, %val
+  ret void
+}
+
+; CHECK-LABEL: define void @f2
+; CHECK: call void @
+define void @f2(i32*) {
+  %old = atomicrmw volatile add i32* %0, i32 1 syncscope("<target-scope>") acquire
+  %inc = add nsw i32 %old, 1
+  %val = load i32, i32* %0, align 4
+  %eq = icmp eq i32 %inc, %val
+  ret void
+}
+

llvm/test/Transforms/MergeFunc/ir-cmp-binOp.ll

+; RUN: opt -mergefunc -S < %s | FileCheck %s
+
+;; Make sure that two same BinaryOperator are treated as equal.
+
+target datalayout = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32"
+
+;; Currently there is no special state being checked for comparison of BinaryOperator Instructions.
+
+; CHECK-LABEL: define void @f1
+; CHECK-NOT: call void @
+define void @f1(i32 %m, i32 %n, float %u, float %v) {
+  %1 = add nsw i32 %m, %n
+  %2 = sub nsw i32 %m, %n
+  %3 = mul nsw i32 %m, %n
+  %4 = udiv i32 %m, %n
+  %5 = sdiv i32 %m, %n
+  %6 = urem i32 %m, %n
+  %7 = srem i32 %m, %n
+  %8 = shl nsw i32 %m, %n
+  %9 = lshr i32 %m, %n
+  %10 = ashr i32 %m, %n
+  %11 = and i32 %m, %n
+  %12 = or i32 %m, %n
+  %13 = xor i32 %m, %n
+  %14 = fadd float %u, %v
+  %15 = fsub float %u, %v
+  %16 = fmul float %u, %v
+  %17 = fdiv float %u, %v
+  %18 = frem float %u, %v
+  ret void
+}
+
+; CHECK-LABEL: define void @f2
+; CHECK: call void @
+define void @f2(i32 %m, i32 %n, float %u, float %v) {
+  %1 = add nsw i32 %m, %n
+  %2 = sub nsw i32 %m, %n
+  %3 = mul nsw i32 %m, %n
+  %4 = udiv i32 %m, %n
+  %5 = sdiv i32 %m, %n
+  %6 = urem i32 %m, %n
+  %7 = srem i32 %m, %n
+  %8 = shl nsw i32 %m, %n
+  %9 = lshr i32 %m, %n
+  %10 = ashr i32 %m, %n
+  %11 = and i32 %m, %n
+  %12 = or i32 %m, %n
+  %13 = xor i32 %m, %n
+  %14 = fadd float %u, %v
+  %15 = fsub float %u, %v
+  %16 = fmul float %u, %v
+  %17 = fdiv float %u, %v
+  %18 = frem float %u, %v
+  ret void
+}

llvm/test/Transforms/MergeFunc/ir-cmp-br.ll

+; RUN: opt -mergefunc -S < %s | FileCheck %s
+
+;; Make sure that two same Branch Insts are treated as equal.
+
+target datalayout = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32"
+
+; There is no special state being checked for Branch instructions currently.
+
+; CHECK-LABEL: define i32 @f1
+; CHECK-NOT: call i32 @
+define i32 @f1(i32 %n, i32 %m) nounwind {
+entry:
+  %0 = icmp eq i32 %n, %n
+  br i1 %0, label %bb1, label %bb2
+
+bb1:
+  br label %bb3
+
+bb2:
+  ret i32 1
+
+bb3:
+  ret i32 0
+}
+
+; CHECK-LABEL: define i32 @f2
+; CHECK: call i32 @
+define i32 @f2(i32 %n, i32 %m) nounwind {
+entry:
+  %0 = icmp eq i32 %n, %n
+  br i1 %0, label %bb1, label %bb2
+
+bb1:
+  br label %bb3
+
+bb2:
+  ret i32 1
+
+bb3:
+  ret i32 0
+}
 No newline at end of file

llvm/test/Transforms/MergeFunc/ir-cmp-call1.ll

+; RUN: opt -mergefunc -S < %s | FileCheck %s
+
+;; Make sure that two different Call Insts are not treated as equal.
+
+target datalayout = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32"
+
+;; Calling convention difference
+
+; CHECK-LABEL: define void @f1
+; CHECK-NOT: call void @
+define void @f1() {
+  %1 = call coldcc i8 @dummy(i8 0)
+  %2 = call i8 @dummy(i8 0)
+  %3 = call i8 @dummy(i8 0)
+  %4 = call i8 @dummy(i8 0)
+  %5 = call i8 @dummy(i8 0)
+  ret void
+}
+
+; CHECK-LABEL: define void @f2
+; CHECK-NOT: call void @
+define void @f2() {
+  %1 = call fastcc i8 @dummy(i8 0)
+  %2 = call i8 @dummy(i8 0)
+  %3 = call i8 @dummy(i8 0)
+  %4 = call i8 @dummy(i8 0)
+  %5 = call i8 @dummy(i8 0)
+  ret void
+}
+
+;; Parameter Attributes difference
+
+; CHECK-LABEL: define void @f3
+; CHECK-NOT: call void @
+define void @f3() {
+  %1 = call i8 @dummy(i8 0)
+  %2 = call i8 @dummy(i8 inreg 0)
+  %3 = call i8 @dummy(i8 0)
+  %4 = call i8 @dummy(i8 0)
+  %5 = call i8 @dummy(i8 0)
+  ret void
+}
+
+; CHECK-LABEL: define void @f4
+; CHECK-NOT: call void @
+define void @f4() {
+  %1 = call i8 @dummy(i8 0)
+  %2 = call i8 @dummy(i8 zeroext 0)
+  %3 = call i8 @dummy(i8 0)
+  %4 = call i8 @dummy(i8 0)
+  %5 = call i8 @dummy(i8 0)
+  ret void
+}
+
+;; Operand Bundle Schema Difference
+
+; CHECK-LABEL: define void @f5
+; CHECK-NOT: call void @
+define void @f5() {
+  %1 = call i8 @dummy(i8 0) ["unknown"(i8 0)]
+  %2 = call i8 @dummy(i8 0)
+  %3 = call i8 @dummy(i8 0)
+  %4 = call i8 @dummy(i8 0)
+  %5 = call i8 @dummy(i8 0)
+  ret void
+}
+
+; CHECK-LABEL: define void @f6
+; CHECK-NOT: call void @
+define void @f6() {
+  %1 = call i8 @dummy(i8 0) ["unknown"(i8 0, i8 1)]
+  %2 = call i8 @dummy(i8 0)
+  %3 = call i8 @dummy(i8 0)
+  %4 = call i8 @dummy(i8 0)
+  %5 = call i8 @dummy(i8 0)
+  ret void
+}
+
+;; RangeMetaData Difference
+
+; CHECK-LABEL: define void @f7
+; CHECK-NOT: call void @
+define void @f7() {
+  %1 = call i8 @dummy(i8 0), !range !0
+  %2 = call i8 @dummy(i8 0)
+  %3 = call i8 @dummy(i8 0)
+  %4 = call i8 @dummy(i8 0)
+  %5 = call i8 @dummy(i8 0)
+  ret void
+}
+
+; CHECK-LABEL: define void @f8
+; CHECK-NOT: call void @
+define void @f8() {
+  %1 = call i8 @dummy(i8 0), !range !1
+  %2 = call i8 @dummy(i8 0)
+  %3 = call i8 @dummy(i8 0)
+  %4 = call i8 @dummy(i8 0)
+  %5 = call i8 @dummy(i8 0)
+  ret void
+}
+
+;; TailCallKind Difference
+
+; CHECK-LABEL: define void @f9
+; CHECK-NOT: call void @
+define void @f9() {
+  %1 = tail call i8 @dummy(i8 0)
+  %2 = call i8 @dummy(i8 0)
+  %3 = call i8 @dummy(i8 0)
+  %4 = call i8 @dummy(i8 0)
+  %5 = call i8 @dummy(i8 0)
+  ret void
+}
+
+; CHECK-LABEL: define void @f10
+; CHECK-NOT: call void @
+define void @f10() {
+  %1 = notail call i8 @dummy(i8 0)
+  %2 = call i8 @dummy(i8 0)
+  %3 = call i8 @dummy(i8 0)
+  %4 = call i8 @dummy(i8 0)
+  %5 = call i8 @dummy(i8 0)
+  ret void
+}
+
+!0 = !{i8 0, i8 5}
+!1 = !{i8 1, i8 7}
+
+declare i8 @dummy(i8);
 No newline at end of file

llvm/test/Transforms/MergeFunc/ir-cmp-call2.ll

+; RUN: opt -mergefunc -S < %s | FileCheck %s
+
+;; Make sure that two same Call Insts are treated as equal.
+
+target datalayout = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32"
+
+;; Calling convention, Parameter Attributes, OperandBundleSchema, RangeMetaData, TailCallKind are considered during comparison
+
+; CHECK-LABEL: define void @f1
+; CHECK-NOT: call void @
+define void @f1() {
+  %1 = tail call coldcc i8 @dummy(i8 inreg 0) ["some-bundle"(i8 1)], !range !0
+  %2 = call i8 @dummy(i8 0)
+  %3 = call i8 @dummy(i8 0)
+  ret void
+}
+
+; CHECK-LABEL: define void @f2
+; CHECK: call void @
+define void @f2() {
+  %1 = tail call coldcc i8 @dummy(i8 inreg 0) ["some-bundle"(i8 1)], !range !1
+  %2 = call i8 @dummy(i8 0)
+  %3 = call i8 @dummy(i8 0)
+  ret void
+}
+
+declare i8 @dummy(i8);
+
+!0 = !{i8 1, i8 5}
+!1 = !{i8 1, i8 5}
 No newline at end of file

llvm/test/Transforms/MergeFunc/ir-cmp-callbr1.ll

+; RUN: opt -mergefunc -S < %s | FileCheck %s
+
+;; Make sure that two different CallBr Insts are not treated as equal.
+
+target datalayout = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32"
+
+;; Calling convention difference
+
+; CHECK-LABEL: define void @f1
+; CHECK-NOT: call void @
+define void @f1(i64 %arg, i64* %arg1, i64 %arg2, i32* %arg3) {
+bb:
+  %tmp5 = or i64 %arg2, %arg
+  callbr fastcc void asm sideeffect "", "X,X"(i8* blockaddress(@f1, %bb2), i8* blockaddress(@f1, %bb3))
+          to label %bb1 [label %bb2, label %bb3]
+
+bb1:                                         
+  br label %bb2
+
+bb2:                                             
+  %tmp8 = trunc i64 %tmp5 to i32
+  br label %bb3
+
+bb3:                                              
+  %tmp10 = trunc i64 %tmp5 to i32
+  store i32 %tmp10, i32* %arg3
+  ret void                      
+  
+}
+
+; CHECK-LABEL: define void @f2
+; CHECK-NOT: call void @
+define void @f2(i64 %arg, i64* %arg1, i64 %arg2, i32* %arg3) {
+bb:
+  %tmp5 = or i64 %arg2, %arg
+  callbr coldcc void asm sideeffect "", "X,X"(i8* blockaddress(@f2, %bb2), i8* blockaddress(@f2, %bb3))
+          to label %bb1 [label %bb2, label %bb3]
+
+bb1:                                         
+  br label %bb2
+
+bb2:                                             
+  %tmp8 = trunc i64 %tmp5 to i32
+  br label %bb3
+
+bb3:                                              
+  %tmp10 = trunc i64 %tmp5 to i32
+  store i32 %tmp10, i32* %arg3
+  ret void                      
+  
+}
+
+;; OperandBundle Difference
+
+; CHECK-LABEL: define void @f3
+; CHECK-NOT: call void @
+define void @f3(i64 %arg, i64* %arg1, i64 %arg2, i32* %arg3) {
+bb:
+  %tmp5 = or i64 %arg2, %arg
+  callbr void asm sideeffect "", "X,X"(i8* blockaddress(@f3, %bb2), i8* blockaddress(@f3, %bb3)) ["some-bundle"(i32 0)]
+          to label %bb1 [label %bb2, label %bb3]
+
+bb1:                                         
+  br label %bb2
+
+bb2:                                             
+  %tmp8 = trunc i64 %tmp5 to i32
+  br label %bb3
+
+bb3:                                              
+  %tmp10 = trunc i64 %tmp5 to i32
+  store i32 %tmp10, i32* %arg3
+  ret void                      
+}
+
+; CHECK-LABEL: define void @f4
+; CHECK-NOT: call void @
+define void @f4(i64 %arg, i64* %arg1, i64 %arg2, i32* %arg3) {
+bb:
+  %tmp5 = or i64 %arg2, %arg
+  callbr void asm sideeffect "", "X,X"(i8* blockaddress(@f4, %bb2), i8* blockaddress(@f4, %bb3)) ["unknown"(i32 1)]
+          to label %bb1 [label %bb2, label %bb3]
+
+bb1:                                         
+  br label %bb2
+
+bb2:                                             
+  %tmp8 = trunc i64 %tmp5 to i32
+  br label %bb3
+
+bb3:                                              
+  %tmp10 = trunc i64 %tmp5 to i32
+  store i32 %tmp10, i32* %arg3
+  ret void                      
+}
+

llvm/test/Transforms/MergeFunc/ir-cmp-callbr2.ll

+; RUN: opt -mergefunc -S < %s | FileCheck %s
+
+;; Make sure that two different CallBr Insts are not treated as equal.
+
+target datalayout = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32"
+
+;; Calling convention difference
+
+; CHECK-LABEL: define void @f1
+; CHECK-NOT: call void @
+define void @f1(i64 %arg, i64* %arg1, i64 %arg2, i32* %arg3) {
+bb:
+  %tmp5 = or i64 %arg2, %arg
+  callbr fastcc void asm sideeffect "", "X,X"(i8* blockaddress(@f1, %bb2), i8* blockaddress(@f1, %bb3)) ["unknown"(i32 2)]
+          to label %bb1 [label %bb2, label %bb3]
+
+bb1:                                         
+  br label %bb2
+
+bb2:                                             
+  %tmp8 = trunc i64 %tmp5 to i32
+  br label %bb3
+
+bb3:                                              
+  %tmp10 = trunc i64 %tmp5 to i32
+  store i32 %tmp10, i32* %arg3
+  ret void                      
+  
+}
+
+; CHECK-LABEL: define void @f2
+; CHECK: call void @
+define void @f2(i64 %arg, i64* %arg1, i64 %arg2, i32* %arg3) {
+bb:
+  %tmp5 = or i64 %arg2, %arg
+  callbr fastcc void asm sideeffect "", "X,X"(i8* blockaddress(@f2, %bb2), i8* blockaddress(@f2, %bb3)) ["unknown"(i32 2)]
+          to label %bb1 [label %bb2, label %bb3]
+
+bb1:                                         
+  br label %bb2
+
+bb2:                                             
+  %tmp8 = trunc i64 %tmp5 to i32
+  br label %bb3
+
+bb3:                                              
+  %tmp10 = trunc i64 %tmp5 to i32
+  store i32 %tmp10, i32* %arg3
+  ret void                      
+  
+}

llvm/test/Transforms/MergeFunc/ir-cmp-cast.ll

+; RUN: opt -mergefunc -S < %s | FileCheck %s
+
+;; Make sure that two same Cast Insts are treated as equal.
+
+target datalayout = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32"
+
+;; Currently there is no special state being checked for comparison of Cast Instructions.
+
+; CHECK-LABEL: define void @f1
+; CHECK-NOT: call void @
+define void @f1(i32 %m, i32* %n, double %u, float %v) {
+  %1 = trunc i32 %m to i16
+  %2 = zext i32 %m to i64
+  %3 = sext i32 %m to i64
+  %4 = fptrunc double %u to float
+  %5 = fpext float %v to double
+  %6 = fptoui float %v to i32
+  %7 = fptosi double %u to i32
+  %8 = uitofp i32 %m to float
+  %9 = sitofp i32 %m to double
+  %10 = ptrtoint i32* %n to i8
+  %11 = inttoptr i32 %m to i8*
+  %12 = bitcast i32 %m to <1 x i32>
+  %13 = addrspacecast i32* %n to i32 addrspace(1)* 
+  ret void
+}
+
+; CHECK-LABEL: define void @f2
+; CHECK: call void @
+define void @f2(i32 %m, i32* %n, double %u, float %v) {
+  %1 = trunc i32 %m to i16
+  %2 = zext i32 %m to i64
+  %3 = sext i32 %m to i64
+  %4 = fptrunc double %u to float
+  %5 = fpext float %v to double
+  %6 = fptoui float %v to i32
+  %7 = fptosi double %u to i32
+  %8 = uitofp i32 %m to float
+  %9 = sitofp i32 %m to double
+  %10 = ptrtoint i32* %n to i8
+  %11 = inttoptr i32 %m to i8*
+  %12 = bitcast i32 %m to <1 x i32>
+  %13 = addrspacecast i32* %n to i32 addrspace(1)* 
+  ret void
+}

llvm/test/Transforms/MergeFunc/ir-cmp-catchret-cleanuppad-catchpad.ll

+; RUN: opt -mergefunc -S < %s | FileCheck %s
+
+;; Make sure that two same CatchRet, CleanupPad, CatchPad Insts are treated as equal.
+
+target datalayout = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32"
+
+; There is no special state being checked for CatchRet, CleanupPad, CatchPad instructions currently.
+
+; CHECK-LABEL: define i32 @f1
+; CHECK-NOT: call i32 @
+define i32 @f1() personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
+entry:
+  invoke void @g()
+          to label %return unwind label %ehcleanup
+
+ehcleanup:                                       
+  %0 = cleanuppad within none []
+  cleanupret from %0 unwind label %catch.dispatch
+
+catch.dispatch:                                  
+  %cs1 = catchswitch within none [label %catch] unwind to caller
+
+catch:                                            
+  %1 = catchpad within %cs1 [i8* null, i32 u0x40, i8* null]
+  catchret from %1 to label %return
+
+return:                                          
+  %retval.0 = phi i32 [ 1, %catch ], [ 0, %entry ]
+  ret i32 %retval.0
+}
+
+; CHECK-LABEL: define i32 @f2
+; CHECK: call i32 @
+define i32 @f2() personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
+entry:
+  invoke void @g()
+          to label %return unwind label %ehcleanup
+
+ehcleanup:                                       
+  %0 = cleanuppad within none []
+  cleanupret from %0 unwind label %catch.dispatch
+
+catch.dispatch:                                  
+  %cs1 = catchswitch within none [label %catch] unwind to caller
+
+catch:                                            
+  %1 = catchpad within %cs1 [i8* null, i32 u0x40, i8* null]
+  catchret from %1 to label %return
+
+return:                                          
+  %retval.0 = phi i32 [ 1, %catch ], [ 0, %entry ]
+  ret i32 %retval.0
+}
+
+declare void @g()
+declare i32 @__CxxFrameHandler3(...)
 No newline at end of file

llvm/test/Transforms/MergeFunc/ir-cmp-catchswitch.ll

+; RUN: opt -mergefunc -S < %s | FileCheck %s
+
+;; Make sure that two different CatchSwitch Insts are not treated as equal.
+
+target datalayout = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32"
+
+; Unwinds to caller difference.
+
+; CHECK-LABEL: define void @f1
+; CHECK-NOT: call void @
+define void @f1() personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
+entry:
+  invoke void @g() to label %invoke.cont unwind label %ehcleanup
+
+invoke.cont:                                      ; preds = %entry
+  br label %try.cont
+
+ehcleanup:                                        ; preds = %entry
+  %0 = cleanuppad within none []
+  cleanupret from %0 unwind label %catch.dispatch
+
+catch.dispatch:                                   ; preds = %ehcleanup
+  %cs1 = catchswitch within none [label %catch] unwind label %ehcleanup.1
+
+catch:                                            ; preds = %catch.dispatch
+  %cp2 = catchpad within %cs1 [i8* null, i32 u0x40, i8* null]
+  catchret from %cp2 to label %catchret.dest
+
+catchret.dest:                                    ; preds = %catch
+  br label %try.cont
+
+try.cont:                                         ; preds = %catchret.dest, %invoke.cont
+  ret void
+
+ehcleanup.1:
+  %cp3 = cleanuppad within none []
+  cleanupret from %cp3 unwind to caller
+}
+
+; CHECK-LABEL: define void @f2
+; CHECK-NOT: call void @
+define void @f2() personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
+entry:
+  invoke void @g() to label %invoke.cont unwind label %ehcleanup
+
+invoke.cont:                                      ; preds = %entry
+  br label %try.cont
+
+ehcleanup:                                        ; preds = %entry
+  %0 = cleanuppad within none []
+  cleanupret from %0 unwind label %catch.dispatch
+
+catch.dispatch:                                   ; preds = %ehcleanup
+  %cs1 = catchswitch within none [label %catch] unwind to caller
+
+catch:                                            ; preds = %catch.dispatch
+  %cp2 = catchpad within %cs1 [i8* null, i32 u0x40, i8* null]
+  catchret from %cp2 to label %catchret.dest
+
+catchret.dest:                                    ; preds = %catch
+  br label %try.cont
+
+try.cont:                                         ; preds = %catchret.dest, %invoke.cont
+  ret void
+
+ehcleanup.1:
+  %cp3 = cleanuppad within none []
+  cleanupret from %cp3 unwind to caller
+}
+
+declare void @g()
+declare i32 @__CxxFrameHandler3(...)
 No newline at end of file

llvm/test/Transforms/MergeFunc/ir-cmp-cleanupret1.ll

+; RUN: opt -mergefunc -S < %s | FileCheck %s
+
+;; Make sure that two different CleanupRet Insts are not treated as equal.
+
+target datalayout = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32"
+
+; Unwinds to caller difference.
+
+; CHECK-LABEL: define void @f1
+; CHECK-NOT: call void @
+define void @f1() personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
+entry:
+  invoke void @g() to label %invoke.cont unwind label %ehcleanup
+
+invoke.cont:                                      ; preds = %entry
+  ret void
+
+ehcleanup:                                        ; preds = %entry
+  %0 = cleanuppad within none []
+  cleanupret from %0 unwind label %ehcleanup.1
+
+ehcleanup.1:                                      ; preds = %ehcleanup
+  %1 = cleanuppad within none []
+  ret void
+}
+
+; CHECK-LABEL: define void @f2
+; CHECK-NOT: call void @
+define void @f2() personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
+entry:
+  invoke void @g() to label %invoke.cont unwind label %ehcleanup
+
+invoke.cont:                                      ; preds = %entry
+  ret void
+
+ehcleanup:                                        ; preds = %entry
+  %0 = cleanuppad within none []
+  cleanupret from %0 unwind to caller
+
+ehcleanup.1:                                      ; preds = %ehcleanup
+  %1 = cleanuppad within none []
+  ret void
+}
+
+declare void @g()
+declare i32 @__CxxFrameHandler3(...)
 No newline at end of file

llvm/test/Transforms/MergeFunc/ir-cmp-cleanupret2.ll

+; RUN: opt -mergefunc -S < %s | FileCheck %s
+
+;; Make sure that two same CleanupRet Insts are treated as equal.
+
+target datalayout = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32"
+
+; Unwinds to caller is considered during comparison
+
+; CHECK-LABEL: define void @f1
+; CHECK-NOT: call void @
+define void @f1() personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
+entry:
+  invoke void @g() to label %invoke.cont unwind label %ehcleanup
+
+invoke.cont:                                      ; preds = %entry
+  ret void
+
+ehcleanup:                                        ; preds = %entry
+  %0 = cleanuppad within none []
+  cleanupret from %0 unwind label %ehcleanup.1
+
+ehcleanup.1:                                      ; preds = %ehcleanup
+  %1 = cleanuppad within none []
+  cleanupret from %1 unwind to caller
+}
+
+; CHECK-LABEL: define void @f2
+; CHECK: call void @
+define void @f2() personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
+entry:
+  invoke void @g() to label %invoke.cont unwind label %ehcleanup
+
+invoke.cont:                                      ; preds = %entry
+  ret void
+
+ehcleanup:                                        ; preds = %entry
+  %0 = cleanuppad within none []
+  cleanupret from %0 unwind label %ehcleanup.1
+
+ehcleanup.1:                                      ; preds = %ehcleanup
+  %1 = cleanuppad within none []
+  cleanupret from %1 unwind to caller
+}
+
+
+declare void @g()
+declare i32 @__CxxFrameHandler3(...)
 No newline at end of file

llvm/test/Transforms/MergeFunc/ir-cmp-cmpXchg1.ll

+; RUN: opt -mergefunc -S < %s | FileCheck %s
+
+;; Make sure that two different CmpXChg Insts are not treated as equal.
+
+target datalayout = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32"
+
+;; Volatile difference
+
+; CHECK-LABEL: define void @f1
+; CHECK-NOT: call void @
+define void @f1(i32*) {
+  %val_success = cmpxchg volatile i32* %0, i32 0, i32 1 acq_rel monotonic
+  %value_loaded = extractvalue { i32, i1 } %val_success, 0
+  %success = extractvalue { i32, i1 } %val_success, 1
+  ret void
+}
+
+; CHECK-LABEL: define void @f2
+; CHECK-NOT: call void @
+define void @f2(i32*) {
+  %val_success = cmpxchg i32* %0, i32 0, i32 1 acq_rel acquire
+  %value_loaded = extractvalue { i32, i1 } %val_success, 0
+  %success = extractvalue { i32, i1 } %val_success, 1
+  ret void
+}
+
+;; Weak difference
+
+; CHECK-LABEL: define void @f3
+; CHECK-NOT: call void @
+define void @f3(i32*) {
+  %val_success = cmpxchg weak i32* %0, i32 1, i32 1 acq_rel monotonic
+  %value_loaded = extractvalue { i32, i1 } %val_success, 0
+  %success = extractvalue { i32, i1 } %val_success, 1
+  ret void
+}
+
+; CHECK-LABEL: define void @f4
+; CHECK-NOT: call void @
+define void @f4(i32*) {
+  %val_success = cmpxchg i32* %0, i32 1, i32 1 acq_rel monotonic
+  %value_loaded = extractvalue { i32, i1 } %val_success, 0
+  %success = extractvalue { i32, i1 } %val_success, 1
+  ret void
+}
+
+;; Success Ordering difference
+
+; CHECK-LABEL: define void @f5
+; CHECK-NOT: call void @
+define void @f5(i32*) {
+  %val_success = cmpxchg i32* %0, i32 0, i32 1 acq_rel monotonic
+  %value_loaded = extractvalue { i32, i1 } %val_success, 0
+  %success = extractvalue { i32, i1 } %val_success, 1
+  ret void
+}
+
+; CHECK-LABEL: define void @f6
+; CHECK-NOT: call void @
+define void @f6(i32*) {
+  %val_success = cmpxchg i32* %0, i32 0, i32 1 acquire monotonic
+  %value_loaded = extractvalue { i32, i1 } %val_success, 0
+  %success = extractvalue { i32, i1 } %val_success, 1
+  ret void
+}
+
+;; Failure Ordering difference
+
+; CHECK-LABEL: define i32 @f7
+; CHECK-NOT: call i32 @
+define i32 @f7(i32*) {
+  %val_success = cmpxchg i32* %0, i32 0, i32 1 acq_rel acquire
+  %value_loaded = extractvalue { i32, i1 } %val_success, 0
+  %success = extractvalue { i32, i1 } %val_success, 1
+  ret i32 0
+}
+
+; CHECK-LABEL: define i32 @f8
+; CHECK-NOT: call i32 @
+define i32 @f8(i32*) {
+  %val_success = cmpxchg i32* %0, i32 0, i32 1 acq_rel monotonic
+  %value_loaded = extractvalue { i32, i1 } %val_success, 0
+  %success = extractvalue { i32, i1 } %val_success, 1
+  ret i32 0
+}
+
+;; SyncScopeID difference
+
+; CHECK-LABEL: define void @f9
+; CHECK-NOT: call void @
+define void @f9(i32*) {
+  %val_success = cmpxchg i32* %0, i32 0, i32 1 syncscope("<target-scope>") acq_rel monotonic
+  %value_loaded = extractvalue { i32, i1 } %val_success, 0
+  %success = extractvalue { i32, i1 } %val_success, 1
+  ret void
+}
+
+; CHECK-LABEL: define void @f10
+; CHECK-NOT: call void @
+define void @f10(i32*) {
+  %val_success = cmpxchg i32* %0, i32 0, i32 1 syncscope("singlethread") acq_rel monotonic
+  %value_loaded = extractvalue { i32, i1 } %val_success, 0
+  %success = extractvalue { i32, i1 } %val_success, 1
+  ret void
+}

llvm/test/Transforms/MergeFunc/ir-cmp-cmpXchg2.ll

+; RUN: opt -mergefunc -S < %s | FileCheck %s
+
+;; Make sure that two same CmpXChg Insts are treated as equal.
+
+target datalayout = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32"
+
+;; Volatility, isWeak, Success Ordering, Failure Ordering and SyncScopeID are being checked
+
+; CHECK-LABEL: define void @f1
+; CHECK-NOT: call void @
+define void @f1(i32*) {
+  %val_success = cmpxchg weak i32* %0, i32 0, i32 1 syncscope("<target-scope>") acq_rel monotonic
+  %value_loaded = extractvalue { i32, i1 } %val_success, 0
+  %success = extractvalue { i32, i1 } %val_success, 1
+  ret void
+}
+
+; CHECK-LABEL: define void @f2
+; CHECK: call void @
+define void @f2(i32*) {
+  %val_success = cmpxchg weak i32* %0, i32 0, i32 1 syncscope("<target-scope>") acq_rel monotonic
+  %value_loaded = extractvalue { i32, i1 } %val_success, 0
+  %success = extractvalue { i32, i1 } %val_success, 1
+  ret void
+}

llvm/test/Transforms/MergeFunc/ir-cmp-cmpinst.ll

+; RUN: opt -mergefunc -S < %s | FileCheck %s
+
+;; Make sure that two same Cmp Insts are treated as equal.
+
+target datalayout = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32"
+
+;; The predicate being considered for comparison of Cmp Instructions.
+
+; CHECK-LABEL: define void @f1
+; CHECK-NOT: call void @
+define void @f1(i32 %m, i32 %n, float %u, float %v) {
+  %1 = icmp eq i32 %m, %n
+  %2 = icmp ne i32 %m, %n
+  %3 = icmp ugt i32 %m, %n
+  %4 = icmp ult i32 %m, %n
+  %5 = icmp ule i32 %m, %n
+  %6 = icmp uge i32 %m, %n
+  %7 = icmp sgt i32 %m, %n
+  %8 = icmp sge i32 %m, %n
+  %9 = icmp slt i32 %m, %n
+  %10 = icmp sle i32 %m, %n
+  %11 = fcmp false float %u, %v
+  %12 = fcmp oeq float %u, %v
+  %13 = fcmp ogt float %u, %v
+  %14 = fcmp olt float %u, %v
+  %15 = fcmp ole float %u, %v
+  %16 = fcmp one float %u, %v
+  %17 = fcmp ord float %u, %v
+  %18 = fcmp ueq float %u, %v
+  %19 = fcmp ugt float %u, %v
+  %20 = fcmp uge float %u, %v
+  %21 = fcmp ult float %u, %v
+  %22 = fcmp ule float %u, %v
+  %23 = fcmp une float %u, %v
+  %24 = fcmp uno float %u, %v
+  %25 = fcmp true float %u, %v
+  ret void
+}
+
+; CHECK-LABEL: define void @f2
+; CHECK: call void @
+define void @f2(i32 %m, i32 %n, float %u, float %v) {
+  %1 = icmp eq i32 %m, %n
+  %2 = icmp ne i32 %m, %n
+  %3 = icmp ugt i32 %m, %n
+  %4 = icmp ult i32 %m, %n
+  %5 = icmp ule i32 %m, %n
+  %6 = icmp uge i32 %m, %n
+  %7 = icmp sgt i32 %m, %n
+  %8 = icmp sge i32 %m, %n
+  %9 = icmp slt i32 %m, %n
+  %10 = icmp sle i32 %m, %n
+  %11 = fcmp false float %u, %v
+  %12 = fcmp oeq float %u, %v
+  %13 = fcmp ogt float %u, %v
+  %14 = fcmp olt float %u, %v
+  %15 = fcmp ole float %u, %v
+  %16 = fcmp one float %u, %v
+  %17 = fcmp ord float %u, %v
+  %18 = fcmp ueq float %u, %v
+  %19 = fcmp ugt float %u, %v
+  %20 = fcmp uge float %u, %v
+  %21 = fcmp ult float %u, %v
+  %22 = fcmp ule float %u, %v
+  %23 = fcmp une float %u, %v
+  %24 = fcmp uno float %u, %v
+  %25 = fcmp true float %u, %v
+  ret void
+}

llvm/test/Transforms/MergeFunc/ir-cmp-extractelm.ll

+; RUN: opt -mergefunc -S < %s | FileCheck %s
+
+;; Make sure that two same ExtractElement insts are treated as equal.
+
+target datalayout = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32"
+
+; Currently there is no special state being compared for ExtractElement Instruction.
+
+; CHECK-LABEL: define i32 @f1
+; CHECK-NOT: call i32 @
+define i32 @f1(<4 x float> %vec) {
+  %i0 = extractelement <4 x float> %vec, i32 0
+  %i1 = extractelement <4 x float> %vec, i32 1
+  %i2 = extractelement <4 x float> %vec, i32 2
+  %i3 = extractelement <4 x float> %vec, i32 3
+  ret i32 0
+}
+
+; CHECK-LABEL: define i32 @f2
+; CHECK: call i32 @
+define i32 @f2(<4 x float> %vec) {
+  %i0 = extractelement <4 x float> %vec, i32 0
+  %i1 = extractelement <4 x float> %vec, i32 1
+  %i2 = extractelement <4 x float> %vec, i32 2
+  %i3 = extractelement <4 x float> %vec, i32 3
+  ret i32 0
+}
+

llvm/test/Transforms/MergeFunc/ir-cmp-extractval1.ll

+; RUN: opt -mergefunc -S < %s | FileCheck %s
+
+;; Make sure that two different ExtractValue Insts are not treated as equal.
+
+target datalayout = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32"
+
+; Index Size difference.
+
+; CHECK-LABEL: define void @f1
+; CHECK-NOT: call void @
+define void @f1({i8, i32, float, {i8, i16}} %agg) {
+  %1 = extractvalue {i8, i32, float, {i8, i16}} %agg, 0
+  %2 = extractvalue {i8, i32, float, {i8, i16}} %agg, 1
+  %3 = extractvalue {i8, i32, float, {i8, i16}} %agg, 2
+  %4 = extractvalue {i8, i32, float, {i8, i16}} %agg, 3
+  ret void
+}
+
+; CHECK-LABEL: define void @f2
+; CHECK-NOT: call void @
+define void @f2({i8, i32, float, {i8, i16}} %agg) {
+  %1 = extractvalue {i8, i32, float, {i8, i16}} %agg, 0
+  %2 = extractvalue {i8, i32, float, {i8, i16}} %agg, 1
+  %3 = extractvalue {i8, i32, float, {i8, i16}} %agg, 2
+  %4 = extractvalue {i8, i32, float, {i8, i16}} %agg, 3, 1
+  ret void
+}
+
+; Indices difference.
+
+; CHECK-LABEL: define void @f3
+; CHECK-NOT: call void @
+define void @f3({i8, i32, float, {i8, i16}} %agg) {
+  %1 = extractvalue {i8, i32, float, {i8, i16}} %agg, 0
+  %2 = extractvalue {i8, i32, float, {i8, i16}} %agg, 3, 0
+  ret void
+}
+
+; CHECK-LABEL: define void @f4
+; CHECK-NOT: call void @
+define void @f4({i8, i32, float, {i8, i16}} %agg) {
+  %1 = extractvalue {i8, i32, float, {i8, i16}} %agg, 2
+  %2 = extractvalue {i8, i32, float, {i8, i16}} %agg, 3, 1
+  ret void
+}

llvm/test/Transforms/MergeFunc/ir-cmp-extractval2.ll

+; RUN: opt -mergefunc -S < %s | FileCheck %s
+
+;; Make sure that two same ExtractValue Insts are treated as equal.
+
+target datalayout = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32"
+
+; Indices are considered during comparison
+
+; CHECK-LABEL: define void @f1
+; CHECK-NOT: call void @
+define void @f1({i8, i32, float, {i8, i16}} %agg) {
+  %1 = extractvalue {i8, i32, float, {i8, i16}} %agg, 0
+  %2 = extractvalue {i8, i32, float, {i8, i16}} %agg, 1
+  %3 = extractvalue {i8, i32, float, {i8, i16}} %agg, 2
+  %4 = extractvalue {i8, i32, float, {i8, i16}} %agg, 3, 1
+  ret void
+}
+
+; CHECK-LABEL: define void @f2
+; CHECK: call void @
+define void @f2({i8, i32, float, {i8, i16}} %agg) {
+  %1 = extractvalue {i8, i32, float, {i8, i16}} %agg, 0
+  %2 = extractvalue {i8, i32, float, {i8, i16}} %agg, 1
+  %3 = extractvalue {i8, i32, float, {i8, i16}} %agg, 2
+  %4 = extractvalue {i8, i32, float, {i8, i16}} %agg, 3, 1
+  ret void
+}
+
+

llvm/test/Transforms/MergeFunc/ir-cmp-fence1.ll

+; RUN: opt -mergefunc -S < %s | FileCheck %s
+
+;; Make sure that two different Fence Insts are not treated as equal.
+
+target datalayout = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32"
+
+;; Ordering difference
+
+; CHECK-LABEL: define void @f1
+; CHECK-NOT: call void @
+define void @f1(i64 %n) {
+entry:
+  br label %loop
+loop:
+  %iv = phi i64 [0, %entry], [%iv.next, %loop]
+  fence release
+  %iv.next = add i64 %iv, 1
+  %test = icmp slt i64 %iv, %n
+  br i1 %test, label %loop, label %exit
+exit:
+  ret void
+}
+
+; CHECK-LABEL: define void @f2
+; CHECK-NOT: call void @
+define void @f2(i64 %n) {
+entry:
+  br label %loop
+loop:
+  %iv = phi i64 [0, %entry], [%iv.next, %loop]
+  fence acquire
+  %iv.next = add i64 %iv, 1
+  %test = icmp slt i64 %iv, %n
+  br i1 %test, label %loop, label %exit
+exit:
+  ret void
+}
+
+;; SyncScopeID difference
+
+; CHECK-LABEL: define void @f3
+; CHECK-NOT: call void @
+define void @f3(i64 %n) {
+entry:
+  br label %loop
+loop:
+  %iv = phi i64 [0, %entry], [%iv.next, %loop]
+  fence syncscope("singlethread") release
+  %iv.next = add i64 %iv, 1
+  %test = icmp slt i64 %iv, %n
+  br i1 %test, label %loop, label %exit
+exit:
+  ret void
+}
+
+; CHECK-LABEL: define void @f4
+; CHECK-NOT: call void @
+define void @f4(i64 %n) {
+entry:
+  br label %loop
+loop:
+  %iv = phi i64 [0, %entry], [%iv.next, %loop]
+  fence syncscope("<target-scope>") release
+  %iv.next = add i64 %iv, 1
+  %test = icmp slt i64 %iv, %n
+  br i1 %test, label %loop, label %exit
+exit:
+  ret void
+}

llvm/test/Transforms/MergeFunc/ir-cmp-fence2.ll

+; RUN: opt -mergefunc -S < %s | FileCheck %s
+
+;; Make sure that two same Fence Insts are treated as equal.
+
+target datalayout = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32"
+
+;; Ordering and SyncScope are considered during comparison
+
+; CHECK-LABEL: define void @f1
+; CHECK-NOT: call void @
+define void @f1(i64 %n) {
+entry:
+  br label %loop
+loop:
+  %iv = phi i64 [0, %entry], [%iv.next, %loop]
+  fence syncscope("<target-scope>") release
+  %iv.next = add i64 %iv, 1
+  %test = icmp slt i64 %iv, %n
+  br i1 %test, label %loop, label %exit
+exit:
+  ret void
+}
+
+; CHECK-LABEL: define void @f2
+; CHECK: call void @
+define void @f2(i64 %n) {
+entry:
+  br label %loop
+loop:
+  %iv = phi i64 [0, %entry], [%iv.next, %loop]
+  fence syncscope("<target-scope>") release
+  %iv.next = add i64 %iv, 1
+  %test = icmp slt i64 %iv, %n
+  br i1 %test, label %loop, label %exit
+exit:
+  ret void
+}

llvm/test/Transforms/MergeFunc/ir-cmp-fneg.ll

+; RUN: opt -mergefunc -S < %s | FileCheck %s
+
+;; Make sure that two same FNeg are treated as equal.
+
+target datalayout = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32"
+
+;; Currently there is no special state being checked for comparison of Fneg Instructions.
+
+; CHECK-LABEL: define void @f1
+; CHECK-NOT: call void @
+define void @f1(float %v, <4 x float> %u) {
+  %1 = fneg float %v
+  %2 = fneg float %v
+  %3 = fneg <4 x float> %u 
+  ret void
+}
+
+; CHECK-LABEL: define void @f2
+; CHECK: call void @
+define void @f2(float %v, <4 x float> %u) {
+  %1 = fneg float %v
+  %2 = fneg float %v
+  %3 = fneg <4 x float> %u
+  ret void
+}

llvm/test/Transforms/MergeFunc/ir-cmp-freeze.ll

+; RUN: opt -mergefunc -S < %s | FileCheck %s
+
+;; Make sure that two same Freeze are treated as equal.
+
+target datalayout = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32"
+
+;; Currently there is no special state being checked for comparison of Freeze Instructions.
+
+; CHECK-LABEL: define void @f1
+; CHECK-NOT: call void @
+define void @f1(i32 %u) {
+  %1 = freeze i32 %u
+  %2 = add nsw i32 %u, %u
+  %3 = freeze i32 %2
+  ret void
+}
+
+; CHECK-LABEL: define void @f2
+; CHECK: call void @
+define void @f2(i32 %u) {
+  %1 = freeze i32 %u
+  %2 = add nsw i32 %u, %u
+  %3 = freeze i32 %2
+  ret void
+}

llvm/test/Transforms/MergeFunc/ir-cmp-indirectbr.ll

+; RUN: opt -mergefunc -S < %s | FileCheck %s
+
+;; Make sure that two same IndirectBr Insts are treated as equal.
+
+target datalayout = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32"
+
+;; Currently there is no special state being checked for comparison of IndirectBr Instructions.
+
+; CHECK-LABEL: define i32 @f1
+; CHECK-NOT: call i32 @
+define i32 @f1(i32 %val) {
+entry:
+  %c = icmp eq i32 %val, 0
+  br i1 %c, label %bb1, label %bb2
+
+bb1:
+  br label %branch.block
+
+
+bb2:
+  br label %branch.block
+
+branch.block:
+  %addr = phi i8* [blockaddress(@f1, %target1), %bb1], [blockaddress(@f1, %target2), %bb2]
+  indirectbr i8* %addr, [label %target1, label %target2]
+
+target1:
+  br label %target2
+
+target2:
+  ret i32 0
+}
+
+; CHECK-LABEL: define i32 @f2
+; CHECK: call i32 @
+define i32 @f2(i32 %val) {
+entry:
+  %c = icmp eq i32 %val, 0
+  br i1 %c, label %bb1, label %bb2
+
+bb1:
+  br label %branch.block
+
+
+bb2:
+  br label %branch.block
+
+branch.block:
+  %addr = phi i8* [blockaddress(@f2, %target1), %bb1], [blockaddress(@f2, %target2), %bb2]
+  indirectbr i8* %addr, [label %target1, label %target2]
+
+target1:
+  br label %target2
+
+target2:
+  ret i32 0
+}

llvm/test/Transforms/MergeFunc/ir-cmp-insertelm.ll

+; RUN: opt -mergefunc -S < %s | FileCheck %s
+
+;; Make sure that two same InsertElement insts are treated as equal.
+
+target datalayout = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32"
+
+; Currently there is no special state being compared for InsertElement Instruction.
+
+; CHECK-LABEL: define i32 @f1
+; CHECK-NOT: call i32 @
+define i32 @f1(<4 x i32> %vec) {
+  %i0 = insertelement <4 x i32> %vec, i32 100, i32 0
+  %i1 = insertelement <4 x i32> %vec, i32 101, i32 1
+  %i2 = insertelement <4 x i32> %vec, i32 102, i32 2
+  %i3 = insertelement <4 x i32> %vec, i32 103, i32 3
+  ret i32 0
+}
+
+; CHECK-LABEL: define i32 @f2
+; CHECK: call i32 @
+define i32 @f2(<4 x i32> %vec) {
+  %i0 = insertelement <4 x i32> %vec, i32 100, i32 0
+  %i1 = insertelement <4 x i32> %vec, i32 101, i32 1
+  %i2 = insertelement <4 x i32> %vec, i32 102, i32 2
+  %i3 = insertelement <4 x i32> %vec, i32 103, i32 3
+  ret i32 0
+}
+

llvm/test/Transforms/MergeFunc/ir-cmp-insertval1.ll

+; RUN: opt -mergefunc -S < %s | FileCheck %s
+
+;; Make sure that two different InsertValue Insts are not treated as equal.
+
+target datalayout = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32"
+
+; Indices difference.
+
+; CHECK-LABEL: define void @f1
+; CHECK-NOT: call void @
+define void @f1({i8, i32, float, {i8, i16}} %agg) {
+  %1 = insertvalue {i8, i32, float, {i8, i16}} %agg, i8 1, 0
+  %2 = insertvalue {i8, i32, float, {i8, i16}} %agg, i32 2, 1
+  %3 = insertvalue {i8, i32, float, {i8, i16}} %agg, float 5.0, 2
+  %4 = insertvalue {i8, i32, float, {i8, i16}} %agg, i8 2, 3, 0
+  ret void
+}
+
+; CHECK-LABEL: define void @f2
+; CHECK-NOT: call void @
+define void @f2({i8, i32, float, {i8, i16}} %agg) {
+  %1 = insertvalue {i8, i32, float, {i8, i16}} %agg, i8 1, 0
+  %2 = insertvalue {i8, i32, float, {i8, i16}} %agg, i32 2, 1
+  %3 = insertvalue {i8, i32, float, {i8, i16}} %agg, float 5.0, 2
+  %4 = insertvalue {i8, i32, float, {i8, i16}} %agg, i16 2, 3, 1
+  ret void
+}

llvm/test/Transforms/MergeFunc/ir-cmp-insertval2.ll

+; RUN: opt -mergefunc -S < %s | FileCheck %s
+
+;; Make sure that two same InsertValue Insts are treated as equal.
+
+target datalayout = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32"
+
+; Indices are considered during comparison
+
+; CHECK-LABEL: define void @f1
+; CHECK-NOT: call void @
+define void @f1({i8, i32, float, {i8, i16}} %agg) {
+  %1 = insertvalue {i8, i32, float, {i8, i16}} %agg, i8 1, 0
+  %2 = insertvalue {i8, i32, float, {i8, i16}} %agg, i32 2, 1
+  %3 = insertvalue {i8, i32, float, {i8, i16}} %agg, float 5.0, 2
+  %4 = insertvalue {i8, i32, float, {i8, i16}} %agg, i8 2, 3, 0
+  ret void
+}
+
+; CHECK-LABEL: define void @f2
+; CHECK: call void @
+define void @f2({i8, i32, float, {i8, i16}} %agg) {
+  %1 = insertvalue {i8, i32, float, {i8, i16}} %agg, i8 1, 0
+  %2 = insertvalue {i8, i32, float, {i8, i16}} %agg, i32 2, 1
+  %3 = insertvalue {i8, i32, float, {i8, i16}} %agg, float 5.0, 2
+  %4 = insertvalue {i8, i32, float, {i8, i16}} %agg, i8 2, 3, 0
+  ret void
+}
+
+

llvm/test/Transforms/MergeFunc/ir-cmp-invoke1.ll

+; RUN: opt -mergefunc -S < %s | FileCheck %s
+
+;; Make sure that two different Invoke Insts are not treated as equal.
+
+target datalayout = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32"
+
+;; Calling convention difference
+
+; CHECK-LABEL: define i8 @f1
+; CHECK-NOT: call i8 @
+define i8 @f1() personality i8* undef {
+  %out = invoke fastcc i8 @dummy(i8 0) to label %next unwind label %lpad
+
+next:
+  ret i8 %out
+
+lpad:
+  %pad = landingpad { i8*, i32 } cleanup
+  resume { i8*, i32 } zeroinitializer
+}
+
+; CHECK-LABEL: define i8 @f2
+; CHECK-NOT: call i8 @
+define i8 @f2() personality i8* undef {
+  %out = invoke coldcc i8 @dummy(i8 0) to label %next unwind label %lpad
+
+next:
+  ret i8 %out
+
+lpad:
+  %pad = landingpad { i8*, i32 } cleanup
+  resume { i8*, i32 } zeroinitializer
+}
+
+;; Parameter Attributes difference
+
+; CHECK-LABEL: define i8 @f3
+; CHECK-NOT: call i8 @
+define i8 @f3() personality i8* undef {
+  %out = invoke i8 @dummy(i8 zeroext 0) to label %next unwind label %lpad
+
+next:
+  ret i8 %out
+
+lpad:
+  %pad = landingpad { i8*, i32 } cleanup
+  resume { i8*, i32 } zeroinitializer
+}
+
+; CHECK-LABEL: define i8 @f4
+; CHECK-NOT: call i8 @
+define i8 @f4() personality i8* undef {
+  %out = invoke i8 @dummy(i8 inreg 0) to label %next unwind label %lpad
+
+next:
+  ret i8 %out
+
+lpad:
+  %pad = landingpad { i8*, i32 } cleanup
+  resume { i8*, i32 } zeroinitializer
+}
+
+;; RangeMetaData Difference
+
+; CHECK-LABEL: define i8 @f5
+; CHECK-NOT: call i8 @
+define i8 @f5() personality i8* undef {
+  %out = invoke i8 @dummy(i8 0) to label %next unwind label %lpad, !range !0
+
+next:
+  ret i8 %out
+
+lpad:
+  %pad = landingpad { i8*, i32 } cleanup
+  resume { i8*, i32 } zeroinitializer
+}
+
+; CHECK-LABEL: define i8 @f6
+; CHECK-NOT: call i8 @
+define i8 @f6() personality i8* undef {
+  %out = invoke i8 @dummy(i8 0) to label %next unwind label %lpad, !range !1
+
+next:
+  ret i8 %out
+
+lpad:
+  %pad = landingpad { i8*, i32 } cleanup
+  resume { i8*, i32 } zeroinitializer
+}
+
+;; OperandBundleSchema Difference
+
+; CHECK-LABEL: define i8 @f7
+; CHECK-NOT: call i8 @
+define i8 @f7() personality i8* undef {
+  %out = invoke i8 @dummy(i8 0) ["some-bundle"(i8 1)] to label %next unwind label %lpad 
+
+next:
+  ret i8 %out
+
+lpad:
+  %pad = landingpad { i8*, i32 } cleanup
+  resume { i8*, i32 } zeroinitializer
+}
+
+; CHECK-LABEL: define i8 @f8
+; CHECK-NOT: call i8 @
+define i8 @f8() personality i8* undef {
+  %out = invoke i8 @dummy(i8 0) ["some-other-bundle"(i8 1)] to label %next unwind label %lpad
+
+next:
+  ret i8 %out
+
+lpad:
+  %pad = landingpad { i8*, i32 } cleanup
+  resume { i8*, i32 } zeroinitializer
+}
+
+!0 = !{i8 0, i8 5}
+!1 = !{i8 1, i8 7}
+
+declare i8 @dummy(i8);

llvm/test/Transforms/MergeFunc/ir-cmp-invoke2.ll

+; RUN: opt -mergefunc -S < %s | FileCheck %s
+
+;; Make sure that two same Invoke Insts are treated as equal.
+
+target datalayout = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32"
+
+;; Calling convention, Parameter Attribues, RangeMetaData, OperandBundleSchema are considered during comparison
+
+; CHECK-LABEL: define i8 @f1
+; CHECK-NOT: call i8 @
+define i8 @f1() personality i8* undef {
+  %out = invoke fastcc i8 @dummy(i8 inreg 0) ["some-bundle"(i8 1)] to label %next unwind label %lpad, !range !0
+
+next:
+  ret i8 %out
+
+lpad:
+  %pad = landingpad { i8*, i32 } cleanup
+  resume { i8*, i32 } zeroinitializer
+}
+
+; CHECK-LABEL: define i8 @f2
+; CHECK: call i8 @
+define i8 @f2() personality i8* undef {
+  %out = invoke fastcc i8 @dummy(i8 inreg 0) ["some-bundle"(i8 1)] to label %next unwind label %lpad, !range !1
+
+next:
+  ret i8 %out
+
+lpad:
+  %pad = landingpad { i8*, i32 } cleanup
+  resume { i8*, i32 } zeroinitializer
+}
+
+!0 = !{i8 0, i8 5}
+!1 = !{i8 0, i8 5}
+
+declare i8 @dummy(i8);

llvm/test/Transforms/MergeFunc/ir-cmp-load1.ll

+; RUN: opt -mergefunc -S < %s | FileCheck %s
+
+;; Make sure that two different load Insts are not treated as equal.
+
+target datalayout = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32"
+
+;; Volatile difference
+
+; CHECK-LABEL: define void @load1
+; CHECK-NOT: call void @
+define void @load1() {
+  %ptr = alloca i32, align 4
+  store i32 0, i32* %ptr
+  %val = load volatile i32, i32* %ptr
+  ret void
+}
+
+; CHECK-LABEL: define void @load2
+; CHECK-NOT: call void @
+define void @load2() {
+  %ptr = alloca i32, align 4
+  store i32 0, i32* %ptr
+  %val = load i32, i32* %ptr
+  ret void
+}
+
+;; Alignment difference
+
+; CHECK-LABEL: define void @load3
+; CHECK-NOT: call void @
+define void @load3() {
+  %ptr = alloca i64, align 4
+  store i64 0, i64* %ptr
+  %val = load i64, i64* %ptr, align 4
+  ret void
+}
+
+; CHECK-LABEL: define void @load4
+; CHECK-NOT: call void @
+define void @load4() {
+  %ptr = alloca i64, align 4
+  store i64 0, i64* %ptr
+  %val = load i64, i64* %ptr, align 8
+  ret void
+}
+
+;; Ordering difference
+
+; CHECK-LABEL: define void @load5
+; CHECK-NOT: call void @
+define void @load5() {
+  %ptr = alloca i64, align 4
+  store i64 0, i64* %ptr
+  %val = load atomic i64, i64* %ptr unordered, align 4
+  ret void
+}
+
+; CHECK-LABEL: define void @load6
+; CHECK-NOT: call void @
+define void @load6() {
+  %ptr = alloca i64, align 4
+  store i64 0, i64* %ptr
+  %val = load atomic i64, i64* %ptr acquire, align 4
+  ret void
+}
+
+;; MetaData difference
+
+; CHECK-LABEL: define void @load7
+; CHECK-NOT: call void @
+define void @load7() {
+  %ptr = alloca i8, align 1
+  store i8 0, i8* %ptr
+  %val = load i8, i8* %ptr, align 1, !range !0
+  ret void
+}
+
+; CHECK-LABEL: define void @load8
+; CHECK-NOT: call void @
+define void @load8() {
+  %ptr = alloca i8, align 1
+  store i8 0, i8* %ptr
+  %val = load i8, i8* %ptr, align 1, !range !1
+  ret void
+}
+
+!0 = !{ i8 0, i8 2}
+!1 = !{ i8 0, i8 4}
+
+;; SyncScopeID difference
+
+; CHECK-LABEL: define void @load9
+; CHECK-NOT: call void @
+define void @load9() {
+  %ptr = alloca i64, align 4
+  store i64 0, i64* %ptr
+  %val = load atomic i64, i64* %ptr syncscope("singlethread") unordered, align 4
+  ret void
+}
+
+; CHECK-LABEL: define void @load10
+; CHECK-NOT: call void @
+define void @load10() {
+  %ptr = alloca i64, align 4
+  store i64 0, i64* %ptr
+  %val = load atomic i64, i64* %ptr  syncscope("<target-scope>") unordered, align 4
+  ret void
+}

llvm/test/Transforms/MergeFunc/ir-cmp-load2.ll

+; RUN: opt -mergefunc -S < %s | FileCheck %s
+
+;; Make sure that two same load Insts are treated as equal.
+
+target datalayout = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32"
+
+;; Checks if two functions with same load instructions are being merged
+;; Volatility, Alignment, Orderings, RangeMetadata, SyncScopeID are being checked
+
+; CHECK-LABEL: define void @load1
+; CHECK-NOT: call void @
+define void @load1(i8*) {
+  %ptr = alloca i32, align 4
+  store i32 0, i32* %ptr
+  %val1 = load volatile i32, i32* %ptr, align 4
+  %val2 = load atomic i8, i8* %0 syncscope("singlethread") monotonic, align 1, !range !0
+  ret void
+}
+
+; CHECK-LABEL: define void @load2
+; CHECK: call void @
+define void @load2(i8*) {
+  %ptr = alloca i32, align 4
+  store i32 0, i32* %ptr
+  %val1 = load volatile i32, i32* %ptr, align 4
+  %val2 = load atomic i8, i8* %0 syncscope("singlethread") monotonic, align 1, !range !0
+  ret void
+}
+
+!0 = !{i8 1, i8 3, i8 7, i8 9}
+!1 = !{i8 1, i8 3, i8 7, i8 9}

llvm/test/Transforms/MergeFunc/ir-cmp-resume.ll

+; RUN: opt -mergefunc -S < %s | FileCheck %s
+
+;; Make sure that two same Resume Insts are treated as equal.
+
+target datalayout = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32"
+
+;; Currently there is no special state being compared for Resume instructions.
+
+; CHECK-LABEL: define i8 @f1
+; CHECK-NOT: call i8 @
+define i8 @f1() personality i8* undef {
+  %out = invoke i8 @dummy(i8 0) to label %next unwind label %lpad
+
+next:
+  ret i8 %out
+
+lpad:
+  %pad = landingpad { i8*, i32 } cleanup
+  resume { i8*, i32 } zeroinitializer
+}
+
+; CHECK-LABEL: define i8 @f2
+; CHECK: call i8 @
+define i8 @f2() personality i8* undef {
+  %out = invoke i8 @dummy(i8 0) to label %next unwind label %lpad
+
+next:
+  ret i8 %out
+
+lpad:
+  %pad = landingpad { i8*, i32 } cleanup
+  resume { i8*, i32 } zeroinitializer
+}
+
+declare i8 @dummy(i8);

llvm/test/Transforms/MergeFunc/ir-cmp-ret.ll

+; RUN: opt -mergefunc -S < %s | FileCheck %s
+
+;; Make sure that two same Ret insts are treated as equal.
+
+target datalayout = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32"
+
+; Currently there is no special state being compared for Ret Instruction.
+
+; CHECK-LABEL: define i8* @f1
+; CHECK-NOT: call i8* @
+define i8* @f1() {
+  %v = alloca i8, align 1
+  store i8 0, i8* %v, align 1
+  ret i8* %v
+}
+
+; CHECK-LABEL: define i8* @f2
+; CHECK: call i8* @
+define i8* @f2() {
+  %v = alloca i8, align 1
+  store i8 0, i8* %v, align 1
+  ret i8* %v
+}
+

llvm/test/Transforms/MergeFunc/ir-cmp-store1.ll

+; RUN: opt -mergefunc -S < %s | FileCheck %s
+
+;; Make sure that two different Store Insts are not treated as equal.
+
+target datalayout = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32"
+
+;; Volatile difference
+
+; CHECK-LABEL: define void @store1
+; CHECK-NOT: call void @
+define void @store1() {
+  %ptr = alloca i32, align 4
+  store volatile i32 0, i32* %ptr, align 4
+  ret void
+}
+
+; CHECK-LABEL: define void @store2
+; CHECK-NOT: call void @
+define void @store2() {
+  %ptr = alloca i32, align 4
+  store i32 0, i32* %ptr, align 4
+  ret void
+}
+
+;; Alignment difference
+
+; CHECK-LABEL: define void @store3
+; CHECK-NOT: call void @
+define void @store3() {
+  %ptr = alloca i64, align 4
+  store i64 0, i64* %ptr, align 4
+  ret void
+}
+
+; CHECK-LABEL: define void @store4
+; CHECK-NOT: call void @
+define void @store4() {
+  %ptr = alloca i64, align 4
+  store i64 0, i64* %ptr, align 8
+  ret void
+}
+
+;; Ordering difference
+
+; CHECK-LABEL: define void @store5
+; CHECK-NOT: call void @
+define void @store5() {
+  %ptr = alloca i64, align 4
+  store atomic i64 0, i64* %ptr unordered, align 4
+  ret void
+}
+
+; CHECK-LABEL: define void @load6
+; CHECK-NOT: call void @
+define void @load6() {
+  %ptr = alloca i64, align 4
+  store atomic i64 0, i64* %ptr monotonic, align 4
+  ret void
+}
+
+;; SyncScopeID difference
+
+; CHECK-LABEL: define void @load9
+; CHECK-NOT: call void @
+define void @load9() {
+  %ptr = alloca i64, align 4
+  store atomic i64 0, i64* %ptr syncscope("singlethread") monotonic, align 4
+  ret void
+}
+
+; CHECK-LABEL: define void @load10
+; CHECK-NOT: call void @
+define void @load10() {
+  %ptr = alloca i64, align 4
+  store atomic i64 0, i64* %ptr syncscope("<target-scope>") monotonic, align 4
+  ret void
+}

llvm/test/Transforms/MergeFunc/ir-cmp-store2.ll

+; RUN: opt -mergefunc -S < %s | FileCheck %s
+
+;; Make sure that two same Store Insts are treated as equal.
+
+target datalayout = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32"
+
+;; Checks if two functions with same Store instructions are being merged
+;; Volatility, Alignment, Orderings, SyncScopeID are being checked
+
+; CHECK-LABEL: define void @store1
+; CHECK-NOT: call void @
+define void @store1(i8*) {
+  %ptr = alloca i32, align 4
+  store volatile i32 0, i32* %ptr
+  store atomic i8 0, i8* %0 syncscope("singlethread") monotonic, align 1
+  ret void
+}
+
+; CHECK-LABEL: define void @store2
+; CHECK: call void @
+define void @store2(i8*) {
+  %ptr = alloca i32, align 4
+  store volatile i32 0, i32* %ptr
+  store atomic i8 0, i8* %0 syncscope("singlethread") monotonic, align 1
+  ret void
+}

llvm/test/Transforms/MergeFunc/ir-cmp-switch.ll

+; RUN: opt -mergefunc -S < %s | FileCheck %s
+
+;; Make sure that two same Switch Insts are treated as equal.
+
+target datalayout = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32"
+
+;; Currently there is no special state being checked for comparison of Switch Instructions.
+
+; CHECK-LABEL: define void @f1
+; CHECK-NOT: call void @
+define void @f1(i32 %val) {
+  switch i32 %val, label %bb4 [i32 0, label %bb1
+                               i32 1, label %bb2
+                               i32 2, label %bb3]
+bb1:
+  br label %bb4
+
+bb2:
+  br label %bb4
+
+bb3:
+  br label %bb4
+
+bb4:
+  ret void
+}
+
+; CHECK-LABEL: define void @f2
+; CHECK: call void @
+define void @f2(i32 %val) {
+  switch i32 %val, label %bb4 [i32 0, label %bb1
+                               i32 1, label %bb2
+                               i32 2, label %bb3]
+bb1:
+  br label %bb4
+
+bb2:
+  br label %bb4
+
+bb3:
+  br label %bb4
+                                
+bb4:
+  ret void
+}

llvm/test/Transforms/MergeFunc/ir-cmp-unreachable.ll

+; RUN: opt -mergefunc -S < %s | FileCheck %s
+
+;; Make sure that two same Unreachable Insts are treated as equal.
+
+target datalayout = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32"
+
+; There is no special state being checked for Unreachable Insts currently.
+
+; CHECK-LABEL: define void @f1
+; CHECK-NOT: call void @
+define void @f1(i32* %p) {
+entry:
+  br label %end
+
+bb2:
+  %v2 = load i32, i32* %p, align 4
+  %c2 = icmp eq i32 %v2, 0
+  unreachable
+
+end:
+  ret void
+}
+
+; CHECK-LABEL: define void @f2
+; CHECK: call void @
+define void @f2(i32* %p) {
+entry:
+  br label %end
+
+bb2:
+  %v2 = load i32, i32* %p, align 4
+  %c2 = icmp eq i32 %v2, 0
+  unreachable
+
+end:
+  ret void
+}