[TableGen] Add IntrNoMerge as intrinsic property

[kparzysz]

Summary

This is motivated by downstream changes, where merging of certain intrinsics should be avoided. Because the intrinsics are out-of-tree, there is no LLVM codegen testcase, but a generic TableGen testcase is included. This seems like a natural extension to the already existing intrinsic properties IntrNoDuplicate and IntrConvergent, and there is already a function attribute NoMerge, hence the upstream patch.

[kparzysz]

Gentle ping.

[jdoerfert]

LG, given that we have the attribute already

llvm/include/llvm/IR/Intrinsics.td

 
 // Applied by default.
 def IntrWillReturn : IntrinsicProperty<1>;
 
 // IntrCold - Calls to this intrinsic are cold.
 // Parallels the cold attribute on LLVM IR functions.
 def IntrCold : IntrinsicProperty;
 
-// IntrNoduplicate - Calls to this intrinsic cannot be duplicated.
+// IntrNoDuplicate - Calls to this intrinsic cannot be duplicated.
 // Parallels the noduplicate attribute on LLVM IR functions.
 def IntrNoDuplicate : IntrinsicProperty;
 
+// IntrNoMerge - Calls to this intrinsic cannot be merged
+// Parallels the nomerge attribute on LLVM IR functions.
+def IntrNoMerge : IntrinsicProperty;
+
 // IntrConvergent - Calls to this intrinsic are convergent and may not be made
 // control-dependent on any additional values.
 // Parallels the convergent attribute on LLVM IR functions.
 def IntrConvergent : IntrinsicProperty;
 
 // This property indicates that the intrinsic is safe to speculate.
 def IntrSpeculatable : IntrinsicProperty;
 

llvm/test/TableGen/intrin-properties.td

+// RUN: sed -e 's/<PROP>/ArgMemOnly/;s/<ATTR>/ArgMemOnly/' < %s > %t; llvm-tblgen -gen-intrinsic-impl -I %p/../../include %t | FileCheck %t
+// RUN: sed -e 's/<PROP>/Cold/;s/<ATTR>/Cold/' < %s > %t; llvm-tblgen -gen-intrinsic-impl -I %p/../../include %t | FileCheck %t
+// RUN: sed -e 's/<PROP>/Convergent/;s/<ATTR>/Convergent/' < %s > %t; llvm-tblgen -gen-intrinsic-impl -I %p/../../include %t | FileCheck %t
+// RUN: sed -e 's/<PROP>/InaccessibleMemOnly/;s/<ATTR>/InaccessibleMemOnly/' < %s > %t; llvm-tblgen -gen-intrinsic-impl -I %p/../../include %t | FileCheck %t
+// RUN: sed -e 's/<PROP>/InaccessibleMemOrArgMemOnly/;s/<ATTR>/InaccessibleMemOrArgMemOnly/' < %s > %t; llvm-tblgen -gen-intrinsic-impl -I %p/../../include %t | FileCheck %t
+// RUN: sed -e 's/<PROP>/NoDuplicate/;s/<ATTR>/NoDuplicate/' < %s > %t; llvm-tblgen -gen-intrinsic-impl -I %p/../../include %t | FileCheck %t
+// RUN: sed -e 's/<PROP>/NoFree/;s/<ATTR>/NoFree/' < %s > %t; llvm-tblgen -gen-intrinsic-impl -I %p/../../include %t | FileCheck %t
+// RUN: sed -e 's/<PROP>/NoMem/;s/<ATTR>/ReadNone/' < %s > %t; llvm-tblgen -gen-intrinsic-impl -I %p/../../include %t | FileCheck %t
+// RUN: sed -e 's/<PROP>/NoMerge/;s/<ATTR>/NoMerge/' < %s > %t; llvm-tblgen -gen-intrinsic-impl -I %p/../../include %t | FileCheck %t
+// RUN: sed -e 's/<PROP>/NoReturn/;s/<ATTR>/NoReturn/' < %s > %t; llvm-tblgen -gen-intrinsic-impl -I %p/../../include %t | FileCheck %t
+// RUN: sed -e 's/<PROP>/NoSync/;s/<ATTR>/NoSync/' < %s > %t; llvm-tblgen -gen-intrinsic-impl -I %p/../../include %t | FileCheck %t
+// RUN: sed -e 's/<PROP>/ReadMem/;s/<ATTR>/ReadOnly/' < %s > %t; llvm-tblgen -gen-intrinsic-impl -I %p/../../include %t | FileCheck %t
+// RUN: sed -e 's/<PROP>/Speculatable/;s/<ATTR>/Speculatable/' < %s > %t; llvm-tblgen -gen-intrinsic-impl -I %p/../../include %t | FileCheck %t
+// RUN: sed -e 's/<PROP>/WillReturn/;s/<ATTR>/WillReturn/' < %s > %t; llvm-tblgen -gen-intrinsic-impl -I %p/../../include %t | FileCheck %t
+// RUN: sed -e 's/<PROP>/WriteMem/;s/<ATTR>/WriteOnly/' < %s > %t; llvm-tblgen -gen-intrinsic-impl -I %p/../../include %t | FileCheck %t
+
+include "llvm/IR/Intrinsics.td"
+
+// CHECK: [[I:[0-9]+]], // llvm.tgtest.Intr<PROP>
+// CHECK: case [[I]]:
+// CHECK-NEXT: Atts[] = {{.*}}Attribute::<ATTR>
+def int_tgtest_Intr<PROP>:
+  Intrinsic<[llvm_i32_ty], [llvm_ptr_ty], [Intr<PROP>]>;
+

