[mlir][ods] Make Attr/Type def accessors match the dialect

[Mogball]

Summary

The generated attribute and type def accessors are changed to match the setting on the dialect. Most importantly, "prefixed" will now correctly convert snake case to camel case (e.g. weight_zp -> getWeightZp)

[jpienaar]

Yay thanks Jeff! (of course now I wish I had flipped more of these to _Both or _Prefixed already ;-))

[rriddle]

This looks like a regression to me in many cases. We are trying to remove snake case, but this seems to be adding more uses of it.

[rriddle]

I don't see a reason to regress from Attr/TypeDef using prefixed always, can we instead just fix the emission there to properly convert snake case?

[Mogball]

Are we trying to get rid of snake case or are we providing the option of either?

[csigg]

In D127688#3579664, @Mogball wrote:

Are we trying to get rid of snake case or are we providing the option of either?

We want to get rid of snake case in C++, according to this paragraph.

[Mogball]

Okay that makes sense. I'll fix the "regression". Nice catch river lol

[Mogball]

just fix camel case

[Mogball]

remove ununsed include

[rriddle]

LG, but please do not land patches that are marked as "Requested Changes".

[Mogball]

Yeah, my bad

mlir/include/mlir/TableGen/AttrOrTypeDef.h

explicit AttrOrTypeParameter(const llvm::DagInit *def, unsigned index)
       : def(def), index(index) {}
 
   /// Returns true if the parameter is anonymous (has no name).
   bool isAnonymous() const;
 
   /// Get the parameter name.
   StringRef getName() const;
 
+  /// Get the parameter accessor name.
+  std::string getAccessorName() const;
+
   /// If specified, get the custom allocator code for this parameter.
   Optional<StringRef> getAllocator() const;
 
   /// If specified, get the custom comparator code for this parameter.
   StringRef getComparator() const;
 
   /// Get the C++ type of this parameter.
   StringRef getCppType() const;

mlir/lib/Conversion/TosaToLinalg/TosaToLinalg.cpp

