================
@@ -1363,112 +1378,215 @@ def LLVM_GetActiveLaneMaskOp
 }
 
 /// Create a call to Masked Load intrinsic.
-def LLVM_MaskedLoadOp : LLVM_OneResultIntrOp<"masked.load"> {
-  let arguments = (ins LLVM_AnyPointer:$data, LLVM_VectorOf<I1>:$mask,
-                   Optional<LLVM_AnyVector>:$pass_thru, I32Attr:$alignment,
-                   UnitAttr:$nontemporal);
+def LLVM_MaskedLoadOp
+    : LLVM_OneResultIntrOp<"masked.load", /*overloadedResults=*/[],
+      /*overloadedOperands=*/[], /*traits=*/[],
+      /*requiresAccessGroup=*/1, /*requiresAliasAnalysis=*/1> {
+  dag args = (ins LLVM_AnyPointer:$data, LLVM_VectorOf<I1>:$mask,
+                  Optional<LLVM_AnyVector>:$pass_thru,
+                  OptionalAttr<I64Attr>:$alignment, UnitAttr:$nontemporal);
+  let arguments = !con(args, baseArgs);
   let results = (outs LLVM_AnyVector:$res);
+  let builders = [
+    OpBuilder<(ins "Type":$res, "Value":$data, "Value":$mask,
+                   "Value":$pass_thru, "uint64_t":$alignment,
+                   CArg<"bool", "false">:$nontemporal), [{
+      build($_builder, $_state, res, data, mask, pass_thru,
+            $_builder.getI64IntegerAttr(alignment),
+            nontemporal ? $_builder.getUnitAttr() : nullptr,
+            /*access_groups=*/nullptr, /*alias_scopes=*/nullptr,
+            /*noalias_scopes=*/nullptr, /*tbaa=*/nullptr);
+    }]>
+  ];
   let assemblyFormat =
     "operands attr-dict `:` functional-type(operands, results)";
 
   string llvmBuilder = [{
+    // An absent alignment attribute means the ABI alignment of the type, which
+    // LLVM spells as an absent align parameter attribute. The IRBuilder helper
+    // always attaches one, so remove it again in that case.
+    llvm::Align alignment =
+        $alignment ? llvm::Align(*$alignment) : llvm::Align(1);
     auto *inst = $pass_thru ? builder.CreateMaskedLoad(
-        $_resultType, $data, llvm::Align($alignment), $mask, $pass_thru) :
+        $_resultType, $data, alignment, $mask, $pass_thru) :
       builder.CreateMaskedLoad(
-        $_resultType, $data, llvm::Align($alignment), $mask);
+        $_resultType, $data, alignment, $mask);
+    if (!$alignment)
+      inst->removeParamAttr(0, llvm::Attribute::Alignment);
     $res = inst;
-  }] #setNonTemporalMetadataCode;
+  }] # setNonTemporalMetadataCode
+     # setAccessGroupsMetadataCode
+     # setAliasAnalysisMetadataCode;
   string mlirBuilder = [{
     auto *intrinInst = dyn_cast<llvm::IntrinsicInst>(inst);
     bool nontemporal = 
intrinInst->hasMetadata(llvm::LLVMContext::MD_nontemporal);
-    llvm::Align alignment = intrinInst->getParamAlign(0).valueOrOne();
+    llvm::MaybeAlign alignment = intrinInst->getParamAlign(0);
     $res = LLVM::MaskedLoadOp::create($_builder, $_location,
       $_resultType, $data, $mask, $pass_thru,
-      $_builder.getI32IntegerAttr(alignment.value()),
-      nontemporal ? $_builder.getUnitAttr() : nullptr);
+      alignment ? $_builder.getI64IntegerAttr(alignment->value())
+                : ::mlir::IntegerAttr(),
+      nontemporal ? $_builder.getUnitAttr() : nullptr,
+      /*access_groups=*/nullptr, /*alias_scopes=*/nullptr,
+      /*noalias_scopes=*/nullptr, /*tbaa=*/nullptr);
   }];
-  list<int> llvmArgIndices = [0, 1, 2, -1, -1];
+  list<int> llvmArgIndices = [0, 1, 2, -1, -1, -1, -1, -1, -1];
 }
 
 /// Create a call to Masked Store intrinsic.