llvm/utils/TableGen/CodeGenIntrinsics.h

struct CodeGenIntrinsic {
   bool isCommutative;
 
   /// True if the intrinsic can throw.
   bool canThrow;
 
   /// True if the intrinsic is marked as noduplicate.
   bool isNoDuplicate;
 
+  /// True if the intrinsic is marked as nomerge.
+  bool isNoMerge;
+
   /// True if the intrinsic is no-return.
   bool isNoReturn;
 
   /// True if the intrinsic is no-sync.
   bool isNoSync;
 
   /// True if the intrinsic is no-free.
   bool isNoFree;

llvm/utils/TableGen/CodeGenTarget.cpp

CodeGenIntrinsic::CodeGenIntrinsic(Record *R,
   isCommutative = false;
   canThrow = false;
   isNoReturn = false;
   isNoSync = false;
   isNoFree = false;
   isWillReturn = false;
   isCold = false;
   isNoDuplicate = false;
+  isNoMerge = false;
   isConvergent = false;
   isSpeculatable = false;
   hasSideEffects = false;
 
   if (DefName.size() <= 4 ||
       std::string(DefName.begin(), DefName.begin() + 4) != "int_")
     PrintFatalError(DefLoc,
                     "Intrinsic '" + DefName + "' does not start with 'int_'!");
else if (R->getName() == "IntrInaccessibleMemOrArgMemOnly")
     ModRef = ModRefBehavior((ModRef & ~MR_Anywhere) | MR_ArgMem |
                             MR_InaccessibleMem);
   else if (R->getName() == "Commutative")
     isCommutative = true;
   else if (R->getName() == "Throws")
     canThrow = true;
   else if (R->getName() == "IntrNoDuplicate")
     isNoDuplicate = true;
+  else if (R->getName() == "IntrNoMerge")
+    isNoMerge = true;
   else if (R->getName() == "IntrConvergent")
     isConvergent = true;
   else if (R->getName() == "IntrNoReturn")
     isNoReturn = true;
   else if (R->getName() == "IntrNoSync")
     isNoSync = true;
   else if (R->getName() == "IntrNoFree")
     isNoFree = true;

llvm/utils/TableGen/IntrinsicEmitter.cpp

struct AttributeComparator {
   bool operator()(const CodeGenIntrinsic *L, const CodeGenIntrinsic *R) const {
     // Sort throwing intrinsics after non-throwing intrinsics.
     if (L->canThrow != R->canThrow)
       return R->canThrow;
 
     if (L->isNoDuplicate != R->isNoDuplicate)
       return R->isNoDuplicate;
 
+    if (L->isNoMerge != R->isNoMerge)
+      return R->isNoMerge;
+
     if (L->isNoReturn != R->isNoReturn)
       return R->isNoReturn;
 
     if (L->isNoSync != R->isNoSync)
       return R->isNoSync;
 
     if (L->isNoFree != R->isNoFree)
       return R->isNoFree;
if (ae) {
       }
     }
 
     if (!intrinsic.canThrow ||
         (intrinsic.ModRef != CodeGenIntrinsic::ReadWriteMem &&
          !intrinsic.hasSideEffects) ||
         intrinsic.isNoReturn || intrinsic.isNoSync || intrinsic.isNoFree ||
         intrinsic.isWillReturn || intrinsic.isCold || intrinsic.isNoDuplicate ||
-        intrinsic.isConvergent || intrinsic.isSpeculatable) {
+        intrinsic.isNoMerge || intrinsic.isConvergent ||
+        intrinsic.isSpeculatable) {
       OS << "      const Attribute::AttrKind Atts[] = {";
       ListSeparator LS(",");
       if (!intrinsic.canThrow)
         OS << LS << "Attribute::NoUnwind";
       if (intrinsic.isNoReturn)
         OS << LS << "Attribute::NoReturn";
       if (intrinsic.isNoSync)
         OS << LS << "Attribute::NoSync";
       if (intrinsic.isNoFree)
         OS << LS << "Attribute::NoFree";
       if (intrinsic.isWillReturn)
         OS << LS << "Attribute::WillReturn";
       if (intrinsic.isCold)
         OS << LS << "Attribute::Cold";
       if (intrinsic.isNoDuplicate)
         OS << LS << "Attribute::NoDuplicate";
+      if (intrinsic.isNoMerge)
+        OS << LS << "Attribute::NoMerge";
       if (intrinsic.isConvergent)
         OS << LS << "Attribute::Convergent";
       if (intrinsic.isSpeculatable)
         OS << LS << "Attribute::Speculatable";
 
       switch (intrinsic.ModRef) {
       case CodeGenIntrinsic::NoMem:
         if (intrinsic.hasSideEffects)