[mlir][spirv] Switch to kEmitAccessorPrefix_Predixed

[kuhar]

Summary

Fixes https://github.com/llvm/llvm-project/issues/57887

[kuhar]

Removed a stale comment.

[kuhar]

Undid an accidental edit.

[antiagainst]

Fantastic! Thanks for taking care of this!!

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVBase.td

let extraClassDeclaration = [{
 
     /// Dialect attribute parsing hook.
     Attribute parseAttribute(
         DialectAsmParser &parser, Type type) const override;
     /// Dialect attribute printing hook.
     void printAttribute(
         Attribute attr, DialectAsmPrinter &printer) const override;
   }];
-
-  // TODO(https://github.com/llvm/llvm-project/issues/57887): Switch to
-  // _Prefixed accessors.
-  let emitAccessorPrefix = kEmitAccessorPrefix_Both;
 }
 
 //===----------------------------------------------------------------------===//
 // Utility definitions
 //===----------------------------------------------------------------------===//
 
 // Wrapper over base BitEnumAttr to set common fields.
 class SPV_BitEnum<string name, string description,

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVControlFlowOps.td

[{
       $_state.addOperands(arguments);
     }]>
   ];
 
   let skipDefaultBuilders = 1;
 
   let extraClassDeclaration = [{
     /// Returns the block arguments.
-    operand_range getBlockArguments() { return targetOperands(); }
+    operand_range getBlockArguments() { return getTargetOperands(); }
   }];
 
   let autogenSerialization = 0;
 
   let assemblyFormat = [{
     $target (`(` $targetOperands^ `:` type($targetOperands) `)`)? attr-dict
   }];
 }
