Support alias.scope and noalias metadata lowering on intrinsics.

[nimiwio]

Summary

Builds on https://reviews.llvm.org/D107870 to support annotating intrinsics with alias.scope and noalias metadata.

[nimiwio]

Thank you for the reviews! Could you please land this when you get a chance?

mlir/include/mlir/Dialect/ArmNeon/ArmNeon.td

 //===----------------------------------------------------------------------===//
 // ArmNeon op definitions
 //===----------------------------------------------------------------------===//
 
 // ArmNeon dialect op that corresponds (and is convertible to) an LLVM IR
 // intrinsic.
 class ArmNeon_IntrOp<string mnemonic, list<int> overloadedResults,
                      list<int> overloadedOperands, int numResults,
-                     list<OpTrait> traits = [], bit requiresAccessGroup = 0>
+                     list<OpTrait> traits = [], bit requiresAccessGroup = 0,
+                     bit requiresAliasScope = 0>
     : LLVM_IntrOpBase</*dialect=*/ArmNeon_Dialect,
                       /*opName=*/"intr." # mnemonic,
                       /*enumName=*/"aarch64_neon_" # !subst(".", "_", mnemonic),
                       /*overloadedResults=*/overloadedResults,
                       /*overloadedOperands=*/overloadedOperands,
                       /*traits=*/traits,
                       /*numResults=*/numResults,
-                      /*requiresAccessGroup=*/requiresAccessGroup>;
+                      /*requiresAccessGroup=*/requiresAccessGroup,
+                      /*requiresAliasScope=*/requiresAliasScope>;
 
 // ArmNeon dialect op that corresponds to an LLVM IR intrinsic with one
 // overloaded result.
 class ArmNeon_OverloadedOneResultIntrOp<string mnemonic,
                                         list<OpTrait> traits = []>
   : ArmNeon_IntrOp<mnemonic, [0], [], 1, traits>;
 
 // ArmNeon dialect op that corresponds to an LLVM IR intrinsic with one

mlir/include/mlir/Dialect/LLVMIR/LLVMOpBase.td

 // single struct result. In this case, the types of any overloaded results need
 // to be accessed via the LLVMStructType, instead of directly via the result.
 // "opName" contains the name of the operation to be associated with the
 // intrinsic and "enumName" contains the name of the intrinsic as appears in
 // `llvm::Intrinsic` enum; one usually wants these to be related.
 class LLVM_IntrOpBase<Dialect dialect, string opName, string enumName,
                       list<int> overloadedResults, list<int> overloadedOperands,
                       list<OpTrait> traits, int numResults,
-                      bit requiresAccessGroup = 0>
+                      bit requiresAccessGroup = 0, bit requiresAliasScope = 0>
     : LLVM_OpBase<dialect, opName, traits>,
       Results<!if(!gt(numResults, 0), (outs LLVM_Type:$res), (outs))> {
   string resultPattern = !if(!gt(numResults, 1),
                              LLVM_IntrPatterns.structResult,
                              LLVM_IntrPatterns.result);
   let llvmBuilder = [{
     llvm::Module *module = builder.GetInsertBlock()->getModule();
     llvm::Function *fn = llvm::Intrinsic::getDeclaration(
         module,
         llvm::Intrinsic::}] # enumName # [{,
         { }] # !interleave(!listconcat(
             ListIntSubst<resultPattern, overloadedResults>.lst,
             ListIntSubst<LLVM_IntrPatterns.operand,
                          overloadedOperands>.lst), ", ") # [{
         });
     auto operands = moduleTranslation.lookupValues(opInst.getOperands());
     }] # [{auto *inst = builder.CreateCall(fn, operands);
     }] # !if(!gt(requiresAccessGroup, 0),
       "moduleTranslation.setAccessGroupsMetadata(op, inst);",
       "(void) inst;")
+    # !if(!gt(requiresAliasScope, 0),
+      "moduleTranslation.setAliasScopeMetadata(op, inst);",
+      "(void) inst;")
     # !if(!gt(numResults, 0), "$res = inst;", "");
 }
 
 // Base class for LLVM intrinsic operations, should not be used directly. Places
 // the intrinsic into the LLVM dialect and prefixes its name with "intr.".
 class LLVM_IntrOp<string mnem, list<int> overloadedResults,
                   list<int> overloadedOperands, list<OpTrait> traits,
