[mlir][llvm] Add experimental alias scope decl intrinsic.

[gysit]

Summary

The revision adds the llvm.experimental.noalias.scope.decl intrinsic
to the LLVM dialect and updates the import and export accordingly.

[Dinistro]

LGTM, modulo minor comments.

mlir/include/mlir/Dialect/LLVMIR/LLVMIntrinsicOps.td

174

If I understand this correctly, we use this function to explicitly create a list of scopes, even though there is only one element. The Lang Ref specifies this in this manner, but I would like to see a comment somewhere that explains this unexpected handling.

mlir/test/Target/LLVMIR/Import/metadata-alias-scopes.ll

85

Shouldn't these scopes be in the beginning, i.e., before the first usage of the !2?

mlir/test/Target/LLVMIR/llvmir.mlir

2019–2020

That's in general a nice test improvement, thanks.

2037

Again, shouldn't this be at the beginning of the basic block?

[gysit]

Address review comments.

[gysit]

mlir/test/Target/LLVMIR/Import/metadata-alias-scopes.ll

85

Yes I that makes sense and seems to be more inline with the examples in the language reference.

mlir/include/mlir/Dialect/LLVMIR/LLVMIntrinsicOps.td

OpBuilder<(ins "Value":$dst, "Value":$val, "Value":$len,
                     "Value":$isVolatile), [{
       build($_builder, $_state, dst, val, len, isVolatile,
             /*access_groups=*/nullptr, /*alias_scopes=*/nullptr,
             /*noalias_scopes=*/nullptr, /*tbaa=*/nullptr);
     }]
   >];
 }
 
+def LLVM_NoAliasScopeDeclOp
+    : LLVM_ZeroResultIntrOp<"experimental.noalias.scope.decl"> {
+  let arguments = (ins SymbolRefAttr:$scope);
+  string llvmBuilder = [{
+    // Wrap the scope argument into a list since the LLVM IR intrinsic takes
+    // a list containing exactly one scope rather than a scope itself.
+    llvm::MDNode* node = moduleTranslation.getAliasScopes(op, {$scope});
+    builder.CreateNoAliasScopeDeclaration(node);
+  }];
+  string mlirBuilder = [{
+    FailureOr<SmallVector<SymbolRefAttr>> scopeAttrs =
+      moduleImport.matchAliasScopeAttrs(llvmOperands[0]);
+    // Drop the intrinsic if the alias scope translation fails since the scope
+    // is not used by an aliasing operation, such as a load or store, that is
+    // used to convert the alias scope metadata.
+    if (failed(scopeAttrs))
+      return success();
+    if (scopeAttrs->size() != 1)
+      return failure();
+    $_op = $_builder.create<LLVM::NoAliasScopeDeclOp>(
+      $_location, (*scopeAttrs)[0]);
+  }];
+  let assemblyFormat = "$scope attr-dict";
+}
+
 //===----------------------------------------------------------------------===//
 // Lifetime Markers
 //===----------------------------------------------------------------------===//
 
 /// Base operation for lifetime markers. The LLVM intrinsics require the size
 /// operand to be an immediate. In MLIR it is encoded as an attribute.
 class LLVM_LifetimeBaseOp<string opName> : LLVM_ZeroResultIntrOp<opName> {
   let arguments = (ins I64Attr:$size, LLVM_AnyPointer:$ptr);

mlir/include/mlir/Target/LLVMIR/ModuleImport.h

public:
 
   /// Converts `value` to an integer attribute. Asserts if the matching fails.
   IntegerAttr matchIntegerAttr(llvm::Value *value);
 
   /// Converts `value` to a local variable attribute. Asserts if the matching
   /// fails.
   DILocalVariableAttr matchLocalVariableAttr(llvm::Value *value);
 
+  /// Converts `value` to an array of symbol references pointing to alias scope
+  /// operations, or returns failure if the conversion fails.
+  FailureOr<SmallVector<SymbolRefAttr>>
+  matchAliasScopeAttrs(llvm::Value *value);
+
   /// Translates the debug location.
   Location translateLoc(llvm::DILocation *loc);
 
   /// Converts the type from LLVM to MLIR LLVM dialect.
   Type convertType(llvm::Type *type) {
     return typeTranslator.translateType(type);
   }
 

mlir/include/mlir/Target/LLVMIR/ModuleTranslation.h

llvm::Instruction *lookupBranch(Operation *op) const {
     return branchMapping.lookup(op);
   }
 
   /// Removes the mapping for blocks contained in the region and values defined
   /// in these blocks.
   void forgetMapping(Region &region);
 
   /// Returns the LLVM metadata corresponding to a symbol reference to an mlir
-  /// LLVM dialect alias scope operation
+  /// LLVM dialect alias scope operation.
   llvm::MDNode *getAliasScope(Operation *op, SymbolRefAttr aliasScopeRef) const;
 
+  /// Returns the LLVM metadata corresponding to an array of symbol references
+  /// to mlir LLVM dialect alias scope operations.
+  llvm::MDNode *getAliasScopes(Operation *op,
+                               ArrayRef<SymbolRefAttr> aliasScopeRefs) const;
+
   // Sets LLVM metadata for memory operations that are in a parallel loop.
   void setAccessGroupsMetadata(AccessGroupOpInterface op,
                                llvm::Instruction *inst);
 
   // Sets LLVM metadata for memory operations that have alias scope information.
   void setAliasScopeMetadata(AliasAnalysisOpInterface op,
                              llvm::Instruction *inst);
 

mlir/lib/Target/LLVMIR/ModuleImport.cpp

 }
 
 DILocalVariableAttr ModuleImport::matchLocalVariableAttr(llvm::Value *value) {
   auto *nodeAsVal = cast<llvm::MetadataAsValue>(value);
   auto *node = cast<llvm::DILocalVariable>(nodeAsVal->getMetadata());
   return debugImporter->translate(node);
 }
 