auto constant =
         rewriter.create<arith::ConstantOp>(loc, IntegerAttr::get(elementTy, 0));
     return rewriter.create<arith::SubIOp>(loc, resultTypes, constant, args[0]);
   }
 
   if (isa<tosa::NegateOp>(op) && elementTy.isa<IntegerType>() &&
       cast<tosa::NegateOp>(op).quantization_info()) {
     auto quantizationInfo = cast<tosa::NegateOp>(op).quantization_info();
     int32_t inputBitWidth = elementTy.getIntOrFloatBitWidth();
-    int64_t inZp = quantizationInfo.getValue().getInput_zp();
-    int64_t outZp = quantizationInfo.getValue().getOutput_zp();
+    int64_t inZp = quantizationInfo.getValue().getInputZp();
+    int64_t outZp = quantizationInfo.getValue().getOutputZp();
 
     // Compute the maximum value that can occur in the intermediate buffer.
     int64_t zpAdd = inZp + outZp;
     int64_t maxValue = APInt::getSignedMaxValue(inputBitWidth).getSExtValue() +
                        std::abs(zpAdd) + 1;
 
     // Convert that maximum value into the maximum bitwidth needed to represent
     // it. We assume 48-bit numbers may be supported further in the pipeline.
if (padOp.pad_const()) {
           loc, padOp.pad_const(), ValueRange({}));
     } else {
       Attribute constantAttr;
       if (elementTy.isa<FloatType>()) {
         constantAttr = rewriter.getFloatAttr(elementTy, 0.0);
       } else if (elementTy.isa<IntegerType>() && !padOp.quantization_info()) {
         constantAttr = rewriter.getIntegerAttr(elementTy, 0);
       } else if (elementTy.isa<IntegerType>() && padOp.quantization_info()) {
-        int64_t value = padOp.quantization_info().getValue().getInput_zp();
+        int64_t value = padOp.quantization_info().getValue().getInputZp();
         constantAttr = rewriter.getIntegerAttr(elementTy, value);
       }
       if (constantAttr)
         padConstant = rewriter.create<arith::ConstantOp>(loc, constantAttr);
     }
 
     if (!padConstant) {
       return rewriter.notifyMatchFailure(

mlir/lib/Conversion/TosaToLinalg/TosaToLinalgNamed.cpp

matchAndRewrite(tosa::Conv2DOp op, OpAdaptor adaptor,
 
     auto weightShape = weightTy.getShape();
 
     // Apply padding as necessary.
     Attribute zeroAttr = rewriter.getZeroAttr(inputETy);
     if (isQuantized) {
       auto quantizationInfo =
           op->getAttr("quantization_info").cast<tosa::ConvOpQuantizationAttr>();
-      int64_t iZp = quantizationInfo.getInput_zp();
+      int64_t iZp = quantizationInfo.getInputZp();
 
       int64_t intMin =
           APInt::getSignedMinValue(inputETy.getIntOrFloatBitWidth())
               .getSExtValue();
       int64_t intMax =
           APInt::getSignedMaxValue(inputETy.getIntOrFloatBitWidth())
               .getSExtValue();
 
matchAndRewrite(tosa::Conv2DOp op, OpAdaptor adaptor,
     indexingMaps.push_back(rewriter.getMultiDimIdentityMap(resultTy.getRank()));
 
     Value biasInitTensor = rewriter.create<linalg::InitTensorOp>(
         loc, filteredDims, resultTy.getShape(), resultETy);
 
     if (isQuantized) {
       auto quantizationInfo =
           op->getAttr("quantization_info").cast<tosa::ConvOpQuantizationAttr>();
-      auto iZp = rewriter.getI32IntegerAttr(quantizationInfo.getInput_zp());
-      auto kZp = rewriter.getI32IntegerAttr(quantizationInfo.getWeight_zp());
+      auto iZp = rewriter.getI32IntegerAttr(quantizationInfo.getInputZp());
+      auto kZp = rewriter.getI32IntegerAttr(quantizationInfo.getWeightZp());
 
       auto iZpVal = rewriter.create<arith::ConstantOp>(loc, iZp);
       auto kZpVal = rewriter.create<arith::ConstantOp>(loc, kZp);
       Value conv =
           rewriter
               .create<linalg::Conv2DNhwcHwcfQOp>(
                   loc, resultTy, ValueRange{input, weight, iZpVal, kZpVal},
                   ValueRange{zeroTensor}, strideAttr, dilationAttr)
SmallVector<Value> filteredDims = inferDynamicDimsForConv(
         0, 1, rewriter);
 
     bool isQuantized = op->hasAttr("quantization_info");
     IntegerAttr iZp;
     IntegerAttr kZp;
     if (isQuantized) {
       auto quantizationInfo =
           op->getAttr("quantization_info").cast<tosa::ConvOpQuantizationAttr>();
-      iZp = rewriter.getI32IntegerAttr(quantizationInfo.getInput_zp());
-      kZp = rewriter.getI32IntegerAttr(quantizationInfo.getWeight_zp());
+      iZp = rewriter.getI32IntegerAttr(quantizationInfo.getInputZp());
+      kZp = rewriter.getI32IntegerAttr(quantizationInfo.getWeightZp());
     }
 
     auto weightShape = weightTy.getShape();
     auto resultShape = resultTy.getShape();
 
     // Apply padding as necessary.
     Attribute zeroAttr = rewriter.getZeroAttr(inputETy);
     if (isQuantized) {
       auto quantizationInfo =
           op->getAttr("quantization_info").cast<tosa::ConvOpQuantizationAttr>();
-      int64_t iZp = quantizationInfo.getInput_zp();
+      int64_t iZp = quantizationInfo.getInputZp();
 
       int64_t intMin =
           APInt::getSignedMinValue(inputETy.getIntOrFloatBitWidth())
               .getSExtValue();
       int64_t intMax =
           APInt::getSignedMaxValue(inputETy.getIntOrFloatBitWidth())
               .getSExtValue();
 
if (!op.quantization_info()) {
       rewriter.replaceOpWithNewOp<linalg::BatchMatmulOp>(
           op, TypeRange{op.getType()}, ValueRange{adaptor.a(), adaptor.b()},
           ValueRange{zeroTensor});
       return success();
     }
 
     auto quantizationInfo = op.quantization_info().getValue();
     auto aZp = rewriter.create<arith::ConstantOp>(
-        loc, rewriter.getI32IntegerAttr(quantizationInfo.getA_zp()));
+        loc, rewriter.getI32IntegerAttr(quantizationInfo.getAZp()));
     auto bZp = rewriter.create<arith::ConstantOp>(
-        loc, rewriter.getI32IntegerAttr(quantizationInfo.getB_zp()));
+        loc, rewriter.getI32IntegerAttr(quantizationInfo.getBZp()));
     rewriter.replaceOpWithNewOp<linalg::QuantizedBatchMatmulOp>(
         op, TypeRange{op.getType()},
         ValueRange{adaptor.a(), adaptor.b(), aZp, bZp}, zeroTensor);
 
     return success();
   }
 };
 
if (!op.quantization_info()) {
                   })
               .getResult(0);
       rewriter.replaceOp(op, result);
       return success();
     }
 
     auto quantizationInfo = op.quantization_info().getValue();
     auto inputZp = rewriter.create<arith::ConstantOp>(
-        loc, rewriter.getI32IntegerAttr(quantizationInfo.getInput_zp()));
+        loc, rewriter.getI32IntegerAttr(quantizationInfo.getInputZp()));
     auto outputZp = rewriter.create<arith::ConstantOp>(
-        loc, rewriter.getI32IntegerAttr(quantizationInfo.getWeight_zp()));
+        loc, rewriter.getI32IntegerAttr(quantizationInfo.getWeightZp()));
     Value matmul =
         rewriter
             .create<linalg::QuantizedMatmulOp>(
                 loc, TypeRange{op.getType()},
                 ValueRange{input, transposedWeight, inputZp, outputZp},
                 zeroTensor)
             ->getResult(0);
     Value result =