-                  int numResults, bit requiresAccessGroup = 0>
+                  int numResults, bit requiresAccessGroup = 0,
+                  bit requiresAliasScope = 0>
     : LLVM_IntrOpBase<LLVM_Dialect, "intr." # mnem, !subst(".", "_", mnem),
                       overloadedResults, overloadedOperands, traits,
-                      numResults, requiresAccessGroup>;
+                      numResults, requiresAccessGroup, requiresAliasScope>;
 
 // Base class for LLVM intrinsic operations returning no results. Places the
 // intrinsic into the LLVM dialect and prefixes its name with "intr.".
 //
 // Sample use: derive an entry from this class and populate the fields.
 //
 //    def LLVM_Name : LLVM_ZeroResultIntrOp<"name", [0], [NoSideEffect]>,
 //                    Arguments<(ins LLVM_Type, LLVM_Type)>;

mlir/test/mlir-tblgen/llvm-intrinsics.td

 // The second operand is overloadable, but the first operand needs to
 // match the result type.
 // CHECK: [1]
 // It has no side effects.
 // CHECK: [NoSideEffect]
 // It has a result.
 // CHECK: 1,
 // It does not require an access group.
+// CHECK: 0,
+// It does not require alias scopes.
 // CHECK: 0>
 // CHECK: Arguments<(ins LLVM_Type, LLVM_Type
 
 //---------------------------------------------------------------------------//
 
 // This checks that we can define an op that takes in an access group metadata.
 //
 // RUN: cat %S/../../../llvm/include/llvm/IR/Intrinsics.td \
 // RUN: | grep -v "llvm/IR/Intrinsics" \
 // RUN: | mlir-tblgen -gen-llvmir-intrinsics -I %S/../../../llvm/include/ --llvmir-intrinsics-filter=ptrmask --llvmir-intrinsics-access-group-regexp=ptrmask \
 // RUN: | FileCheck --check-prefix=GROUPS %s
 
 // GROUPS-LABEL: def LLVM_ptrmask
 // GROUPS: LLVM_IntrOp<"ptrmask
 // It has no side effects.
 // GROUPS: [NoSideEffect]
 // It has a result.
 // GROUPS: 1,
 // It requires generation of an access group LLVM metadata.
-// GROUPS: 1>
+// GROUPS: 1,
+// It does not require alias scopes.
+// GROUPS: 0>
 // It has an access group attribute.
 // GROUPS: OptionalAttr<SymbolRefArrayAttr>:$access_groups
 
 //---------------------------------------------------------------------------//
 
+// This checks that we can define an op that takes in alias scopes metadata.
+//
+// RUN: cat %S/../../../llvm/include/llvm/IR/Intrinsics.td \
+// RUN: | grep -v "llvm/IR/Intrinsics" \
+// RUN: | mlir-tblgen -gen-llvmir-intrinsics -I %S/../../../llvm/include/ --llvmir-intrinsics-filter=ptrmask --llvmir-intrinsics-alias-scopes-regexp=ptrmask \
+// RUN: | FileCheck --check-prefix=ALIAS %s
+
+// ALIAS-LABEL: def LLVM_ptrmask
+// ALIAS: LLVM_IntrOp<"ptrmask
+// It has no side effects.
+// ALIAS: [NoSideEffect]
+// It has a result.
+// ALIAS: 1,
+// It does not require an access group.
+// ALIAS: 0,
+// It requires generation of alias scopes LLVM metadata.
+// ALIAS: 1>
+// It has alias scopes and noalias.
+// ALIAS: OptionalAttr<SymbolRefArrayAttr>:$alias_scopes
+// ALIAS: OptionalAttr<SymbolRefArrayAttr>:$noalias_scopes
+
+//---------------------------------------------------------------------------//
+
 // This checks that the ODS we produce can be consumed by MLIR tablegen. We only
 // make sure the entire process does not fail and produces some C++. The shape
 // of this C++ code is tested by ODS tests.
 
 // RUN: cat %S/../../../llvm/include/llvm/IR/Intrinsics.td \
 // RUN: | grep -v "llvm/IR/Intrinsics" \
 // RUN: | mlir-tblgen -gen-llvmir-intrinsics -I %S/../../../llvm/include/ --llvmir-intrinsics-filter=vastart \
 // RUN: | mlir-tblgen -gen-op-decls -I %S/../../include \