+FailureOr<SmallVector<SymbolRefAttr>>
+ModuleImport::matchAliasScopeAttrs(llvm::Value *value) {
+  auto *nodeAsVal = cast<llvm::MetadataAsValue>(value);
+  auto *node = cast<llvm::MDNode>(nodeAsVal->getMetadata());
+  return lookupAliasScopeAttrs(node);
+}
+
 Location ModuleImport::translateLoc(llvm::DILocation *loc) {
   return debugImporter->translateLoc(loc);
 }
 
 LogicalResult
 ModuleImport::convertBranchArgs(llvm::Instruction *branch,
                                 llvm::BasicBlock *target,
                                 SmallVectorImpl<Value> &blockArguments) {

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

ModuleTranslation::getAliasScope(Operation *op,
   StringAttr scopeName = aliasScopeRef.getLeafReference();
   auto metadataOp = SymbolTable::lookupNearestSymbolFrom<LLVM::MetadataOp>(
       op->getParentOp(), metadataName);
   Operation *aliasScopeOp =
       SymbolTable::lookupNearestSymbolFrom(metadataOp, scopeName);
   return aliasScopeMetadataMapping.lookup(aliasScopeOp);
 }
 
+llvm::MDNode *ModuleTranslation::getAliasScopes(
+    Operation *op, ArrayRef<SymbolRefAttr> aliasScopeRefs) const {
+  SmallVector<llvm::Metadata *> nodes;
+  nodes.reserve(aliasScopeRefs.size());
+  for (SymbolRefAttr aliasScopeRef : aliasScopeRefs)
+    nodes.push_back(getAliasScope(op, aliasScopeRef));
+  return llvm::MDNode::get(getLLVMContext(), nodes);
+}
+
 void ModuleTranslation::setAliasScopeMetadata(AliasAnalysisOpInterface op,
                                               llvm::Instruction *inst) {
-  auto populateScopeMetadata = [&](ArrayAttr scopeRefs, unsigned kind) {
-    if (!scopeRefs || scopeRefs.empty())
+  auto populateScopeMetadata = [&](ArrayAttr aliasScopeRefs, unsigned kind) {
+    if (!aliasScopeRefs || aliasScopeRefs.empty())
       return;
-    llvm::Module *module = inst->getModule();
-    SmallVector<llvm::Metadata *> scopeMDs;
-    for (SymbolRefAttr scopeRef : scopeRefs.getAsRange<SymbolRefAttr>())
-      scopeMDs.push_back(getAliasScope(op, scopeRef));
-    llvm::MDNode *node = llvm::MDNode::get(module->getContext(), scopeMDs);
+    llvm::MDNode *node = getAliasScopes(
+        op, llvm::to_vector(aliasScopeRefs.getAsRange<SymbolRefAttr>()));
     inst->setMetadata(kind, node);
   };
 
   populateScopeMetadata(op.getAliasScopesOrNull(),
                         llvm::LLVMContext::MD_alias_scope);
   populateScopeMetadata(op.getNoAliasScopesOrNull(),
                         llvm::LLVMContext::MD_noalias);
 }

mlir/test/Dialect/LLVMIR/roundtrip.mlir

 
 // CHECK-LABEL: @stackrestore_opaque_pointers
 // CHECK-SAME: %[[ARG0:.*]]: !llvm.ptr
 llvm.func @stackrestore_opaque_pointers(%arg0: !llvm.ptr)  {
   // CHECK: llvm.intr.stackrestore %[[ARG0]] : !llvm.ptr
   llvm.intr.stackrestore %arg0 : !llvm.ptr
   llvm.return
 }
+
+// CHECK-LABEL: @experimental_noalias_scope_decl
+llvm.func @experimental_noalias_scope_decl() {
+  // CHECK: llvm.intr.experimental.noalias.scope.decl @metadata::@scope
+  llvm.intr.experimental.noalias.scope.decl @metadata::@scope
+  llvm.return
+}
+
+llvm.metadata @metadata {
+  llvm.alias_scope_domain @domain {description = "The domain"}
+  llvm.alias_scope @scope {domain = @domain, description = "The first scope"}
+}

mlir/test/Target/LLVMIR/Import/import-failure.ll

entry:
   br i1 %arg, label %bb1, label %bb2, !prof !0
 bb1:
   ret void
 bb2:
   ret void
 }
 
 !0 = !{!"function_entry_count", i64 42}
+
+; // -----
+
+; CHECK:      import-failure.ll
+; CHECK-SAME: warning: dropped instruction: call void @llvm.experimental.noalias.scope.decl(metadata !0)
+define void @unused_scope() {
+  call void @llvm.experimental.noalias.scope.decl(metadata !0)
+  ret void
+}
+
+declare void @llvm.experimental.noalias.scope.decl(metadata)
+
+!0 = !{!1}
+!1 = !{!1, !2}
+!2 = distinct !{!2, !"The domain"}

mlir/test/Target/LLVMIR/Import/metadata-alias-scopes.ll

 !1 = distinct !{!1}
 !2 = !{!2, !0}
 !3 = !{!3, !1}
 !4 = !{!2}
 !5 = !{!3}
 
 ; // -----
 
+; CHECK: llvm.metadata @__llvm_global_metadata {
+; CHECK:   llvm.alias_scope_domain @[[DOMAIN:.*]] {description = "The domain"}
+; CHECK:   llvm.alias_scope @[[$SCOPE:.*]] {domain = @[[DOMAIN]]}
+; CHECK: }
+
 ; CHECK-LABEL: llvm.func @supported_ops
 define void @supported_ops(ptr %arg1, float %arg2, i32 %arg3, i32 %arg4) {
-  ; CHECK: llvm.load {{.*}}alias_scopes =
-  %1 = load i32, ptr %arg1, !alias.scope !3
-  ; CHECK: llvm.store {{.*}}alias_scopes =
-  store i32 %1, ptr %arg1, !alias.scope !3
-  ; CHECK: llvm.atomicrmw {{.*}}alias_scopes =
-  %2 = atomicrmw fmax ptr %arg1, float %arg2 acquire, !alias.scope !3
-  ; CHECK: llvm.cmpxchg {{.*}}alias_scopes =
-  %3 = cmpxchg ptr %arg1, i32 %arg3, i32 %arg4 monotonic seq_cst, !alias.scope !3
-  ; CHECK: "llvm.intr.memcpy"{{.*}}alias_scopes =
-  call void @llvm.memcpy.p0.p0.i32(ptr %arg1, ptr %arg1, i32 4, i1 false), !alias.scope !3
-  ; CHECK: "llvm.intr.memset"{{.*}}alias_scopes =
-  call void @llvm.memset.p0.i32(ptr %arg1, i8 42, i32 4, i1 false), !alias.scope !3
+  ; CHECK: llvm.intr.experimental.noalias.scope.decl @__llvm_global_metadata::@[[$SCOPE]]
+  call void @llvm.experimental.noalias.scope.decl(metadata !2)
+  ; CHECK: llvm.load {{.*}}alias_scopes = [@__llvm_global_metadata::@[[$SCOPE]]]
+  %1 = load i32, ptr %arg1, !alias.scope !2
+  ; CHECK: llvm.store {{.*}}alias_scopes = [@__llvm_global_metadata::@[[$SCOPE]]]
+  store i32 %1, ptr %arg1, !alias.scope !2
+  ; CHECK: llvm.atomicrmw {{.*}}alias_scopes = [@__llvm_global_metadata::@[[$SCOPE]]]
+  %2 = atomicrmw fmax ptr %arg1, float %arg2 acquire, !alias.scope !2
+  ; CHECK: llvm.cmpxchg {{.*}}alias_scopes = [@__llvm_global_metadata::@[[$SCOPE]]]
+  %3 = cmpxchg ptr %arg1, i32 %arg3, i32 %arg4 monotonic seq_cst, !alias.scope !2
+  ; CHECK: "llvm.intr.memcpy"{{.*}}alias_scopes = [@__llvm_global_metadata::@[[$SCOPE]]]
+  call void @llvm.memcpy.p0.p0.i32(ptr %arg1, ptr %arg1, i32 4, i1 false), !alias.scope !2
+  ; CHECK: "llvm.intr.memset"{{.*}}alias_scopes = [@__llvm_global_metadata::@[[$SCOPE]]]
+  call void @llvm.memset.p0.i32(ptr %arg1, i8 42, i32 4, i1 false), !alias.scope !2
   ret void
 }
 
+declare void @llvm.experimental.noalias.scope.decl(metadata)
 declare void @llvm.memcpy.p0.p0.i32(ptr noalias nocapture writeonly, ptr noalias nocapture readonly, i32, i1 immarg)
 declare void @llvm.memset.p0.i32(ptr nocapture writeonly, i8, i32, i1 immarg)
 
 !0 = distinct !{!0, !"The domain"}
-!1 = distinct !{!1}
-!2 = !{!2, !0}
-!3 = !{!2}
+!1 = !{!1, !0}
+!2 = !{!1}

mlir/test/Target/LLVMIR/llvmir.mlir

 ^bb3: // pred: ^bb0
   llvm.return %arg0 : i32
 }
 
 // CHECK: ![[SWITCH_WEIGHT_NODE]] = !{!"branch_weights", i32 13, i32 17, i32 19}
 
 // -----
 