let extraClassDeclaration = [{
     /// Returns the target block for the true branch.
     Block *getTrueBlock() { return getOperation()->getSuccessor(kTrueIndex); }
 
     /// Returns the target block for the false branch.
     Block *getFalseBlock() { return getOperation()->getSuccessor(kFalseIndex); }
 
     /// Returns the number of arguments to the true target block.
     unsigned getNumTrueBlockArguments() {
-      return trueTargetOperands().size();
+      return getTrueTargetOperands().size();
     }
 
     /// Returns the number of arguments to the false target block.
     unsigned getNumFalseBlockArguments() {
-      return falseTargetOperands().size();
+      return getFalseTargetOperands().size();
     }
 
     // Iterator and range support for true target block arguments.
     operand_range getTrueBlockArguments() {
-      return trueTargetOperands();
+      return getTrueTargetOperands();
     }
 
     // Iterator and range support for false target block arguments.
     operand_range getFalseBlockArguments() {
-      return falseTargetOperands();
+      return getFalseTargetOperands();
     }
 
   private:
     /// Gets the index of the first true block argument in the operand list.
     unsigned getTrueBlockArgumentIndex() {
       return 1; // Omit the first argument, which is the condition.
     }
 

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVStructureOps.td

def SPV_GlobalVariableOp : SPV_Op<"GlobalVariable", [InModuleScope, Symbol]> {
   let results = (outs);
 
   let builders = [
     OpBuilder<(ins "TypeAttr":$type,
                    "StringAttr":$sym_name,
                    CArg<"FlatSymbolRefAttr", "nullptr">:$initializer),
     [{
       $_state.addAttribute("type", type);
-      $_state.addAttribute(sym_nameAttrName($_state.name), sym_name);
+      $_state.addAttribute(getSymNameAttrName($_state.name), sym_name);
       if (initializer)
-        $_state.addAttribute(initializerAttrName($_state.name), initializer);
+        $_state.addAttribute(getInitializerAttrName($_state.name), initializer);
     }]>,
     OpBuilder<(ins "TypeAttr":$type, "ArrayRef<NamedAttribute>":$namedAttrs),
     [{
       $_state.addAttribute("type", type);
       $_state.addAttributes(namedAttrs);
     }]>,
     OpBuilder<(ins "Type":$type, "StringRef":$name,
       "unsigned":$descriptorSet, "unsigned":$binding)>,
     OpBuilder<(ins "Type":$type, "StringRef":$name,
       "spirv::BuiltIn":$builtin)>,
     OpBuilder<(ins "Type":$type,
                    "StringRef":$sym_name,
                     CArg<"FlatSymbolRefAttr", "{}">:$initializer),
     [{
       $_state.addAttribute("type", TypeAttr::get(type));
-      $_state.addAttribute(sym_nameAttrName($_state.name), $_builder.getStringAttr(sym_name));
+      $_state.addAttribute(getSymNameAttrName($_state.name), $_builder.getStringAttr(sym_name));
       if (initializer)
-        $_state.addAttribute(initializerAttrName($_state.name), initializer);
+        $_state.addAttribute(getInitializerAttrName($_state.name), initializer);
     }]>
   ];
 
   let hasOpcode = 0;
 
   let autogenSerialization = 0;
 
   let extraClassDeclaration = [{
     ::mlir::spirv::StorageClass storageClass() {
-      return this->type().cast<::mlir::spirv::PointerType>().getStorageClass();
+      return this->getType().cast<::mlir::spirv::PointerType>().getStorageClass();
     }
   }];
 }
 
 // -----
 
 def SPV_ModuleOp : SPV_Op<"module",
     [IsolatedFromAbove, NoRegionArguments, NoTerminator,
def SPV_ModuleOp : SPV_Op<"module",
   let hasOpcode = 0;
 
   let autogenSerialization = 0;
 
   let extraClassDeclaration = [{
 
     bool isOptionalSymbol() { return true; }
 
-    Optional<StringRef> getName() { return sym_name(); }
+    Optional<StringRef> getName() { return getSymName(); }
 
     static StringRef getVCETripleAttrName() { return "vce_triple"; }
   }];
 
   let hasVerifier = 0;
   let hasRegionVerifier = 1;
 }
 

mlir/lib/Conversion/MemRefToSPIRV/MemRefToSPIRV.cpp

static Value adjustAccessChainForBitwidth(SPIRVTypeConverter &typeConverter,
                                           OpBuilder &builder) {
   assert(targetBits % sourceBits == 0);
   const auto loc = op.getLoc();
   IntegerType targetType = builder.getIntegerType(targetBits);
   IntegerAttr attr =
       builder.getIntegerAttr(targetType, targetBits / sourceBits);
   auto idx = builder.create<spirv::ConstantOp>(loc, targetType, attr);
   auto lastDim = op->getOperand(op.getNumOperands() - 1);
-  auto indices = llvm::to_vector<4>(op.indices());
+  auto indices = llvm::to_vector<4>(op.getIndices());
   // There are two elements if this is a 1-D tensor.
   assert(indices.size() == 2);
   indices.back() = builder.create<spirv::SDivOp>(loc, lastDim, idx);
-  Type t = typeConverter.convertType(op.component_ptr().getType());
-  return builder.create<spirv::AccessChainOp>(loc, t, op.base_ptr(), indices);
+  Type t = typeConverter.convertType(op.getComponentPtr().getType());
+  return builder.create<spirv::AccessChainOp>(loc, t, op.getBasePtr(), indices);
 }
 
 /// Returns the shifted `targetBits`-bit value with the given offset.
 static Value shiftValue(Location loc, Value value, Value offset, Value mask,
                         int targetBits, OpBuilder &builder) {
   Type targetType = builder.getIntegerType(targetBits);
   Value result = builder.create<spirv::BitwiseAndOp>(loc, value, mask);
   return builder.create<spirv::ShiftLeftLogicalOp>(loc, targetType, result,
IntLoadOpPattern::matchAndRewrite(memref::LoadOp loadOp, OpAdaptor adaptor,
 
   auto accessChainOp = accessChain.getDefiningOp<spirv::AccessChainOp>();
   if (!accessChainOp)
     return failure();
 
   // Assume that getElementPtr() works linearizely. If it's a scalar, the method
   // still returns a linearized accessing. If the accessing is not linearized,
   // there will be offset issues.
-  assert(accessChainOp.indices().size() == 2);
+  assert(accessChainOp.getIndices().size() == 2);
   Value adjustedPtr = adjustAccessChainForBitwidth(typeConverter, accessChainOp,
                                                    srcBits, dstBits, rewriter);
   Value spvLoadOp = rewriter.create<spirv::LoadOp>(
       loc, dstType, adjustedPtr,
       loadOp->getAttrOfType<spirv::MemoryAccessAttr>(
           spirv::attributeName<spirv::MemoryAccess>()),
       loadOp->getAttrOfType<IntegerAttr>("alignment"));
 
IntStoreOpPattern::matchAndRewrite(memref::StoreOp storeOp, OpAdaptor adaptor,
   // 1) load a 32-bit integer
   // 2) clear 8 bits in the loading value
   // 3) store 32-bit value back
   // 4) load a 32-bit integer
   // 5) modify 8 bits in the loading value
   // 6) store 32-bit value back
   // The step 1 to step 3 are done by AtomicAnd as one atomic step, and the step
   // 4 to step 6 are done by AtomicOr as another atomic step.
-  assert(accessChainOp.indices().size() == 2);
+  assert(accessChainOp.getIndices().size() == 2);
   Value lastDim = accessChainOp->getOperand(accessChainOp.getNumOperands() - 1);
   Value offset = getOffsetForBitwidth(loc, lastDim, srcBits, dstBits, rewriter);
 
   // Create a mask to clear the destination. E.g., if it is the second i8 in
   // i32, 0xFFFF00FF is created.
   Value mask = rewriter.create<spirv::ConstantOp>(
       loc, dstType, rewriter.getIntegerAttr(dstType, (1 << srcBits) - 1));
   Value clearBitsMask =

mlir/lib/Conversion/SCFToSPIRV/SCFToSPIRV.cpp

ForOpConversion::matchAndRewrite(scf::ForOp forOp, OpAdaptor adaptor,
   auto loc = forOp.getLoc();
   auto loopOp = rewriter.create<spirv::LoopOp>(loc, spirv::LoopControl::None);
   loopOp.addEntryAndMergeBlock();
 
   OpBuilder::InsertionGuard guard(rewriter);
   // Create the block for the header.
   auto *header = new Block();
   // Insert the header.
-  loopOp.body().getBlocks().insert(getBlockIt(loopOp.body(), 1), header);
+  loopOp.getBody().getBlocks().insert(getBlockIt(loopOp.getBody(), 1), header);
 
   // Create the new induction variable to use.
   Value adapLowerBound = adaptor.getLowerBound();
   BlockArgument newIndVar =
       header->addArgument(adapLowerBound.getType(), adapLowerBound.getLoc());
   for (Value arg : adaptor.getInitArgs())
     header->addArgument(arg.getType(), arg.getLoc());
   Block *body = forOp.getBody();
 
   // Apply signature conversion to the body of the forOp. It has a single block,
   // with argument which is the induction variable. That has to be replaced with
   // the new induction variable.
   TypeConverter::SignatureConversion signatureConverter(
       body->getNumArguments());
   signatureConverter.remapInput(0, newIndVar);
   for (unsigned i = 1, e = body->getNumArguments(); i < e; i++)
     signatureConverter.remapInput(i, header->getArgument(i));
   body = rewriter.applySignatureConversion(&forOp.getLoopBody(),
                                            signatureConverter);
 
   // Move the blocks from the forOp into the loopOp. This is the body of the
   // loopOp.
-  rewriter.inlineRegionBefore(forOp->getRegion(0), loopOp.body(),
-                              getBlockIt(loopOp.body(), 2));
+  rewriter.inlineRegionBefore(forOp->getRegion(0), loopOp.getBody(),
+                              getBlockIt(loopOp.getBody(), 2));
 
   SmallVector<Value, 8> args(1, adaptor.getLowerBound());
   args.append(adaptor.getInitArgs().begin(), adaptor.getInitArgs().end());
   // Branch into it from the entry.
-  rewriter.setInsertionPointToEnd(&(loopOp.body().front()));
+  rewriter.setInsertionPointToEnd(&(loopOp.getBody().front()));
   rewriter.create<spirv::BranchOp>(loc, header, args);
 
   // Generate the rest of the loop header.
   rewriter.setInsertionPointToEnd(header);
   auto *mergeBlock = loopOp.getMergeBlock();
   auto cmpOp = rewriter.create<spirv::SLessThanOp>(
       loc, rewriter.getI1Type(), newIndVar, adaptor.getUpperBound());
 
IfOpConversion::matchAndRewrite(scf::IfOp ifOp, OpAdaptor adaptor,
   // before the control flow diverges and a merge block where control flow
   // subsequently converges.
   auto loc = ifOp.getLoc();
 
   // Create `spv.selection` operation, selection header block and merge block.
   auto selectionOp =
       rewriter.create<spirv::SelectionOp>(loc, spirv::SelectionControl::None);
   auto *mergeBlock =
-      rewriter.createBlock(&selectionOp.body(), selectionOp.body().end());
+      rewriter.createBlock(&selectionOp.getBody(), selectionOp.getBody().end());
   rewriter.create<spirv::MergeOp>(loc);
 
   OpBuilder::InsertionGuard guard(rewriter);
   auto *selectionHeaderBlock =
-      rewriter.createBlock(&selectionOp.body().front());
+      rewriter.createBlock(&selectionOp.getBody().front());
 
   // Inline `then` region before the merge block and branch to it.
   auto &thenRegion = ifOp.getThenRegion();
   auto *thenBlock = &thenRegion.front();
   rewriter.setInsertionPointToEnd(&thenRegion.back());
   rewriter.create<spirv::BranchOp>(loc, mergeBlock);
   rewriter.inlineRegionBefore(thenRegion, mergeBlock);
 
if (!conditionVal)
     return failure();
 
   auto yield = cast<scf::YieldOp>(afterBlock.getTerminator());
   SmallVector<Value> yieldArgs;
   if (failed(rewriter.getRemappedValues(yield.getResults(), yieldArgs)))
     return failure();
 
   // Move the while before block as the initial loop header block.
-  rewriter.inlineRegionBefore(beforeRegion, loopOp.body(),
-                              getBlockIt(loopOp.body(), 1));
+  rewriter.inlineRegionBefore(beforeRegion, loopOp.getBody(),
+                              getBlockIt(loopOp.getBody(), 1));
 
   // Move the while after block as the initial loop body block.
-  rewriter.inlineRegionBefore(afterRegion, loopOp.body(),
-                              getBlockIt(loopOp.body(), 2));
+  rewriter.inlineRegionBefore(afterRegion, loopOp.getBody(),
+                              getBlockIt(loopOp.getBody(), 2));
 
   // Jump from the loop entry block to the loop header block.
   rewriter.setInsertionPointToEnd(&entryBlock);
   rewriter.create<spirv::BranchOp>(loc, &beforeBlock, adaptor.getInits());
 
   auto condLoc = cond.getLoc();
 
   SmallVector<Value> resultValues(condArgs.size());

mlir/lib/Conversion/SPIRVToLLVM/ConvertLaunchFuncToLLVMCalls.cpp

 /// binding numbers.
 static std::string
 createGlobalVariableWithBindName(spirv::GlobalVariableOp op,
                                  StringRef kernelModuleName) {
   IntegerAttr descriptorSet =
       op->getAttrOfType<IntegerAttr>(descriptorSetName());
   IntegerAttr binding = op->getAttrOfType<IntegerAttr>(bindingName());
   return llvm::formatv("{0}_{1}_descriptor_set{2}_binding{3}",
-                       kernelModuleName.str(), op.sym_name().str(),
+                       kernelModuleName.str(), op.getSymName().str(),
                        std::to_string(descriptorSet.getInt()),
                        std::to_string(binding.getInt()));
 }
 
 /// Returns true if the given global variable has both a descriptor set number
 /// and a binding number.
 static bool hasDescriptorSetAndBinding(spirv::GlobalVariableOp op) {
   IntegerAttr descriptorSet =
if (hasDescriptorSetAndBinding(globalOp))
       globalVariableMap[calculateGlobalIndex(globalOp)] = globalOp;
   }
   return success();
 }
 
 /// Encodes the SPIR-V module's symbolic name into the name of the entry point
 /// function.
 static LogicalResult encodeKernelName(spirv::ModuleOp module) {
-  StringRef spvModuleName = *module.sym_name();
+  StringRef spvModuleName = *module.getSymName();
   // We already know that the module contains exactly one entry point function
   // based on `getKernelGlobalVariables()` call. Update this function's name
   // to:
   //   {spv_module_name}_{function_name}
   auto entryPoint = *module.getOps<spirv::EntryPointOp>().begin();
-  StringRef funcName = entryPoint.fn();
-  auto funcOp = module.lookupSymbol<spirv::FuncOp>(entryPoint.fnAttr());
+  StringRef funcName = entryPoint.getFn();
+  auto funcOp = module.lookupSymbol<spirv::FuncOp>(entryPoint.getFnAttr());
   StringAttr newFuncName =
       StringAttr::get(module->getContext(), spvModuleName + "_" + funcName);
   if (failed(SymbolTable::replaceAllSymbolUses(funcOp, newFuncName, module)))
     return failure();
   SymbolTable::setSymbolName(funcOp, newFuncName);
   return success();
 }
 
for (const auto &operand : llvm::enumerate(kernelOperands)) {
       MemRefDescriptor descriptor(operand.value());
       Value src = descriptor.allocatedPtr(rewriter, loc);
 
       // Get the global variable in the SPIR-V module that is associated with
       // the kernel operand. Construct its new name and create a corresponding
       // LLVM dialect global variable.
       spirv::GlobalVariableOp spirvGlobal = globalVariableMap[operand.index()];
       auto pointeeType =
-          spirvGlobal.type().cast<spirv::PointerType>().getPointeeType();
+          spirvGlobal.getType().cast<spirv::PointerType>().getPointeeType();
       auto dstGlobalType = typeConverter->convertType(pointeeType);
       if (!dstGlobalType)
         return failure();
       std::string name =
           createGlobalVariableWithBindName(spirvGlobal, spvModuleName);
       // Check if this variable has already been created.
       auto dstGlobal = module.lookupSymbol<LLVM::GlobalOp>(name);
       if (!dstGlobal) {

mlir/lib/Conversion/SPIRVToLLVM/SPIRVToLLVM.cpp

static LogicalResult replaceWithLoadOrStore(Operation *op, ValueRange operands,
                                             LLVMTypeConverter &typeConverter,
                                             unsigned alignment, bool isVolatile,
                                             bool isNonTemporal) {
   if (auto loadOp = dyn_cast<spirv::LoadOp>(op)) {
     auto dstType = typeConverter.convertType(loadOp.getType());
     if (!dstType)
       return failure();
     rewriter.replaceOpWithNewOp<LLVM::LoadOp>(
-        loadOp, dstType, spirv::LoadOpAdaptor(operands).ptr(), alignment,
+        loadOp, dstType, spirv::LoadOpAdaptor(operands).getPtr(), alignment,
         isVolatile, isNonTemporal);
     return success();
   }
   auto storeOp = cast<spirv::StoreOp>(op);
   spirv::StoreOpAdaptor adaptor(operands);
-  rewriter.replaceOpWithNewOp<LLVM::StoreOp>(storeOp, adaptor.value(),
-                                             adaptor.ptr(), alignment,
+  rewriter.replaceOpWithNewOp<LLVM::StoreOp>(storeOp, adaptor.getValue(),
+                                             adaptor.getPtr(), alignment,
                                              isVolatile, isNonTemporal);
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Type conversion
 //===----------------------------------------------------------------------===//
 

 
 class AccessChainPattern : public SPIRVToLLVMConversion<spirv::AccessChainOp> {
 public:
   using SPIRVToLLVMConversion<spirv::AccessChainOp>::SPIRVToLLVMConversion;
 
   LogicalResult
   matchAndRewrite(spirv::AccessChainOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    auto dstType = typeConverter.convertType(op.component_ptr().getType());
+    auto dstType = typeConverter.convertType(op.getComponentPtr().getType());
     if (!dstType)
       return failure();
     // To use GEP we need to add a first 0 index to go through the pointer.
-    auto indices = llvm::to_vector<4>(adaptor.indices());
-    Type indexType = op.indices().front().getType();
+    auto indices = llvm::to_vector<4>(adaptor.getIndices());
+    Type indexType = op.getIndices().front().getType();
     auto llvmIndexType = typeConverter.convertType(indexType);
     if (!llvmIndexType)
       return failure();
     Value zero = rewriter.create<LLVM::ConstantOp>(
         op.getLoc(), llvmIndexType, rewriter.getIntegerAttr(indexType, 0));
     indices.insert(indices.begin(), zero);
-    rewriter.replaceOpWithNewOp<LLVM::GEPOp>(op, dstType, adaptor.base_ptr(),
+    rewriter.replaceOpWithNewOp<LLVM::GEPOp>(op, dstType, adaptor.getBasePtr(),
                                              indices);
     return success();
   }
 };
 
 class AddressOfPattern : public SPIRVToLLVMConversion<spirv::AddressOfOp> {
 public:
   using SPIRVToLLVMConversion<spirv::AddressOfOp>::SPIRVToLLVMConversion;
 
   LogicalResult
   matchAndRewrite(spirv::AddressOfOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    auto dstType = typeConverter.convertType(op.pointer().getType());
+    auto dstType = typeConverter.convertType(op.getPointer().getType());
     if (!dstType)
       return failure();
-    rewriter.replaceOpWithNewOp<LLVM::AddressOfOp>(op, dstType, op.variable());
+    rewriter.replaceOpWithNewOp<LLVM::AddressOfOp>(op, dstType, op.getVariable());
     return success();
   }
 };
 
 class BitFieldInsertPattern
     : public SPIRVToLLVMConversion<spirv::BitFieldInsertOp> {
 public:
   using SPIRVToLLVMConversion<spirv::BitFieldInsertOp>::SPIRVToLLVMConversion;
 
   LogicalResult
   matchAndRewrite(spirv::BitFieldInsertOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto srcType = op.getType();
     auto dstType = typeConverter.convertType(srcType);
     if (!dstType)
       return failure();
     Location loc = op.getLoc();
 
     // Process `Offset` and `Count`: broadcast and extend/truncate if needed.
-    Value offset = processCountOrOffset(loc, op.offset(), srcType, dstType,
+    Value offset = processCountOrOffset(loc, op.getOffset(), srcType, dstType,
                                         typeConverter, rewriter);
-    Value count = processCountOrOffset(loc, op.count(), srcType, dstType,
+    Value count = processCountOrOffset(loc, op.getCount(), srcType, dstType,
                                        typeConverter, rewriter);
 
     // Create a mask with bits set outside [Offset, Offset + Count - 1].
     Value minusOne = createConstantAllBitsSet(loc, srcType, dstType, rewriter);
     Value maskShiftedByCount =
         rewriter.create<LLVM::ShlOp>(loc, dstType, minusOne, count);
     Value negated = rewriter.create<LLVM::XOrOp>(loc, dstType,
                                                  maskShiftedByCount, minusOne);
     Value maskShiftedByCountAndOffset =
         rewriter.create<LLVM::ShlOp>(loc, dstType, negated, offset);
     Value mask = rewriter.create<LLVM::XOrOp>(
         loc, dstType, maskShiftedByCountAndOffset, minusOne);
 
     // Extract unchanged bits from the `Base`  that are outside of
     // [Offset, Offset + Count - 1]. Then `or` with shifted `Insert`.
     Value baseAndMask =
-        rewriter.create<LLVM::AndOp>(loc, dstType, op.base(), mask);
+        rewriter.create<LLVM::AndOp>(loc, dstType, op.getBase(), mask);
     Value insertShiftedByOffset =
-        rewriter.create<LLVM::ShlOp>(loc, dstType, op.insert(), offset);
+        rewriter.create<LLVM::ShlOp>(loc, dstType, op.getInsert(), offset);
     rewriter.replaceOpWithNewOp<LLVM::OrOp>(op, dstType, baseAndMask,
                                             insertShiftedByOffset);
     return success();
   }
 };
 
 /// Converts SPIR-V ConstantOp with scalar or vector type.
 class ConstantScalarAndVectorPattern
matchAndRewrite(spirv::ConstantOp constOp, OpAdaptor adaptor,
     // sign bit may have unexpected behaviour. However, it is better to handle
     // it case-by-case, given that the purpose of the conversion is not to
     // cover all possible corner cases.
     if (isSignedIntegerOrVector(srcType) ||
         isUnsignedIntegerOrVector(srcType)) {
       auto signlessType = rewriter.getIntegerType(getBitWidth(srcType));
 
       if (srcType.isa<VectorType>()) {
-        auto dstElementsAttr = constOp.value().cast<DenseIntElementsAttr>();
+        auto dstElementsAttr = constOp.getValue().cast<DenseIntElementsAttr>();
         rewriter.replaceOpWithNewOp<LLVM::ConstantOp>(
             constOp, dstType,
             dstElementsAttr.mapValues(
                 signlessType, [&](const APInt &value) { return value; }));
         return success();
       }
-      auto srcAttr = constOp.value().cast<IntegerAttr>();
+      auto srcAttr = constOp.getValue().cast<IntegerAttr>();
       auto dstAttr = rewriter.getIntegerAttr(signlessType, srcAttr.getValue());
       rewriter.replaceOpWithNewOp<LLVM::ConstantOp>(constOp, dstType, dstAttr);
       return success();
     }
     rewriter.replaceOpWithNewOp<LLVM::ConstantOp>(
         constOp, dstType, adaptor.getOperands(), constOp->getAttrs());
     return success();
   }
matchAndRewrite(spirv::BitFieldSExtractOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto srcType = op.getType();
     auto dstType = typeConverter.convertType(srcType);
     if (!dstType)
       return failure();
     Location loc = op.getLoc();
 
     // Process `Offset` and `Count`: broadcast and extend/truncate if needed.
-    Value offset = processCountOrOffset(loc, op.offset(), srcType, dstType,
+    Value offset = processCountOrOffset(loc, op.getOffset(), srcType, dstType,
                                         typeConverter, rewriter);
-    Value count = processCountOrOffset(loc, op.count(), srcType, dstType,
+    Value count = processCountOrOffset(loc, op.getCount(), srcType, dstType,
                                        typeConverter, rewriter);
 
     // Create a constant that holds the size of the `Base`.
     IntegerType integerType;
     if (auto vecType = srcType.dyn_cast<VectorType>())
       integerType = vecType.getElementType().cast<IntegerType>();
     else
       integerType = srcType.cast<IntegerType>();
 
     auto baseSize = rewriter.getIntegerAttr(integerType, getBitWidth(srcType));
     Value size =
         srcType.isa<VectorType>()
             ? rewriter.create<LLVM::ConstantOp>(
                   loc, dstType,
                   SplatElementsAttr::get(srcType.cast<ShapedType>(), baseSize))
             : rewriter.create<LLVM::ConstantOp>(loc, dstType, baseSize);
 
     // Shift `Base` left by [sizeof(Base) - (Count + Offset)], so that the bit
     // at Offset + Count - 1 is the most significant bit now.
     Value countPlusOffset =
         rewriter.create<LLVM::AddOp>(loc, dstType, count, offset);
     Value amountToShiftLeft =
         rewriter.create<LLVM::SubOp>(loc, dstType, size, countPlusOffset);
     Value baseShiftedLeft = rewriter.create<LLVM::ShlOp>(
-        loc, dstType, op.base(), amountToShiftLeft);
+        loc, dstType, op.getBase(), amountToShiftLeft);
 
     // Shift the result right, filling the bits with the sign bit.
     Value amountToShiftRight =
         rewriter.create<LLVM::AddOp>(loc, dstType, offset, amountToShiftLeft);
     rewriter.replaceOpWithNewOp<LLVM::AShrOp>(op, dstType, baseShiftedLeft,
                                               amountToShiftRight);
     return success();
   }
matchAndRewrite(spirv::BitFieldUExtractOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto srcType = op.getType();
     auto dstType = typeConverter.convertType(srcType);
     if (!dstType)
       return failure();
     Location loc = op.getLoc();
 
     // Process `Offset` and `Count`: broadcast and extend/truncate if needed.
-    Value offset = processCountOrOffset(loc, op.offset(), srcType, dstType,
+    Value offset = processCountOrOffset(loc, op.getOffset(), srcType, dstType,
                                         typeConverter, rewriter);
-    Value count = processCountOrOffset(loc, op.count(), srcType, dstType,
+    Value count = processCountOrOffset(loc, op.getCount(), srcType, dstType,
                                        typeConverter, rewriter);
 
     // Create a mask with bits set at [0, Count - 1].
     Value minusOne = createConstantAllBitsSet(loc, srcType, dstType, rewriter);
     Value maskShiftedByCount =
         rewriter.create<LLVM::ShlOp>(loc, dstType, minusOne, count);
     Value mask = rewriter.create<LLVM::XOrOp>(loc, dstType, maskShiftedByCount,
                                               minusOne);
 
     // Shift `Base` by `Offset` and apply the mask on it.
     Value shiftedBase =
-        rewriter.create<LLVM::LShrOp>(loc, dstType, op.base(), offset);
+        rewriter.create<LLVM::LShrOp>(loc, dstType, op.getBase(), offset);
     rewriter.replaceOpWithNewOp<LLVM::AndOp>(op, dstType, shiftedBase, mask);
     return success();
   }
 };
 
 class BranchConversionPattern : public SPIRVToLLVMConversion<spirv::BranchOp> {
 public:
   using SPIRVToLLVMConversion<spirv::BranchOp>::SPIRVToLLVMConversion;
public:
   using SPIRVToLLVMConversion<
       spirv::BranchConditionalOp>::SPIRVToLLVMConversion;
 
   LogicalResult
   matchAndRewrite(spirv::BranchConditionalOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     // If branch weights exist, map them to 32-bit integer vector.
     ElementsAttr branchWeights = nullptr;
-    if (auto weights = op.branch_weights()) {
+    if (auto weights = op.getBranchWeights()) {
       VectorType weightType = VectorType::get(2, rewriter.getI32Type());
       branchWeights = DenseElementsAttr::get(weightType, weights->getValue());
     }
 
     rewriter.replaceOpWithNewOp<LLVM::CondBrOp>(
-        op, op.condition(), op.getTrueBlockArguments(),
+        op, op.getCondition(), op.getTrueBlockArguments(),
         op.getFalseBlockArguments(), branchWeights, op.getTrueBlock(),
         op.getFalseBlock());
     return success();
   }
 };
 
-/// Converts `spv.CompositeExtract` to `llvm.extractvalue` if the container type
+/// Converts `spv.getCompositeExtract` to `llvm.extractvalue` if the container type
 /// is an aggregate type (struct or array). Otherwise, converts to
 /// `llvm.extractelement` that operates on vectors.
 class CompositeExtractPattern
     : public SPIRVToLLVMConversion<spirv::CompositeExtractOp> {
 public:
   using SPIRVToLLVMConversion<spirv::CompositeExtractOp>::SPIRVToLLVMConversion;
 
   LogicalResult
   matchAndRewrite(spirv::CompositeExtractOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto dstType = this->typeConverter.convertType(op.getType());
     if (!dstType)
       return failure();
 
-    Type containerType = op.composite().getType();
+    Type containerType = op.getComposite().getType();
     if (containerType.isa<VectorType>()) {
       Location loc = op.getLoc();
-      IntegerAttr value = op.indices()[0].cast<IntegerAttr>();
+      IntegerAttr value = op.getIndices()[0].cast<IntegerAttr>();
       Value index = createI32ConstantOf(loc, rewriter, value.getInt());
       rewriter.replaceOpWithNewOp<LLVM::ExtractElementOp>(
-          op, dstType, adaptor.composite(), index);
+          op, dstType, adaptor.getComposite(), index);
       return success();
     }
 
     rewriter.replaceOpWithNewOp<LLVM::ExtractValueOp>(
-        op, adaptor.composite(), LLVM::convertArrayToIndices(op.indices()));
+        op, adaptor.getComposite(), LLVM::convertArrayToIndices(op.getIndices()));
     return success();
   }
 };
 
-/// Converts `spv.CompositeInsert` to `llvm.insertvalue` if the container type
+/// Converts `spv.getCompositeInsert` to `llvm.insertvalue` if the container type
 /// is an aggregate type (struct or array). Otherwise, converts to
 /// `llvm.insertelement` that operates on vectors.
 class CompositeInsertPattern
     : public SPIRVToLLVMConversion<spirv::CompositeInsertOp> {
 public:
   using SPIRVToLLVMConversion<spirv::CompositeInsertOp>::SPIRVToLLVMConversion;
 
   LogicalResult
   matchAndRewrite(spirv::CompositeInsertOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto dstType = this->typeConverter.convertType(op.getType());
     if (!dstType)
       return failure();
 
-    Type containerType = op.composite().getType();
+    Type containerType = op.getComposite().getType();
     if (containerType.isa<VectorType>()) {
       Location loc = op.getLoc();
-      IntegerAttr value = op.indices()[0].cast<IntegerAttr>();
+      IntegerAttr value = op.getIndices()[0].cast<IntegerAttr>();
       Value index = createI32ConstantOf(loc, rewriter, value.getInt());
       rewriter.replaceOpWithNewOp<LLVM::InsertElementOp>(
-          op, dstType, adaptor.composite(), adaptor.object(), index);
+          op, dstType, adaptor.getComposite(), adaptor.getObject(), index);
       return success();
     }
 
     rewriter.replaceOpWithNewOp<LLVM::InsertValueOp>(
-        op, adaptor.composite(), adaptor.object(),
-        LLVM::convertArrayToIndices(op.indices()));
+        op, adaptor.getComposite(), adaptor.getObject(),
+        LLVM::convertArrayToIndices(op.getIndices()));
     return success();
   }
 };
 
 /// Converts SPIR-V operations that have straightforward LLVM equivalent
 /// into LLVM dialect operations.
 template <typename SPIRVOp, typename LLVMOp>
 class DirectConversionPattern : public SPIRVToLLVMConversion<SPIRVOp> {
public:
 
   LogicalResult
   matchAndRewrite(spirv::ExecutionModeOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     // First, create the global struct's name that would be associated with
     // this entry point's execution mode. We set it to be:
     //   __spv__{SPIR-V module name}_{function name}_execution_mode_info_{mode}
     ModuleOp module = op->getParentOfType<ModuleOp>();
-    spirv::ExecutionModeAttr executionModeAttr = op.execution_modeAttr();
+    spirv::ExecutionModeAttr executionModeAttr = op.getExecutionModeAttr();
     std::string moduleName;
     if (module.getName().has_value())
-      moduleName = "_" + module.getName().value().str();
+      moduleName = "_" + module.getName()->str();
     else
       moduleName = "";
     std::string executionModeInfoName = llvm::formatv(
-        "__spv_{0}_{1}_execution_mode_info_{2}", moduleName, op.fn().str(),
+        "__spv_{0}_{1}_execution_mode_info_{2}", moduleName, op.getFn().str(),
         static_cast<uint32_t>(executionModeAttr.getValue()));
 
     MLIRContext *context = rewriter.getContext();
     OpBuilder::InsertionGuard guard(rewriter);
     rewriter.setInsertionPointToStart(module.getBody());
 
     // Create a struct type, corresponding to the C struct below.
     // struct {
     //   int32_t executionMode;
     //   int32_t values[];          // optional values
     // };
     auto llvmI32Type = IntegerType::get(context, 32);
     SmallVector<Type, 2> fields;
     fields.push_back(llvmI32Type);
-    ArrayAttr values = op.values();
+    ArrayAttr values = op.getValues();
     if (!values.empty()) {
       auto arrayType = LLVM::LLVMArrayType::get(llvmI32Type, values.size());
       fields.push_back(arrayType);
     }
     auto structType = LLVM::LLVMStructType::getLiteral(context, fields);
 
     // Create `llvm.mlir.global` with initializer region containing one block.
     auto global = rewriter.create<LLVM::GlobalOp>(

 public:
   using SPIRVToLLVMConversion<spirv::GlobalVariableOp>::SPIRVToLLVMConversion;
 
   LogicalResult
   matchAndRewrite(spirv::GlobalVariableOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     // Currently, there is no support of initialization with a constant value in
     // SPIR-V dialect. Specialization constants are not considered as well.
-    if (op.initializer())
+    if (op.getInitializer())
       return failure();
 
-    auto srcType = op.type().cast<spirv::PointerType>();
+    auto srcType = op.getType().cast<spirv::PointerType>();
     auto dstType = typeConverter.convertType(srcType.getPointeeType());
     if (!dstType)
       return failure();
 
     // Limit conversion to the current invocation only or `StorageBuffer`
     // required by SPIR-V runner.
     // This is okay because multiple invocations are not supported yet.
     auto storageClass = srcType.getStorageClass();
matchAndRewrite(spirv::GlobalVariableOp op, OpAdaptor adaptor,
     // module and cannot be accessed by other modules. However, a module may be
     // written to export or import functions and global (module scope)
     // variables.". Therefore, map 'Private' storage class to private linkage,
     // 'Input' and 'Output' to external linkage.
     auto linkage = storageClass == spirv::StorageClass::Private
                        ? LLVM::Linkage::Private
                        : LLVM::Linkage::External;
     auto newGlobalOp = rewriter.replaceOpWithNewOp<LLVM::GlobalOp>(
-        op, dstType, isConstant, linkage, op.sym_name(), Attribute(),
+        op, dstType, isConstant, linkage, op.getSymName(), Attribute(),
         /*alignment=*/0);
 
     // Attach location attribute if applicable
-    if (op.locationAttr())
-      newGlobalOp->setAttr(op.locationAttrName(), op.locationAttr());
+    if (op.getLocationAttr())
+      newGlobalOp->setAttr(op.getLocationAttrName(), op.getLocationAttr());
 
     return success();
   }
 };
 
 /// Converts SPIR-V cast ops that do not have straightforward LLVM
 /// equivalent in LLVM dialect.
 template <typename SPIRVOp, typename LLVMExtOp, typename LLVMTruncOp>
 class IndirectCastPattern : public SPIRVToLLVMConversion<SPIRVOp> {
 public:
   using SPIRVToLLVMConversion<SPIRVOp>::SPIRVToLLVMConversion;
 
   LogicalResult
   matchAndRewrite(SPIRVOp operation, typename SPIRVOp::Adaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
 
-    Type fromType = operation.operand().getType();
+    Type fromType = operation.getOperand().getType();
     Type toType = operation.getType();
 
     auto dstType = this->typeConverter.convertType(toType);
     if (!dstType)
       return failure();
 
     if (getBitWidth(fromType) < getBitWidth(toType)) {
       rewriter.template replaceOpWithNewOp<LLVMExtOp>(operation, dstType,
public:
   matchAndRewrite(SPIRVOp operation, typename SPIRVOp::Adaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
 
     auto dstType = this->typeConverter.convertType(operation.getType());
     if (!dstType)
       return failure();
 
     rewriter.template replaceOpWithNewOp<LLVM::FCmpOp>(
-        operation, dstType, predicate, operation.operand1(),
-        operation.operand2());
+        operation, dstType, predicate, operation.getOperand1(),
+        operation.getOperand2());
     return success();
   }
 };
 
 /// Converts SPIR-V integer comparisons to llvm.icmp "predicate"
 template <typename SPIRVOp, LLVM::ICmpPredicate predicate>
 class IComparePattern : public SPIRVToLLVMConversion<SPIRVOp> {
 public:
   using SPIRVToLLVMConversion<SPIRVOp>::SPIRVToLLVMConversion;
 
   LogicalResult
   matchAndRewrite(SPIRVOp operation, typename SPIRVOp::Adaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
 
     auto dstType = this->typeConverter.convertType(operation.getType());
     if (!dstType)
       return failure();
 
     rewriter.template replaceOpWithNewOp<LLVM::ICmpOp>(
-        operation, dstType, predicate, operation.operand1(),
-        operation.operand2());
+        operation, dstType, predicate, operation.getOperand1(),
+        operation.getOperand2());
     return success();
   }
 };
 
 class InverseSqrtPattern
     : public SPIRVToLLVMConversion<spirv::GLInverseSqrtOp> {
 public:
   using SPIRVToLLVMConversion<spirv::GLInverseSqrtOp>::SPIRVToLLVMConversion;
 
   LogicalResult
   matchAndRewrite(spirv::GLInverseSqrtOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto srcType = op.getType();
     auto dstType = typeConverter.convertType(srcType);
     if (!dstType)
       return failure();
 
     Location loc = op.getLoc();
     Value one = createFPConstant(loc, srcType, dstType, rewriter, 1.0);
-    Value sqrt = rewriter.create<LLVM::SqrtOp>(loc, dstType, op.operand());
+    Value sqrt = rewriter.create<LLVM::SqrtOp>(loc, dstType, op.getOperand());
     rewriter.replaceOpWithNewOp<LLVM::FDivOp>(op, dstType, one, sqrt);
     return success();
   }
 };
 
 /// Converts `spv.Load` and `spv.Store` to LLVM dialect.
 template <typename SPIRVOp>
 class LoadStorePattern : public SPIRVToLLVMConversion<SPIRVOp> {
 public:
   using SPIRVToLLVMConversion<SPIRVOp>::SPIRVToLLVMConversion;
 
   LogicalResult
   matchAndRewrite(SPIRVOp op, typename SPIRVOp::Adaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    if (!op.memory_access()) {
+    if (!op.getMemoryAccess()) {
       return replaceWithLoadOrStore(op, adaptor.getOperands(), rewriter,
                                     this->typeConverter, /*alignment=*/0,
                                     /*isVolatile=*/false,
                                     /*isNonTemporal=*/false);
     }
-    auto memoryAccess = *op.memory_access();
+    auto memoryAccess = *op.getMemoryAccess();
     switch (memoryAccess) {
     case spirv::MemoryAccess::Aligned:
     case spirv::MemoryAccess::None:
     case spirv::MemoryAccess::Nontemporal:
     case spirv::MemoryAccess::Volatile: {
       unsigned alignment =
-          memoryAccess == spirv::MemoryAccess::Aligned ? *op.alignment() : 0;
+          memoryAccess == spirv::MemoryAccess::Aligned ? *op.getAlignment() : 0;
       bool isNonTemporal = memoryAccess == spirv::MemoryAccess::Nontemporal;
       bool isVolatile = memoryAccess == spirv::MemoryAccess::Volatile;
       return replaceWithLoadOrStore(op, adaptor.getOperands(), rewriter,
                                     this->typeConverter, alignment, isVolatile,
                                     isNonTemporal);
     }
     default:
       // There is no support of other memory access attributes.
matchAndRewrite(SPIRVOp notOp, typename SPIRVOp::Adaptor adaptor,
     IntegerAttr minusOne = minusOneIntegerAttribute(srcType, rewriter);
     auto mask = srcType.template isa<VectorType>()
                     ? rewriter.create<LLVM::ConstantOp>(
                           loc, dstType,
                           SplatElementsAttr::get(
                               srcType.template cast<VectorType>(), minusOne))
                     : rewriter.create<LLVM::ConstantOp>(loc, dstType, minusOne);
     rewriter.template replaceOpWithNewOp<LLVM::XOrOp>(notOp, dstType,
-                                                      notOp.operand(), mask);
+                                                      notOp.getOperand(), mask);
     return success();
   }
 };
 
 /// A template pattern that erases the given `SPIRVOp`.
 template <typename SPIRVOp>
 class ErasePattern : public SPIRVToLLVMConversion<SPIRVOp> {
 public:

 class LoopPattern : public SPIRVToLLVMConversion<spirv::LoopOp> {
 public:
   using SPIRVToLLVMConversion<spirv::LoopOp>::SPIRVToLLVMConversion;
 
   LogicalResult
   matchAndRewrite(spirv::LoopOp loopOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     // There is no support of loop control at the moment.
-    if (loopOp.loop_control() != spirv::LoopControl::None)
+    if (loopOp.getLoopControl() != spirv::LoopControl::None)
       return failure();
 
     Location loc = loopOp.getLoc();
 
     // Split the current block after `spv.mlir.loop`. The remaining ops will be
     // used in `endBlock`.
     Block *currentBlock = rewriter.getBlock();
     auto position = Block::iterator(loopOp);
matchAndRewrite(spirv::LoopOp loopOp, OpAdaptor adaptor,
 
     // Branch from merge block to end block.
     Block *mergeBlock = loopOp.getMergeBlock();
     Operation *terminator = mergeBlock->getTerminator();
     ValueRange terminatorOperands = terminator->getOperands();
     rewriter.setInsertionPointToEnd(mergeBlock);
     rewriter.create<LLVM::BrOp>(loc, terminatorOperands, endBlock);
 
-    rewriter.inlineRegionBefore(loopOp.body(), endBlock);
+    rewriter.inlineRegionBefore(loopOp.getBody(), endBlock);
     rewriter.replaceOp(loopOp, endBlock->getArguments());
     return success();
   }
 };
 
 /// Converts `spv.mlir.selection` with `spv.BranchConditional` in its header
 /// block. All blocks within selection should be reachable for conversion to
 /// succeed.
 class SelectionPattern : public SPIRVToLLVMConversion<spirv::SelectionOp> {
 public:
   using SPIRVToLLVMConversion<spirv::SelectionOp>::SPIRVToLLVMConversion;
 
   LogicalResult
   matchAndRewrite(spirv::SelectionOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     // There is no support for `Flatten` or `DontFlatten` selection control at
     // the moment. This are just compiler hints and can be performed during the
     // optimization passes.
-    if (op.selection_control() != spirv::SelectionControl::None)
+    if (op.getSelectionControl() != spirv::SelectionControl::None)
       return failure();
 
     // `spv.mlir.selection` should have at least two blocks: one selection
     // header block and one merge block. If no blocks are present, or control
     // flow branches straight to merge block (two blocks are present), the op is
     // redundant and it is erased.
-    if (op.body().getBlocks().size() <= 2) {
+    if (op.getBody().getBlocks().size() <= 2) {
       rewriter.eraseOp(op);
       return success();
     }
 
     Location loc = op.getLoc();
 
     // Split the current block after `spv.mlir.selection`. The remaining ops
     // will be used in `continueBlock`.
matchAndRewrite(spirv::SelectionOp op, OpAdaptor adaptor,
     ValueRange terminatorOperands = terminator->getOperands();
     rewriter.setInsertionPointToEnd(mergeBlock);
     rewriter.create<LLVM::BrOp>(loc, terminatorOperands, continueBlock);
 
     // Link current block to `true` and `false` blocks within the selection.
     Block *trueBlock = condBrOp.getTrueBlock();
     Block *falseBlock = condBrOp.getFalseBlock();
     rewriter.setInsertionPointToEnd(currentBlock);
-    rewriter.create<LLVM::CondBrOp>(loc, condBrOp.condition(), trueBlock,
-                                    condBrOp.trueTargetOperands(), falseBlock,
-                                    condBrOp.falseTargetOperands());
+    rewriter.create<LLVM::CondBrOp>(loc, condBrOp.getCondition(), trueBlock,
+                                    condBrOp.getTrueTargetOperands(), falseBlock,
+                                    condBrOp.getFalseTargetOperands());
 
-    rewriter.inlineRegionBefore(op.body(), continueBlock);
+    rewriter.inlineRegionBefore(op.getBody(), continueBlock);
     rewriter.replaceOp(op, continueBlock->getArguments());
     return success();
   }
 };
 
 /// Converts SPIR-V shift ops to LLVM shift ops. Since LLVM dialect
 /// puts a restriction on `Shift` and `Base` to have the same bit width,
 /// `Shift` is zero or sign extended to match this specification. Cases when
 /// `Shift` bit width > `Base` bit width are considered to be illegal.
 template <typename SPIRVOp, typename LLVMOp>
 class ShiftPattern : public SPIRVToLLVMConversion<SPIRVOp> {
 public:
   using SPIRVToLLVMConversion<SPIRVOp>::SPIRVToLLVMConversion;
 
   LogicalResult
   matchAndRewrite(SPIRVOp operation, typename SPIRVOp::Adaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
 
     auto dstType = this->typeConverter.convertType(operation.getType());
     if (!dstType)
       return failure();
 
-    Type op1Type = operation.operand1().getType();
-    Type op2Type = operation.operand2().getType();
+    Type op1Type = operation.getOperand1().getType();
+    Type op2Type = operation.getOperand2().getType();
 
     if (op1Type == op2Type) {
       rewriter.template replaceOpWithNewOp<LLVMOp>(operation, dstType,
                                                    adaptor.getOperands());
       return success();
     }
 
     Location loc = operation.getLoc();
     Value extended;
     if (isUnsignedIntegerOrVector(op2Type)) {
       extended = rewriter.template create<LLVM::ZExtOp>(loc, dstType,
-                                                        adaptor.operand2());
+                                                        adaptor.getOperand2());
     } else {
       extended = rewriter.template create<LLVM::SExtOp>(loc, dstType,
-                                                        adaptor.operand2());
+                                                        adaptor.getOperand2());
     }
     Value result = rewriter.template create<LLVMOp>(
-        loc, dstType, adaptor.operand1(), extended);
+        loc, dstType, adaptor.getOperand1(), extended);
     rewriter.replaceOp(operation, result);
     return success();
   }
 };
 
 class TanPattern : public SPIRVToLLVMConversion<spirv::GLTanOp> {
 public:
   using SPIRVToLLVMConversion<spirv::GLTanOp>::SPIRVToLLVMConversion;
 
   LogicalResult
   matchAndRewrite(spirv::GLTanOp tanOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto dstType = typeConverter.convertType(tanOp.getType());
     if (!dstType)
       return failure();
 
     Location loc = tanOp.getLoc();
-    Value sin = rewriter.create<LLVM::SinOp>(loc, dstType, tanOp.operand());
-    Value cos = rewriter.create<LLVM::CosOp>(loc, dstType, tanOp.operand());
+    Value sin = rewriter.create<LLVM::SinOp>(loc, dstType, tanOp.getOperand());
+    Value cos = rewriter.create<LLVM::CosOp>(loc, dstType, tanOp.getOperand());
     rewriter.replaceOpWithNewOp<LLVM::FDivOp>(tanOp, dstType, sin, cos);
     return success();
   }
 };
 
 /// Convert `spv.Tanh` to
 ///
 ///   exp(2x) - 1
matchAndRewrite(spirv::GLTanhOp tanhOp, OpAdaptor adaptor,
     auto srcType = tanhOp.getType();
     auto dstType = typeConverter.convertType(srcType);
     if (!dstType)
       return failure();
 
     Location loc = tanhOp.getLoc();
     Value two = createFPConstant(loc, srcType, dstType, rewriter, 2.0);
     Value multiplied =
-        rewriter.create<LLVM::FMulOp>(loc, dstType, two, tanhOp.operand());
+        rewriter.create<LLVM::FMulOp>(loc, dstType, two, tanhOp.getOperand());
     Value exponential = rewriter.create<LLVM::ExpOp>(loc, dstType, multiplied);
     Value one = createFPConstant(loc, srcType, dstType, rewriter, 1.0);
     Value numerator =
         rewriter.create<LLVM::FSubOp>(loc, dstType, exponential, one);
     Value denominator =
         rewriter.create<LLVM::FAddOp>(loc, dstType, exponential, one);
     rewriter.replaceOpWithNewOp<LLVM::FDivOp>(tanhOp, dstType, numerator,
                                               denominator);
     return success();
   }
 };
 
 class VariablePattern : public SPIRVToLLVMConversion<spirv::VariableOp> {
 public:
   using SPIRVToLLVMConversion<spirv::VariableOp>::SPIRVToLLVMConversion;
 
   LogicalResult
   matchAndRewrite(spirv::VariableOp varOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto srcType = varOp.getType();
     // Initialization is supported for scalars and vectors only.
     auto pointerTo = srcType.cast<spirv::PointerType>().getPointeeType();
-    auto init = varOp.initializer();
+    auto init = varOp.getInitializer();
     if (init && !pointerTo.isIntOrFloat() && !pointerTo.isa<VectorType>())
       return failure();
 
     auto dstType = typeConverter.convertType(srcType);
     if (!dstType)
       return failure();
 
     Location loc = varOp.getLoc();
     Value size = createI32ConstantOf(loc, rewriter, 1);
     if (!init) {
       rewriter.replaceOpWithNewOp<LLVM::AllocaOp>(varOp, dstType, size);
       return success();
     }
     Value allocated = rewriter.create<LLVM::AllocaOp>(loc, dstType, size);
-    rewriter.create<LLVM::StoreOp>(loc, adaptor.initializer(), allocated);
+    rewriter.create<LLVM::StoreOp>(loc, adaptor.getInitializer(), allocated);
     rewriter.replaceOp(varOp, allocated);
     return success();
   }
 };
 
 //===----------------------------------------------------------------------===//
 // FuncOp conversion
 //===----------------------------------------------------------------------===//
matchAndRewrite(spirv::FuncOp funcOp, OpAdaptor adaptor,
 
     // Create a new `LLVMFuncOp`
     Location loc = funcOp.getLoc();
     StringRef name = funcOp.getName();
     auto newFuncOp = rewriter.create<LLVM::LLVMFuncOp>(loc, name, llvmType);
 
     // Convert SPIR-V Function Control to equivalent LLVM function attribute
     MLIRContext *context = funcOp.getContext();
-    switch (funcOp.function_control()) {
+    switch (funcOp.getFunctionControl()) {
 #define DISPATCH(functionControl, llvmAttr)                                    \
   case functionControl:                                                        \
     newFuncOp->setAttr("passthrough", ArrayAttr::get(context, {llvmAttr}));    \
     break;
 
       DISPATCH(spirv::FunctionControl::Inline,
                StringAttr::get(context, "alwaysinline"));
       DISPATCH(spirv::FunctionControl::DontInline,

 class VectorShufflePattern
     : public SPIRVToLLVMConversion<spirv::VectorShuffleOp> {
 public:
   using SPIRVToLLVMConversion<spirv::VectorShuffleOp>::SPIRVToLLVMConversion;
   LogicalResult
   matchAndRewrite(spirv::VectorShuffleOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     Location loc = op.getLoc();
-    auto components = adaptor.components();
-    auto vector1 = adaptor.vector1();
-    auto vector2 = adaptor.vector2();
+    auto components = adaptor.getComponents();
+    auto vector1 = adaptor.getVector1();
+    auto vector2 = adaptor.getVector2();
     int vector1Size = vector1.getType().cast<VectorType>().getNumElements();
     int vector2Size = vector2.getType().cast<VectorType>().getNumElements();
     if (vector1Size == vector2Size) {
       rewriter.replaceOpWithNewOp<LLVM::ShuffleVectorOp>(
           op, vector1, vector2,
           LLVM::convertArrayToIndices<int32_t>(components));
       return success();
     }
spvModule.walk([&](spirv::GlobalVariableOp op) {
       IntegerAttr binding = op->getAttrOfType<IntegerAttr>(kBinding);
       // For every global variable in the module, get the ones with descriptor
       // set and binding numbers.
       if (descriptorSet && binding) {
         // Encode these numbers into the variable's symbolic name. If the
         // SPIR-V module has a name, add it at the beginning.
         auto moduleAndName =
             spvModule.getName().has_value()
-                ? spvModule.getName().value().str() + "_" + op.sym_name().str()
-                : op.sym_name().str();
+                ? spvModule.getName()->str() + "_" + op.getSymName().str()
+                : op.getSymName().str();
         std::string name =
             llvm::formatv("{0}_descriptor_set{1}_binding{2}", moduleAndName,
                           std::to_string(descriptorSet.getInt()),
                           std::to_string(binding.getInt()));
         auto nameAttr = StringAttr::get(op->getContext(), name);
 
         // Replace all symbol uses and set the new symbol name. Finally, remove
         // descriptor set and binding attributes.

mlir/lib/Dialect/SPIRV/IR/SPIRVCanonicalization.cpp

 /// `spirv::AccessChainOp` operation.
 struct CombineChainedAccessChain
     : public OpRewritePattern<spirv::AccessChainOp> {
   using OpRewritePattern<spirv::AccessChainOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(spirv::AccessChainOp accessChainOp,
                                 PatternRewriter &rewriter) const override {
     auto parentAccessChainOp = dyn_cast_or_null<spirv::AccessChainOp>(
-        accessChainOp.base_ptr().getDefiningOp());
+        accessChainOp.getBasePtr().getDefiningOp());
 
     if (!parentAccessChainOp) {
       return failure();
     }
 
     // Combine indices.
-    SmallVector<Value, 4> indices(parentAccessChainOp.indices());
-    indices.append(accessChainOp.indices().begin(),
-                   accessChainOp.indices().end());
+    SmallVector<Value, 4> indices(parentAccessChainOp.getIndices());
+    indices.append(accessChainOp.getIndices().begin(),
+                   accessChainOp.getIndices().end());
 
     rewriter.replaceOpWithNewOp<spirv::AccessChainOp>(
-        accessChainOp, parentAccessChainOp.base_ptr(), indices);
+        accessChainOp, parentAccessChainOp.getBasePtr(), indices);
 
     return success();
   }
 };
 } // namespace
 
 void spirv::AccessChainOp::getCanonicalizationPatterns(
     RewritePatternSet &results, MLIRContext *context) {
void spirv::BitcastOp::getCanonicalizationPatterns(RewritePatternSet &results,
   results.add<ConvertChainedBitcast>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // spv.CompositeExtractOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult spirv::CompositeExtractOp::fold(ArrayRef<Attribute> operands) {
-  if (auto insertOp = composite().getDefiningOp<spirv::CompositeInsertOp>()) {
-    if (indices() == insertOp.indices())
-      return insertOp.object();
+  if (auto insertOp =
+          getComposite().getDefiningOp<spirv::CompositeInsertOp>()) {
+    if (getIndices() == insertOp.getIndices())
+      return insertOp.getObject();
   }
 
   if (auto constructOp =
-          composite().getDefiningOp<spirv::CompositeConstructOp>()) {
+          getComposite().getDefiningOp<spirv::CompositeConstructOp>()) {
     auto type = constructOp.getType().cast<spirv::CompositeType>();
-    if (indices().size() == 1 &&
-        constructOp.constituents().size() == type.getNumElements()) {
-      auto i = indices().begin()->cast<IntegerAttr>();
-      return constructOp.constituents()[i.getValue().getSExtValue()];
+    if (getIndices().size() == 1 &&
+        constructOp.getConstituents().size() == type.getNumElements()) {
+      auto i = getIndices().begin()->cast<IntegerAttr>();
+      return constructOp.getConstituents()[i.getValue().getSExtValue()];
     }
   }
 
   auto indexVector =
-      llvm::to_vector<8>(llvm::map_range(indices(), [](Attribute attr) {
+      llvm::to_vector<8>(llvm::map_range(getIndices(), [](Attribute attr) {
         return static_cast<unsigned>(attr.cast<IntegerAttr>().getInt());
       }));
   return extractCompositeElement(operands[0], indexVector);
 }
 
 //===----------------------------------------------------------------------===//
 // spv.Constant
 //===----------------------------------------------------------------------===//
 
 OpFoldResult spirv::ConstantOp::fold(ArrayRef<Attribute> operands) {
   assert(operands.empty() && "spv.Constant has no operands");
-  return value();
+  return getValue();
 }
 
 //===----------------------------------------------------------------------===//
 // spv.IAdd
 //===----------------------------------------------------------------------===//
 
 OpFoldResult spirv::IAddOp::fold(ArrayRef<Attribute> operands) {
   assert(operands.size() == 2 && "spv.IAdd expects two operands");
   // x + 0 = x
-  if (matchPattern(operand2(), m_Zero()))
-    return operand1();
+  if (matchPattern(getOperand2(), m_Zero()))
+    return getOperand1();
 
   // According to the SPIR-V spec:
   //
   // The resulting value will equal the low-order N bits of the correct result
   // R, where N is the component width and R is computed with enough precision
   // to avoid overflow and underflow.
   return constFoldBinaryOp<IntegerAttr>(
       operands, [](APInt a, const APInt &b) { return std::move(a) + b; });
 }
 
 //===----------------------------------------------------------------------===//
 // spv.IMul
 //===----------------------------------------------------------------------===//
 
 OpFoldResult spirv::IMulOp::fold(ArrayRef<Attribute> operands) {
   assert(operands.size() == 2 && "spv.IMul expects two operands");
   // x * 0 == 0
-  if (matchPattern(operand2(), m_Zero()))
-    return operand2();
+  if (matchPattern(getOperand2(), m_Zero()))
+    return getOperand2();
   // x * 1 = x
-  if (matchPattern(operand2(), m_One()))
-    return operand1();
+  if (matchPattern(getOperand2(), m_One()))
+    return getOperand1();
 
   // According to the SPIR-V spec:
   //
   // The resulting value will equal the low-order N bits of the correct result
   // R, where N is the component width and R is computed with enough precision
   // to avoid overflow and underflow.
   return constFoldBinaryOp<IntegerAttr>(
       operands, [](const APInt &a, const APInt &b) { return a * b; });
 }
 
 //===----------------------------------------------------------------------===//
 // spv.ISub
 //===----------------------------------------------------------------------===//
 
 OpFoldResult spirv::ISubOp::fold(ArrayRef<Attribute> operands) {
   // x - x = 0
-  if (operand1() == operand2())
+  if (getOperand1() == getOperand2())
     return Builder(getContext()).getIntegerAttr(getType(), 0);
 
   // According to the SPIR-V spec:
   //
   // The resulting value will equal the low-order N bits of the correct result
   // R, where N is the component width and R is computed with enough precision
   // to avoid overflow and underflow.
   return constFoldBinaryOp<IntegerAttr>(
       operands, [](APInt a, const APInt &b) { return std::move(a) - b; });
 }
 
 //===----------------------------------------------------------------------===//
 // spv.LogicalAnd
 //===----------------------------------------------------------------------===//
 
 OpFoldResult spirv::LogicalAndOp::fold(ArrayRef<Attribute> operands) {
   assert(operands.size() == 2 && "spv.LogicalAnd should take two operands");
 
   if (Optional<bool> rhs = getScalarOrSplatBoolAttr(operands.back())) {
     // x && true = x
     if (rhs.value())
-      return operand1();
+      return getOperand1();
 
     // x && false = false
     if (!rhs.value())
       return operands.back();
   }
 
   return Attribute();
 }
OpFoldResult spirv::LogicalOrOp::fold(ArrayRef<Attribute> operands) {
 
   if (auto rhs = getScalarOrSplatBoolAttr(operands.back())) {
     if (rhs.value())
       // x || true = true
       return operands.back();
 
     // x || false = x
     if (!rhs.value())
-      return operand1();
+      return getOperand1();
   }
 
   return Attribute();
 }
 
 //===----------------------------------------------------------------------===//
 // spv.mlir.selection
 //===----------------------------------------------------------------------===//
LogicalResult matchAndRewrite(spirv::SelectionOp selectionOp,
 
     auto trueValue = getSrcValue(trueBlock);
     auto falseValue = getSrcValue(falseBlock);
     auto ptrValue = getDstPtr(trueBlock);
     auto storeOpAttributes =
         cast<spirv::StoreOp>(trueBlock->front())->getAttrs();
 
     auto selectOp = rewriter.create<spirv::SelectOp>(
-        selectionOp.getLoc(), trueValue.getType(), brConditionalOp.condition(),
-        trueValue, falseValue);
+        selectionOp.getLoc(), trueValue.getType(),
+        brConditionalOp.getCondition(), trueValue, falseValue);
     rewriter.create<spirv::StoreOp>(selectOp.getLoc(), ptrValue,
                                     selectOp.getResult(), storeOpAttributes);
 
     // `spv.mlir.selection` is not needed anymore.
     rewriter.eraseOp(op);
     return success();
   }
 
private:
 
   bool isSameAttrList(spirv::StoreOp lhs, spirv::StoreOp rhs) const {
     return lhs->getAttrDictionary() == rhs->getAttrDictionary();
   }
 
   // Returns a source value for the given block.
   Value getSrcValue(Block *block) const {
     auto storeOp = cast<spirv::StoreOp>(block->front());
-    return storeOp.value();
+    return storeOp.getValue();
   }
 
   // Returns a destination value for the given block.
   Value getDstPtr(Block *block) const {
     auto storeOp = cast<spirv::StoreOp>(block->front());
-    return storeOp.ptr();
+    return storeOp.getPtr();
   }
 };
 
 LogicalResult ConvertSelectionOpToSelect::canCanonicalizeSelection(
     Block *trueBlock, Block *falseBlock, Block *mergeBlock) const {
   // Each block must consists of 2 operations.
   if ((std::distance(trueBlock->begin(), trueBlock->end()) != 2) ||
       (std::distance(falseBlock->begin(), falseBlock->end()) != 2)) {
if (!trueBrStoreOp || !trueBrBranchOp || !falseBrStoreOp ||
     return failure();
   }
 
   // Checks that given type is valid for `spv.SelectOp`.
   // According to SPIR-V spec:
   // "Before version 1.4, Result Type must be a pointer, scalar, or vector.
   // Starting with version 1.4, Result Type can additionally be a composite type
   // other than a vector."
-  bool isScalarOrVector = trueBrStoreOp.value()
+  bool isScalarOrVector = trueBrStoreOp.getValue()
                               .getType()
                               .cast<spirv::SPIRVType>()
                               .isScalarOrVector();
 
   // Check that each `spv.Store` uses the same pointer, memory access
   // attributes and a valid type of the value.
-  if ((trueBrStoreOp.ptr() != falseBrStoreOp.ptr()) ||
+  if ((trueBrStoreOp.getPtr() != falseBrStoreOp.getPtr()) ||
       !isSameAttrList(trueBrStoreOp, falseBrStoreOp) || !isScalarOrVector) {
     return failure();
   }
 
   if ((trueBrBranchOp->getSuccessor(0) != mergeBlock) ||
       (falseBrBranchOp->getSuccessor(0) != mergeBlock)) {
     return failure();
   }

mlir/lib/Dialect/SPIRV/IR/SPIRVDialect.cpp

void handleTerminator(Operation *op,
     // Only spv.ReturnValue needs to be handled here.
     auto retValOp = dyn_cast<spirv::ReturnValueOp>(op);
     if (!retValOp)
       return;
 
     // Replace the values directly with the return operands.
     assert(valuesToRepl.size() == 1 &&
            "spv.ReturnValue expected to only handle one result");
-    valuesToRepl.front().replaceAllUsesWith(retValOp.value());
+    valuesToRepl.front().replaceAllUsesWith(retValOp.getValue());
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // SPIR-V Dialect
 //===----------------------------------------------------------------------===//
 

mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp

static bool isDirectInModuleLikeOp(Operation *op) {
   return op && op->hasTrait<OpTrait::SymbolTable>();
 }
 
 static LogicalResult extractValueFromConstOp(Operation *op, int32_t &value) {
   auto constOp = dyn_cast_or_null<spirv::ConstantOp>(op);
   if (!constOp) {
     return failure();
   }
-  auto valueAttr = constOp.value();
+  auto valueAttr = constOp.getValue();
   auto integerValueAttr = valueAttr.dyn_cast<IntegerAttr>();
   if (!integerValueAttr) {
     return failure();
   }
 
   if (integerValueAttr.getType().isSignlessInteger())
     value = integerValueAttr.getInt();
   else

 template <typename MemoryOpTy>
 static void printMemoryAccessAttribute(
     MemoryOpTy memoryOp, OpAsmPrinter &printer,
     SmallVectorImpl<StringRef> &elidedAttrs,
     Optional<spirv::MemoryAccess> memoryAccessAtrrValue = None,
     Optional<uint32_t> alignmentAttrValue = None) {
   // Print optional memory access attribute.
   if (auto memAccess = (memoryAccessAtrrValue ? memoryAccessAtrrValue
-                                              : memoryOp.memory_access())) {
+                                              : memoryOp.getMemoryAccess())) {
     elidedAttrs.push_back(kMemoryAccessAttrName);
 
     printer << " [\"" << stringifyMemoryAccess(*memAccess) << "\"";
 
     if (spirv::bitEnumContainsAll(*memAccess, spirv::MemoryAccess::Aligned)) {
       // Print integer alignment attribute.
       if (auto alignment = (alignmentAttrValue ? alignmentAttrValue
-                                               : memoryOp.alignment())) {
+                                               : memoryOp.getAlignment())) {
         elidedAttrs.push_back(kAlignmentAttrName);
         printer << ", " << alignment;
       }
     }
     printer << "]";
   }
   elidedAttrs.push_back(spirv::attributeName<spirv::StorageClass>());
 }
 
 // TODO Make sure to merge this and the previous function into one template
 // parameterized by memory access attribute name and alignment. Doing so now
 // results in VS2017 in producing an internal error (at the call site) that's
 // not detailed enough to understand what is happening.
 template <typename MemoryOpTy>
 static void printSourceMemoryAccessAttribute(
     MemoryOpTy memoryOp, OpAsmPrinter &printer,
     SmallVectorImpl<StringRef> &elidedAttrs,
     Optional<spirv::MemoryAccess> memoryAccessAtrrValue = None,
     Optional<uint32_t> alignmentAttrValue = None) {
 
   printer << ", ";
 
   // Print optional memory access attribute.
   if (auto memAccess = (memoryAccessAtrrValue ? memoryAccessAtrrValue
-                                              : memoryOp.memory_access())) {
+                                              : memoryOp.getMemoryAccess())) {
     elidedAttrs.push_back(kSourceMemoryAccessAttrName);
 
     printer << " [\"" << stringifyMemoryAccess(*memAccess) << "\"";
 
     if (spirv::bitEnumContainsAll(*memAccess, spirv::MemoryAccess::Aligned)) {
       // Print integer alignment attribute.
       if (auto alignment = (alignmentAttrValue ? alignmentAttrValue
-                                               : memoryOp.alignment())) {
+                                               : memoryOp.getAlignment())) {
         elidedAttrs.push_back(kSourceAlignmentAttrName);
         printer << ", " << alignment;
       }
     }
     printer << "]";
   }
   elidedAttrs.push_back(spirv::attributeName<spirv::StorageClass>());
 }
ParseResult spirv::AccessChainOp::parse(OpAsmParser &parser,
   }
 
   result.addTypes(resultType);
   return success();
 }
 
 template <typename Op>
 static void printAccessChain(Op op, ValueRange indices, OpAsmPrinter &printer) {
-  printer << ' ' << op.base_ptr() << '[' << indices
-          << "] : " << op.base_ptr().getType() << ", " << indices.getTypes();
+  printer << ' ' << op.getBasePtr() << '[' << indices
+          << "] : " << op.getBasePtr().getType() << ", " << indices.getTypes();
 }
 
 void spirv::AccessChainOp::print(OpAsmPrinter &printer) {
-  printAccessChain(*this, indices(), printer);
+  printAccessChain(*this, getIndices(), printer);
 }
 
 template <typename Op>
 static LogicalResult verifyAccessChain(Op accessChainOp, ValueRange indices) {
-  auto resultType = getElementPtrType(accessChainOp.base_ptr().getType(),
+  auto resultType = getElementPtrType(accessChainOp.getBasePtr().getType(),
                                       indices, accessChainOp.getLoc());
   if (!resultType)
     return failure();
 
   auto providedResultType =
       accessChainOp.getType().template dyn_cast<spirv::PointerType>();
   if (!providedResultType)
     return accessChainOp.emitOpError(
                "result type must be a pointer, but provided")
            << providedResultType;
 
   if (resultType != providedResultType)
     return accessChainOp.emitOpError("invalid result type: expected ")
            << resultType << ", but provided " << providedResultType;
 
   return success();
 }
 
 LogicalResult spirv::AccessChainOp::verify() {
-  return verifyAccessChain(*this, indices());
+  return verifyAccessChain(*this, getIndices());
 }
 
 //===----------------------------------------------------------------------===//
 // spv.mlir.addressof
 //===----------------------------------------------------------------------===//
 
 void spirv::AddressOfOp::build(OpBuilder &builder, OperationState &state,
                                spirv::GlobalVariableOp var) {
-  build(builder, state, var.type(), SymbolRefAttr::get(var));
+  build(builder, state, var.getType(), SymbolRefAttr::get(var));
 }
 
 LogicalResult spirv::AddressOfOp::verify() {
   auto varOp = dyn_cast_or_null<spirv::GlobalVariableOp>(
       SymbolTable::lookupNearestSymbolFrom((*this)->getParentOp(),
-                                           variableAttr()));
+                                           getVariableAttr()));
   if (!varOp) {
     return emitOpError("expected spv.GlobalVariable symbol");
   }
-  if (pointer().getType() != varOp.type()) {
+  if (getPointer().getType() != varOp.getType()) {
     return emitOpError(
         "result type mismatch with the referenced global variable's type");
   }
   return success();
 }
 
 template <typename T>
 static void printAtomicCompareExchangeImpl(T atomOp, OpAsmPrinter &printer) {
-  printer << " \"" << stringifyScope(atomOp.memory_scope()) << "\" \""
-          << stringifyMemorySemantics(atomOp.equal_semantics()) << "\" \""
-          << stringifyMemorySemantics(atomOp.unequal_semantics()) << "\" "
-          << atomOp.getOperands() << " : " << atomOp.pointer().getType();
+  printer << " \"" << stringifyScope(atomOp.getMemoryScope()) << "\" \""
+          << stringifyMemorySemantics(atomOp.getEqualSemantics()) << "\" \""
+          << stringifyMemorySemantics(atomOp.getUnequalSemantics()) << "\" "
+          << atomOp.getOperands() << " : " << atomOp.getPointer().getType();
 }
 
 static ParseResult parseAtomicCompareExchangeImpl(OpAsmParser &parser,
                                                   OperationState &state) {
   spirv::Scope memoryScope;
   spirv::MemorySemantics equalSemantics, unequalSemantics;
   SmallVector<OpAsmParser::UnresolvedOperand, 3> operandInfo;
   Type type;

 }
 
 template <typename T>
 static LogicalResult verifyAtomicCompareExchangeImpl(T atomOp) {
   // According to the spec:
   // "The type of Value must be the same as Result Type. The type of the value
   // pointed to by Pointer must be the same as Result Type. This type must also
   // match the type of Comparator."
-  if (atomOp.getType() != atomOp.value().getType())
+  if (atomOp.getType() != atomOp.getValue().getType())
     return atomOp.emitOpError("value operand must have the same type as the op "
                               "result, but found ")
-           << atomOp.value().getType() << " vs " << atomOp.getType();
+           << atomOp.getValue().getType() << " vs " << atomOp.getType();
 
-  if (atomOp.getType() != atomOp.comparator().getType())
+  if (atomOp.getType() != atomOp.getComparator().getType())
     return atomOp.emitOpError(
                "comparator operand must have the same type as the op "
                "result, but found ")
-           << atomOp.comparator().getType() << " vs " << atomOp.getType();
+           << atomOp.getComparator().getType() << " vs " << atomOp.getType();
 
-  Type pointeeType = atomOp.pointer()
+  Type pointeeType = atomOp.getPointer()
                          .getType()
                          .template cast<spirv::PointerType>()
                          .getPointeeType();
   if (atomOp.getType() != pointeeType)
     return atomOp.emitOpError(
                "pointer operand's pointee type must have the same "
                "as the op result type, but found ")
            << pointeeType << " vs " << atomOp.getType();
void spirv::AtomicCompareExchangeWeakOp::print(OpAsmPrinter &p) {
   ::printAtomicCompareExchangeImpl(*this, p);
 }
 
 //===----------------------------------------------------------------------===//
 // spv.AtomicExchange
 //===----------------------------------------------------------------------===//
 
 void spirv::AtomicExchangeOp::print(OpAsmPrinter &printer) {
-  printer << " \"" << stringifyScope(memory_scope()) << "\" \""
-          << stringifyMemorySemantics(semantics()) << "\" " << getOperands()
-          << " : " << pointer().getType();
+  printer << " \"" << stringifyScope(getMemoryScope()) << "\" \""
+          << stringifyMemorySemantics(getSemantics()) << "\" " << getOperands()
+          << " : " << getPointer().getType();
 }
 
 ParseResult spirv::AtomicExchangeOp::parse(OpAsmParser &parser,
                                            OperationState &result) {
   spirv::Scope memoryScope;
   spirv::MemorySemantics semantics;
   SmallVector<OpAsmParser::UnresolvedOperand, 2> operandInfo;
   Type type;
ParseResult spirv::AtomicExchangeOp::parse(OpAsmParser &parser,
   if (parser.resolveOperands(operandInfo, {ptrType, ptrType.getPointeeType()},
                              parser.getNameLoc(), result.operands))
     return failure();
 
   return parser.addTypeToList(ptrType.getPointeeType(), result.types);
 }
 
 LogicalResult spirv::AtomicExchangeOp::verify() {
-  if (getType() != value().getType())
+  if (getType() != getValue().getType())
     return emitOpError("value operand must have the same type as the op "
                        "result, but found ")
-           << value().getType() << " vs " << getType();
+           << getValue().getType() << " vs " << getType();
 
   Type pointeeType =
-      pointer().getType().cast<spirv::PointerType>().getPointeeType();
+      getPointer().getType().cast<spirv::PointerType>().getPointeeType();
   if (getType() != pointeeType)
     return emitOpError("pointer operand's pointee type must have the same "
                        "as the op result type, but found ")
            << pointeeType << " vs " << getType();
 
   return success();
 }
 

 
 //===----------------------------------------------------------------------===//
 // spv.BitcastOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::BitcastOp::verify() {
   // TODO: The SPIR-V spec validation rules are different for different
   // versions.
-  auto operandType = operand().getType();
-  auto resultType = result().getType();
+  auto operandType = getOperand().getType();
+  auto resultType = getResult().getType();
   if (operandType == resultType) {
     return emitError("result type must be different from operand type");
   }
   if (operandType.isa<spirv::PointerType>() &&
       !resultType.isa<spirv::PointerType>()) {
     return emitError(
         "unhandled bit cast conversion from pointer type to non-pointer type");
   }
LogicalResult spirv::BitcastOp::verify() {
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // spv.PtrCastToGenericOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::PtrCastToGenericOp::verify() {
-  auto operandType = pointer().getType().cast<spirv::PointerType>();
-  auto resultType = result().getType().cast<spirv::PointerType>();
+  auto operandType = getPointer().getType().cast<spirv::PointerType>();
+  auto resultType = getResult().getType().cast<spirv::PointerType>();
 
   spirv::StorageClass operandStorage = operandType.getStorageClass();
   if (operandStorage != spirv::StorageClass::Workgroup &&
       operandStorage != spirv::StorageClass::CrossWorkgroup &&
       operandStorage != spirv::StorageClass::Function)
     return emitError("pointer must point to the Workgroup, CrossWorkgroup"
                      ", or Function Storage Class");
 
LogicalResult spirv::PtrCastToGenericOp::verify() {
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // spv.GenericCastToPtrOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::GenericCastToPtrOp::verify() {
-  auto operandType = pointer().getType().cast<spirv::PointerType>();
-  auto resultType = result().getType().cast<spirv::PointerType>();
+  auto operandType = getPointer().getType().cast<spirv::PointerType>();
+  auto resultType = getResult().getType().cast<spirv::PointerType>();
 
   spirv::StorageClass operandStorage = operandType.getStorageClass();
   if (operandStorage != spirv::StorageClass::Generic)
     return emitError("pointer type must be of storage class Generic");
 
   spirv::StorageClass resultStorage = resultType.getStorageClass();
   if (resultStorage != spirv::StorageClass::Workgroup &&
       resultStorage != spirv::StorageClass::CrossWorkgroup &&
LogicalResult spirv::GenericCastToPtrOp::verify() {
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // spv.GenericCastToPtrExplicitOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::GenericCastToPtrExplicitOp::verify() {
-  auto operandType = pointer().getType().cast<spirv::PointerType>();
-  auto resultType = result().getType().cast<spirv::PointerType>();
+  auto operandType = getPointer().getType().cast<spirv::PointerType>();
+  auto resultType = getResult().getType().cast<spirv::PointerType>();
 
   spirv::StorageClass operandStorage = operandType.getStorageClass();
   if (operandStorage != spirv::StorageClass::Generic)
     return emitError("pointer type must be of storage class Generic");
 
   spirv::StorageClass resultStorage = resultType.getStorageClass();
   if (resultStorage != spirv::StorageClass::Workgroup &&
       resultStorage != spirv::StorageClass::CrossWorkgroup &&

 }
 
 //===----------------------------------------------------------------------===//
 // spv.BranchOp
 //===----------------------------------------------------------------------===//
 
 SuccessorOperands spirv::BranchOp::getSuccessorOperands(unsigned index) {
   assert(index == 0 && "invalid successor index");
-  return SuccessorOperands(0, targetOperandsMutable());
+  return SuccessorOperands(0, getTargetOperandsMutable());
 }
 
 //===----------------------------------------------------------------------===//
 // spv.BranchConditionalOp
 //===----------------------------------------------------------------------===//
 
 SuccessorOperands
 spirv::BranchConditionalOp::getSuccessorOperands(unsigned index) {
   assert(index < 2 && "invalid successor index");
-  return SuccessorOperands(index == kTrueIndex ? trueTargetOperandsMutable()
-                                               : falseTargetOperandsMutable());
+  return SuccessorOperands(index == kTrueIndex
+                               ? getTrueTargetOperandsMutable()
+                               : getFalseTargetOperandsMutable());
 }
 
 ParseResult spirv::BranchConditionalOp::parse(OpAsmParser &parser,
                                               OperationState &result) {
   auto &builder = parser.getBuilder();
   OpAsmParser::UnresolvedOperand condInfo;
   Block *dest;
 
result.addAttribute(spirv::BranchConditionalOp::getOperandSegmentSizeAttr(),
                       builder.getDenseI32ArrayAttr(
                           {1, static_cast<int32_t>(trueOperands.size()),
                            static_cast<int32_t>(falseOperands.size())}));
 
   return success();
 }
 
 void spirv::BranchConditionalOp::print(OpAsmPrinter &printer) {
-  printer << ' ' << condition();
+  printer << ' ' << getCondition();
 
-  if (auto weights = branch_weights()) {
+  if (auto weights = getBranchWeights()) {
     printer << " [";
     llvm::interleaveComma(weights->getValue(), printer, [&](Attribute a) {
       printer << a.cast<IntegerAttr>().getInt();
     });
     printer << "]";
   }
 
   printer << ", ";
   printer.printSuccessorAndUseList(getTrueBlock(), getTrueBlockArguments());
   printer << ", ";
   printer.printSuccessorAndUseList(getFalseBlock(), getFalseBlockArguments());
 }
 
 LogicalResult spirv::BranchConditionalOp::verify() {
-  if (auto weights = branch_weights()) {
+  if (auto weights = getBranchWeights()) {
     if (weights->getValue().size() != 2) {
       return emitOpError("must have exactly two branch weights");
     }
     if (llvm::all_of(*weights, [](Attribute attr) {
           return attr.cast<IntegerAttr>().getValue().isNullValue();
         }))
       return emitOpError("branch weights cannot both be zero");
   }
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // spv.CompositeConstruct
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::CompositeConstructOp::verify() {
   auto cType = getType().cast<spirv::CompositeType>();
-  operand_range constituents = this->constituents();
+  operand_range constituents = this->getConstituents();
 
   if (auto coopType = cType.dyn_cast<spirv::CooperativeMatrixNVType>()) {
     if (constituents.size() != 1)
       return emitOpError("has incorrect number of operands: expected ")
              << "1, but provided " << constituents.size();
     if (coopType.getElementType() != constituents.front().getType())
       return emitOpError("operand type mismatch: expected operand type ")
              << coopType.getElementType() << ", but provided "
ParseResult spirv::CompositeExtractOp::parse(OpAsmParser &parser,
   if (!resultType) {
     return failure();
   }
   result.addTypes(resultType);
   return success();
 }
 
 void spirv::CompositeExtractOp::print(OpAsmPrinter &printer) {
-  printer << ' ' << composite() << indices() << " : " << composite().getType();
+  printer << ' ' << getComposite() << getIndices() << " : "
+          << getComposite().getType();
 }
 
 LogicalResult spirv::CompositeExtractOp::verify() {
-  auto indicesArrayAttr = indices().dyn_cast<ArrayAttr>();
+  auto indicesArrayAttr = getIndices().dyn_cast<ArrayAttr>();
   auto resultType =
-      getElementType(composite().getType(), indicesArrayAttr, getLoc());
+      getElementType(getComposite().getType(), indicesArrayAttr, getLoc());
   if (!resultType)
     return failure();
 
   if (resultType != getType()) {
     return emitOpError("invalid result type: expected ")
            << resultType << " but provided " << getType();
   }
 
return failure(
       parser.parseColonType(objectType) ||
       parser.parseKeywordType("into", compositeType) ||
       parser.resolveOperands(operands, {objectType, compositeType}, loc,
                              result.operands) ||
       parser.addTypesToList(compositeType, result.types));
 }
 
 LogicalResult spirv::CompositeInsertOp::verify() {
-  auto indicesArrayAttr = indices().dyn_cast<ArrayAttr>();
+  auto indicesArrayAttr = getIndices().dyn_cast<ArrayAttr>();
   auto objectType =
-      getElementType(composite().getType(), indicesArrayAttr, getLoc());
+      getElementType(getComposite().getType(), indicesArrayAttr, getLoc());
   if (!objectType)
     return failure();
 
-  if (objectType != object().getType()) {
+  if (objectType != getObject().getType()) {
     return emitOpError("object operand type should be ")
-           << objectType << ", but found " << object().getType();
+           << objectType << ", but found " << getObject().getType();
   }
 
-  if (composite().getType() != getType()) {
+  if (getComposite().getType() != getType()) {
     return emitOpError("result type should be the same as "
                        "the composite type, but found ")
-           << composite().getType() << " vs " << getType();
+           << getComposite().getType() << " vs " << getType();
   }
 
   return success();
 }
 
 void spirv::CompositeInsertOp::print(OpAsmPrinter &printer) {
-  printer << " " << object() << ", " << composite() << indices() << " : "
-          << object().getType() << " into " << composite().getType();
+  printer << " " << getObject() << ", " << getComposite() << getIndices()
+          << " : " << getObject().getType() << " into "
+          << getComposite().getType();
 }
 
 //===----------------------------------------------------------------------===//
 // spv.Constant
 //===----------------------------------------------------------------------===//
 
 ParseResult spirv::ConstantOp::parse(OpAsmParser &parser,
                                      OperationState &result) {
   Attribute value;
   if (parser.parseAttribute(value, kValueAttrName, result.attributes))
     return failure();
 
   Type type = NoneType::get(parser.getContext());
   if (auto typedAttr = value.dyn_cast<TypedAttr>())
     type = typedAttr.getType();
   if (type.isa<NoneType, TensorType>()) {
     if (parser.parseColonType(type))
       return failure();
   }
 
   return parser.addTypeToList(type, result.types);
 }
 
 void spirv::ConstantOp::print(OpAsmPrinter &printer) {
-  printer << ' ' << value();
+  printer << ' ' << getValue();
   if (getType().isa<spirv::ArrayType>())
     printer << " : " << getType();
 }
 
 static LogicalResult verifyConstantType(spirv::ConstantOp op, Attribute value,
                                         Type opType) {
   if (value.isa<IntegerAttr, FloatAttr>()) {
     auto valueType = value.cast<TypedAttr>().getType();
static LogicalResult verifyConstantType(spirv::ConstantOp op, Attribute value,
   }
   return op.emitOpError("cannot have attribute: ") << value;
 }
 
 LogicalResult spirv::ConstantOp::verify() {
   // ODS already generates checks to make sure the result type is valid. We just
   // need to additionally check that the value's attribute type is consistent
   // with the result type.
-  return verifyConstantType(*this, valueAttr(), getType());
+  return verifyConstantType(*this, getValueAttr(), getType());
 }
 
 bool spirv::ConstantOp::isBuildableWith(Type type) {
   // Must be valid SPIR-V type first.
   if (!type.isa<spirv::SPIRVType>())
     return false;
 
   if (isa<SPIRVDialect>(type.getDialect())) {
void mlir::spirv::ConstantOp::getAsmResultNames(
   Type type = getType();
 
   SmallString<32> specialNameBuffer;
   llvm::raw_svector_ostream specialName(specialNameBuffer);
   specialName << "cst";
 
   IntegerType intTy = type.dyn_cast<IntegerType>();
 
-  if (IntegerAttr intCst = value().dyn_cast<IntegerAttr>()) {
+  if (IntegerAttr intCst = getValue().dyn_cast<IntegerAttr>()) {
     if (intTy && intTy.getWidth() == 1) {
       return setNameFn(getResult(), (intCst.getInt() ? "true" : "false"));
     }
 
     if (intTy.isSignless()) {
       specialName << intCst.getInt();
     } else {
       specialName << intCst.getSInt();
void mlir::spirv::ConstantOp::getAsmResultNames(
 
   setNameFn(getResult(), specialName.str());
 }
 
 void mlir::spirv::AddressOfOp::getAsmResultNames(
     llvm::function_ref<void(mlir::Value, llvm::StringRef)> setNameFn) {
   SmallString<32> specialNameBuffer;
   llvm::raw_svector_ostream specialName(specialNameBuffer);
-  specialName << variable() << "_addr";
+  specialName << getVariable() << "_addr";
   setNameFn(getResult(), specialName.str());
 }
 
 //===----------------------------------------------------------------------===//
 // spv.ControlBarrierOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::ControlBarrierOp::verify() {
-  return verifyMemorySemantics(getOperation(), memory_semantics());
+  return verifyMemorySemantics(getOperation(), getMemorySemantics());
 }
 
 //===----------------------------------------------------------------------===//
 // spv.ConvertFToSOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::ConvertFToSOp::verify() {
   return verifyCastOp(*this, /*requireSameBitWidth=*/false,
if (parser.parseCommaSeparatedList([&]() -> ParseResult {
       return failure();
   }
   result.addAttribute(kInterfaceAttrName,
                       parser.getBuilder().getArrayAttr(interfaceVars));
   return success();
 }
 
 void spirv::EntryPointOp::print(OpAsmPrinter &printer) {
-  printer << " \"" << stringifyExecutionModel(execution_model()) << "\" ";
-  printer.printSymbolName(fn());
-  auto interfaceVars = interface().getValue();
+  printer << " \"" << stringifyExecutionModel(getExecutionModel()) << "\" ";
+  printer.printSymbolName(getFn());
+  auto interfaceVars = getInterface().getValue();
   if (!interfaceVars.empty()) {
     printer << ", ";
     llvm::interleaveComma(interfaceVars, printer);
   }
 }
 
 LogicalResult spirv::EntryPointOp::verify() {
   // Checks for fn and interface symbol reference are done in spirv::ModuleOp
ParseResult spirv::ExecutionModeOp::parse(OpAsmParser &parser,
   }
   result.addAttribute(kValuesAttrName,
                       parser.getBuilder().getI32ArrayAttr(values));
   return success();
 }
 
 void spirv::ExecutionModeOp::print(OpAsmPrinter &printer) {
   printer << " ";
-  printer.printSymbolName(fn());
-  printer << " \"" << stringifyExecutionMode(execution_mode()) << "\"";
-  auto values = this->values();
+  printer.printSymbolName(getFn());
+  printer << " \"" << stringifyExecutionMode(getExecutionMode()) << "\"";
+  auto values = this->getValues();
   if (values.empty())
     return;
   printer << ", ";
   llvm::interleaveComma(values, printer, [&](Attribute a) {
     printer << a.cast<IntegerAttr>().getInt();
   });
 }
 
ParseResult spirv::FuncOp::parse(OpAsmParser &parser, OperationState &result) {
   OptionalParseResult parseResult =
       parser.parseOptionalRegion(*body, entryArgs);
   return failure(parseResult.has_value() && failed(*parseResult));
 }
 
 void spirv::FuncOp::print(OpAsmPrinter &printer) {
   // Print function name, signature, and control.
   printer << " ";
-  printer.printSymbolName(sym_name());
+  printer.printSymbolName(getSymName());
   auto fnType = getFunctionType();
   function_interface_impl::printFunctionSignature(
       printer, *this, fnType.getInputs(),
       /*isVariadic=*/false, fnType.getResults());
-  printer << " \"" << spirv::stringifyFunctionControl(function_control())
+  printer << " \"" << spirv::stringifyFunctionControl(getFunctionControl())
           << "\"";
   function_interface_impl::printFunctionAttributes(
       printer, *this, fnType.getNumInputs(), fnType.getNumResults(),
       {spirv::attributeName<spirv::FunctionControl>()});
 
   // Print the body if this is not an external function.
-  Region &body = this->body();
+  Region &body = this->getBody();
   if (!body.empty()) {
     printer << ' ';
     printer.printRegion(body, /*printEntryBlockArgs=*/false,
                         /*printBlockTerminators=*/true);
   }
 }
 
 LogicalResult spirv::FuncOp::verifyType() {
if (auto retOp = dyn_cast<spirv::ReturnOp>(op)) {
       if (fnType.getNumResults() != 0)
         return retOp.emitOpError("cannot be used in functions returning value");
     } else if (auto retOp = dyn_cast<spirv::ReturnValueOp>(op)) {
       if (fnType.getNumResults() != 1)
         return retOp.emitOpError(
                    "returns 1 value but enclosing function requires ")
                << fnType.getNumResults() << " results";
 
-      auto retOperandType = retOp.value().getType();
+      auto retOperandType = retOp.getValue().getType();
       auto fnResultType = fnType.getResult(0);
       if (retOperandType != fnResultType)
         return retOp.emitOpError(" return value's type (")
                << retOperandType << ") mismatch with function's result type ("
                << fnResultType << ")";
     }
     return WalkResult::advance();
   });
void spirv::FuncOp::build(OpBuilder &builder, OperationState &state,
   state.addAttribute(spirv::attributeName<spirv::FunctionControl>(),
                      builder.getAttr<spirv::FunctionControlAttr>(control));
   state.attributes.append(attrs.begin(), attrs.end());
   state.addRegion();
 }
 
 // CallableOpInterface
 Region *spirv::FuncOp::getCallableRegion() {
-  return isExternal() ? nullptr : &body();
+  return isExternal() ? nullptr : &getBody();
 }
 
 // CallableOpInterface
 ArrayRef<Type> spirv::FuncOp::getCallableResults() {
   return getFunctionType().getResults();
 }
 
 //===----------------------------------------------------------------------===//
 // spv.FunctionCall
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::FunctionCallOp::verify() {
-  auto fnName = calleeAttr();
+  auto fnName = getCalleeAttr();
 
   auto funcOp = dyn_cast_or_null<spirv::FuncOp>(
       SymbolTable::lookupNearestSymbolFrom((*this)->getParentOp(), fnName));
   if (!funcOp) {
     return emitOpError("callee function '")
            << fnName.getValue() << "' not found in nearest symbol table";
   }
 
LogicalResult spirv::FunctionCallOp::verify() {
   return success();
 }
 
 CallInterfaceCallable spirv::FunctionCallOp::getCallableForCallee() {
   return (*this)->getAttrOfType<SymbolRefAttr>(kCallee);
 }
 
 Operation::operand_range spirv::FunctionCallOp::getArgOperands() {
-  return arguments();
+  return getArguments();
 }
 
 //===----------------------------------------------------------------------===//
 // spv.GLFClampOp
 //===----------------------------------------------------------------------===//
 
 ParseResult spirv::GLFClampOp::parse(OpAsmParser &parser,
                                      OperationState &result) {

 }
 
 void spirv::GlobalVariableOp::print(OpAsmPrinter &printer) {
   SmallVector<StringRef, 4> elidedAttrs{
       spirv::attributeName<spirv::StorageClass>()};
 
   // Print variable name.
   printer << ' ';
-  printer.printSymbolName(sym_name());
+  printer.printSymbolName(getSymName());
   elidedAttrs.push_back(SymbolTable::getSymbolAttrName());
 
   // Print optional initializer
-  if (auto initializer = this->initializer()) {
+  if (auto initializer = this->getInitializer()) {
     printer << " " << kInitializerAttrName << '(';
     printer.printSymbolName(*initializer);
     printer << ')';
     elidedAttrs.push_back(kInitializerAttrName);
   }
 
   elidedAttrs.push_back(kTypeAttrName);
   printVariableDecorations(*this, printer, elidedAttrs);
-  printer << " : " << type();
+  printer << " : " << getType();
 }
 
 LogicalResult spirv::GlobalVariableOp::verify() {
   // SPIR-V spec: "Storage Class is the Storage Class of the memory holding the
   // object. It cannot be Generic. It must be the same as the Storage Class
   // operand of the Result Type."
   // Also, Function storage class is reserved by spv.Variable.
   auto storageClass = this->storageClass();
LogicalResult spirv::GlobalVariableOp::verify() {
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // spv.GroupBroadcast
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::GroupBroadcastOp::verify() {
-  spirv::Scope scope = execution_scope();
+  spirv::Scope scope = getExecutionScope();
   if (scope != spirv::Scope::Workgroup && scope != spirv::Scope::Subgroup)
     return emitOpError("execution scope must be 'Workgroup' or 'Subgroup'");
 
-  if (auto localIdTy = localid().getType().dyn_cast<VectorType>())
+  if (auto localIdTy = getLocalid().getType().dyn_cast<VectorType>())
     if (localIdTy.getNumElements() != 2 && localIdTy.getNumElements() != 3)
       return emitOpError("localid is a vector and can be with only "
                          " 2 or 3 components, actual number is ")
              << localIdTy.getNumElements();
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // spv.GroupNonUniformBallotOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::GroupNonUniformBallotOp::verify() {
-  spirv::Scope scope = execution_scope();
+  spirv::Scope scope = getExecutionScope();
   if (scope != spirv::Scope::Workgroup && scope != spirv::Scope::Subgroup)
     return emitOpError("execution scope must be 'Workgroup' or 'Subgroup'");
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // spv.GroupNonUniformBroadcast
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::GroupNonUniformBroadcastOp::verify() {
-  spirv::Scope scope = execution_scope();
+  spirv::Scope scope = getExecutionScope();
   if (scope != spirv::Scope::Workgroup && scope != spirv::Scope::Subgroup)
     return emitOpError("execution scope must be 'Workgroup' or 'Subgroup'");
 
   // SPIR-V spec: "Before version 1.5, Id must come from a
   // constant instruction.
   auto targetEnv = spirv::getDefaultTargetEnv(getContext());
   if (auto spirvModule = (*this)->getParentOfType<spirv::ModuleOp>())
     targetEnv = spirv::lookupTargetEnvOrDefault(spirvModule);
 
   if (targetEnv.getVersion() < spirv::Version::V_1_5) {
-    auto *idOp = id().getDefiningOp();
+    auto *idOp = getId().getDefiningOp();
     if (!idOp || !isa<spirv::ConstantOp,           // for normal constant
                       spirv::ReferenceOfOp>(idOp)) // for spec constant
       return emitOpError("id must be the result of a constant op");
   }
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // spv.GroupNonUniformShuffle*
 //===----------------------------------------------------------------------===//
 
 template <typename OpTy>
 static LogicalResult verifyGroupNonUniformShuffleOp(OpTy op) {
-  spirv::Scope scope = op.execution_scope();
+  spirv::Scope scope = op.getExecutionScope();
   if (scope != spirv::Scope::Workgroup && scope != spirv::Scope::Subgroup)
     return op.emitOpError("execution scope must be 'Workgroup' or 'Subgroup'");
 
   if (op.getOperands().back().getType().isSignedInteger())
     return op.emitOpError("second operand must be a singless/unsigned integer");
 
   return success();
 }
if (parser.resolveOperand(ptrInfo, ptrType, result.operands)) {
     return failure();
   }
 
   result.addTypes(elementType);
   return success();
 }
 
 void spirv::INTELSubgroupBlockReadOp::print(OpAsmPrinter &printer) {
-  printer << " " << ptr() << " : " << getType();
+  printer << " " << getPtr() << " : " << getType();
 }
 
 LogicalResult spirv::INTELSubgroupBlockReadOp::verify() {
-  if (failed(verifyBlockReadWritePtrAndValTypes(*this, ptr(), value())))
+  if (failed(verifyBlockReadWritePtrAndValTypes(*this, getPtr(), getValue())))
     return failure();
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // spv.INTEL.SubgroupBlockWrite
 //===----------------------------------------------------------------------===//
ParseResult spirv::INTELSubgroupBlockWriteOp::parse(OpAsmParser &parser,
   if (parser.resolveOperands(operandInfo, {ptrType, elementType}, loc,
                              result.operands)) {
     return failure();
   }
   return success();
 }
 
 void spirv::INTELSubgroupBlockWriteOp::print(OpAsmPrinter &printer) {
-  printer << " " << ptr() << ", " << value() << " : " << value().getType();
+  printer << " " << getPtr() << ", " << getValue() << " : "
+          << getValue().getType();
 }
 
 LogicalResult spirv::INTELSubgroupBlockWriteOp::verify() {
-  if (failed(verifyBlockReadWritePtrAndValTypes(*this, ptr(), value())))
+  if (failed(verifyBlockReadWritePtrAndValTypes(*this, getPtr(), getValue())))
     return failure();
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // spv.GroupNonUniformElectOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::GroupNonUniformElectOp::verify() {
-  spirv::Scope scope = execution_scope();
+  spirv::Scope scope = getExecutionScope();
   if (scope != spirv::Scope::Workgroup && scope != spirv::Scope::Subgroup)
     return emitOpError("execution scope must be 'Workgroup' or 'Subgroup'");
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // spv.GroupNonUniformFAddOp

 // spv.IAddCarryOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::IAddCarryOp::verify() {
   auto resultType = getType().cast<spirv::StructType>();
   if (resultType.getNumElements() != 2)
     return emitOpError("expected result struct type containing two members");
 
-  if (!llvm::all_equal({operand1().getType(), operand2().getType(),
+  if (!llvm::all_equal({getOperand1().getType(), getOperand2().getType(),
                         resultType.getElementType(0),
                         resultType.getElementType(1)}))
     return emitOpError(
         "expected all operand types and struct member types are the same");
 
   return success();
 }
 

 // spv.ISubBorrowOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::ISubBorrowOp::verify() {
   auto resultType = getType().cast<spirv::StructType>();
   if (resultType.getNumElements() != 2)
     return emitOpError("expected result struct type containing two members");
 
-  if (!llvm::all_equal({operand1().getType(), operand2().getType(),
+  if (!llvm::all_equal({getOperand1().getType(), getOperand2().getType(),
                         resultType.getElementType(0),
                         resultType.getElementType(1)}))
     return emitOpError(
         "expected all operand types and struct member types are the same");
 
   return success();
 }
 
ParseResult spirv::LoadOp::parse(OpAsmParser &parser, OperationState &result) {
 
   result.addTypes(elementType);
   return success();
 }
 
 void spirv::LoadOp::print(OpAsmPrinter &printer) {
   SmallVector<StringRef, 4> elidedAttrs;
   StringRef sc = stringifyStorageClass(
-      ptr().getType().cast<spirv::PointerType>().getStorageClass());
-  printer << " \"" << sc << "\" " << ptr();
+      getPtr().getType().cast<spirv::PointerType>().getStorageClass());
+  printer << " \"" << sc << "\" " << getPtr();
 
   printMemoryAccessAttribute(*this, printer, elidedAttrs);
 
   printer.printOptionalAttrDict((*this)->getAttrs(), elidedAttrs);
   printer << " : " << getType();
 }
 
 LogicalResult spirv::LoadOp::verify() {
   // SPIR-V spec : "Result Type is the type of the loaded object. It must be a
   // type with fixed size; i.e., it cannot be, nor include, any
   // OpTypeRuntimeArray types."
-  if (failed(verifyLoadStorePtrAndValTypes(*this, ptr(), value()))) {
+  if (failed(verifyLoadStorePtrAndValTypes(*this, getPtr(), getValue()))) {
     return failure();
   }
   return verifyMemoryAccessAttribute(*this);
 }
 
 //===----------------------------------------------------------------------===//
 // spv.mlir.loop
 //===----------------------------------------------------------------------===//
 
 void spirv::LoopOp::build(OpBuilder &builder, OperationState &state) {
   state.addAttribute("loop_control", builder.getAttr<spirv::LoopControlAttr>(
                                          spirv::LoopControl::None));
   state.addRegion();
 }
 
 ParseResult spirv::LoopOp::parse(OpAsmParser &parser, OperationState &result) {
   if (parseControlAttribute<spirv::LoopControlAttr, spirv::LoopControl>(parser,
                                                                         result))
     return failure();
   return parser.parseRegion(*result.addRegion(), /*arguments=*/{});
 }
 
 void spirv::LoopOp::print(OpAsmPrinter &printer) {
-  auto control = loop_control();
+  auto control = getLoopControl();
   if (control != spirv::LoopControl::None)
     printer << " control(" << spirv::stringifyLoopControl(control) << ")";
   printer << ' ';
   printer.printRegion(getRegion(), /*printEntryBlockArgs=*/false,
                       /*printBlockTerminators=*/true);
 }
 
 /// Returns true if the given `srcBlock` contains only one `spv.Branch` to the
for (auto i : llvm::seq<unsigned>(0, block.getNumSuccessors())) {
       }
     }
   }
 
   return success();
 }
 
 Block *spirv::LoopOp::getEntryBlock() {
-  assert(!body().empty() && "op region should not be empty!");
-  return &body().front();
+  assert(!getBody().empty() && "op region should not be empty!");
+  return &getBody().front();
 }
 
 Block *spirv::LoopOp::getHeaderBlock() {
-  assert(!body().empty() && "op region should not be empty!");
+  assert(!getBody().empty() && "op region should not be empty!");
   // The second block is the loop header block.
-  return &*std::next(body().begin());
+  return &*std::next(getBody().begin());
 }
 
 Block *spirv::LoopOp::getContinueBlock() {
-  assert(!body().empty() && "op region should not be empty!");
+  assert(!getBody().empty() && "op region should not be empty!");
   // The second to last block is the loop continue block.
-  return &*std::prev(body().end(), 2);
+  return &*std::prev(getBody().end(), 2);
 }
 
 Block *spirv::LoopOp::getMergeBlock() {
-  assert(!body().empty() && "op region should not be empty!");
+  assert(!getBody().empty() && "op region should not be empty!");
   // The last block is the loop merge block.
-  return &body().back();
+  return &getBody().back();
 }
 
 void spirv::LoopOp::addEntryAndMergeBlock() {
-  assert(body().empty() && "entry and merge block already exist");
-  body().push_back(new Block());
+  assert(getBody().empty() && "entry and merge block already exist");
+  getBody().push_back(new Block());
   auto *mergeBlock = new Block();
-  body().push_back(mergeBlock);
+  getBody().push_back(mergeBlock);
   OpBuilder builder = OpBuilder::atBlockEnd(mergeBlock);
 
   // Add a spv.mlir.merge op into the merge block.
   builder.create<spirv::MergeOp>(getLoc());
 }
 
 //===----------------------------------------------------------------------===//
 // spv.MemoryBarrierOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::MemoryBarrierOp::verify() {
-  return verifyMemorySemantics(getOperation(), memory_semantics());
+  return verifyMemorySemantics(getOperation(), getMemorySemantics());
 }
 
 //===----------------------------------------------------------------------===//
 // spv.mlir.merge
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::MergeOp::verify() {
   auto *parentOp = (*this)->getParentOp();

 void spirv::ModuleOp::print(OpAsmPrinter &printer) {
   if (Optional<StringRef> name = getName()) {
     printer << ' ';
     printer.printSymbolName(*name);
   }
 
   SmallVector<StringRef, 2> elidedAttrs;
 
-  printer << " " << spirv::stringifyAddressingModel(addressing_model()) << " "
-          << spirv::stringifyMemoryModel(memory_model());
+  printer << " " << spirv::stringifyAddressingModel(getAddressingModel()) << " "
+          << spirv::stringifyMemoryModel(getMemoryModel());
   auto addressingModelAttrName = spirv::attributeName<spirv::AddressingModel>();
   auto memoryModelAttrName = spirv::attributeName<spirv::MemoryModel>();
   elidedAttrs.assign({addressingModelAttrName, memoryModelAttrName,
                       mlir::SymbolTable::getSymbolAttrName()});
 
-  if (Optional<spirv::VerCapExtAttr> triple = vce_triple()) {
+  if (Optional<spirv::VerCapExtAttr> triple = getVceTriple()) {
     printer << " requires " << *triple;
     elidedAttrs.push_back(spirv::ModuleOp::getVCETripleAttrName());
   }
 
   printer.printOptionalAttrDictWithKeyword((*this)->getAttrs(), elidedAttrs);
   printer << ' ';
   printer.printRegion(getRegion());
 }
 
 LogicalResult spirv::ModuleOp::verifyRegions() {
   Dialect *dialect = (*this)->getDialect();
   DenseMap<std::pair<spirv::FuncOp, spirv::ExecutionModel>, spirv::EntryPointOp>
       entryPoints;
   mlir::SymbolTable table(*this);
 
   for (auto &op : *getBody()) {
     if (op.getDialect() != dialect)
       return op.emitError("'spv.module' can only contain spv.* ops");
 
     // For EntryPoint op, check that the function and execution model is not
     // duplicated in EntryPointOps. Also verify that the interface specified
     // comes from globalVariables here to make this check cheaper.
     if (auto entryPointOp = dyn_cast<spirv::EntryPointOp>(op)) {
-      auto funcOp = table.lookup<spirv::FuncOp>(entryPointOp.fn());
+      auto funcOp = table.lookup<spirv::FuncOp>(entryPointOp.getFn());
       if (!funcOp) {
         return entryPointOp.emitError("function '")
-               << entryPointOp.fn() << "' not found in 'spv.module'";
+               << entryPointOp.getFn() << "' not found in 'spv.module'";
       }
-      if (auto interface = entryPointOp.interface()) {
+      if (auto interface = entryPointOp.getInterface()) {
         for (Attribute varRef : interface) {
           auto varSymRef = varRef.dyn_cast<FlatSymbolRefAttr>();
           if (!varSymRef) {
             return entryPointOp.emitError(
                        "expected symbol reference for interface "
                        "specification instead of '")
                    << varRef;
           }
           auto variableOp =
               table.lookup<spirv::GlobalVariableOp>(varSymRef.getValue());
           if (!variableOp) {
             return entryPointOp.emitError("expected spv.GlobalVariable "
                                           "symbol reference instead of'")
                    << varSymRef << "'";
           }
         }
       }
 
       auto key = std::pair<spirv::FuncOp, spirv::ExecutionModel>(
-          funcOp, entryPointOp.execution_model());
+          funcOp, entryPointOp.getExecutionModel());
       auto entryPtIt = entryPoints.find(key);
       if (entryPtIt != entryPoints.end()) {
         return entryPointOp.emitError("duplicate of a previous EntryPointOp");
       }
       entryPoints[key] = entryPointOp;
     } else if (auto funcOp = dyn_cast<spirv::FuncOp>(op)) {
       if (funcOp.isExternal())
         return op.emitError("'spv.module' cannot contain external functions");

 }
 
 //===----------------------------------------------------------------------===//
 // spv.mlir.referenceof
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::ReferenceOfOp::verify() {
   auto *specConstSym = SymbolTable::lookupNearestSymbolFrom(
-      (*this)->getParentOp(), spec_constAttr());
+      (*this)->getParentOp(), getSpecConstAttr());
   Type constType;
 
   auto specConstOp = dyn_cast_or_null<spirv::SpecConstantOp>(specConstSym);
   if (specConstOp)
-    constType = specConstOp.default_value().getType();
+    constType = specConstOp.getDefaultValue().getType();
 
   auto specConstCompositeOp =
       dyn_cast_or_null<spirv::SpecConstantCompositeOp>(specConstSym);
   if (specConstCompositeOp)
-    constType = specConstCompositeOp.type();
+    constType = specConstCompositeOp.getType();
 
   if (!specConstOp && !specConstCompositeOp)
     return emitOpError(
         "expected spv.SpecConstant or spv.SpecConstantComposite symbol");
 
-  if (reference().getType() != constType)
+  if (getReference().getType() != constType)
     return emitOpError("result type mismatch with the referenced "
                        "specialization constant's type");
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // spv.Return
LogicalResult spirv::ReturnValueOp::verify() {
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // spv.Select
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::SelectOp::verify() {
-  if (auto conditionTy = condition().getType().dyn_cast<VectorType>()) {
-    auto resultVectorTy = result().getType().dyn_cast<VectorType>();
+  if (auto conditionTy = getCondition().getType().dyn_cast<VectorType>()) {
+    auto resultVectorTy = getResult().getType().dyn_cast<VectorType>();
     if (!resultVectorTy) {
       return emitOpError("result expected to be of vector type when "
                          "condition is of vector type");
     }
     if (resultVectorTy.getNumElements() != conditionTy.getNumElements()) {
       return emitOpError("result should have the same number of elements as "
                          "the condition when condition is of vector type");
     }
ParseResult spirv::SelectionOp::parse(OpAsmParser &parser,
                                       OperationState &result) {
   if (parseControlAttribute<spirv::SelectionControlAttr,
                             spirv::SelectionControl>(parser, result))
     return failure();
   return parser.parseRegion(*result.addRegion(), /*arguments=*/{});
 }
 
 void spirv::SelectionOp::print(OpAsmPrinter &printer) {
-  auto control = selection_control();
+  auto control = getSelectionControl();
   if (control != spirv::SelectionControl::None)
     printer << " control(" << spirv::stringifySelectionControl(control) << ")";
   printer << ' ';
   printer.printRegion(getRegion(), /*printEntryBlockArgs=*/false,
                       /*printBlockTerminators=*/true);
 }
 
 LogicalResult spirv::SelectionOp::verifyRegions() {
LogicalResult spirv::SelectionOp::verifyRegions() {
 
   if (std::next(region.begin()) == region.end())
     return emitOpError("must have a selection header block");
 
   return success();
 }
 
 Block *spirv::SelectionOp::getHeaderBlock() {
-  assert(!body().empty() && "op region should not be empty!");
+  assert(!getBody().empty() && "op region should not be empty!");
   // The first block is the loop header block.
-  return &body().front();
+  return &getBody().front();
 }
 
 Block *spirv::SelectionOp::getMergeBlock() {
-  assert(!body().empty() && "op region should not be empty!");
+  assert(!getBody().empty() && "op region should not be empty!");
   // The last block is the loop merge block.
-  return &body().back();
+  return &getBody().back();
 }
 
 void spirv::SelectionOp::addMergeBlock() {
-  assert(body().empty() && "entry and merge block already exist");
+  assert(getBody().empty() && "entry and merge block already exist");
   auto *mergeBlock = new Block();
-  body().push_back(mergeBlock);
+  getBody().push_back(mergeBlock);
   OpBuilder builder = OpBuilder::atBlockEnd(mergeBlock);
 
   // Add a spv.mlir.merge op into the merge block.
   builder.create<spirv::MergeOp>(getLoc());
 }
 
 spirv::SelectionOp spirv::SelectionOp::createIfThen(
     Location loc, Value condition,
if (parser.parseEqual() ||
                             result.attributes))
     return failure();
 
   return success();
 }
 
 void spirv::SpecConstantOp::print(OpAsmPrinter &printer) {
   printer << ' ';
-  printer.printSymbolName(sym_name());
+  printer.printSymbolName(getSymName());
   if (auto specID = (*this)->getAttrOfType<IntegerAttr>(kSpecIdAttrName))
     printer << ' ' << kSpecIdAttrName << '(' << specID.getInt() << ')';
-  printer << " = " << default_value();
+  printer << " = " << getDefaultValue();
 }
 
 LogicalResult spirv::SpecConstantOp::verify() {
   if (auto specID = (*this)->getAttrOfType<IntegerAttr>(kSpecIdAttrName))
     if (specID.getValue().isNegative())
       return emitOpError("SpecId cannot be negative");
 
-  auto value = default_value();
+  auto value = getDefaultValue();
   if (value.isa<IntegerAttr, FloatAttr>()) {
     // Make sure bitwidth is allowed.
     if (!value.getType().isa<spirv::SPIRVType>())
       return emitOpError("default value bitwidth disallowed");
     return success();
   }
   return emitOpError(
       "default value can only be a bool, integer, or float scalar");
if (parser.resolveOperands(operandInfo, {ptrType, elementType}, loc,
     return failure();
   }
   return success();
 }
 
 void spirv::StoreOp::print(OpAsmPrinter &printer) {
   SmallVector<StringRef, 4> elidedAttrs;
   StringRef sc = stringifyStorageClass(
-      ptr().getType().cast<spirv::PointerType>().getStorageClass());
-  printer << " \"" << sc << "\" " << ptr() << ", " << value();
+      getPtr().getType().cast<spirv::PointerType>().getStorageClass());
+  printer << " \"" << sc << "\" " << getPtr() << ", " << getValue();
 
   printMemoryAccessAttribute(*this, printer, elidedAttrs);
 
-  printer << " : " << value().getType();
+  printer << " : " << getValue().getType();
   printer.printOptionalAttrDict((*this)->getAttrs(), elidedAttrs);
 }
 
 LogicalResult spirv::StoreOp::verify() {
   // SPIR-V spec : "Pointer is the pointer to store through. Its type must be an
   // OpTypePointer whose Type operand is the same as the type of Object."
-  if (failed(verifyLoadStorePtrAndValTypes(*this, ptr(), value())))
+  if (failed(verifyLoadStorePtrAndValTypes(*this, getPtr(), getValue())))
     return failure();
   return verifyMemoryAccessAttribute(*this);
 }
 
 //===----------------------------------------------------------------------===//
 // spv.Unreachable
 //===----------------------------------------------------------------------===//
 
ParseResult spirv::VariableOp::parse(OpAsmParser &parser,
   return success();
 }
 
 void spirv::VariableOp::print(OpAsmPrinter &printer) {
   SmallVector<StringRef, 4> elidedAttrs{
       spirv::attributeName<spirv::StorageClass>()};
   // Print optional initializer
   if (getNumOperands() != 0)
-    printer << " init(" << initializer() << ")";
+    printer << " init(" << getInitializer() << ")";
 
   printVariableDecorations(*this, printer, elidedAttrs);
   printer << " : " << getType();
 }
 
 LogicalResult spirv::VariableOp::verify() {
   // SPIR-V spec: "Storage Class is the Storage Class of the memory holding the
   // object. It cannot be Generic. It must be the same as the Storage Class
   // operand of the Result Type."
-  if (storage_class() != spirv::StorageClass::Function) {
+  if (getStorageClass() != spirv::StorageClass::Function) {
     return emitOpError(
         "can only be used to model function-level variables. Use "
         "spv.GlobalVariable for module-level variables.");
   }
 
-  auto pointerType = pointer().getType().cast<spirv::PointerType>();
-  if (storage_class() != pointerType.getStorageClass())
+  auto pointerType = getPointer().getType().cast<spirv::PointerType>();
+  if (getStorageClass() != pointerType.getStorageClass())
     return emitOpError(
         "storage class must match result pointer's storage class");
 
   if (getNumOperands() != 0) {
     // SPIR-V spec: "Initializer must be an <id> from a constant instruction or
     // a global (module scope) OpVariable instruction".
     auto *initOp = getOperand(0).getDefiningOp();
     if (!initOp || !isa<spirv::ConstantOp,    // for normal constant

 //===----------------------------------------------------------------------===//
 // spv.VectorShuffle
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::VectorShuffleOp::verify() {
   VectorType resultType = getType().cast<VectorType>();
 
   size_t numResultElements = resultType.getNumElements();
-  if (numResultElements != components().size())
+  if (numResultElements != getComponents().size())
     return emitOpError("result type element count (")
            << numResultElements
            << ") mismatch with the number of component selectors ("
-           << components().size() << ")";
+           << getComponents().size() << ")";
 
   size_t totalSrcElements =
-      vector1().getType().cast<VectorType>().getNumElements() +
-      vector2().getType().cast<VectorType>().getNumElements();
+      getVector1().getType().cast<VectorType>().getNumElements() +
+      getVector2().getType().cast<VectorType>().getNumElements();
 
-  for (const auto &selector : components().getAsValueRange<IntegerAttr>()) {
+  for (const auto &selector : getComponents().getAsValueRange<IntegerAttr>()) {
     uint32_t index = selector.getZExtValue();
     if (index >= totalSrcElements &&
         index != std::numeric_limits<uint32_t>().max())
       return emitOpError("component selector ")
              << index << " out of range: expected to be in [0, "
              << totalSrcElements << ") or 0xffffffff";
   }
   return success();
if (parser.resolveOperands(operandInfo,
     return failure();
   }
 
   result.addTypes(elementType);
   return success();
 }
 
 void spirv::NVCooperativeMatrixLoadOp::print(OpAsmPrinter &printer) {
-  printer << " " << pointer() << ", " << stride() << ", " << columnmajor();
+  printer << " " << getPointer() << ", " << getStride() << ", "
+          << getColumnmajor();
   // Print optional memory access attribute.
-  if (auto memAccess = memory_access())
+  if (auto memAccess = getMemoryAccess())
     printer << " [\"" << stringifyMemoryAccess(*memAccess) << "\"]";
-  printer << " : " << pointer().getType() << " as " << getType();
+  printer << " : " << getPointer().getType() << " as " << getType();
 }
 
 static LogicalResult verifyPointerAndCoopMatrixType(Operation *op, Type pointer,
                                                     Type coopMatrix) {
   Type pointeeType = pointer.cast<spirv::PointerType>().getPointeeType();
   if (!pointeeType.isa<spirv::ScalarType>() && !pointeeType.isa<VectorType>())
     return op->emitError(
                "Pointer must point to a scalar or vector type but provided ")
            << pointeeType;
   spirv::StorageClass storage =
       pointer.cast<spirv::PointerType>().getStorageClass();
   if (storage != spirv::StorageClass::Workgroup &&
       storage != spirv::StorageClass::StorageBuffer &&
       storage != spirv::StorageClass::PhysicalStorageBuffer)
     return op->emitError(
                "Pointer storage class must be Workgroup, StorageBuffer or "
                "PhysicalStorageBufferEXT but provided ")
            << stringifyStorageClass(storage);
   return success();
 }
 
 LogicalResult spirv::NVCooperativeMatrixLoadOp::verify() {
-  return verifyPointerAndCoopMatrixType(*this, pointer().getType(),
-                                        result().getType());
+  return verifyPointerAndCoopMatrixType(*this, getPointer().getType(),
+                                        getResult().getType());
 }
 
 //===----------------------------------------------------------------------===//
 // spv.NV.CooperativeMatrixStore
 //===----------------------------------------------------------------------===//
 
 ParseResult spirv::NVCooperativeMatrixStoreOp::parse(OpAsmParser &parser,
                                                      OperationState &result) {
if (parser.resolveOperands(
           parser.getNameLoc(), result.operands)) {
     return failure();
   }
 
   return success();
 }
 
 void spirv::NVCooperativeMatrixStoreOp::print(OpAsmPrinter &printer) {
-  printer << " " << pointer() << ", " << object() << ", " << stride() << ", "
-          << columnmajor();
+  printer << " " << getPointer() << ", " << getObject() << ", " << getStride()
+          << ", " << getColumnmajor();
   // Print optional memory access attribute.
-  if (auto memAccess = memory_access())
+  if (auto memAccess = getMemoryAccess())
     printer << " [\"" << stringifyMemoryAccess(*memAccess) << "\"]";
-  printer << " : " << pointer().getType() << ", " << getOperand(1).getType();
+  printer << " : " << getPointer().getType() << ", " << getOperand(1).getType();
 }
 
 LogicalResult spirv::NVCooperativeMatrixStoreOp::verify() {
-  return verifyPointerAndCoopMatrixType(*this, pointer().getType(),
-                                        object().getType());
+  return verifyPointerAndCoopMatrixType(*this, getPointer().getType(),
+                                        getObject().getType());
 }
 
 //===----------------------------------------------------------------------===//
 // spv.NV.CooperativeMatrixMulAdd
 //===----------------------------------------------------------------------===//
 
 static LogicalResult
 verifyCoopMatrixMulAdd(spirv::NVCooperativeMatrixMulAddOp op) {
-  if (op.c().getType() != op.result().getType())
+  if (op.getC().getType() != op.getResult().getType())
     return op.emitOpError("result and third operand must have the same type");
-  auto typeA = op.a().getType().cast<spirv::CooperativeMatrixNVType>();
-  auto typeB = op.b().getType().cast<spirv::CooperativeMatrixNVType>();
-  auto typeC = op.c().getType().cast<spirv::CooperativeMatrixNVType>();
-  auto typeR = op.result().getType().cast<spirv::CooperativeMatrixNVType>();
+  auto typeA = op.getA().getType().cast<spirv::CooperativeMatrixNVType>();
+  auto typeB = op.getB().getType().cast<spirv::CooperativeMatrixNVType>();
+  auto typeC = op.getC().getType().cast<spirv::CooperativeMatrixNVType>();
+  auto typeR = op.getResult().getType().cast<spirv::CooperativeMatrixNVType>();
   if (typeA.getRows() != typeR.getRows() ||
       typeA.getColumns() != typeB.getRows() ||
       typeB.getColumns() != typeR.getColumns())
     return op.emitOpError("matrix size must match");
   if (typeR.getScope() != typeA.getScope() ||
       typeR.getScope() != typeB.getScope() ||
       typeR.getScope() != typeC.getScope())
     return op.emitOpError("matrix scope must match");
verifyPointerAndJointMatrixType(Operation *op, Type pointer, Type jointMatrix) {
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // spv.INTEL.JointMatrixLoad
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::INTELJointMatrixLoadOp::verify() {
-  return verifyPointerAndJointMatrixType(*this, pointer().getType(),
-                                         result().getType());
+  return verifyPointerAndJointMatrixType(*this, getPointer().getType(),
+                                         getResult().getType());
 }
 
 //===----------------------------------------------------------------------===//
 // spv.INTEL.JointMatrixStore
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::INTELJointMatrixStoreOp::verify() {
-  return verifyPointerAndJointMatrixType(*this, pointer().getType(),
-                                         object().getType());
+  return verifyPointerAndJointMatrixType(*this, getPointer().getType(),
+                                         getObject().getType());
 }
 
 //===----------------------------------------------------------------------===//
 // spv.INTEL.JointMatrixMad
 //===----------------------------------------------------------------------===//
 
 static LogicalResult verifyJointMatrixMad(spirv::INTELJointMatrixMadOp op) {
-  if (op.c().getType() != op.result().getType())
+  if (op.getC().getType() != op.getResult().getType())
     return op.emitOpError("result and third operand must have the same type");
-  auto typeA = op.a().getType().cast<spirv::JointMatrixINTELType>();
-  auto typeB = op.b().getType().cast<spirv::JointMatrixINTELType>();
-  auto typeC = op.c().getType().cast<spirv::JointMatrixINTELType>();
-  auto typeR = op.result().getType().cast<spirv::JointMatrixINTELType>();
+  auto typeA = op.getA().getType().cast<spirv::JointMatrixINTELType>();
+  auto typeB = op.getB().getType().cast<spirv::JointMatrixINTELType>();
+  auto typeC = op.getC().getType().cast<spirv::JointMatrixINTELType>();
+  auto typeR = op.getResult().getType().cast<spirv::JointMatrixINTELType>();
   if (typeA.getRows() != typeR.getRows() ||
       typeA.getColumns() != typeB.getRows() ||
       typeB.getColumns() != typeR.getColumns())
     return op.emitOpError("matrix size must match");
   if (typeR.getScope() != typeA.getScope() ||
       typeR.getScope() != typeB.getScope() ||
       typeR.getScope() != typeC.getScope())
     return op.emitOpError("matrix scope must match");

 //===----------------------------------------------------------------------===//
 // spv.MatrixTimesScalar
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::MatrixTimesScalarOp::verify() {
   // We already checked that result and matrix are both of matrix type in the
   // auto-generated verify method.
 
-  auto inputMatrix = matrix().getType().cast<spirv::MatrixType>();
-  auto resultMatrix = result().getType().cast<spirv::MatrixType>();
+  auto inputMatrix = getMatrix().getType().cast<spirv::MatrixType>();
+  auto resultMatrix = getResult().getType().cast<spirv::MatrixType>();
 
   // Check that the scalar type is the same as the matrix element type.
-  if (scalar().getType() != inputMatrix.getElementType())
+  if (getScalar().getType() != inputMatrix.getElementType())
     return emitError("input matrix components' type and scaling value must "
                      "have the same type");
 
   // Note that the next three checks could be done using the AllTypesMatch
   // trait in the Op definition file but it generates a vague error message.
 
   // Check that the input and result matrices have the same columns' count
   if (inputMatrix.getNumColumns() != resultMatrix.getNumColumns())

 //===----------------------------------------------------------------------===//
 // spv.CopyMemory
 //===----------------------------------------------------------------------===//
 
 void spirv::CopyMemoryOp::print(OpAsmPrinter &printer) {
   printer << ' ';
 
   StringRef targetStorageClass = stringifyStorageClass(
-      target().getType().cast<spirv::PointerType>().getStorageClass());
-  printer << " \"" << targetStorageClass << "\" " << target() << ", ";
+      getTarget().getType().cast<spirv::PointerType>().getStorageClass());
+  printer << " \"" << targetStorageClass << "\" " << getTarget() << ", ";
 
   StringRef sourceStorageClass = stringifyStorageClass(
-      source().getType().cast<spirv::PointerType>().getStorageClass());
-  printer << " \"" << sourceStorageClass << "\" " << source();
+      getSource().getType().cast<spirv::PointerType>().getStorageClass());
+  printer << " \"" << sourceStorageClass << "\" " << getSource();
 
   SmallVector<StringRef, 4> elidedAttrs;
   printMemoryAccessAttribute(*this, printer, elidedAttrs);
   printSourceMemoryAccessAttribute(*this, printer, elidedAttrs,
-                                   source_memory_access(), source_alignment());
+                                   getSourceMemoryAccess(),
+                                   getSourceAlignment());
 
   printer.printOptionalAttrDict((*this)->getAttrs(), elidedAttrs);
 
   Type pointeeType =
-      target().getType().cast<spirv::PointerType>().getPointeeType();
+      getTarget().getType().cast<spirv::PointerType>().getPointeeType();
   printer << " : " << pointeeType;
 }
 
 ParseResult spirv::CopyMemoryOp::parse(OpAsmParser &parser,
                                        OperationState &result) {
   spirv::StorageClass targetStorageClass;
   OpAsmParser::UnresolvedOperand targetPtrInfo;
 
if (parser.resolveOperand(targetPtrInfo, targetPtrType, result.operands) ||
     return failure();
   }
 
   return success();
 }
 
 LogicalResult spirv::CopyMemoryOp::verify() {
   Type targetType =
-      target().getType().cast<spirv::PointerType>().getPointeeType();
+      getTarget().getType().cast<spirv::PointerType>().getPointeeType();
 
   Type sourceType =
-      source().getType().cast<spirv::PointerType>().getPointeeType();
+      getSource().getType().cast<spirv::PointerType>().getPointeeType();
 
   if (targetType != sourceType)
     return emitOpError("both operands must be pointers to the same type");
 
   if (failed(verifyMemoryAccessAttribute(*this)))
     return failure();
 
   // TODO - According to the spec:
   //
   // If two masks are present, the first applies to Target and cannot include
   // MakePointerVisible, and the second applies to Source and cannot include
   // MakePointerAvailable.
   //
   // Add such verification here.
 
   return verifySourceMemoryAccessAttribute(*this);
 }
 
 //===----------------------------------------------------------------------===//
 // spv.Transpose
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::TransposeOp::verify() {
-  auto inputMatrix = matrix().getType().cast<spirv::MatrixType>();
-  auto resultMatrix = result().getType().cast<spirv::MatrixType>();
+  auto inputMatrix = getMatrix().getType().cast<spirv::MatrixType>();
+  auto resultMatrix = getResult().getType().cast<spirv::MatrixType>();
 
   // Verify that the input and output matrices have correct shapes.
   if (inputMatrix.getNumRows() != resultMatrix.getNumColumns())
     return emitError("input matrix rows count must be equal to "
                      "output matrix columns count");
 
   if (inputMatrix.getNumColumns() != resultMatrix.getNumRows())
     return emitError("input matrix columns count must be equal to "
                      "output matrix rows count");
 
   // Verify that the input and output matrices have the same component type
   if (inputMatrix.getElementType() != resultMatrix.getElementType())
     return emitError("input and output matrices must have the same "
                      "component type");
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // spv.MatrixTimesMatrix
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::MatrixTimesMatrixOp::verify() {
-  auto leftMatrix = leftmatrix().getType().cast<spirv::MatrixType>();
-  auto rightMatrix = rightmatrix().getType().cast<spirv::MatrixType>();
-  auto resultMatrix = result().getType().cast<spirv::MatrixType>();
+  auto leftMatrix = getLeftmatrix().getType().cast<spirv::MatrixType>();
+  auto rightMatrix = getRightmatrix().getType().cast<spirv::MatrixType>();
+  auto resultMatrix = getResult().getType().cast<spirv::MatrixType>();
 
   // left matrix columns' count and right matrix rows' count must be equal
   if (leftMatrix.getNumColumns() != rightMatrix.getNumRows())
     return emitError("left matrix columns' count must be equal to "
                      "the right matrix rows' count");
 
   // right and result matrices columns' count must be the same
   if (rightMatrix.getNumColumns() != resultMatrix.getNumColumns())
ParseResult spirv::SpecConstantCompositeOp::parse(OpAsmParser &parser,
 
   result.addAttribute(kTypeAttrName, TypeAttr::get(type));
 
   return success();
 }
 
 void spirv::SpecConstantCompositeOp::print(OpAsmPrinter &printer) {
   printer << " ";
-  printer.printSymbolName(sym_name());
+  printer.printSymbolName(getSymName());
   printer << " (";
-  auto constituents = this->constituents().getValue();
+  auto constituents = this->getConstituents().getValue();
 
   if (!constituents.empty())
     llvm::interleaveComma(constituents, printer);
 
-  printer << ") : " << type();
+  printer << ") : " << getType();
 }
 
 LogicalResult spirv::SpecConstantCompositeOp::verify() {
-  auto cType = type().dyn_cast<spirv::CompositeType>();
-  auto constituents = this->constituents().getValue();
+  auto cType = getType().dyn_cast<spirv::CompositeType>();
+  auto constituents = this->getConstituents().getValue();
 
   if (!cType)
     return emitError("result type must be a composite type, but provided ")
-           << type();
+           << getType();
 
   if (cType.isa<spirv::CooperativeMatrixNVType>())
     return emitError("unsupported composite type  ") << cType;
   if (cType.isa<spirv::JointMatrixINTELType>())
     return emitError("unsupported composite type  ") << cType;
   if (constituents.size() != cType.getNumElements())
     return emitError("has incorrect number of operands: expected ")
            << cType.getNumElements() << ", but provided "
            << constituents.size();
 
   for (auto index : llvm::seq<uint32_t>(0, constituents.size())) {
     auto constituent = constituents[index].cast<FlatSymbolRefAttr>();
 
     auto constituentSpecConstOp =
         dyn_cast<spirv::SpecConstantOp>(SymbolTable::lookupNearestSymbolFrom(
             (*this)->getParentOp(), constituent.getAttr()));
 
-    if (constituentSpecConstOp.default_value().getType() !=
+    if (constituentSpecConstOp.getDefaultValue().getType() !=
         cType.getElementType(index))
       return emitError("has incorrect types of operands: expected ")
              << cType.getElementType(index) << ", but provided "
-             << constituentSpecConstOp.default_value().getType();
+             << constituentSpecConstOp.getDefaultValue().getType();
   }
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // spv.SpecConstantOperation
 //===----------------------------------------------------------------------===//
ParseResult spirv::SpecConstantOperationOp::parse(OpAsmParser &parser,
   if (parser.parseOptionalAttrDict(result.attributes))
     return failure();
 
   return success();
 }
 
 void spirv::SpecConstantOperationOp::print(OpAsmPrinter &printer) {
   printer << " wraps ";
-  printer.printGenericOp(&body().front().front());
+  printer.printGenericOp(&getBody().front().front());
 }
 
 LogicalResult spirv::SpecConstantOperationOp::verifyRegions() {
   Block &block = getRegion().getBlocks().front();
 
   if (block.getOperations().size() != 2)
     return emitOpError("expected exactly 2 nested ops");
 
LogicalResult spirv::SpecConstantOperationOp::verifyRegions() {
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // spv.GL.FrexpStruct
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::GLFrexpStructOp::verify() {
-  spirv::StructType structTy = result().getType().dyn_cast<spirv::StructType>();
+  spirv::StructType structTy =
+      getResult().getType().dyn_cast<spirv::StructType>();
 
   if (structTy.getNumElements() != 2)
     return emitError("result type must be a struct type with two memebers");
 
   Type significandTy = structTy.getElementType(0);
   Type exponentTy = structTy.getElementType(1);
   VectorType exponentVecTy = exponentTy.dyn_cast<VectorType>();
   IntegerType exponentIntTy = exponentTy.dyn_cast<IntegerType>();
 
-  Type operandTy = operand().getType();
+  Type operandTy = getOperand().getType();
   VectorType operandVecTy = operandTy.dyn_cast<VectorType>();
   FloatType operandFTy = operandTy.dyn_cast<FloatType>();
 
   if (significandTy != operandTy)
     return emitError("member zero of the resulting struct type must be the "
                      "same type as the operand");
 
   if (exponentVecTy) {
return emitError("member one of the resulting struct type must have the same "
                    "number of components as the operand type");
 }
 
 //===----------------------------------------------------------------------===//
 // spv.GL.Ldexp
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::GLLdexpOp::verify() {
-  Type significandType = x().getType();
-  Type exponentType = exp().getType();
+  Type significandType = getX().getType();
+  Type exponentType = getExp().getType();
 
   if (significandType.isa<FloatType>() != exponentType.isa<IntegerType>())
     return emitOpError("operands must both be scalars or vectors");
 
   auto getNumElements = [](Type type) -> unsigned {
     if (auto vectorType = type.dyn_cast<VectorType>())
       return vectorType.getNumElements();
     return 1;
   };
 
   if (getNumElements(significandType) != getNumElements(exponentType))
     return emitOpError("operands must have the same number of elements");
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // spv.ImageDrefGather
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::ImageDrefGatherOp::verify() {
-  VectorType resultType = result().getType().cast<VectorType>();
+  VectorType resultType = getResult().getType().cast<VectorType>();
   auto sampledImageType =
-      sampledimage().getType().cast<spirv::SampledImageType>();
+      getSampledimage().getType().cast<spirv::SampledImageType>();
   auto imageType = sampledImageType.getImageType().cast<spirv::ImageType>();
 
   if (resultType.getNumElements() != 4)
     return emitOpError("result type must be a vector of four components");
 
   Type elementType = resultType.getElementType();
   Type sampledElementType = imageType.getElementType();
   if (!sampledElementType.isa<NoneType>() && elementType != sampledElementType)
     return emitOpError(
         "the component type of result must be the same as sampled type of the "
         "underlying image type");
 
   spirv::Dim imageDim = imageType.getDim();
   spirv::ImageSamplingInfo imageMS = imageType.getSamplingInfo();
 
   if (imageDim != spirv::Dim::Dim2D && imageDim != spirv::Dim::Cube &&
       imageDim != spirv::Dim::Rect)
     return emitOpError(
         "the Dim operand of the underlying image type must be 2D, Cube, or "
         "Rect");
 
   if (imageMS != spirv::ImageSamplingInfo::SingleSampled)
     return emitOpError("the MS operand of the underlying image type must be 0");
 
-  spirv::ImageOperandsAttr attr = imageoperandsAttr();
-  auto operandArguments = operand_arguments();
+  spirv::ImageOperandsAttr attr = getImageoperandsAttr();
+  auto operandArguments = getOperandArguments();
 
   return verifyImageOperands(*this, attr, operandArguments);
 }
 
 //===----------------------------------------------------------------------===//
 // spv.ShiftLeftLogicalOp
 //===----------------------------------------------------------------------===//
 
LogicalResult spirv::ShiftRightLogicalOp::verify() {
   return verifyShiftOp(*this);
 }
 
 //===----------------------------------------------------------------------===//
 // spv.ImageQuerySize
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::ImageQuerySizeOp::verify() {
-  spirv::ImageType imageType = image().getType().cast<spirv::ImageType>();
-  Type resultType = result().getType();
+  spirv::ImageType imageType = getImage().getType().cast<spirv::ImageType>();
+  Type resultType = getResult().getType();
 
   spirv::Dim dim = imageType.getDim();
   spirv::ImageSamplingInfo samplingInfo = imageType.getSamplingInfo();
   spirv::ImageSamplerUseInfo samplerInfo = imageType.getSamplerUseInfo();
   switch (dim) {
   case spirv::Dim::Dim1D:
   case spirv::Dim::Dim2D:
   case spirv::Dim::Dim3D:
if (!resultType)
     return failure();
 
   state.addTypes(resultType);
   return success();
 }
 
 template <typename Op>
 static auto concatElemAndIndices(Op op) {
-  SmallVector<Value> ret(op.indices().size() + 1);
-  ret[0] = op.element();
-  llvm::copy(op.indices(), ret.begin() + 1);
+  SmallVector<Value> ret(op.getIndices().size() + 1);
+  ret[0] = op.getElement();
+  llvm::copy(op.getIndices(), ret.begin() + 1);
   return ret;
 }
 
 //===----------------------------------------------------------------------===//
 // spv.InBoundsPtrAccessChainOp
 //===----------------------------------------------------------------------===//
 
 void spirv::InBoundsPtrAccessChainOp::build(OpBuilder &builder,
return parsePtrAccessChainOpImpl(
       spirv::InBoundsPtrAccessChainOp::getOperationName(), parser, result);
 }
 
 void spirv::InBoundsPtrAccessChainOp::print(OpAsmPrinter &printer) {
   printAccessChain(*this, concatElemAndIndices(*this), printer);
 }
 
 LogicalResult spirv::InBoundsPtrAccessChainOp::verify() {
-  return verifyAccessChain(*this, indices());
+  return verifyAccessChain(*this, getIndices());
 }
 
 //===----------------------------------------------------------------------===//
 // spv.PtrAccessChainOp
 //===----------------------------------------------------------------------===//
 
 void spirv::PtrAccessChainOp::build(OpBuilder &builder, OperationState &state,
                                     Value basePtr, Value element,
return parsePtrAccessChainOpImpl(spirv::PtrAccessChainOp::getOperationName(),
                                    parser, result);
 }
 
 void spirv::PtrAccessChainOp::print(OpAsmPrinter &printer) {
   printAccessChain(*this, concatElemAndIndices(*this), printer);
 }
 
 LogicalResult spirv::PtrAccessChainOp::verify() {
-  return verifyAccessChain(*this, indices());
+  return verifyAccessChain(*this, getIndices());
 }
 
 //===----------------------------------------------------------------------===//
 // spv.VectorTimesScalarOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::VectorTimesScalarOp::verify() {
-  if (vector().getType() != getType())
+  if (getVector().getType() != getType())
     return emitOpError("vector operand and result type mismatch");
   auto scalarType = getType().cast<VectorType>().getElementType();
-  if (scalar().getType() != scalarType)
+  if (getScalar().getType() != scalarType)
     return emitOpError("scalar operand and result element type match");
   return success();
 }
 
 // TableGen'erated operation interfaces for querying versions, extensions, and
 // capabilities.
 #include "mlir/Dialect/SPIRV/IR/SPIRVAvailability.cpp.inc"
 

mlir/lib/Dialect/SPIRV/Linking/ModuleCombiner/ModuleCombiner.cpp

 
 OwningOpRef<spirv::ModuleOp> combine(ArrayRef<spirv::ModuleOp> inputModules,
                                      OpBuilder &combinedModuleBuilder,
                                      SymbolRenameListener symRenameListener) {
   if (inputModules.empty())
     return nullptr;
 
   spirv::ModuleOp firstModule = inputModules.front();
-  auto addressingModel = firstModule.addressing_model();
-  auto memoryModel = firstModule.memory_model();
-  auto vceTriple = firstModule.vce_triple();
+  auto addressingModel = firstModule.getAddressingModel();
+  auto memoryModel = firstModule.getMemoryModel();
+  auto vceTriple = firstModule.getVceTriple();
 
   // First check whether there are conflicts between addressing/memory model.
   // Return early if so.
   for (auto module : inputModules) {
-    if (module.addressing_model() != addressingModel ||
-        module.memory_model() != memoryModel ||
-        module.vce_triple() != vceTriple) {
+    if (module.getAddressingModel() != addressingModel ||
+        module.getMemoryModel() != memoryModel ||
+        module.getVceTriple() != vceTriple) {
       module.emitError("input modules differ in addressing model, memory "
                        "model, and/or VCE triple");
       return nullptr;
     }
   }
 
   auto combinedModule = combinedModuleBuilder.create<spirv::ModuleOp>(
       firstModule.getLoc(), addressingModel, memoryModel, vceTriple);

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

class SPIRVGlobalVariableOpLayoutInfoDecoration
     : public OpRewritePattern<spirv::GlobalVariableOp> {
 public:
   using OpRewritePattern<spirv::GlobalVariableOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(spirv::GlobalVariableOp op,
                                 PatternRewriter &rewriter) const override {
     SmallVector<NamedAttribute, 4> globalVarAttrs;
 
-    auto ptrType = op.type().cast<spirv::PointerType>();
+    auto ptrType = op.getType().cast<spirv::PointerType>();
     auto structType = VulkanLayoutUtils::decorateType(
         ptrType.getPointeeType().cast<spirv::StructType>());
 
     if (!structType)
       return failure();
 
     auto decoratedType =
         spirv::PointerType::get(structType, ptrType.getStorageClass());

 class SPIRVAddressOfOpLayoutInfoDecoration
     : public OpRewritePattern<spirv::AddressOfOp> {
 public:
   using OpRewritePattern<spirv::AddressOfOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(spirv::AddressOfOp op,
                                 PatternRewriter &rewriter) const override {
     auto spirvModule = op->getParentOfType<spirv::ModuleOp>();
-    auto varName = op.variableAttr();
+    auto varName = op.getVariableAttr();
     auto varOp = spirvModule.lookupSymbol<spirv::GlobalVariableOp>(varName);
 
     rewriter.replaceOpWithNewOp<spirv::AddressOfOp>(
-        op, varOp.type(), SymbolRefAttr::get(varName.getAttr()));
+        op, varOp.getType(), SymbolRefAttr::get(varName.getAttr()));
     return success();
   }
 };
 
 template <typename OpT>
 class SPIRVPassThroughConversion : public OpConversionPattern<OpT> {
 public:
   using OpConversionPattern<OpT>::OpConversionPattern;
void DecorateSPIRVCompositeTypeLayoutPass::runOnOperation() {
   auto module = getOperation();
   RewritePatternSet patterns(module.getContext());
   populateSPIRVLayoutInfoPatterns(patterns);
   ConversionTarget target(*(module.getContext()));
   target.addLegalDialect<spirv::SPIRVDialect>();
   target.addLegalOp<func::FuncOp>();
   target.addDynamicallyLegalOp<spirv::GlobalVariableOp>(
       [](spirv::GlobalVariableOp op) {
-        return VulkanLayoutUtils::isLegalType(op.type());
+        return VulkanLayoutUtils::isLegalType(op.getType());
       });
 
   // Change the type for the direct users.
   target.addDynamicallyLegalOp<spirv::AddressOfOp>([](spirv::AddressOfOp op) {
-    return VulkanLayoutUtils::isLegalType(op.pointer().getType());
+    return VulkanLayoutUtils::isLegalType(op.getPointer().getType());
   });
 
   // Change the type for the indirect users.
   target.addDynamicallyLegalOp<spirv::AccessChainOp, spirv::LoadOp,
                                spirv::StoreOp>([&](Operation *op) {
     for (Value operand : op->getOperands()) {
       auto addrOp = operand.getDefiningOp<spirv::AddressOfOp>();
-      if (addrOp && !VulkanLayoutUtils::isLegalType(addrOp.pointer().getType()))
+      if (addrOp &&
+          !VulkanLayoutUtils::isLegalType(addrOp.getPointer().getType()))
         return false;
     }
     return true;
   });
 
   FrozenRewritePatternSet frozenPatterns(std::move(patterns));
   for (auto spirvModule : module.getOps<spirv::ModuleOp>())
     if (failed(applyFullConversion(spirvModule, target, frozenPatterns)))
       signalPassFailure();
 }
 
 std::unique_ptr<OperationPass<ModuleOp>>
 mlir::spirv::createDecorateSPIRVCompositeTypeLayoutPass() {
   return std::make_unique<DecorateSPIRVCompositeTypeLayoutPass>();
 }

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

getInterfaceVariables(spirv::FuncOp funcOp,
   }
   SetVector<Operation *> interfaceVarSet;
 
   // TODO: This should in reality traverse the entry function
   // call graph and collect all the interfaces. For now, just traverse the
   // instructions in this function.
   funcOp.walk([&](spirv::AddressOfOp addressOfOp) {
     auto var =
-        module.lookupSymbol<spirv::GlobalVariableOp>(addressOfOp.variable());
+        module.lookupSymbol<spirv::GlobalVariableOp>(addressOfOp.getVariable());
     // TODO: Per SPIR-V spec: "Before version 1.4, the interface’s
     // storage classes are limited to the Input and Output storage classes.
     // Starting with version 1.4, the interface’s storage classes are all
     // storage classes used in declaring all global variables referenced by the
     // entry point’s call tree." We should consider the target environment here.
-    switch (var.type().cast<spirv::PointerType>().getStorageClass()) {
+    switch (var.getType().cast<spirv::PointerType>().getStorageClass()) {
     case spirv::StorageClass::Input:
     case spirv::StorageClass::Output:
       interfaceVarSet.insert(var.getOperation());
       break;
     default:
       break;
     }
   });
   for (auto &var : interfaceVarSet) {
     interfaceVars.push_back(SymbolRefAttr::get(
-        funcOp.getContext(), cast<spirv::GlobalVariableOp>(var).sym_name()));
+        funcOp.getContext(), cast<spirv::GlobalVariableOp>(var).getSymName()));
   }
   return success();
 }
 
 /// Lowers the entry point attribute.
 static LogicalResult lowerEntryPointABIAttr(spirv::FuncOp funcOp,
                                             OpBuilder &builder) {
   auto entryPointAttrName = spirv::getEntryPointABIAttrName();
for (const auto &argType :
     // TODO: This is loading value of the scalar into registers
     // at the start of the function. It is probably better to do the load just
     // before the use. There might be multiple loads and currently there is no
     // easy way to replace all uses with a sequence of operations.
     if (argType.value().cast<spirv::SPIRVType>().isScalarOrVector()) {
       auto zero =
           spirv::ConstantOp::getZero(indexType, funcOp.getLoc(), rewriter);
       auto loadPtr = rewriter.create<spirv::AccessChainOp>(
-          funcOp.getLoc(), replacement, zero.constant());
+          funcOp.getLoc(), replacement, zero.getConstant());
       replacement = rewriter.create<spirv::LoadOp>(funcOp.getLoc(), loadPtr);
     }
     signatureConverter.remapInput(argType.index(), replacement);
   }
   if (failed(rewriter.convertRegionTypes(&funcOp.getBody(), *getTypeConverter(),
                                          &signatureConverter)))
     return failure();
 

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

void RewriteInsertsPass::runOnOperation() {
   for (const auto &insertions : workList) {
     auto lastCompositeInsertOp = insertions.back();
     auto compositeType = lastCompositeInsertOp.getType();
     auto location = lastCompositeInsertOp.getLoc();
 
     SmallVector<Value, 4> operands;
     // Collect inserted objects.
     for (auto insertionOp : insertions)
-      operands.push_back(insertionOp.object());
+      operands.push_back(insertionOp.getObject());
 
     OpBuilder builder(lastCompositeInsertOp);
     auto compositeConstructOp = builder.create<spirv::CompositeConstructOp>(
         location, compositeType, operands);
 
     lastCompositeInsertOp.replaceAllUsesWith(
         compositeConstructOp->getResult(0));
 
     // Erase ops.
     for (auto insertOp : llvm::reverse(insertions)) {
       auto *op = insertOp.getOperation();
       if (op->use_empty())
         insertOp.erase();
     }
   }
 }
 
 LogicalResult RewriteInsertsPass::collectInsertionChain(
     spirv::CompositeInsertOp op,
     SmallVectorImpl<spirv::CompositeInsertOp> &insertions) {
-  auto indicesArrayAttr = op.indices().cast<ArrayAttr>();
+  auto indicesArrayAttr = op.getIndices().cast<ArrayAttr>();
   // TODO: handle nested composite object.
   if (indicesArrayAttr.size() == 1) {
-    auto numElements =
-        op.composite().getType().cast<spirv::CompositeType>().getNumElements();
+    auto numElements = op.getComposite()
+                           .getType()
+                           .cast<spirv::CompositeType>()
+                           .getNumElements();
 
     auto index = indicesArrayAttr[0].cast<IntegerAttr>().getInt();
     // Need a last index to collect a sequential chain.
     if (index + 1 != numElements)
       return failure();
 
     insertions.resize(numElements);
     while (true) {
       insertions[index] = op;
 
       if (index == 0)
         return success();
 
-      op = op.composite().getDefiningOp<spirv::CompositeInsertOp>();
+      op = op.getComposite().getDefiningOp<spirv::CompositeInsertOp>();
       if (!op)
         return failure();
 
       --index;
-      indicesArrayAttr = op.indices().cast<ArrayAttr>();
+      indicesArrayAttr = op.getIndices().cast<ArrayAttr>();
       if ((indicesArrayAttr.size() != 1) ||
           (indicesArrayAttr[0].cast<IntegerAttr>().getInt() != index))
         return failure();
     }
   }
   return failure();
 }
 
 std::unique_ptr<mlir::OperationPass<spirv::ModuleOp>>
 mlir::spirv::createRewriteInsertsPass() {
   return std::make_unique<RewriteInsertsPass>();
 }

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

static spirv::PointerType getPushConstantStorageType(unsigned elementCount,
   return spirv::PointerType::get(structType, spirv::StorageClass::PushConstant);
 }
 
 /// Returns the push constant varible containing `elementCount` 32-bit integer
 /// values in `body`. Returns null op if such an op does not exit.
 static spirv::GlobalVariableOp getPushConstantVariable(Block &body,
                                                        unsigned elementCount) {
   for (auto varOp : body.getOps<spirv::GlobalVariableOp>()) {
-    auto ptrType = varOp.type().dyn_cast<spirv::PointerType>();
+    auto ptrType = varOp.getType().dyn_cast<spirv::PointerType>();
     if (!ptrType)
       continue;
 
     // Note that Vulkan requires "There must be no more than one push constant
     // block statically used per shader entry point." So we should always reuse
     // the existing one.
     if (ptrType.getStorageClass() == spirv::StorageClass::PushConstant) {
       auto numElements = ptrType.getPointeeType()
bool SPIRVConversionTarget::isLegalOp(Operation *op) {
   // Ensure that all types have been converted to SPIRV types.
   if (llvm::any_of(valueTypes,
                    [](Type t) { return !t.isa<spirv::SPIRVType>(); }))
     return false;
 
   // Special treatment for global variables, whose type requirements are
   // conveyed by type attributes.
   if (auto globalVar = dyn_cast<spirv::GlobalVariableOp>(op))
-    valueTypes.push_back(globalVar.type());
+    valueTypes.push_back(globalVar.getType());
 
   // Make sure the op's operands/results use types that are allowed by the
   // target environment.
   SmallVector<ArrayRef<spirv::Extension>, 4> typeExtensions;
   SmallVector<ArrayRef<spirv::Capability>, 8> typeCapabilities;
   for (Type valueType : valueTypes) {
     typeExtensions.clear();
     valueType.cast<spirv::SPIRVType>().getExtensions(typeExtensions);

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

 using AliasedResourceMap =
     DenseMap<Descriptor, SmallVector<spirv::GlobalVariableOp>>;
 
 /// Collects all aliased resources in the given SPIR-V `moduleOp`.
 static AliasedResourceMap collectAliasedResources(spirv::ModuleOp moduleOp) {
   AliasedResourceMap aliasedResources;
   moduleOp->walk([&aliasedResources](spirv::GlobalVariableOp varOp) {
     if (varOp->getAttrOfType<UnitAttr>("aliased")) {
-      Optional<uint32_t> set = varOp.descriptor_set();
-      Optional<uint32_t> binding = varOp.binding();
+      Optional<uint32_t> set = varOp.getDescriptorSet();
+      Optional<uint32_t> binding = varOp.getBinding();
       if (set && binding)
         aliasedResources[{*set, *binding}].push_back(varOp);
     }
   });
   return aliasedResources;
 }
 
 /// Returns the element type if the given `type` is a runtime array resource:

 
 bool ResourceAliasAnalysis::shouldUnify(Operation *op) const {
   if (auto varOp = dyn_cast<spirv::GlobalVariableOp>(op)) {
     auto canonicalOp = getCanonicalResource(varOp);
     return canonicalOp && varOp != canonicalOp;
   }
   if (auto addressOp = dyn_cast<spirv::AddressOfOp>(op)) {
     auto moduleOp = addressOp->getParentOfType<spirv::ModuleOp>();
-    auto *varOp = SymbolTable::lookupSymbolIn(moduleOp, addressOp.variable());
+    auto *varOp = SymbolTable::lookupSymbolIn(moduleOp, addressOp.getVariable());
     return shouldUnify(varOp);
   }
 
   if (auto acOp = dyn_cast<spirv::AccessChainOp>(op))
-    return shouldUnify(acOp.base_ptr().getDefiningOp());
+    return shouldUnify(acOp.getBasePtr().getDefiningOp());
   if (auto loadOp = dyn_cast<spirv::LoadOp>(op))
-    return shouldUnify(loadOp.ptr().getDefiningOp());
+    return shouldUnify(loadOp.getPtr().getDefiningOp());
   if (auto storeOp = dyn_cast<spirv::StoreOp>(op))
-    return shouldUnify(storeOp.ptr().getDefiningOp());
+    return shouldUnify(storeOp.getPtr().getDefiningOp());
 
   return false;
 }
 
 spirv::GlobalVariableOp ResourceAliasAnalysis::getCanonicalResource(
     const Descriptor &descriptor) const {
   auto varIt = canonicalResourceMap.find(descriptor);
   if (varIt == canonicalResourceMap.end())
ResourceAliasAnalysis::getElementType(spirv::GlobalVariableOp varOp) const {
   return it->second;
 }
 
 void ResourceAliasAnalysis::recordIfUnifiable(
     const Descriptor &descriptor, ArrayRef<spirv::GlobalVariableOp> resources) {
   // Collect the element types for all resources in the current set.
   SmallVector<spirv::SPIRVType> elementTypes;
   for (spirv::GlobalVariableOp resource : resources) {
-    Type elementType = getRuntimeArrayElementType(resource.type());
+    Type elementType = getRuntimeArrayElementType(resource.getType());
     if (!elementType)
       return; // Unexpected resource variable type.
 
     auto type = elementType.cast<spirv::SPIRVType>();
     if (!type.isScalarOrVector())
       return; // Unexpected resource element type.
 
     elementTypes.push_back(type);
struct ConvertAddressOf : public ConvertAliasResource<spirv::AddressOfOp> {
   using ConvertAliasResource::ConvertAliasResource;
 
   LogicalResult
   matchAndRewrite(spirv::AddressOfOp addressOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     // Rewrite the AddressOf op to get the address of the canoncical resource.
     auto moduleOp = addressOp->getParentOfType<spirv::ModuleOp>();
     auto srcVarOp = cast<spirv::GlobalVariableOp>(
-        SymbolTable::lookupSymbolIn(moduleOp, addressOp.variable()));
+        SymbolTable::lookupSymbolIn(moduleOp, addressOp.getVariable()));
     auto dstVarOp = analysis.getCanonicalResource(srcVarOp);
     rewriter.replaceOpWithNewOp<spirv::AddressOfOp>(addressOp, dstVarOp);
     return success();
   }
 };
 
 struct ConvertAccessChain : public ConvertAliasResource<spirv::AccessChainOp> {
   using ConvertAliasResource::ConvertAliasResource;
 
   LogicalResult
   matchAndRewrite(spirv::AccessChainOp acOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    auto addressOp = acOp.base_ptr().getDefiningOp<spirv::AddressOfOp>();
+    auto addressOp = acOp.getBasePtr().getDefiningOp<spirv::AddressOfOp>();
     if (!addressOp)
       return rewriter.notifyMatchFailure(acOp, "base ptr not addressof op");
 
     auto moduleOp = acOp->getParentOfType<spirv::ModuleOp>();
     auto srcVarOp = cast<spirv::GlobalVariableOp>(
-        SymbolTable::lookupSymbolIn(moduleOp, addressOp.variable()));
+        SymbolTable::lookupSymbolIn(moduleOp, addressOp.getVariable()));
     auto dstVarOp = analysis.getCanonicalResource(srcVarOp);
 
     spirv::SPIRVType srcElemType = analysis.getElementType(srcVarOp);
     spirv::SPIRVType dstElemType = analysis.getElementType(dstVarOp);
 
     if (srcElemType == dstElemType ||
         areSameBitwidthScalarType(srcElemType, dstElemType)) {
       // We have the same bitwidth for source and destination element types.
       // Thie indices keep the same.
       rewriter.replaceOpWithNewOp<spirv::AccessChainOp>(
-          acOp, adaptor.base_ptr(), adaptor.indices());
+          acOp, adaptor.getBasePtr(), adaptor.getIndices());
       return success();
     }
 
     Location loc = acOp.getLoc();
     auto i32Type = rewriter.getI32Type();
 
     if (srcElemType.isIntOrFloat() && dstElemType.isa<VectorType>()) {
       // The source indices are for a buffer with scalar element types. Rewrite
       // them into a buffer with vector element types. We need to scale the last
       // index for the vector as a whole, then add one level of index for inside
       // the vector.
       int srcNumBytes = *srcElemType.getSizeInBytes();
       int dstNumBytes = *dstElemType.getSizeInBytes();
       assert(dstNumBytes >= srcNumBytes && dstNumBytes % srcNumBytes == 0);
       int ratio = dstNumBytes / srcNumBytes;
       auto ratioValue = rewriter.create<spirv::ConstantOp>(
           loc, i32Type, rewriter.getI32IntegerAttr(ratio));
 
-      auto indices = llvm::to_vector<4>(acOp.indices());
+      auto indices = llvm::to_vector<4>(acOp.getIndices());
       Value oldIndex = indices.back();
       indices.back() =
           rewriter.create<spirv::SDivOp>(loc, i32Type, oldIndex, ratioValue);
       indices.push_back(
           rewriter.create<spirv::SModOp>(loc, i32Type, oldIndex, ratioValue));
 
       rewriter.replaceOpWithNewOp<spirv::AccessChainOp>(
-          acOp, adaptor.base_ptr(), indices);
+          acOp, adaptor.getBasePtr(), indices);
       return success();
     }
 
     if ((srcElemType.isIntOrFloat() && dstElemType.isIntOrFloat()) ||
         (srcElemType.isa<VectorType>() && dstElemType.isa<VectorType>())) {
       // The source indices are for a buffer with larger bitwidth scalar/vector
       // element types. Rewrite them into a buffer with smaller bitwidth element
       // types. We only need to scale the last index.
       int srcNumBytes = *srcElemType.getSizeInBytes();
       int dstNumBytes = *dstElemType.getSizeInBytes();
       assert(srcNumBytes >= dstNumBytes && srcNumBytes % dstNumBytes == 0);
       int ratio = srcNumBytes / dstNumBytes;
       auto ratioValue = rewriter.create<spirv::ConstantOp>(
           loc, i32Type, rewriter.getI32IntegerAttr(ratio));
 
-      auto indices = llvm::to_vector<4>(acOp.indices());
+      auto indices = llvm::to_vector<4>(acOp.getIndices());
       Value oldIndex = indices.back();
       indices.back() =
           rewriter.create<spirv::IMulOp>(loc, i32Type, oldIndex, ratioValue);
 
       rewriter.replaceOpWithNewOp<spirv::AccessChainOp>(
-          acOp, adaptor.base_ptr(), indices);
+          acOp, adaptor.getBasePtr(), indices);
       return success();
     }
 
     return rewriter.notifyMatchFailure(
         acOp, "unsupported src/dst types for spv.AccessChain");
   }
 };
 
 struct ConvertLoad : public ConvertAliasResource<spirv::LoadOp> {
   using ConvertAliasResource::ConvertAliasResource;
 
   LogicalResult
   matchAndRewrite(spirv::LoadOp loadOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    auto srcPtrType = loadOp.ptr().getType().cast<spirv::PointerType>();
+    auto srcPtrType = loadOp.getPtr().getType().cast<spirv::PointerType>();
     auto srcElemType = srcPtrType.getPointeeType().cast<spirv::SPIRVType>();
-    auto dstPtrType = adaptor.ptr().getType().cast<spirv::PointerType>();
+    auto dstPtrType = adaptor.getPtr().getType().cast<spirv::PointerType>();
     auto dstElemType = dstPtrType.getPointeeType().cast<spirv::SPIRVType>();
 
     Location loc = loadOp.getLoc();
-    auto newLoadOp = rewriter.create<spirv::LoadOp>(loc, adaptor.ptr());
+    auto newLoadOp = rewriter.create<spirv::LoadOp>(loc, adaptor.getPtr());
     if (srcElemType == dstElemType) {
       rewriter.replaceOp(loadOp, newLoadOp->getResults());
       return success();
     }
 
     if (areSameBitwidthScalarType(srcElemType, dstElemType)) {
       auto castOp = rewriter.create<spirv::BitcastOp>(loc, srcElemType,
-                                                      newLoadOp.value());
+                                                      newLoadOp.getValue());
       rewriter.replaceOp(loadOp, castOp->getResults());
 
       return success();
     }
 
     if ((srcElemType.isIntOrFloat() && dstElemType.isIntOrFloat()) ||
         (srcElemType.isa<VectorType>() && dstElemType.isa<VectorType>())) {
       // The source and destination have scalar types of different bitwidths, or
       // vector types of different component counts. For such cases, we load
       // multiple smaller bitwidth values and construct a larger bitwidth one.
 
       int srcNumBytes = *srcElemType.getSizeInBytes();
       int dstNumBytes = *dstElemType.getSizeInBytes();
       assert(srcNumBytes > dstNumBytes && srcNumBytes % dstNumBytes == 0);
       int ratio = srcNumBytes / dstNumBytes;
       if (ratio > 4)
         return rewriter.notifyMatchFailure(loadOp, "more than 4 components");
 
       SmallVector<Value> components;
       components.reserve(ratio);
       components.push_back(newLoadOp);
 
-      auto acOp = adaptor.ptr().getDefiningOp<spirv::AccessChainOp>();
+      auto acOp = adaptor.getPtr().getDefiningOp<spirv::AccessChainOp>();
       if (!acOp)
         return rewriter.notifyMatchFailure(loadOp, "ptr not spv.AccessChain");
 
       auto i32Type = rewriter.getI32Type();
       Value oneValue = spirv::ConstantOp::getOne(i32Type, loc, rewriter);
-      auto indices = llvm::to_vector<4>(acOp.indices());
+      auto indices = llvm::to_vector<4>(acOp.getIndices());
       for (int i = 1; i < ratio; ++i) {
         // Load all subsequent components belonging to this element.
         indices.back() = rewriter.create<spirv::IAddOp>(
             loc, i32Type, indices.back(), oneValue);
         auto componentAcOp = rewriter.create<spirv::AccessChainOp>(
-            loc, acOp.base_ptr(), indices);
+            loc, acOp.getBasePtr(), indices);
         // Assuming little endian, this reads lower-ordered bits of the number
         // to lower-numbered components of the vector.
         components.push_back(
             rewriter.create<spirv::LoadOp>(loc, componentAcOp));
       }
 
       // Create a vector of the components and then cast back to the larger
       // bitwidth element type. For spv.bitcast, the lower-numbered components

 
 struct ConvertStore : public ConvertAliasResource<spirv::StoreOp> {
   using ConvertAliasResource::ConvertAliasResource;
 
   LogicalResult
   matchAndRewrite(spirv::StoreOp storeOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto srcElemType =
-        storeOp.ptr().getType().cast<spirv::PointerType>().getPointeeType();
+        storeOp.getPtr().getType().cast<spirv::PointerType>().getPointeeType();
     auto dstElemType =
-        adaptor.ptr().getType().cast<spirv::PointerType>().getPointeeType();
+        adaptor.getPtr().getType().cast<spirv::PointerType>().getPointeeType();
     if (!srcElemType.isIntOrFloat() || !dstElemType.isIntOrFloat())
       return rewriter.notifyMatchFailure(storeOp, "not scalar type");
     if (!areSameBitwidthScalarType(srcElemType, dstElemType))
       return rewriter.notifyMatchFailure(storeOp, "different bitwidth");
 
     Location loc = storeOp.getLoc();
-    Value value = adaptor.value();
+    Value value = adaptor.getValue();
     if (srcElemType != dstElemType)
       value = rewriter.create<spirv::BitcastOp>(loc, dstElemType, value);
-    rewriter.replaceOpWithNewOp<spirv::StoreOp>(storeOp, adaptor.ptr(), value,
+    rewriter.replaceOpWithNewOp<spirv::StoreOp>(storeOp, adaptor.getPtr(), value,
                                                 storeOp->getAttrs());
     return success();
   }
 };
 
 //===----------------------------------------------------------------------===//
 // Pass
 //===----------------------------------------------------------------------===//

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

WalkResult walkResult = module.walk([&](Operation *op) -> WalkResult {
 
     SmallVector<Type, 4> valueTypes;
     valueTypes.append(op->operand_type_begin(), op->operand_type_end());
     valueTypes.append(op->result_type_begin(), op->result_type_end());
 
     // Special treatment for global variables, whose type requirements are
     // conveyed by type attributes.
     if (auto globalVar = dyn_cast<spirv::GlobalVariableOp>(op))
-      valueTypes.push_back(globalVar.type());
+      valueTypes.push_back(globalVar.getType());
 
     // Requirements from values' types
     SmallVector<ArrayRef<spirv::Extension>, 4> typeExtensions;
     SmallVector<ArrayRef<spirv::Capability>, 8> typeCapabilities;
     for (Type valueType : valueTypes) {
       typeExtensions.clear();
       valueType.cast<spirv::SPIRVType>().getExtensions(typeExtensions);
       if (failed(checkAndUpdateExtensionRequirements(

mlir/lib/Target/SPIRV/Deserialization/DeserializeOps.cpp

 Value spirv::Deserializer::getValue(uint32_t id) {
   if (auto constInfo = getConstant(id)) {
     // Materialize a `spv.Constant` op at every use site.
     return opBuilder.create<spirv::ConstantOp>(unknownLoc, constInfo->second,
                                                constInfo->first);
   }
   if (auto varOp = getGlobalVariable(id)) {
     auto addressOfOp = opBuilder.create<spirv::AddressOfOp>(
-        unknownLoc, varOp.type(), SymbolRefAttr::get(varOp.getOperation()));
-    return addressOfOp.pointer();
+        unknownLoc, varOp.getType(), SymbolRefAttr::get(varOp.getOperation()));
+    return addressOfOp.getPointer();
   }
   if (auto constOp = getSpecConstant(id)) {
     auto referenceOfOp = opBuilder.create<spirv::ReferenceOfOp>(
-        unknownLoc, constOp.default_value().getType(),
+        unknownLoc, constOp.getDefaultValue().getType(),
         SymbolRefAttr::get(constOp.getOperation()));
-    return referenceOfOp.reference();
+    return referenceOfOp.getReference();
   }
   if (auto constCompositeOp = getSpecConstantComposite(id)) {
     auto referenceOfOp = opBuilder.create<spirv::ReferenceOfOp>(
-        unknownLoc, constCompositeOp.type(),
+        unknownLoc, constCompositeOp.getType(),
         SymbolRefAttr::get(constCompositeOp.getOperation()));
-    return referenceOfOp.reference();
+    return referenceOfOp.getReference();
   }
   if (auto specConstOperationInfo = getSpecConstantOperation(id)) {
     return materializeSpecConstantOperation(
         id, specConstOperationInfo->enclodesOpcode,
         specConstOperationInfo->resultTypeID,
         specConstOperationInfo->enclosedOpOperands);
   }
   if (auto undef = getUndefType(id)) {

mlir/lib/Target/SPIRV/Deserialization/Deserializer.cpp

Value spirv::Deserializer::materializeSpecConstantOperation(
   // Since the enclosed op is emitted in the current block, split it in a
   // separate new block.
   Block *enclosedBlock = curBlock->splitBlock(&curBlock->back());
 
   auto loc = createFileLineColLoc(opBuilder);
   auto specConstOperationOp =
       opBuilder.create<spirv::SpecConstantOperationOp>(loc, resultType);
 
-  Region &body = specConstOperationOp.body();
+  Region &body = specConstOperationOp.getBody();
   // Move the new block into SpecConstantOperation's body.
   body.getBlocks().splice(body.end(), curBlock->getParent()->getBlocks(),
                           Region::iterator(enclosedBlock));
   Block &block = body.back();
 
   // RAII guard to reset the insertion point to the module's region after
   // deserializing the body of the specConstantOperation.
   OpBuilder::InsertionGuard moduleInsertionGuard(opBuilder);
if (auto branchOp = dyn_cast<spirv::BranchOp>(op)) {
       // Replace the previous branch op with a new one with block arguments.
       opBuilder.create<spirv::BranchOp>(branchOp.getLoc(), branchOp.getTarget(),
                                         blockArgs);
       branchOp.erase();
     } else if (auto branchCondOp = dyn_cast<spirv::BranchConditionalOp>(op)) {
       assert((branchCondOp.getTrueBlock() == target ||
               branchCondOp.getFalseBlock() == target) &&
              "expected target to be either the true or false target");
-      if (target == branchCondOp.trueTarget())
+      if (target == branchCondOp.getTrueTarget())
         opBuilder.create<spirv::BranchConditionalOp>(
-            branchCondOp.getLoc(), branchCondOp.condition(), blockArgs,
+            branchCondOp.getLoc(), branchCondOp.getCondition(), blockArgs,
             branchCondOp.getFalseBlockArguments(),
-            branchCondOp.branch_weightsAttr(), branchCondOp.trueTarget(),
-            branchCondOp.falseTarget());
+            branchCondOp.getBranchWeightsAttr(), branchCondOp.getTrueTarget(),
+            branchCondOp.getFalseTarget());
       else
         opBuilder.create<spirv::BranchConditionalOp>(
-            branchCondOp.getLoc(), branchCondOp.condition(),
+            branchCondOp.getLoc(), branchCondOp.getCondition(),
             branchCondOp.getTrueBlockArguments(), blockArgs,
-            branchCondOp.branch_weightsAttr(), branchCondOp.getTrueBlock(),
+            branchCondOp.getBranchWeightsAttr(), branchCondOp.getTrueBlock(),
             branchCondOp.getFalseBlock());
 
       branchCondOp.erase();
     } else {
       return emitError(unknownLoc, "unimplemented terminator for Phi creation");
     }
 
     LLVM_DEBUG({

mlir/lib/Target/SPIRV/Serialization/Serialization.cpp

 #include "llvm/Support/Debug.h"
 
 #define DEBUG_TYPE "spirv-serialization"
 
 namespace mlir {
 LogicalResult spirv::serialize(spirv::ModuleOp module,
                                SmallVectorImpl<uint32_t> &binary,
                                const SerializationOptions &options) {
-  if (!module.vce_triple())
+  if (!module.getVceTriple())
     return module.emitError(
         "module must have 'vce_triple' attribute to be serializeable");
 
   Serializer serializer(module, options);
 
   if (failed(serializer.serialize()))
     return failure();
 
   LLVM_DEBUG(serializer.printValueIDMap(llvm::dbgs()));
 
   serializer.collect(binary);
   return success();
 }
 } // namespace mlir

mlir/lib/Target/SPIRV/Serialization/SerializeOps.cpp

if (failed(blockHandler(block)))
       return failure();
   }
   return success();
 }
 
 namespace mlir {
 namespace spirv {
 LogicalResult Serializer::processConstantOp(spirv::ConstantOp op) {
-  if (auto resultID = prepareConstant(op.getLoc(), op.getType(), op.value())) {
+  if (auto resultID =
+          prepareConstant(op.getLoc(), op.getType(), op.getValue())) {
     valueIDMap[op.getResult()] = resultID;
     return success();
   }
   return failure();
 }
 
 LogicalResult Serializer::processSpecConstantOp(spirv::SpecConstantOp op) {
-  if (auto resultID = prepareConstantScalar(op.getLoc(), op.default_value(),
+  if (auto resultID = prepareConstantScalar(op.getLoc(), op.getDefaultValue(),
                                             /*isSpec=*/true)) {
     // Emit the OpDecorate instruction for SpecId.
     if (auto specID = op->getAttrOfType<IntegerAttr>("spec_id")) {
       auto val = static_cast<uint32_t>(specID.getInt());
       if (failed(emitDecoration(resultID, spirv::Decoration::SpecId, {val})))
         return failure();
     }
 
-    specConstIDMap[op.sym_name()] = resultID;
-    return processName(resultID, op.sym_name());
+    specConstIDMap[op.getSymName()] = resultID;
+    return processName(resultID, op.getSymName());
   }
   return failure();
 }
 
 LogicalResult
 Serializer::processSpecConstantCompositeOp(spirv::SpecConstantCompositeOp op) {
   uint32_t typeID = 0;
-  if (failed(processType(op.getLoc(), op.type(), typeID))) {
+  if (failed(processType(op.getLoc(), op.getType(), typeID))) {
     return failure();
   }
 
   auto resultID = getNextID();
 
   SmallVector<uint32_t, 8> operands;
   operands.push_back(typeID);
   operands.push_back(resultID);
 
-  auto constituents = op.constituents();
+  auto constituents = op.getConstituents();
 
   for (auto index : llvm::seq<uint32_t>(0, constituents.size())) {
     auto constituent = constituents[index].dyn_cast<FlatSymbolRefAttr>();
 
     auto constituentName = constituent.getValue();
     auto constituentID = getSpecConstID(constituentName);
 
     if (!constituentID) {
       return op.emitError("unknown result <id> for specialization constant ")
              << constituentName;
     }
 
     operands.push_back(constituentID);
   }
 
   encodeInstructionInto(typesGlobalValues,
                         spirv::Opcode::OpSpecConstantComposite, operands);
-  specConstIDMap[op.sym_name()] = resultID;
+  specConstIDMap[op.getSymName()] = resultID;
 
-  return processName(resultID, op.sym_name());
+  return processName(resultID, op.getSymName());
 }
 
 LogicalResult
 Serializer::processSpecConstantOperationOp(spirv::SpecConstantOperationOp op) {
   uint32_t typeID = 0;
   if (failed(processType(op.getLoc(), op.getType(), typeID))) {
     return failure();
   }
LogicalResult Serializer::processFuncOp(spirv::FuncOp op) {
   if (failed(processType(op.getLoc(),
                          (resultTypes.empty() ? getVoidType() : resultTypes[0]),
                          resTypeID))) {
     return failure();
   }
   operands.push_back(resTypeID);
   auto funcID = getOrCreateFunctionID(op.getName());
   operands.push_back(funcID);
-  operands.push_back(static_cast<uint32_t>(op.function_control()));
+  operands.push_back(static_cast<uint32_t>(op.getFunctionControl()));
   operands.push_back(fnTypeID);
   encodeInstructionInto(functionHeader, spirv::Opcode::OpFunction, operands);
 
   // Add function name.
   if (failed(processName(funcID, op.getName()))) {
     return failure();
   }
 
LogicalResult Serializer::processVariableOp(spirv::VariableOp op) {
   return success();
 }
 
 LogicalResult
 Serializer::processGlobalVariableOp(spirv::GlobalVariableOp varOp) {
   // Get TypeID.
   uint32_t resultTypeID = 0;
   SmallVector<StringRef, 4> elidedAttrs;
-  if (failed(processType(varOp.getLoc(), varOp.type(), resultTypeID))) {
+  if (failed(processType(varOp.getLoc(), varOp.getType(), resultTypeID))) {
     return failure();
   }
 
   elidedAttrs.push_back("type");
   SmallVector<uint32_t, 4> operands;
   operands.push_back(resultTypeID);
   auto resultID = getNextID();
 
   // Encode the name.
-  auto varName = varOp.sym_name();
+  auto varName = varOp.getSymName();
   elidedAttrs.push_back(SymbolTable::getSymbolAttrName());
   if (failed(processName(resultID, varName))) {
     return failure();
   }
   globalVarIDMap[varName] = resultID;
   operands.push_back(resultID);
 
   // Encode StorageClass.
   operands.push_back(static_cast<uint32_t>(varOp.storageClass()));
 
   // Encode initialization.
-  if (auto initializer = varOp.initializer()) {
+  if (auto initializer = varOp.getInitializer()) {
     auto initializerID = getVariableID(*initializer);
     if (!initializerID) {
       return emitError(varOp.getLoc(),
                        "invalid usage of undefined variable as initializer");
     }
     operands.push_back(initializerID);
     elidedAttrs.push_back("initializer");
   }
for (auto attr : varOp->getAttrs()) {
     }
   }
   return success();
 }
 
 LogicalResult Serializer::processSelectionOp(spirv::SelectionOp selectionOp) {
   // Assign <id>s to all blocks so that branches inside the SelectionOp can
   // resolve properly.
-  auto &body = selectionOp.body();
+  auto &body = selectionOp.getBody();
   for (Block &block : body)
     getOrCreateBlockID(&block);
 
   auto *headerBlock = selectionOp.getHeaderBlock();
   auto *mergeBlock = selectionOp.getMergeBlock();
   auto headerID = getBlockID(headerBlock);
   auto mergeID = getBlockID(mergeBlock);
   auto loc = selectionOp.getLoc();
LogicalResult Serializer::processSelectionOp(spirv::SelectionOp selectionOp) {
   // We need to emit an OpSelectionMerge instruction before the selection header
   // block's terminator.
   auto emitSelectionMerge = [&]() {
     if (failed(emitDebugLine(functionBody, loc)))
       return failure();
     lastProcessedWasMergeInst = true;
     encodeInstructionInto(
         functionBody, spirv::Opcode::OpSelectionMerge,
-        {mergeID, static_cast<uint32_t>(selectionOp.selection_control())});
+        {mergeID, static_cast<uint32_t>(selectionOp.getSelectionControl())});
     return success();
   };
   if (failed(
           processBlock(headerBlock, /*omitLabel=*/false, emitSelectionMerge)))
     return failure();
 
   // Process all blocks with a depth-first visitor starting from the header
   // block. The selection header block and merge block are skipped by this
LogicalResult Serializer::processSelectionOp(spirv::SelectionOp selectionOp) {
   LLVM_DEBUG(llvm::dbgs() << "\n");
   return success();
 }
 
 LogicalResult Serializer::processLoopOp(spirv::LoopOp loopOp) {
   // Assign <id>s to all blocks so that branches inside the LoopOp can resolve
   // properly. We don't need to assign for the entry block, which is just for
   // satisfying MLIR region's structural requirement.
-  auto &body = loopOp.body();
+  auto &body = loopOp.getBody();
   for (Block &block : llvm::drop_begin(body))
     getOrCreateBlockID(&block);
 
   auto *headerBlock = loopOp.getHeaderBlock();
   auto *continueBlock = loopOp.getContinueBlock();
   auto *mergeBlock = loopOp.getMergeBlock();
   auto headerID = getBlockID(headerBlock);
   auto continueID = getBlockID(continueBlock);
LogicalResult Serializer::processLoopOp(spirv::LoopOp loopOp) {
   // need to emit an OpLoopMerge instruction before the loop header block's
   // terminator.
   auto emitLoopMerge = [&]() {
     if (failed(emitDebugLine(functionBody, loc)))
       return failure();
     lastProcessedWasMergeInst = true;
     encodeInstructionInto(
         functionBody, spirv::Opcode::OpLoopMerge,
-        {mergeID, continueID, static_cast<uint32_t>(loopOp.loop_control())});
+        {mergeID, continueID, static_cast<uint32_t>(loopOp.getLoopControl())});
     return success();
   };
   if (failed(processBlock(headerBlock, /*omitLabel=*/false, emitLoopMerge)))
     return failure();
 
   // Process all blocks with a depth-first visitor starting from the header
   // block. The loop header block, loop continue block, and loop merge block are
   // skipped by this visitor and handled later in this function.
LogicalResult Serializer::processLoopOp(spirv::LoopOp loopOp) {
   LLVM_DEBUG(llvm::dbgs() << "done merge ");
   LLVM_DEBUG(printBlock(mergeBlock, llvm::dbgs()));
   LLVM_DEBUG(llvm::dbgs() << "\n");
   return success();
 }
 
 LogicalResult Serializer::processBranchConditionalOp(
     spirv::BranchConditionalOp condBranchOp) {
-  auto conditionID = getValueID(condBranchOp.condition());
+  auto conditionID = getValueID(condBranchOp.getCondition());
   auto trueLabelID = getOrCreateBlockID(condBranchOp.getTrueBlock());
   auto falseLabelID = getOrCreateBlockID(condBranchOp.getFalseBlock());
   SmallVector<uint32_t, 5> arguments{conditionID, trueLabelID, falseLabelID};
 
-  if (auto weights = condBranchOp.branch_weights()) {
+  if (auto weights = condBranchOp.getBranchWeights()) {
     for (auto val : weights->getValue())
       arguments.push_back(val.cast<IntegerAttr>().getInt());
   }
 
   if (failed(emitDebugLine(functionBody, condBranchOp.getLoc())))
     return failure();
   encodeInstructionInto(functionBody, spirv::Opcode::OpBranchConditional,
                         arguments);
   return success();
 }
 
 LogicalResult Serializer::processBranchOp(spirv::BranchOp branchOp) {
   if (failed(emitDebugLine(functionBody, branchOp.getLoc())))
     return failure();
   encodeInstructionInto(functionBody, spirv::Opcode::OpBranch,
                         {getOrCreateBlockID(branchOp.getTarget())});
   return success();
 }
 
 LogicalResult Serializer::processAddressOfOp(spirv::AddressOfOp addressOfOp) {
-  auto varName = addressOfOp.variable();
+  auto varName = addressOfOp.getVariable();
   auto variableID = getVariableID(varName);
   if (!variableID) {
     return addressOfOp.emitError("unknown result <id> for variable ")
            << varName;
   }
-  valueIDMap[addressOfOp.pointer()] = variableID;
+  valueIDMap[addressOfOp.getPointer()] = variableID;
   return success();
 }
 
 LogicalResult
 Serializer::processReferenceOfOp(spirv::ReferenceOfOp referenceOfOp) {
-  auto constName = referenceOfOp.spec_const();
+  auto constName = referenceOfOp.getSpecConst();
   auto constID = getSpecConstID(constName);
   if (!constID) {
     return referenceOfOp.emitError(
                "unknown result <id> for specialization constant ")
            << constName;
   }
-  valueIDMap[referenceOfOp.reference()] = constID;
+  valueIDMap[referenceOfOp.getReference()] = constID;
   return success();
 }
 
 template <>
 LogicalResult
 Serializer::processOp<spirv::EntryPointOp>(spirv::EntryPointOp op) {
   SmallVector<uint32_t, 4> operands;
   // Add the ExecutionModel.
-  operands.push_back(static_cast<uint32_t>(op.execution_model()));
+  operands.push_back(static_cast<uint32_t>(op.getExecutionModel()));
   // Add the function <id>.
-  auto funcID = getFunctionID(op.fn());
+  auto funcID = getFunctionID(op.getFn());
   if (!funcID) {
     return op.emitError("missing <id> for function ")
-           << op.fn()
+           << op.getFn()
            << "; function needs to be defined before spv.EntryPoint is "
               "serialized";
   }
   operands.push_back(funcID);
   // Add the name of the function.
-  spirv::encodeStringLiteralInto(operands, op.fn());
+  spirv::encodeStringLiteralInto(operands, op.getFn());
 
   // Add the interface values.
-  if (auto interface = op.interface()) {
+  if (auto interface = op.getInterface()) {
     for (auto var : interface.getValue()) {
       auto id = getVariableID(var.cast<FlatSymbolRefAttr>().getValue());
       if (!id) {
         return op.emitError("referencing undefined global variable."
                             "spv.EntryPoint is at the end of spv.module. All "
                             "referenced variables should already be defined");
       }
       operands.push_back(id);
     }
   }
   encodeInstructionInto(entryPoints, spirv::Opcode::OpEntryPoint, operands);
   return success();
 }
 
 template <>
 LogicalResult
 Serializer::processOp<spirv::ExecutionModeOp>(spirv::ExecutionModeOp op) {
   SmallVector<uint32_t, 4> operands;
   // Add the function <id>.
-  auto funcID = getFunctionID(op.fn());
+  auto funcID = getFunctionID(op.getFn());
   if (!funcID) {
     return op.emitError("missing <id> for function ")
-           << op.fn()
+           << op.getFn()
            << "; function needs to be serialized before ExecutionModeOp is "
               "serialized";
   }
   operands.push_back(funcID);
   // Add the ExecutionMode.
-  operands.push_back(static_cast<uint32_t>(op.execution_mode()));
+  operands.push_back(static_cast<uint32_t>(op.getExecutionMode()));
 
   // Serialize values if any.
-  auto values = op.values();
+  auto values = op.getValues();
   if (values) {
     for (auto &intVal : values.getValue()) {
       operands.push_back(static_cast<uint32_t>(
           intVal.cast<IntegerAttr>().getValue().getZExtValue()));
     }
   }
   encodeInstructionInto(executionModes, spirv::Opcode::OpExecutionMode,
                         operands);
   return success();
 }
 
 template <>
 LogicalResult
 Serializer::processOp<spirv::FunctionCallOp>(spirv::FunctionCallOp op) {
-  auto funcName = op.callee();
+  auto funcName = op.getCallee();
   uint32_t resTypeID = 0;
 
   Type resultTy = op.getNumResults() ? *op.result_type_begin() : getVoidType();
   if (failed(processType(op.getLoc(), resultTy, resTypeID)))
     return failure();
 
   auto funcID = getOrCreateFunctionID(funcName);
   auto funcCallID = getNextID();
   SmallVector<uint32_t, 8> operands{resTypeID, funcCallID, funcID};
 
-  for (auto value : op.arguments()) {
+  for (auto value : op.getArguments()) {
     auto valueID = getValueID(value);
     assert(valueID && "cannot find a value for spv.FunctionCall");
     operands.push_back(valueID);
   }
 
   if (!resultTy.isa<NoneType>())
     valueIDMap[op.getResult(0)] = funcCallID;
 

mlir/lib/Target/SPIRV/Serialization/Serializer.cpp

auto moduleSize = spirv::kHeaderWordCount + capabilities.size() +
                     extensions.size() + extendedSets.size() +
                     memoryModel.size() + entryPoints.size() +
                     executionModes.size() + decorations.size() +
                     typesGlobalValues.size() + functions.size();
 
   binary.clear();
   binary.reserve(moduleSize);
 
-  spirv::appendModuleHeader(binary, module.vce_triple()->getVersion(), nextID);
+  spirv::appendModuleHeader(binary, module.getVceTriple()->getVersion(),
+                            nextID);
   binary.append(capabilities.begin(), capabilities.end());
   binary.append(extensions.begin(), extensions.end());
   binary.append(extendedSets.begin(), extendedSets.end());
   binary.append(memoryModel.begin(), memoryModel.end());
   binary.append(entryPoints.begin(), entryPoints.end());
   binary.append(executionModes.begin(), executionModes.end());
   binary.append(debug.begin(), debug.end());
   binary.append(names.begin(), names.end());
uint32_t Serializer::getOrCreateFunctionID(StringRef fnName) {
   if (!funcID) {
     funcID = getNextID();
     funcIDMap[fnName] = funcID;
   }
   return funcID;
 }
 
 void Serializer::processCapability() {
-  for (auto cap : module.vce_triple()->getCapabilities())
+  for (auto cap : module.getVceTriple()->getCapabilities())
     encodeInstructionInto(capabilities, spirv::Opcode::OpCapability,
                           {static_cast<uint32_t>(cap)});
 }
 
 void Serializer::processDebugInfo() {
   if (!options.emitDebugInfo)
     return;
   auto fileLoc = module.getLoc().dyn_cast<FileLineColLoc>();
   auto fileName = fileLoc ? fileLoc.getFilename().strref() : "<unknown>";
   fileID = getNextID();
   SmallVector<uint32_t, 16> operands;
   operands.push_back(fileID);
   spirv::encodeStringLiteralInto(operands, fileName);
   encodeInstructionInto(debug, spirv::Opcode::OpString, operands);
   // TODO: Encode more debug instructions.
 }
 
 void Serializer::processExtension() {
   llvm::SmallVector<uint32_t, 16> extName;
-  for (spirv::Extension ext : module.vce_triple()->getExtensions()) {
+  for (spirv::Extension ext : module.getVceTriple()->getExtensions()) {
     extName.clear();
     spirv::encodeStringLiteralInto(extName, spirv::stringifyExtension(ext));
     encodeInstructionInto(extensions, spirv::Opcode::OpExtension, extName);
   }
 }
 
 void Serializer::processMemoryModel() {
   auto mm = static_cast<uint32_t>(
for (Block *mlirPredecessor : block->getPredecessors()) {
     Block *spirvPredecessor = getPhiIncomingBlock(mlirPredecessor);
     LLVM_DEBUG(llvm::dbgs() << "  spirv predecessor ");
     LLVM_DEBUG(printBlock(spirvPredecessor, llvm::dbgs()));
     if (auto branchOp = dyn_cast<spirv::BranchOp>(terminator)) {
       predecessors.emplace_back(spirvPredecessor, branchOp.getOperands());
     } else if (auto branchCondOp =
                    dyn_cast<spirv::BranchConditionalOp>(terminator)) {
       Optional<OperandRange> blockOperands;
-      if (branchCondOp.trueTarget() == block) {
-        blockOperands = branchCondOp.trueTargetOperands();
+      if (branchCondOp.getTrueTarget() == block) {
+        blockOperands = branchCondOp.getTrueTargetOperands();
       } else {
-        assert(branchCondOp.falseTarget() == block);
-        blockOperands = branchCondOp.falseTargetOperands();
+        assert(branchCondOp.getFalseTarget() == block);
+        blockOperands = branchCondOp.getFalseTargetOperands();
       }
 
       assert(!blockOperands->empty() &&
              "expected non-empty block operand range");
       predecessors.emplace_back(spirvPredecessor, *blockOperands);
     } else {
       return terminator->emitError("unimplemented terminator for Phi creation");
     }

mlir/tools/mlir-tblgen/SPIRVUtilsGen.cpp

for (const NamedAttribute &namedAttr : srcOp.getAttributes()) {
         // For BitEnumAttr, we need to iterate over each bit to query its
         // availability spec.
         os << formatv("  for (unsigned i = 0; "
                       "i < std::numeric_limits<{0}>::digits; ++i) {{\n",
                       enumAttr.getUnderlyingType());
         os << formatv("    {0}::{1} tblgen_attrVal = this->{2}() & "
                       "static_cast<{0}::{1}>(1 << i);\n",
                       enumAttr.getCppNamespace(), enumAttr.getEnumClassName(),
-                      namedAttr.name);
+                      srcOp.getGetterName(namedAttr.name));
         os << formatv(
             "    if (static_cast<{0}>(tblgen_attrVal) == 0) continue;\n",
             enumAttr.getUnderlyingType());
       } else {
         // For IntEnumAttr, we just need to query the value as a whole.
         os << "  {\n";
         os << formatv("    auto tblgen_attrVal = this->{0}();\n",
-                      namedAttr.name);
+                      srcOp.getGetterName(namedAttr.name));
       }
       os << formatv("    auto tblgen_instance = {0}::{1}(tblgen_attrVal);\n",
                     enumAttr.getCppNamespace(), avail.getQueryFnName());
       os << "    if (tblgen_instance) "
          // TODO` here once ODS supports
          // dialect-specific contents so that we can use not implementing the
          // availability interface as indication of no requirements.
          << std::string(tgfmt(caseSpecs.front().second.getMergeActionCode(),