[mlir][spirv] NFC: simplify load/store builder call sites

[antiagainst]

Summary

This commit introduces default values for load/store builders to
simplify builder call sites.

[merge_guards_bot]

Unit tests: pass. 62195 tests passed, 0 failed and 815 were skipped.

clang-tidy: pass.

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

Pre-merge checks is in beta. Report issue. Please join beta or enable it for your project.

[benvanik]

mlir/include/mlir/Dialect/SPIRV/SPIRVOps.td

268

the /*optional*/ isn't required as you have the {} now

mlir/include/mlir/Dialect/SPIRV/SPIRVOps.td

let arguments = (ins
     OptionalAttr<SPV_MemoryAccessAttr>:$memory_access,
     OptionalAttr<I32Attr>:$alignment
   );
 
   let results = (outs
     SPV_Type:$value
   );
 
-  let builders = [OpBuilder<[{Builder *builder, OperationState &state,
-                  Value basePtr, /*optional*/IntegerAttr memory_access,
-                  /*optional*/IntegerAttr alignment}]>];
+  let builders = [
+    OpBuilder<[{
+      Builder *builder, OperationState &state,
+      Value basePtr, IntegerAttr memory_access = {},
+      IntegerAttr alignment = {}
+    }]>
+  ];
 }
 
 // -----
 
 def SPV_MemoryBarrierOp : SPV_Op<"MemoryBarrier", []> {
   let summary = "Control the order that memory accesses are observed.";
 
   let description = [{
let arguments = (ins
     SPV_AnyPtr:$ptr,
     SPV_Type:$value,
     OptionalAttr<SPV_MemoryAccessAttr>:$memory_access,
     OptionalAttr<I32Attr>:$alignment
   );
 
   let builders = [
     OpBuilder<"Builder *builder, OperationState &state, "
-      "Value ptr, Value value, ArrayRef<NamedAttribute> namedAttrs", [{
+      "Value ptr, Value value, ArrayRef<NamedAttribute> namedAttrs = {}", [{
       state.addOperands(ptr);
       state.addOperands(value);
       state.addAttributes(namedAttrs);
     }]>
   ];
 
   let results = (outs);
 }

mlir/lib/Conversion/StandardToSPIRV/ConvertStandardToSPIRV.cpp

 
 PatternMatchResult
 LoadOpConversion::matchAndRewrite(LoadOp loadOp, ArrayRef<Value> operands,
                                   ConversionPatternRewriter &rewriter) const {
   LoadOpOperandAdaptor loadOperands(operands);
   auto loadPtr = getElementPtr(rewriter, typeConverter, loadOp.getLoc(),
                                loadOp.memref().getType().cast<MemRefType>(),
                                loadOperands.memref(), loadOperands.indices());
-  rewriter.replaceOpWithNewOp<spirv::LoadOp>(loadOp, loadPtr,
-                                             /*memory_access =*/nullptr,
-                                             /*alignment =*/nullptr);
+  rewriter.replaceOpWithNewOp<spirv::LoadOp>(loadOp, loadPtr);
   return matchSuccess();
 }
 
 //===----------------------------------------------------------------------===//
 // ReturnOp
 //===----------------------------------------------------------------------===//
 
 PatternMatchResult

 StoreOpConversion::matchAndRewrite(StoreOp storeOp, ArrayRef<Value> operands,
                                    ConversionPatternRewriter &rewriter) const {
   StoreOpOperandAdaptor storeOperands(operands);
   auto storePtr =
       getElementPtr(rewriter, typeConverter, storeOp.getLoc(),
                     storeOp.memref().getType().cast<MemRefType>(),
                     storeOperands.memref(), storeOperands.indices());
   rewriter.replaceOpWithNewOp<spirv::StoreOp>(storeOp, storePtr,
-                                              storeOperands.value(),
-                                              /*memory_access =*/nullptr,
-                                              /*alignment =*/nullptr);
+                                              storeOperands.value());
   return matchSuccess();
 }
 
 namespace {
 /// Import the Standard Ops to SPIR-V Patterns.
 #include "StandardToSPIRV.cpp.inc"
 } // namespace
 

mlir/lib/Dialect/SPIRV/SPIRVLowering.cpp

Value mlir::spirv::getBuiltinVariableValue(Operation *op,
   auto moduleOp = op->getParentOfType<spirv::ModuleOp>();
   if (!moduleOp) {
     op->emitError("expected operation to be within a SPIR-V module");
     return nullptr;
   }
   spirv::GlobalVariableOp varOp =
       getOrInsertBuiltinVariable(moduleOp, op->getLoc(), builtin, builder);
   Value ptr = builder.create<spirv::AddressOfOp>(op->getLoc(), varOp);
-  return builder.create<spirv::LoadOp>(op->getLoc(), ptr,
-                                       /*memory_access =*/nullptr,
-                                       /*alignment =*/nullptr);
+  return builder.create<spirv::LoadOp>(op->getLoc(), ptr);
 }
 
 //===----------------------------------------------------------------------===//
 // Set ABI attributes for lowering entry functions.
 //===----------------------------------------------------------------------===//
 
 LogicalResult
 mlir::spirv::setABIAttrs(FuncOp funcOp, spirv::EntryPointABIAttr entryPointInfo,

mlir/lib/Dialect/SPIRV/Transforms/LowerABIAttributesPass.cpp

for (auto argType : llvm::enumerate(funcOp.getType().getInputs())) {
     // easy way to replace all uses with a sequence of operations.
     if (isScalarOrVectorType(argType.value())) {
       auto indexType =
           typeConverter.convertType(IndexType::get(funcOp.getContext()));
       auto zero =
           spirv::ConstantOp::getZero(indexType, funcOp.getLoc(), &rewriter);
       auto loadPtr = rewriter.create<spirv::AccessChainOp>(
           funcOp.getLoc(), replacement, zero.constant());
-      replacement = rewriter.create<spirv::LoadOp>(funcOp.getLoc(), loadPtr,
-                                                   /*memory_access=*/nullptr,
-                                                   /*alignment=*/nullptr);
+      replacement = rewriter.create<spirv::LoadOp>(funcOp.getLoc(), loadPtr);
     }
     signatureConverter.remapInput(argType.index(), replacement);
   }
 
   // Creates a new function with the update signature.
   rewriter.updateRootInPlace(funcOp, [&] {
     funcOp.setType(rewriter.getFunctionType(
         signatureConverter.getConvertedTypes(), llvm::None));