-module {
-  llvm.func @aliasScope(%arg1 : !llvm.ptr) {
-      %0 = llvm.mlir.constant(0 : i32) : i32
-      llvm.store %0, %arg1 {alias_scopes = [@metadata::@scope1], noalias_scopes = [@metadata::@scope2, @metadata::@scope3]} : i32, !llvm.ptr
-      %1 = llvm.load %arg1 {alias_scopes = [@metadata::@scope2], noalias_scopes = [@metadata::@scope1, @metadata::@scope3]} : !llvm.ptr -> i32
-      %2 = llvm.atomicrmw add %arg1, %0 monotonic {alias_scopes = [@metadata::@scope3], noalias_scopes = [@metadata::@scope1, @metadata::@scope2]} : !llvm.ptr, i32
-      %3 = llvm.cmpxchg %arg1, %1, %2 acq_rel monotonic {alias_scopes = [@metadata::@scope3]} : !llvm.ptr, i32
-      %4 = llvm.mlir.constant(0 : i1) : i1
-      %5 = llvm.mlir.constant(42 : i8) : i8
-      "llvm.intr.memcpy"(%arg1, %arg1, %0, %4) {alias_scopes = [@metadata::@scope3]} : (!llvm.ptr, !llvm.ptr, i32, i1) -> ()
-      "llvm.intr.memset"(%arg1, %5, %0, %4) {noalias_scopes = [@metadata::@scope3]} : (!llvm.ptr, i8, i32, i1) -> ()
-      llvm.return
-  }
+// CHECK-LABEL: aliasScope
+  // CHECK:  call void @llvm.experimental.noalias.scope.decl(metadata ![[SCOPES1:[0-9]+]])
+  llvm.intr.experimental.noalias.scope.decl @metadata::@scope1
+  // CHECK:  store {{.*}}, !alias.scope ![[SCOPES1]], !noalias ![[SCOPES23:[0-9]+]]
+  // CHECK:  load {{.*}}, !alias.scope ![[SCOPES2:[0-9]+]], !noalias ![[SCOPES13:[0-9]+]]
+  // CHECK:  atomicrmw {{.*}}, !alias.scope ![[SCOPES3:[0-9]+]], !noalias ![[SCOPES12:[0-9]+]]
+  // CHECK:  cmpxchg {{.*}}, !alias.scope ![[SCOPES3]]
+  // CHECK:  llvm.memcpy{{.*}}, !alias.scope ![[SCOPES3]]
+  // CHECK:  llvm.memset{{.*}}, !noalias ![[SCOPES3]]
 
-  llvm.metadata @metadata {
-    llvm.alias_scope_domain @domain {description = "The domain"}
-    llvm.alias_scope @scope1 {domain = @domain, description = "The first scope"}
-    llvm.alias_scope @scope2 {domain = @domain}
-    llvm.alias_scope @scope3 {domain = @domain}
-  }
-}
 