mlir/tools/mlir-tblgen/LLVMIRIntrinsicGen.cpp

opBaseClass("dialect-opclass-base",
                 llvm::cl::init("LLVM_IntrOp"), llvm::cl::cat(IntrinsicGenCat));
 
 static llvm::cl::opt<std::string> accessGroupRegexp(
     "llvmir-intrinsics-access-group-regexp",
     llvm::cl::desc("Mark intrinsics that match the specified "
                    "regexp as taking an access group metadata"),
     llvm::cl::cat(IntrinsicGenCat));
 
+static llvm::cl::opt<std::string> aliasScopesRegexp(
+    "llvmir-intrinsics-alias-scopes-regexp",
+    llvm::cl::desc("Mark intrinsics that match the specified "
+                   "regexp as taking alias.scopes and noalias metadata"),
+    llvm::cl::cat(IntrinsicGenCat));
+
 // Used to represent the indices of overloadable operands/results.
 using IndicesTy = llvm::SmallBitVector;
 
 /// Return a CodeGen value type entry from a type record.
 static llvm::MVT::SimpleValueType getValueType(const llvm::Record *rec) {
   return (llvm::MVT::SimpleValueType)rec->getValueAsDef("VT")->getValueAsInt(
       "Value");
 }

 /// Returns true on error, false on success.
 static bool emitIntrinsic(const llvm::Record &record, llvm::raw_ostream &os) {
   LLVMIntrinsic intr(record);
 
   llvm::Regex accessGroupMatcher(accessGroupRegexp);
   bool requiresAccessGroup =
       !accessGroupRegexp.empty() && accessGroupMatcher.match(record.getName());
 
+  llvm::Regex aliasScopesMatcher(aliasScopesRegexp);
+  bool requiresAliasScopes =
+      !aliasScopesRegexp.empty() && aliasScopesMatcher.match(record.getName());
+
   // Prepare strings for traits, if any.
   llvm::SmallVector<llvm::StringRef, 2> traits;
   if (intr.isCommutative())
     traits.push_back("Commutative");
   if (!intr.hasSideEffects())
     traits.push_back("NoSideEffect");
 
   // Prepare strings for operands.
   llvm::SmallVector<llvm::StringRef, 8> operands(intr.getNumOperands(),
                                                  "LLVM_Type");
   if (requiresAccessGroup)
     operands.push_back("OptionalAttr<SymbolRefArrayAttr>:$access_groups");
+  if (requiresAliasScopes) {
+    operands.push_back("OptionalAttr<SymbolRefArrayAttr>:$alias_scopes");
+    operands.push_back("OptionalAttr<SymbolRefArrayAttr>:$noalias_scopes");
+  }
 
   // Emit the definition.
   os << "def LLVM_" << intr.getProperRecordName() << " : " << opBaseClass
      << "<\"" << intr.getOperationName() << "\", ";
   printBracketedRange(intr.getOverloadableResultsIdxs().set_bits(), os);
   os << ", ";
   printBracketedRange(intr.getOverloadableOperandsIdxs().set_bits(), os);
   os << ", ";
   printBracketedRange(traits, os);
   os << ", " << intr.getNumResults() << ", "
-     << (requiresAccessGroup ? "1" : "0") << ">, Arguments<(ins"
+     << (requiresAccessGroup ? "1" : "0") << ", "
+     << (requiresAliasScopes ? "1" : "0") << ">, Arguments<(ins"
      << (operands.empty() ? "" : " ");
   llvm::interleaveComma(operands, os);
   os << ")>;\n\n";
 
   return false;
 }
 
 /// Traverses the list of TableGen definitions derived from the "Intrinsic"