Integrated cmpOperations() of FunctionComparator into tblgen

[vish99]

Summary

Integrated cmpOperations() of FunctionComparator into tblgen by building a new backend --gen-ir-cmp to tblgen which produces the comparators from IRComprators.td file and changed FunctionComparator to use the file generated by tablegen which is IRComparators.inc

llvm/include/llvm/IR/IRComparators.td

+// The different types in which operands can be compared like cmpNumbers, cmpAttrs, etc
+class OperandCompareType<string name> {
+  string TyName = name;
+}
+
+// To describe comparision of a single operand. CmpCastClass is used when an additional dyn_cast is
+// needed to cast the pointers to another class and then compare Operands
+class OperandCompare<OperandCompareType compare_ty, string fetch_method="", bit need_loop=0, string for_end_method=""> {
+  OperandCompareType compareTy = compare_ty;
+  string OperandFetchMethod = fetch_method;
+  bit needForLoop = need_loop;
+  string forEndMethod = for_end_method;
+}
+
+// Describes the comparision of an instruction and contains the list of operands to compare for this
+// specific instruction
+class InstructionComparator<string inst_cls_name, list<OperandCompare> ops = []> {
+  string InstClassName = inst_cls_name;
+  list<OperandCompare> Operands = ops;
+}
+
+def CmpOperandsAsNumbers : OperandCompareType<"Numbers">;
+
+def CmpOperandsAsTypes : OperandCompareType<"Types">;
+
+def CmpOperandsAsOrderings : OperandCompareType<"Orderings">;
+
+def CmpOperandsAsMetaData : OperandCompareType<"RangeMetadata">;
+
+def CmpOperandsAsAttributes: OperandCompareType<"Attrs">;
+
+def CmpOperandsAsOperandBundle : OperandCompareType<"OperandBundlesSchema">;
+
+def CmpOperandsAsValues : OperandCompareType<"Values">;
+
+def CmpOperandsAsArrayRef : OperandCompareType<"ArrayRef">;
+
+//===----------------------------------------------------------------------===//
+//                                AllocaInst
+//===----------------------------------------------------------------------===//
+
+def AllocaInstTypes : OperandCompare<CmpOperandsAsTypes, "getAllocatedType">;
+
+def AllocaInstAlignment : OperandCompare<CmpOperandsAsNumbers, "getAlignment">;
+
+def AllocaInstCompare : InstructionComparator<"AllocaInst", [AllocaInstTypes, AllocaInstAlignment]>;
+
+//===----------------------------------------------------------------------===//
+//                                LoadInst
+//===----------------------------------------------------------------------===//
+
+def LoadInstVolatile : OperandCompare<CmpOperandsAsNumbers, "isVolatile">;
+
+def LoadInstAlignment : OperandCompare<CmpOperandsAsNumbers, "getAlignment">;
+
+def LoadInstOrdering : OperandCompare<CmpOperandsAsOrderings, "getOrdering">;
+
+def LoadInstScopeID : OperandCompare<CmpOperandsAsNumbers, "getSyncScopeID">;
+
+def LoadInstMetaData : OperandCompare<CmpOperandsAsMetaData, "getMetadata">;
+
+def LoadInstCompare : InstructionComparator<"LoadInst", [LoadInstVolatile, LoadInstAlignment, 
+                             LoadInstOrdering, LoadInstScopeID, LoadInstMetaData]>;
+
+//===----------------------------------------------------------------------===//
+//                                StoreInst
+//===----------------------------------------------------------------------===//
+
+def StoreInstVolatile : OperandCompare<CmpOperandsAsNumbers, "isVolatile">;
+
+def StoreInstAlignment : OperandCompare<CmpOperandsAsNumbers, "getAlignment">;
+
+def StoreInstOrdering : OperandCompare<CmpOperandsAsOrderings, "getOrdering">;
+
+def StoreInstScopeID : OperandCompare<CmpOperandsAsNumbers, "getSyncScopeID">;
+
+def StoreInstCompare : InstructionComparator<"StoreInst", [StoreInstVolatile, StoreInstAlignment, 
+                               StoreInstOrdering, StoreInstScopeID]>;
+
+//===----------------------------------------------------------------------===//
+//                                CmpInst
+//===----------------------------------------------------------------------===//
+
+def CmpInstPredicate : OperandCompare<CmpOperandsAsNumbers, "getPredicate">;
+
+def CmpInstCompare : InstructionComparator<"CmpInst", [CmpInstPredicate]>;
+
+//===----------------------------------------------------------------------===//
+//                                CallBase
+//===----------------------------------------------------------------------===//
+
+def CallBaseCallingConv : OperandCompare<CmpOperandsAsNumbers, "getCallingConv">;
+
+def CallBaseAttr : OperandCompare<CmpOperandsAsAttributes, "getAttributes">;
+
+def CallBaseOperandSchema : OperandCompare<CmpOperandsAsOperandBundle>;
+
+def CallBaseMetaData : OperandCompare<CmpOperandsAsMetaData, "getMetadata">;
+
+
+//===----------------------------------------------------------------------===//
+//                     CallInst (Subclass of CallBase)
+//===----------------------------------------------------------------------===//
+
+def CallInstTailCall : OperandCompare<CmpOperandsAsNumbers, "getTailCallKind">;
+
+def CallInstCompare : InstructionComparator<"CallInst", [CallBaseCallingConv, 
+                             CallBaseAttr, 
+                             CallInstTailCall,
+                             CallBaseOperandSchema, 
+                             CallBaseMetaData]>;
+
+//===----------------------------------------------------------------------===//
+//                     CallBrInst (Subclass of CallBase)
+//===----------------------------------------------------------------------===//
+
+def CallBrInstCompare : InstructionComparator<"CallBrInst", [CallBaseCallingConv, 
+                               CallBaseAttr,
+                                 CallBaseOperandSchema, 
+                                 CallBaseMetaData]>;
+
+//===----------------------------------------------------------------------===//
+//                     GCStatepointInst (Subclass of CallBase)
+//===----------------------------------------------------------------------===//                    
+
+def GCStatePointInstCompare : InstructionComparator<"GCStatepointInst", [CallBaseCallingConv, 
+                                     CallBaseAttr,
+                                         CallBaseOperandSchema, 
+                                         CallBaseMetaData]>;
+
+//===----------------------------------------------------------------------===//
+//                     InvokeInst (Subclass of CallBase)
+//===----------------------------------------------------------------------===//  
+
+def InvokeInstCompare : InstructionComparator<"InvokeInst", [CallBaseCallingConv, 
+                               CallBaseAttr,
+                                 CallBaseOperandSchema, 
+                                 CallBaseMetaData]>;                          
+
+//===----------------------------------------------------------------------===//
+//                                InsertVal
+//===----------------------------------------------------------------------===//
+
+def InsertValIndices : OperandCompare<CmpOperandsAsArrayRef, "getIndices">;
+
+def InsertValCompare : InstructionComparator<"InsertValueInst", [InsertValIndices]>;
+
+//===----------------------------------------------------------------------===//
+//                                ExtractVal
+//===----------------------------------------------------------------------===//
+
+def ExtractValIndices : OperandCompare<CmpOperandsAsArrayRef, "getIndices">;
+
+def ExtractValCompare : InstructionComparator<"ExtractValueInst", [ExtractValIndices]>;
+
+//===----------------------------------------------------------------------===//
+//                                FenceInst
+//===----------------------------------------------------------------------===//
+
+def FenceInstOrdering : OperandCompare<CmpOperandsAsOrderings, "getOrdering">;
+
+def FenceInstScopeID : OperandCompare<CmpOperandsAsNumbers, "getSyncScopeID">;
+
+def FenceInstCompare : InstructionComparator<"FenceInst", [FenceInstOrdering, FenceInstScopeID]>;
+
+//===----------------------------------------------------------------------===//
+//                                AtomicCmpXchgInst
+//===----------------------------------------------------------------------===//
+
+def AtomicCmpXchgInstVolatile : OperandCompare<CmpOperandsAsNumbers, "isVolatile">;
+
+def AtomicCmpXchgInstWeak : OperandCompare<CmpOperandsAsNumbers, "isWeak">;
+
+def AtomicCmpXchgSuccessOrd : OperandCompare<CmpOperandsAsOrderings, "getSuccessOrdering">;
+
+def AtomicCmpXchgFailureOrd : OperandCompare<CmpOperandsAsOrderings, "getFailureOrdering">;
+
+def AtomicCmpXchgScopeID : OperandCompare<CmpOperandsAsNumbers, "getSyncScopeID">;
+
+def AtomicCmpXchgCompare : InstructionComparator<"AtomicCmpXchgInst", [AtomicCmpXchgInstVolatile,
+                                     AtomicCmpXchgInstWeak,
+                                     AtomicCmpXchgSuccessOrd, 
+                                     AtomicCmpXchgFailureOrd,
+                                     AtomicCmpXchgScopeID]>;
+
+//===----------------------------------------------------------------------===//
+//                                AtomicRMWInst
+//===----------------------------------------------------------------------===//
+
+def AtomicRMWOperation : OperandCompare<CmpOperandsAsNumbers, "getOperation">;
+
+def AtomicRMWVolatile : OperandCompare<CmpOperandsAsNumbers, "isVolatile">;
+
+def AtomicRMWOrdering : OperandCompare<CmpOperandsAsOrderings, "getOrdering">;
+
+def AtomicRMWScopeID : OperandCompare<CmpOperandsAsNumbers, "getSyncScopeID">;
+
+def AtomicRMWInstCompare : InstructionComparator<"AtomicRMWInst", [AtomicRMWOperation, AtomicRMWVolatile,
+                                   AtomicRMWOrdering, AtomicRMWScopeID]>;
+
+//===----------------------------------------------------------------------===//
+//                                ShuffleVectorInst
+//===----------------------------------------------------------------------===//
+
+def ShuffleVectMask : OperandCompare<CmpOperandsAsArrayRef, "getShuffleMask">;
+
+def ShuffleVectCompare : InstructionComparator<"ShuffleVectorInst", [ShuffleVectMask]>;
+
+//===----------------------------------------------------------------------===//
+//                                PhiInst
+//===----------------------------------------------------------------------===//
+
+def PhiInstBBCmp : OperandCompare<CmpOperandsAsValues, "getIncomingBlock", 1, "getNumIncomingValues">;
+
+def PhiInstCompare : InstructionComparator<"PHINode", [PhiInstBBCmp]>;
 No newline at end of file