-// Function
-// CHECK-LABEL: aliasScope
-// CHECK:  store {{.*}}, !alias.scope ![[SCOPES1:[0-9]+]], !noalias ![[SCOPES23:[0-9]+]]
-// CHECK:  load {{.*}}, !alias.scope ![[SCOPES2:[0-9]+]], !noalias ![[SCOPES13:[0-9]+]]
-// CHECK:  atomicrmw {{.*}}, !alias.scope ![[SCOPES3:[0-9]+]], !noalias ![[SCOPES12:[0-9]+]]
-// CHECK:  cmpxchg {{.*}}, !alias.scope ![[SCOPES3]]
-// CHECK:  llvm.memcpy{{.*}}, !alias.scope ![[SCOPES3]]
-// CHECK:  llvm.memset{{.*}}, !noalias ![[SCOPES3]]
+// Check the intrinsic declarations.
+// CHECK-DAG: declare void @llvm.experimental.noalias.scope.decl(metadata)
+// CHECK-DAG: declare void @llvm.memcpy.p0.p0.i32(ptr noalias nocapture writeonly, ptr noalias nocapture readonly, i32, i1 immarg)
+// CHECK-DAG: declare void @llvm.memset.p0.i32(ptr nocapture writeonly, i8, i32, i1 immarg)
 