-def LLVM_MaskedStoreOp : LLVM_ZeroResultIntrOp<"masked.store"> {
-  let arguments = (ins LLVM_AnyVector:$value, LLVM_AnyPointer:$data,
-                   LLVM_VectorOf<I1>:$mask, I32Attr:$alignment,
-                   UnitAttr:$nontemporal);
-  let builders = [LLVM_VoidResultTypeOpBuilder, LLVM_ZeroResultOpBuilder];
+def LLVM_MaskedStoreOp
+    : LLVM_ZeroResultIntrOp<"masked.store", /*overloadedOperands=*/[],
+      /*traits=*/[], /*requiresAccessGroup=*/1, /*requiresAliasAnalysis=*/1> {
+  dag args = (ins LLVM_AnyVector:$value, LLVM_AnyPointer:$data,
+                  LLVM_VectorOf<I1>:$mask, OptionalAttr<I64Attr>:$alignment,
+                  UnitAttr:$nontemporal);
+  let arguments = !con(args, baseArgs);
+  let builders = [
+    LLVM_VoidResultTypeOpBuilder, LLVM_ZeroResultOpBuilder,
+    OpBuilder<(ins "Value":$value, "Value":$data, "Value":$mask,
+                   "uint64_t":$alignment,
+                   CArg<"bool", "false">:$nontemporal), [{
+      build($_builder, $_state, value, data, mask,
+            $_builder.getI64IntegerAttr(alignment),
+            nontemporal ? $_builder.getUnitAttr() : nullptr,
+            /*access_groups=*/nullptr, /*alias_scopes=*/nullptr,
+            /*noalias_scopes=*/nullptr, /*tbaa=*/nullptr);
+    }]>
+  ];
   let assemblyFormat = "$value `,` $data `,` $mask attr-dict `:` "
     "type($value) `,` type($mask) `into` qualified(type($data))";
 
   string llvmBuilder = [{
-    auto *inst = builder.CreateMaskedStore(
-      $value, $data, llvm::Align($alignment), $mask);
-  }] #setNonTemporalMetadataCode;
+    // An absent alignment attribute means the ABI alignment of the type, which
+    // LLVM spells as an absent align parameter attribute. The IRBuilder helper
+    // always attaches one, so remove it again in that case.
+    llvm::Align alignment =
+        $alignment ? llvm::Align(*$alignment) : llvm::Align(1);
+    auto *inst = builder.CreateMaskedStore($value, $data, alignment, $mask);
+    if (!$alignment)
+      inst->removeParamAttr(1, llvm::Attribute::Alignment);
+  }] # setNonTemporalMetadataCode
+     # setAccessGroupsMetadataCode
+     # setAliasAnalysisMetadataCode;
   string mlirBuilder = [{
     auto *intrinInst = dyn_cast<llvm::IntrinsicInst>(inst);
-    llvm::Align alignment = intrinInst->getParamAlign(1).valueOrOne();
+    llvm::MaybeAlign alignment = intrinInst->getParamAlign(1);
     bool nontemporal = 
intrinInst->hasMetadata(llvm::LLVMContext::MD_nontemporal);
     $_op = LLVM::MaskedStoreOp::create($_builder, $_location,
-      $value, $data, $mask, $_builder.getI32IntegerAttr(alignment.value()),
-      nontemporal ? $_builder.getUnitAttr() : nullptr);
+      $value, $data, $mask,
+      alignment ? $_builder.getI64IntegerAttr(alignment->value())
+                : ::mlir::IntegerAttr(),
+      nontemporal ? $_builder.getUnitAttr() : nullptr,
+      /*access_groups=*/nullptr, /*alias_scopes=*/nullptr,
+      /*noalias_scopes=*/nullptr, /*tbaa=*/nullptr);
   }];
-  list<int> llvmArgIndices = [0, 1, 2, -1, -1];
+  list<int> llvmArgIndices = [0, 1, 2, -1, -1, -1, -1, -1, -1];
 }
 
 /// Create a call to Masked Gather intrinsic.
-def LLVM_masked_gather : LLVM_OneResultIntrOp<"masked.gather"> {
-  let arguments = (ins LLVM_VectorOf<LLVM_AnyPointer>:$ptrs,
-                   LLVM_VectorOf<I1>:$mask, 
Variadic<LLVM_AnyVector>:$pass_thru,
-                   I32Attr:$alignment);
+def LLVM_masked_gather
----------------
Dinistro wrote:

Side note: Might be nice to rename these in a followup, to be more consistent 
with the rest. 

https://github.com/llvm/llvm-project/pull/221879
_______________________________________________
cfe-commits mailing list
[email protected]
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits

Reply via email to