llvm/include/llvm/Transforms/Utils/FunctionComparator.h

 #ifndef LLVM_TRANSFORMS_UTILS_FUNCTIONCOMPARATOR_H
 #define LLVM_TRANSFORMS_UTILS_FUNCTIONCOMPARATOR_H
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Operator.h"
+#include "llvm/IR/Statepoint.h"
 #include "llvm/IR/ValueMap.h"
 #include "llvm/Support/AtomicOrdering.h"
 #include "llvm/Support/Casting.h"
 #include <cstdint>
 #include <tuple>
 
 namespace llvm {
 
protected:
   /// Stages:
   /// 1. Operations opcodes. Compared as numbers.
   /// 2. Number of operands.
   /// 3. Operation types. Compared with cmpType method.
   /// 4. Compare operation subclass optional data as stream of bytes:
   /// just convert it to integers and call cmpNumbers.
   /// 5. Compare in operation operand types with cmpType in
   /// most significant operand first order.
-  /// 6. Last stage. Check operations for some specific attributes.
-  /// For example, for Load it would be:
-  /// 6.1.Load: volatile (as boolean flag)
-  /// 6.2.Load: alignment (as integer numbers)
-  /// 6.3.Load: ordering (as underlying enum class value)
-  /// 6.4.Load: synch-scope (as integer numbers)
-  /// 6.5.Load: range metadata (as integer ranges)
-  /// On this stage its better to see the code, since its not more than 10-15
-  /// strings for particular instruction, and could change sometimes.
+  /// 6. Uses cmpIROperations to compare instruction specific properites
   ///
   /// Sets \p needToCmpOperands to true if the operands of the instructions
   /// still must be compared afterwards. In this case it's already guaranteed
   /// that both instructions have the same number of operands.
   int cmpOperations(const Instruction *L, const Instruction *R,
                     bool &needToCmpOperands) const;
 
+  /// This is an function in IRComparator.inc to compare specific
+  /// attributes of IR instructions auto-generated by tblgen.
+  /// The backend used is --gen-ir-cmp with tblgen file IRComparators.td
+  int cmpIROperations(const Instruction *L, const Instruction *R) const;
+
   /// cmpType - compares two types,
   /// defines total ordering among the types set.
   ///
   /// Return values:
   /// 0 if types are equal,
   /// -1 if Left is less than Right,
   /// +1 if Left is greater than Right.
   ///
protected:
   /// Otherwise return 0.
   /// 6. For all other cases put llvm_unreachable.
   int cmpTypes(Type *TyL, Type *TyR) const;
 
   int cmpNumbers(uint64_t L, uint64_t R) const;
   int cmpAPInts(const APInt &L, const APInt &R) const;
   int cmpAPFloats(const APFloat &L, const APFloat &R) const;
   int cmpMem(StringRef L, StringRef R) const;
+  int cmpArrayRef(ArrayRef<int> LIndices, ArrayRef<int> RIndices) const;
+  int cmpArrayRef(ArrayRef<unsigned> LIndices,
+                  ArrayRef<unsigned> RIndices) const;
 
   // The two functions undergoing comparison.
   const Function *FnL, *FnR;
 
 private:
   int cmpOrderings(AtomicOrdering L, AtomicOrdering R) const;
   int cmpInlineAsm(const InlineAsm *L, const InlineAsm *R) const;
   int cmpAttrs(const AttributeList L, const AttributeList R) const;

llvm/include/llvm/Transforms/Utils/IRComparator.inc

+/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
+|*                                                                            *|
+|* IRComparator Function Source Fragment                                      *|
+|*                                                                            *|
+|* Automatically generated file, do not edit!                                 *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#include "llvm/Transforms/Utils/FunctionComparator.h"
+using namespace llvm;
+// Function to compare IR instructions for equality
+int FunctionComparator::cmpIROperations(const Instruction *L,
+                                        const Instruction *R) const {
+  assert(L->getOpcode() != R->getOpcode() &&
+         "Cannot compare instructions with different Opcode");
+  assert(L->getNumOperands() != R->getNumOperands() &&
+         "Cannot compare instructions with different number of operands");
+  if (const AllocaInst *castL = dyn_cast<AllocaInst>(L)) {
+    const AllocaInst *castR = cast<AllocaInst>(R);
+    if (int Res =
+            cmpTypes(castL->getAllocatedType(), castR->getAllocatedType()))
+      return Res;
+    return cmpNumbers(castL->getAlignment(), castR->getAlignment());
+  }
+  if (const AtomicCmpXchgInst *castL = dyn_cast<AtomicCmpXchgInst>(L)) {
+    const AtomicCmpXchgInst *castR = cast<AtomicCmpXchgInst>(R);
+    if (int Res = cmpNumbers(castL->isVolatile(), castR->isVolatile()))
+      return Res;
+    if (int Res = cmpNumbers(castL->isWeak(), castR->isWeak()))
+      return Res;
+    if (int Res = cmpOrderings(castL->getSuccessOrdering(),
+                               castR->getSuccessOrdering()))
+      return Res;
+    if (int Res = cmpOrderings(castL->getFailureOrdering(),
+                               castR->getFailureOrdering()))
+      return Res;
+    return cmpNumbers(castL->getSyncScopeID(), castR->getSyncScopeID());
+  }
+  if (const AtomicRMWInst *castL = dyn_cast<AtomicRMWInst>(L)) {
+    const AtomicRMWInst *castR = cast<AtomicRMWInst>(R);
+    if (int Res = cmpNumbers(castL->getOperation(), castR->getOperation()))
+      return Res;
+    if (int Res = cmpNumbers(castL->isVolatile(), castR->isVolatile()))
+      return Res;
+    if (int Res = cmpOrderings(castL->getOrdering(), castR->getOrdering()))
+      return Res;
+    return cmpNumbers(castL->getSyncScopeID(), castR->getSyncScopeID());
+  }
+  if (const CallBrInst *castL = dyn_cast<CallBrInst>(L)) {
+    const CallBrInst *castR = cast<CallBrInst>(R);
+    if (int Res = cmpNumbers(castL->getCallingConv(), castR->getCallingConv()))
+      return Res;
+    if (int Res = cmpAttrs(castL->getAttributes(), castR->getAttributes()))
+      return Res;
+    if (int Res = cmpOperandBundlesSchema(*castL, *castR))
+      return Res;
+    return cmpRangeMetadata(castL->getMetadata(LLVMContext::MD_range),
+                            castR->getMetadata(LLVMContext::MD_range));
+  }
+  if (const CallInst *castL = dyn_cast<CallInst>(L)) {
+    const CallInst *castR = cast<CallInst>(R);
+    if (int Res = cmpNumbers(castL->getCallingConv(), castR->getCallingConv()))
+      return Res;
+    if (int Res = cmpAttrs(castL->getAttributes(), castR->getAttributes()))
+      return Res;
+    if (int Res =
+            cmpNumbers(castL->getTailCallKind(), castR->getTailCallKind()))
+      return Res;
+    if (int Res = cmpOperandBundlesSchema(*castL, *castR))
+      return Res;
+    return cmpRangeMetadata(castL->getMetadata(LLVMContext::MD_range),
+                            castR->getMetadata(LLVMContext::MD_range));
+  }
+  if (const CmpInst *castL = dyn_cast<CmpInst>(L)) {
+    const CmpInst *castR = cast<CmpInst>(R);
+    return cmpNumbers(castL->getPredicate(), castR->getPredicate());
+  }
+  if (const ExtractValueInst *castL = dyn_cast<ExtractValueInst>(L)) {
+    const ExtractValueInst *castR = cast<ExtractValueInst>(R);
+    return cmpArrayRef(castL->getIndices(), castR->getIndices());
+  }
+  if (const FenceInst *castL = dyn_cast<FenceInst>(L)) {
+    const FenceInst *castR = cast<FenceInst>(R);
+    if (int Res = cmpOrderings(castL->getOrdering(), castR->getOrdering()))
+      return Res;
+    return cmpNumbers(castL->getSyncScopeID(), castR->getSyncScopeID());
+  }
+  if (const GCStatepointInst *castL = dyn_cast<GCStatepointInst>(L)) {
+    const GCStatepointInst *castR = cast<GCStatepointInst>(R);
+    if (int Res = cmpNumbers(castL->getCallingConv(), castR->getCallingConv()))
+      return Res;
+    if (int Res = cmpAttrs(castL->getAttributes(), castR->getAttributes()))
+      return Res;
+    if (int Res = cmpOperandBundlesSchema(*castL, *castR))
+      return Res;
+    return cmpRangeMetadata(castL->getMetadata(LLVMContext::MD_range),
+                            castR->getMetadata(LLVMContext::MD_range));
+  }
+  if (const InsertValueInst *castL = dyn_cast<InsertValueInst>(L)) {
+    const InsertValueInst *castR = cast<InsertValueInst>(R);
+    return cmpArrayRef(castL->getIndices(), castR->getIndices());
+  }
+  if (const InvokeInst *castL = dyn_cast<InvokeInst>(L)) {
+    const InvokeInst *castR = cast<InvokeInst>(R);
+    if (int Res = cmpNumbers(castL->getCallingConv(), castR->getCallingConv()))
+      return Res;
+    if (int Res = cmpAttrs(castL->getAttributes(), castR->getAttributes()))
+      return Res;
+    if (int Res = cmpOperandBundlesSchema(*castL, *castR))
+      return Res;
+    return cmpRangeMetadata(castL->getMetadata(LLVMContext::MD_range),
+                            castR->getMetadata(LLVMContext::MD_range));
+  }
+  if (const LoadInst *castL = dyn_cast<LoadInst>(L)) {
+    const LoadInst *castR = cast<LoadInst>(R);
+    if (int Res = cmpNumbers(castL->isVolatile(), castR->isVolatile()))
+      return Res;
+    if (int Res = cmpNumbers(castL->getAlignment(), castR->getAlignment()))
+      return Res;
+    if (int Res = cmpOrderings(castL->getOrdering(), castR->getOrdering()))
+      return Res;
+    if (int Res = cmpNumbers(castL->getSyncScopeID(), castR->getSyncScopeID()))
+      return Res;
+    return cmpRangeMetadata(castL->getMetadata(LLVMContext::MD_range),
+                            castR->getMetadata(LLVMContext::MD_range));
+  }
+  if (const PHINode *castL = dyn_cast<PHINode>(L)) {
+    const PHINode *castR = cast<PHINode>(R);
+    for (unsigned i = 0, e = castL->getNumIncomingValues(); i != e; i++) {
+      if (int Res =
+              cmpValues(castL->getIncomingBlock(i), castR->getIncomingBlock(i)))
+        return Res;
+    }
+  }
+  if (const ShuffleVectorInst *castL = dyn_cast<ShuffleVectorInst>(L)) {
+    const ShuffleVectorInst *castR = cast<ShuffleVectorInst>(R);
+    return cmpArrayRef(castL->getShuffleMask(), castR->getShuffleMask());
+  }
+  if (const StoreInst *castL = dyn_cast<StoreInst>(L)) {
+    const StoreInst *castR = cast<StoreInst>(R);
+    if (int Res = cmpNumbers(castL->isVolatile(), castR->isVolatile()))
+      return Res;
+    if (int Res = cmpNumbers(castL->getAlignment(), castR->getAlignment()))
+      return Res;
+    if (int Res = cmpOrderings(castL->getOrdering(), castR->getOrdering()))
+      return Res;
+    return cmpNumbers(castL->getSyncScopeID(), castR->getSyncScopeID());
+  }
+  return 0;
+}

llvm/lib/Transforms/Utils/FunctionComparator.cpp

 #include "llvm/IR/Operator.h"
 #include "llvm/IR/Type.h"
 #include "llvm/IR/Value.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/Transforms/Utils/IRComparator.inc"
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <utility>
 
 using namespace llvm;
 
 #define DEBUG_TYPE "functioncomparator"
int FunctionComparator::cmpMem(StringRef L, StringRef R) const {
   if (int Res = cmpNumbers(L.size(), R.size()))
     return Res;
 
   // Compare strings lexicographically only when it is necessary: only when
   // strings are equal in size.
   return L.compare(R);
 }
 
+int FunctionComparator::cmpArrayRef(ArrayRef<int> LIndices,
+                                    ArrayRef<int> RIndices) const {
+  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;
+}
+
+int FunctionComparator::cmpArrayRef(ArrayRef<unsigned> LIndices,
+                                    ArrayRef<unsigned> RIndices) const {
+  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;
+}
+
 int FunctionComparator::cmpAttrs(const AttributeList L,
                                  const AttributeList R) const {
   if (int Res = cmpNumbers(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);
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.
-  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)) {
-    return FI->hasSamePropertiesAs(R);
-  }
-  if (const AtomicCmpXchgInst *CXI = dyn_cast<AtomicCmpXchgInst>(L)) {
-    return CXI->hasSamePropertiesAs(R);
-  }
-  if (const AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(L)) {
-    if (int Res = cmpNumbers(RMWI->getOperation(),
-                             cast<AtomicRMWInst>(R)->getOperation()))
-      return Res;
-    if (int Res = cmpNumbers(RMWI->isVolatile(),
-                             cast<AtomicRMWInst>(R)->isVolatile()))
-      return Res;
-    if (int Res = cmpOrderings(RMWI->getOrdering(),
-                               cast<AtomicRMWInst>(R)->getOrdering()))
-      return Res;
-    return cmpNumbers(RMWI->getSyncScopeID(),
-                      cast<AtomicRMWInst>(R)->getSyncScopeID());
-  }
-  if (const ShuffleVectorInst *SVI = dyn_cast<ShuffleVectorInst>(L)) {
-    ArrayRef<int> LMask = SVI->getShuffleMask();
-    ArrayRef<int> RMask = cast<ShuffleVectorInst>(R)->getShuffleMask();
-    if (int Res = cmpNumbers(LMask.size(), RMask.size()))
-      return Res;
-    for (size_t i = 0, e = LMask.size(); i != e; ++i) {
-      if (int Res = cmpNumbers(LMask[i], RMask[i]))
-        return Res;
-    }
-  }
-  if (const PHINode *PNL = dyn_cast<PHINode>(L)) {
-    const PHINode *PNR = cast<PHINode>(R);
-    // Ensure that in addition to the incoming values being identical
-    // (checked by the caller of this function), the incoming blocks
-    // are also identical.
-    for (unsigned i = 0, e = PNL->getNumIncomingValues(); i != e; ++i) {
-      if (int Res =
-              cmpValues(PNL->getIncomingBlock(i), PNR->getIncomingBlock(i)))
-        return Res;
-    }
-  }
-  return 0;
+  return cmpIROperations(L, 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/utils/TableGen/CMakeLists.txt

add_tablegen(llvm-tblgen LLVM
   FastISelEmitter.cpp
   FixedLenDecoderEmitter.cpp
   GICombinerEmitter.cpp
   GlobalISelEmitter.cpp
   InfoByHwMode.cpp
   InstrInfoEmitter.cpp
   InstrDocsEmitter.cpp
   IntrinsicEmitter.cpp
+  IRComparator.cpp
   OptEmitter.cpp
   OptParserEmitter.cpp
   OptRSTEmitter.cpp
   PredicateExpander.cpp
   PseudoLoweringEmitter.cpp
   RISCVCompressInstEmitter.cpp
   RegisterBankEmitter.cpp
   RegisterInfoEmitter.cpp

llvm/utils/TableGen/IRComparator.h

+#ifndef LLVM_UTILS_TABLEGEN_IRCOMPARATORS_H
+#define LLVM_UTILS_TABLEGEN_IRCOMPARATORS_H
+
+#include "llvm/TableGen/Record.h"
+#include <string>
+#include <vector>
+
+namespace llvm {
+class Record;
+class RecordKeeper;
+
+struct ComparableInstruction {
+  Record *TheDef;
+  std::string InstClassName;
+  struct OperandCompareElement {
+    std::string compareTy;
+    std::string fetchMethod;
+    bool requiresForLoop;
+    std::string forloopEndMethod;
+  };
+  std::vector<OperandCompareElement> operandsToCompare;
+
+  ComparableInstruction(Record *R) {
+    TheDef = R;
+    InstClassName = std::string(R->getValueAsString("InstClassName"));
+    ListInit *Operands = R->getValueAsListInit("Operands");
+    for (unsigned i = 0, e = Operands->size(); i != e; ++i) {
+      Record *Op = Operands->getElementAsRecord(i);
+      assert(Op->isSubClassOf("OperandCompare") &&
+             "Expected an element of OperandCompare!");
+      Record *OpTy = Op->getValueAsDef("compareTy");
+      std::string OpTyName = std::string(OpTy->getValueAsString("TyName"));
+      std::string OpFetchMethod =
+          std::string(Op->getValueAsString("OperandFetchMethod"));
+      bool OprequiresForLoop = Op->getValueAsBit("needForLoop");
+      std::string OpforLoopEndMethod =
+          std::string(Op->getValueAsString("forEndMethod"));
+      struct OperandCompareElement Elm;
+      Elm.compareTy = OpTyName;
+      Elm.fetchMethod = OpFetchMethod;
+      Elm.requiresForLoop = OprequiresForLoop;
+      Elm.forloopEndMethod = OpforLoopEndMethod;
+      operandsToCompare.push_back(Elm);
+    }
+  }
+};
+
+class InstructionCompTable {
+  std::vector<ComparableInstruction> Instructions;
+
+public:
+  explicit InstructionCompTable(const RecordKeeper &RC) {
+    std::vector<Record *> Defs =
+        RC.getAllDerivedDefinitions("InstructionComparator");
+    Instructions.reserve(Defs.size());
+
+    for (unsigned i = 0, e = Defs.size(); i != e; ++i)
+      Instructions.push_back(ComparableInstruction(Defs[i]));
+  }
+
+  InstructionCompTable() = default;
+  bool empty() const { return Instructions.empty(); }
+  size_t size() const { return Instructions.size(); }
+  ComparableInstruction &operator[](size_t Pos) { return Instructions[Pos]; }
+  const ComparableInstruction &operator[](size_t Pos) const {
+    return Instructions[Pos];
+  }
+};
+} // namespace llvm
+#endif
 No newline at end of file

llvm/utils/TableGen/IRComparator.cpp

+#include "IRComparator.h"
+#include "TableGenBackends.h"
+#include "llvm/TableGen/Error.h"
+#include "llvm/TableGen/Record.h"
+#include "llvm/TableGen/StringMatcher.h"
+#include "llvm/TableGen/StringToOffsetTable.h"
+#include "llvm/TableGen/TableGenBackend.h"
+using namespace llvm;
+
+namespace {
+class IRComparator {
+  RecordKeeper &Records;
+
+public:
+  IRComparator(RecordKeeper &R) : Records(R) {}
+
+  void run(raw_ostream &OS);
+
+  std::string getIntendation(int tabs);
+
+  void EmitCond(std::string compareTy, std::string fetchMethod, raw_ostream &OS,
+                bool isLast, bool inLoopCmp);
+
+  void EmitCmpFunction(const InstructionCompTable &Insts, raw_ostream &OS);
+};
+} // End anonymous namespace
+
+//===----------------------------------------------------------------------===//
+// IRComparator Implementation
+//===----------------------------------------------------------------------===//
+
+void IRComparator::run(raw_ostream &OS) {
+  emitSourceFileHeader("IRComparator Function Source Fragment", OS);
+
+  InstructionCompTable Insts(Records);
+
+  // Header for helper functions to compare basic types
+  OS << "#include \"llvm/Transforms/Utils/FunctionComparator.h\"\n";
+  OS << "using namespace llvm;\n";
+
+  // Emit the function which checks for similarity between every instruction
+  EmitCmpFunction(Insts, OS);
+}
+
+std::string IRComparator::getIntendation(int tabs) {
+  std::string intend = "";
+  while (tabs--)
+    intend += "  ";
+  return intend;
+}
+
+void IRComparator::EmitCond(std::string compareTy, std::string fetchMethod,
+                            raw_ostream &OS, bool isLast, bool inLoopCmp) {
+  if (compareTy == "OperandBundlesSchema") {
+    OS << "*castL, *castR)";
+  } else if (compareTy == "RangeMetadata") {
+    OS << "castL->" << fetchMethod << "(LLVMContext::MD_range), ";
+    OS << "castR->" << fetchMethod << "(LLVMContext::MD_range))";
+  } else {
+    if (inLoopCmp) {
+      OS << "castL->" << fetchMethod << "(i), ";
+      OS << "castR->" << fetchMethod << "(i))";
+    } else {
+      OS << "castL->" << fetchMethod << "(), ";
+      OS << "castR->" << fetchMethod << "())";
+    }
+  }
+  if (isLast)
+    OS << ";\n";
+  else
+    OS << ")\n";
+  return;
+}
+
+// Function to generate structured operand checks for each Instruction
+void IRComparator::EmitCmpFunction(const InstructionCompTable &Insts,
+                                   raw_ostream &OS) {
+  OS << "// Function to compare IR instructions for equality\n";
+  OS << "int FunctionComparator::cmpIROperations(const Instruction *L, const "
+        "Instruction *R) const {\n";
+  OS << "  assert(L->getOpcode() != R->getOpcode() && \"Cannot compare "
+        "instructions with different Opcode\");\n";
+  OS << "  assert(L->getNumOperands() != R->getNumOperands() && \"Cannot "
+        "compare instructions with different number of operands\");\n";
+  int intend = 1;
+  for (unsigned i = 0, e = Insts.size(); i < e; i++) {
+    OS << getIntendation(intend);
+    OS << "if(const " << Insts[i].InstClassName << " *castL = dyn_cast<"
+       << Insts[i].InstClassName << ">(L)) {\n";
+    intend++;
+    OS << getIntendation(intend);
+    OS << "const " << Insts[i].InstClassName << " *castR = cast<"
+       << Insts[i].InstClassName << ">(R);\n";
+    unsigned last = Insts[i].operandsToCompare.size() - 1;
+
+    for (unsigned i1 = 0, e1 = last + 1; i1 != e1; i1++) {
+      bool requiresFor = Insts[i].operandsToCompare[i1].requiresForLoop;
+      if (i1 < last || Insts[i].operandsToCompare[last].requiresForLoop) {
+        if (requiresFor) {
+          OS << getIntendation(intend);
+          OS << "for(unsigned i = 0, e = castL->"
+             << Insts[i].operandsToCompare[i1].forloopEndMethod
+             << "(); i != e; i++) {\n";
+          intend++;
+        }
+        OS << getIntendation(intend);
+        OS << "if(int Res = cmp" << Insts[i].operandsToCompare[i1].compareTy
+           << "(";
+        EmitCond(Insts[i].operandsToCompare[i1].compareTy,
+                 Insts[i].operandsToCompare[i1].fetchMethod, OS, false,
+                 requiresFor);
+        OS << getIntendation(intend + 1);
+        OS << "return Res;\n";
+        if (requiresFor) {
+          intend--;
+          OS << getIntendation(intend);
+          OS << "}\n";
+          intend--;
+          OS << getIntendation(intend);
+          OS << "}\n";
+        }
+      } else {
+        OS << getIntendation(intend);
+        OS << "return cmp" << Insts[i].operandsToCompare[last].compareTy << "(";
+        EmitCond(Insts[i].operandsToCompare[last].compareTy,
+                 Insts[i].operandsToCompare[last].fetchMethod, OS, true, false);
+        intend--;
+        OS << getIntendation(intend);
+        OS << "}\n";
+      }
+    }
+  }
+  OS << "  return 0;\n";
+  OS << "}\n";
+}
+
+void llvm::EmitIRCompFunc(RecordKeeper &RK, raw_ostream &OS) {
+  IRComparator(RK).run(OS);
+}

llvm/utils/TableGen/TableGen.cpp

 
 enum ActionType {
   PrintRecords,
   DumpJSON,
   GenEmitter,
   GenRegisterInfo,
   GenInstrInfo,
   GenInstrDocs,
+  GenInstCmp,
   GenAsmWriter,
   GenAsmMatcher,
   GenDisassembler,
   GenPseudoLowering,
   GenCompressInst,
   GenCallingConv,
   GenDAGISel,
   GenDFAPacketizer,
cl::values(
                    "Dump all records as machine-readable JSON"),
         clEnumValN(GenEmitter, "gen-emitter", "Generate machine code emitter"),
         clEnumValN(GenRegisterInfo, "gen-register-info",
                    "Generate registers and register classes info"),
         clEnumValN(GenInstrInfo, "gen-instr-info",
                    "Generate instruction descriptions"),
         clEnumValN(GenInstrDocs, "gen-instr-docs",
                    "Generate instruction documentation"),
+        clEnumValN(GenInstCmp, "gen-ir-cmp", "Generate IR Comparator function"),
         clEnumValN(GenCallingConv, "gen-callingconv",
                    "Generate calling convention descriptions"),
         clEnumValN(GenAsmWriter, "gen-asm-writer", "Generate assembly writer"),
         clEnumValN(GenDisassembler, "gen-disassembler",
                    "Generate disassembler"),
         clEnumValN(GenPseudoLowering, "gen-pseudo-lowering",
                    "Generate pseudo instruction lowering"),
         clEnumValN(GenCompressInst, "gen-compress-inst-emitter",
case GenRegisterInfo:
     EmitRegisterInfo(Records, OS);
     break;
   case GenInstrInfo:
     EmitInstrInfo(Records, OS);
     break;
   case GenInstrDocs:
     EmitInstrDocs(Records, OS);
     break;
+  case GenInstCmp:
+    EmitIRCompFunc(Records, OS);
+    break;
   case GenCallingConv:
     EmitCallingConv(Records, OS);
     break;
   case GenAsmWriter:
     EmitAsmWriter(Records, OS);
     break;
   case GenAsmMatcher:
     EmitAsmMatcher(Records, OS);

llvm/utils/TableGen/TableGenBackends.h

 void EmitSearchableTables(RecordKeeper &RK, raw_ostream &OS);
 void EmitGlobalISel(RecordKeeper &RK, raw_ostream &OS);
 void EmitGICombiner(RecordKeeper &RK, raw_ostream &OS);
 void EmitX86EVEX2VEXTables(RecordKeeper &RK, raw_ostream &OS);
 void EmitX86FoldTables(RecordKeeper &RK, raw_ostream &OS);
 void EmitRegisterBank(RecordKeeper &RK, raw_ostream &OS);
 void EmitExegesis(RecordKeeper &RK, raw_ostream &OS);
 void EmitAutomata(RecordKeeper &RK, raw_ostream &OS);
+void EmitIRCompFunc(RecordKeeper &RK, raw_ostream &OS);
 
 } // End llvm namespace
 
 #endif