-// Metadata
+// Check the translated metadata.
 // CHECK-DAG: ![[DOMAIN:[0-9]+]] = distinct !{![[DOMAIN]], !"The domain"}
 // CHECK-DAG: ![[SCOPE1:[0-9]+]] = distinct !{![[SCOPE1]], ![[DOMAIN]], !"The first scope"}
 // CHECK-DAG: ![[SCOPE2:[0-9]+]] = distinct !{![[SCOPE2]], ![[DOMAIN]]}
 // CHECK-DAG: ![[SCOPE3:[0-9]+]] = distinct !{![[SCOPE3]], ![[DOMAIN]]}
 // CHECK-DAG: ![[SCOPES1]] = !{![[SCOPE1]]}
 // CHECK-DAG: ![[SCOPES2]] = !{![[SCOPE2]]}
 // CHECK-DAG: ![[SCOPES3]] = !{![[SCOPE3]]}
 // CHECK-DAG: ![[SCOPES12]] = !{![[SCOPE1]], ![[SCOPE2]]}
 // CHECK-DAG: ![[SCOPES13]] = !{![[SCOPE1]], ![[SCOPE3]]}
 // CHECK-DAG: ![[SCOPES23]] = !{![[SCOPE2]], ![[SCOPE3]]}
 
-
 // -----
 
 // It is okay to have repeated successors if they have no arguments.
 
 // CHECK-LABEL: @duplicate_block_in_switch
 // CHECK-SAME: float %[[FIRST:.*]],
 // CHECK-SAME: float %[[SECOND:.*]])
 // CHECK:   switch i32 %{{.*}}, label %[[DEFAULT:.*]] [