auto genericOp = rewriter.create<linalg::GenericOp>(
                           ->getResult(0);
           } else {
 
             // If we have quantization information we need to apply an offset
             // for the input zp value.
             if (op.quantization_info()) {
               auto quantizationInfo = op.quantization_info().getValue();
               auto inputZp = rewriter.create<arith::ConstantOp>(
-                  loc,
-                  b.getIntegerAttr(accETy, quantizationInfo.getInput_zp()));
+                  loc, b.getIntegerAttr(accETy, quantizationInfo.getInputZp()));
               Value offset =
                   rewriter.create<arith::MulIOp>(loc, accETy, countI, inputZp);
               poolVal =
                   rewriter.create<arith::SubIOp>(loc, accETy, poolVal, offset);
             }
 
             // Compute the multiplier and shift values for the quantization
             // normalization. Preferably we would want to compute more bits
auto genericOp = rewriter.create<linalg::GenericOp>(
                     .getResult();
 
             // If we have quantization information we need to apply output
             // zeropoint.
             if (op.quantization_info()) {
               auto quantizationInfo = op.quantization_info().getValue();
               auto outputZp = rewriter.create<arith::ConstantOp>(
                   loc, b.getIntegerAttr(scaled.getType(),
-                                        quantizationInfo.getOutput_zp()));
+                                        quantizationInfo.getOutputZp()));
               scaled = rewriter.create<arith::AddIOp>(loc, scaled, outputZp)
                            .getResult();
             }
 
             // Apply Clip.
             int64_t outBitwidth = resultETy.getIntOrFloatBitWidth();
 
             auto min = rewriter.create<arith::ConstantIntOp>(

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

if (auto attr = op->getAttrOfType<spirv::EntryPointABIAttr>(
           spirv::getEntryPointABIAttrName()))
     return attr;
 
   return {};
 }
 
 DenseIntElementsAttr spirv::lookupLocalWorkGroupSize(Operation *op) {
   if (auto entryPoint = spirv::lookupEntryPointABI(op))
-    return entryPoint.getLocal_size();
+    return entryPoint.getLocalSize();
 
   return {};
 }
 
 spirv::ResourceLimitsAttr
 spirv::getDefaultResourceLimits(MLIRContext *context) {
   // All the fields have default values. Here we just provide a nicer way to
   // construct a default resource limit attribute.

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

static LogicalResult lowerEntryPointABIAttr(spirv::FuncOp funcOp,
   if (failed(executionModel))
     return funcOp.emitRemark("lower entry point failure: could not select "
                              "execution model based on 'spv.target_env'");
 
   builder.create<spirv::EntryPointOp>(
       funcOp.getLoc(), executionModel.getValue(), funcOp, interfaceVars);
 
   // Specifies the spv.ExecutionModeOp.
-  auto localSizeAttr = entryPointAttr.getLocal_size();
+  auto localSizeAttr = entryPointAttr.getLocalSize();
   if (localSizeAttr) {
     auto values = localSizeAttr.getValues<int32_t>();
     SmallVector<int32_t, 3> localSize(values);
     builder.create<spirv::ExecutionModeOp>(
         funcOp.getLoc(), funcOp, spirv::ExecutionMode::LocalSize, localSize);
     funcOp->removeAttr(entryPointAttrName);
   }
   return success();

mlir/lib/Dialect/Tosa/IR/TosaOps.cpp

LogicalResult matchAndRewrite(tosa::PadOp op,
     Type elementTy = inputTy.getElementType();
 
     Attribute constantAttr;
     if (elementTy.isa<FloatType>()) {
       constantAttr = rewriter.getFloatAttr(elementTy, 0.0);
     } else if (elementTy.isa<IntegerType>() && !op.quantization_info()) {
       constantAttr = rewriter.getIntegerAttr(elementTy, 0);
     } else if (elementTy.isa<IntegerType>() && op.quantization_info()) {
-      auto value = op.quantization_info().getValue().getInput_zp();
+      auto value = op.quantization_info().getValue().getInputZp();
       constantAttr = rewriter.getIntegerAttr(elementTy, value);
     }
 
     if (!constantAttr) {
       return rewriter.notifyMatchFailure(
           op,
           "tosa.pad to linalg lowering encountered an unknown element type");
     }

mlir/lib/Dialect/Tosa/Transforms/TosaDecomposeTransposeConv.cpp

LogicalResult matchAndRewrite(tosa::TransposeConv2DOp op,
     Value weightPaddingVal = createOpAndInfer<tosa::ConstOp>(
         rewriter, loc, weightPaddingAttr.getType(), weightPaddingAttr);
 
     if (op.quantization_info().hasValue()) {
       auto quantInfo = op.quantization_info().getValue();
       weight = createOpAndInfer<tosa::PadOp>(
           rewriter, loc, UnrankedTensorType::get(weightETy), weight,
           weightPaddingVal, nullptr,
-          rewriter.getAttr<PadOpQuantizationAttr>(quantInfo.getWeight_zp()));
+          rewriter.getAttr<PadOpQuantizationAttr>(quantInfo.getWeightZp()));
 
     } else {
       weight = createOpAndInfer<tosa::PadOp>(rewriter, loc,
                                              UnrankedTensorType::get(weightETy),
                                              weight, weightPaddingVal);
     }
 
     weightTy = weight.getType().cast<ShapedType>();
LogicalResult matchAndRewrite(tosa::TransposeConv2DOp op,
     Value inputPaddingVal = createOpAndInfer<tosa::ConstOp>(
         rewriter, loc, inputPaddingAttr.getType(), inputPaddingAttr);
 
     if (op.quantization_info().hasValue()) {
       auto quantInfo = op.quantization_info().getValue();
       input = createOpAndInfer<tosa::PadOp>(
           rewriter, loc, UnrankedTensorType::get(inputETy), input,
           inputPaddingVal, nullptr,
-          rewriter.getAttr<PadOpQuantizationAttr>(quantInfo.getInput_zp()));
+          rewriter.getAttr<PadOpQuantizationAttr>(quantInfo.getInputZp()));
     } else {
       input = createOpAndInfer<tosa::PadOp>(rewriter, loc,
                                             UnrankedTensorType::get(inputETy),
                                             input, inputPaddingVal);
     }
 
     // We use a zero bias as we need to broadcast the bias.
     auto zeroBias = rewriter.create<tosa::ConstOp>(

mlir/lib/TableGen/AttrOrTypeDef.cpp

 bool AttrOrTypeParameter::isAnonymous() const {
   return !def->getArgName(index);
 }
 
 StringRef AttrOrTypeParameter::getName() const {
   return def->getArgName(index)->getValue();
 }
 
+std::string AttrOrTypeParameter::getAccessorName() const {
+  return "get" +
+         llvm::convertToCamelFromSnakeCase(getName(), /*capitalizeFirst=*/true);
+}
+
 Optional<StringRef> AttrOrTypeParameter::getAllocator() const {
   return getDefValue<llvm::StringInit>("allocator");
 }
 
 StringRef AttrOrTypeParameter::getComparator() const {
   return getDefValue<llvm::StringInit>("comparator")
       .getValueOr("$_lhs == $_rhs");
 }

mlir/tools/mlir-tblgen/AttrOrTypeDefGen.cpp

 //===- AttrOrTypeDefGen.cpp - MLIR AttrOrType definitions generator -------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "AttrOrTypeFormatGen.h"
-#include "mlir/Support/LogicalResult.h"
 #include "mlir/TableGen/AttrOrTypeDef.h"
 #include "mlir/TableGen/Class.h"
 #include "mlir/TableGen/CodeGenHelpers.h"
 #include "mlir/TableGen/Format.h"
 #include "mlir/TableGen/GenInfo.h"
 #include "mlir/TableGen/Interfaces.h"
-#include "llvm/ADT/Sequence.h"
-#include "llvm/ADT/SetVector.h"
-#include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/TableGenBackend.h"
 
 #define DEBUG_TYPE "mlir-tblgen-attrortypedefgen"
 
 using namespace mlir;
 using namespace mlir::tblgen;
 
 //===----------------------------------------------------------------------===//
 // Utility Functions
 //===----------------------------------------------------------------------===//
 
-std::string mlir::tblgen::getParameterAccessorName(StringRef name) {
-  assert(!name.empty() && "parameter has empty name");
-  auto ret = "get" + name.str();
-  ret[3] = llvm::toUpper(ret[3]); // uppercase first letter of the name
-  return ret;
-}
-
 /// Find all the AttrOrTypeDef for the specified dialect. If no dialect
 /// specified and can only find one dialect's defs, use that.
 static void collectAllDefs(StringRef selectedDialect,
                            std::vector<llvm::Record *> records,
                            SmallVectorImpl<AttrOrTypeDef> &resultDefs) {
   // Nothing to do if no defs were found.
   if (records.empty())
     return;
void DefGen::emitParserPrinter() {
   // Emit the bodies if we are using the declarative format.
   if (hasAssemblyFormat)
     return generateAttrOrTypeFormat(def, parser->body(), printer->body());
 }
 
 void DefGen::emitAccessors() {
   for (auto &param : params) {
     Method *m = defCls.addMethod(
-        param.getCppAccessorType(), getParameterAccessorName(param.getName()),
+        param.getCppAccessorType(), param.getAccessorName(),
         def.genStorageClass() ? Method::Const : Method::ConstDeclaration);
     // Generate accessor definitions only if we also generate the storage
     // class. Otherwise, let the user define the exact accessor definition.
     if (!def.genStorageClass())
       continue;
     auto scope = m->body().indent().scope("return getImpl()->", ";");
     if (isa<AttributeSelfTypeParameter>(param))
       m->body() << formatv("getType().cast<{0}>()", param.getCppType());

mlir/tools/mlir-tblgen/AttrOrTypeFormatGen.h

 namespace tblgen {
 class AttrOrTypeDef;
 
 /// Generate a parser and printer based on a custom assembly format for an
 /// attribute or type.
 void generateAttrOrTypeFormat(const AttrOrTypeDef &def, MethodBody &parser,
                               MethodBody &printer);
 
-/// From the parameter name, get the name of the accessor function in camelcase.
-/// The first letter of the parameter is upper-cased and prefixed with "get".
-/// E.g. 'value' -> 'getValue'.
-std::string getParameterAccessorName(llvm::StringRef name);
-
 } // namespace tblgen
 } // namespace mlir
 
 #endif // MLIR_TOOLS_MLIRTBLGEN_ATTRORTYPEFORMATGEN_H_

mlir/tools/mlir-tblgen/AttrOrTypeFormatGen.cpp

public:
   /// Returns true if the element contains an optional parameter.
   bool isOptional() const { return param.isOptional(); }
 
   /// Returns the name of the parameter.
   StringRef getName() const { return param.getName(); }
 
   /// Generate the code to check whether the parameter should be printed.
   MethodBody &genPrintGuard(FmtContext &ctx, MethodBody &os) const {
-    std::string self = getParameterAccessorName(getName()) + "()";
+    std::string self = param.getAccessorName() + "()";
     ctx.withSelf(self);
     os << tgfmt("($_self", &ctx);
     if (llvm::Optional<StringRef> defaultValue = getParam().getDefaultValue()) {
       // Use the `comparator` field if it exists, else the equality operator.
       std::string valueStr = tgfmt(*defaultValue, &ctx).str();
       ctx.addSubst("_lhs", self).addSubst("_rhs", valueStr);
       os << " && !(" << tgfmt(getParam().getComparator(), &ctx) << ")";
     }
void DefFormat::genLiteralPrinter(StringRef value, FmtContext &ctx,
   shouldEmitSpace =
       value.size() != 1 || !StringRef("<({[").contains(value.front());
   lastWasPunctuation = !(value.front() == '_' || isalpha(value.front()));
 }
 
 void DefFormat::genVariablePrinter(ParameterElement *el, FmtContext &ctx,
                                    MethodBody &os, bool skipGuard) {
   const AttrOrTypeParameter &param = el->getParam();
-  ctx.withSelf(getParameterAccessorName(param.getName()) + "()");
+  ctx.withSelf(param.getAccessorName() + "()");
 
   // Guard the printer on the presence of optional parameters and that they
   // aren't equal to their default values (if they have one).
   if (el->isOptional() && !skipGuard) {
     el->genPrintGuard(ctx, os << "if (") << ") {\n";
     os.indent();
   }
 
void DefFormat::genCustomPrinter(CustomDirective *el, FmtContext &ctx,
                                  MethodBody &os) {
   os << tgfmt("print$0($_printer", &ctx, el->getName());
   os.indent();
   for (FormatElement *arg : el->getArguments()) {
     FormatElement *param = arg;
     if (auto *ref = dyn_cast<RefDirective>(arg))
       param = ref->getArg();
     os << ",\n"
-       << getParameterAccessorName(cast<ParameterElement>(param)->getName())
-       << "()";
+       << cast<ParameterElement>(param)->getParam().getAccessorName() << "()";
   }
   os.unindent() << ");\n";
 }
 
 void DefFormat::genOptionalGroupPrinter(OptionalElement *el, FmtContext &ctx,
                                         MethodBody &os) {
   FormatElement *anchor = el->getAnchor();
   if (auto *param = dyn_cast<ParameterElement>(anchor)) {