[mlir] Flip dialects from _Both to _Prefixed

[jpienaar]

Summary

Following
https://llvm.discourse.group/t/psa-ods-generated-accessors-will-change-to-have-a-get-prefix-update-you-apis/4476
these have been flipped to both for ~4 weeks, flipping to _Prefixed.

[jpienaar]

Updating C++ calls referencing raw accessors.

flang/lib/Optimizer/CodeGen/CodeGen.cpp

if (global.getType().isa<fir::BoxType>())
       tyAttr = tyAttr.cast<mlir::LLVM::LLVMPointerType>().getElementType();
     auto loc = global.getLoc();
     mlir::Attribute initAttr{};
     if (global.initVal())
       initAttr = global.initVal().getValue();
     auto linkage = convertLinkage(global.linkName());
     auto isConst = global.constant().hasValue();
     auto g = rewriter.create<mlir::LLVM::GlobalOp>(
-        loc, tyAttr, isConst, linkage, global.sym_name(), initAttr);
+        loc, tyAttr, isConst, linkage, global.getSymName(), initAttr);
     auto &gr = g.getInitializerRegion();
     rewriter.inlineRegionBefore(global.region(), gr, gr.end());
     if (!gr.empty()) {
       // Replace insert_on_range with a constant dense attribute if the
       // initialization is on the full range.
       auto insertOnRangeOps = gr.front().getOps<fir::InsertOnRangeOp>();
       for (auto insertOp : insertOnRangeOps) {
         if (isFullRange(insertOp.coor(), insertOp.getType())) {
struct EmboxCommonConversion : public FIROpConversion<OP> {
   getTypeDescriptor(BOX box, mlir::ConversionPatternRewriter &rewriter,
                     mlir::Location loc, fir::RecordType recType) const {
     std::string name = recType.getLoweredName();
     auto module = box->template getParentOfType<mlir::ModuleOp>();
     if (auto global = module.template lookupSymbol<fir::GlobalOp>(name)) {
       auto ty = mlir::LLVM::LLVMPointerType::get(
           this->lowerTy().convertType(global.getType()));
       return rewriter.create<mlir::LLVM::AddressOfOp>(loc, ty,
-                                                      global.sym_name());
+                                                      global.getSymName());
     }
     if (auto global =
             module.template lookupSymbol<mlir::LLVM::GlobalOp>(name)) {
       // The global may have already been translated to LLVM.
       auto ty = mlir::LLVM::LLVMPointerType::get(global.getType());
       return rewriter.create<mlir::LLVM::AddressOfOp>(loc, ty,
-                                                      global.sym_name());
+                                                      global.getSymName());
     }
     // The global does not exist in the current translation unit, but may be
     // defined elsewhere (e.g., type defined in a module).
     // For now, create a extern_weak symbol (will become nullptr if unresolved)
     // to support generating code without the front-end generated symbols.
     // These could be made available_externally to require the symbols to be
     // defined elsewhere and to cause link-time failure otherwise.
     auto i8Ty = rewriter.getIntegerType(8);
struct CoordinateOpConversion
 
   int64_t getIntValue(mlir::Value val) const {
     assert(val && val.dyn_cast<mlir::OpResult>() && "must not be null value");
     mlir::Operation *defop = val.getDefiningOp();
 
     if (auto constOp = dyn_cast<mlir::arith::ConstantIntOp>(defop))
       return constOp.value();
     if (auto llConstOp = dyn_cast<mlir::LLVM::ConstantOp>(defop))
-      if (auto attr = llConstOp.value().dyn_cast<mlir::IntegerAttr>())
+      if (auto attr = llConstOp.getValue().dyn_cast<mlir::IntegerAttr>())
         return attr.getValue().getSExtValue();
     fir::emitFatalError(val.getLoc(), "must be a constant");
   }
 
 private:
   void doRewriteBox(fir::CoordinateOp coor, mlir::Type ty,
                     mlir::ValueRange operands, mlir::Location loc,
                     mlir::ConversionPatternRewriter &rewriter) const {

flang/lib/Optimizer/Transforms/AffinePromotion.cpp

MaybeAffineExpr toAffineExpr(int64_t value) {
     return {mlir::getAffineConstantExpr(value, firCondition.getContext())};
   }
 
   /// Returns an AffineExpr if it is a result of operations that can be done
   /// in an affine expression, this includes -, +, *, rem, constant.
   /// block arguments of a loopOp or forOp are used as dimensions
   MaybeAffineExpr toAffineExpr(mlir::Value value) {
     if (auto op = value.getDefiningOp<mlir::arith::SubIOp>())
-      return affineBinaryOp(mlir::AffineExprKind::Add, toAffineExpr(op.lhs()),
-                            affineBinaryOp(mlir::AffineExprKind::Mul,
-                                           toAffineExpr(op.rhs()),
-                                           toAffineExpr(-1)));
+      return affineBinaryOp(
+          mlir::AffineExprKind::Add, toAffineExpr(op.getLhs()),
+          affineBinaryOp(mlir::AffineExprKind::Mul, toAffineExpr(op.getRhs()),
     if (auto op = value.getDefiningOp<mlir::arith::AddIOp>())
-      return affineBinaryOp(mlir::AffineExprKind::Add, op.lhs(), op.rhs());
+      return affineBinaryOp(mlir::AffineExprKind::Add, op.getLhs(),
+                            op.getRhs());
     if (auto op = value.getDefiningOp<mlir::arith::MulIOp>())
-      return affineBinaryOp(mlir::AffineExprKind::Mul, op.lhs(), op.rhs());
+      return affineBinaryOp(mlir::AffineExprKind::Mul, op.getLhs(),
+                            op.getRhs());
     if (auto op = value.getDefiningOp<mlir::arith::RemUIOp>())
-      return affineBinaryOp(mlir::AffineExprKind::Mod, op.lhs(), op.rhs());
+      return affineBinaryOp(mlir::AffineExprKind::Mod, op.getLhs(),
+                            op.getRhs());
     if (auto op = value.getDefiningOp<mlir::arith::ConstantOp>())
-      if (auto intConstant = op.value().dyn_cast<IntegerAttr>())
+      if (auto intConstant = op.getValue().dyn_cast<IntegerAttr>())
         return toAffineExpr(intConstant.getInt());
     if (auto blockArg = value.dyn_cast<mlir::BlockArgument>()) {
       affineArgs.push_back(value);
       if (isa<fir::DoLoopOp>(blockArg.getOwner()->getParentOp()) ||
           isa<mlir::AffineForOp>(blockArg.getOwner()->getParentOp()))
         return {mlir::getAffineDimExpr(dimCount++, value.getContext())};
       return {mlir::getAffineSymbolExpr(symCount++, value.getContext())};
     }
     return {};
   }
 
   void fromCmpIOp(mlir::arith::CmpIOp cmpOp) {
-    auto lhsAffine = toAffineExpr(cmpOp.lhs());
-    auto rhsAffine = toAffineExpr(cmpOp.rhs());
+    auto lhsAffine = toAffineExpr(cmpOp.getLhs());
+    auto rhsAffine = toAffineExpr(cmpOp.getRhs());
     if (!lhsAffine.hasValue() || !rhsAffine.hasValue())
       return;
     auto constraintPair = constraint(
-        cmpOp.predicate(), rhsAffine.getValue() - lhsAffine.getValue());
+        cmpOp.getPredicate(), rhsAffine.getValue() - lhsAffine.getValue());
     if (!constraintPair)
       return;
     integerSet = mlir::IntegerSet::get(dimCount, symCount,
                                        {constraintPair.getValue().first},
                                        {constraintPair.getValue().second});
     return;
   }
 

flang/unittests/Optimizer/Builder/DoLoopHelperTest.cpp

TEST_F(DoLoopHelperTest, createLoopWithCountTest) {
 
   auto c10 = firBuilder.createIntegerConstant(
       firBuilder.getUnknownLoc(), firBuilder.getIndexType(), 10);
   auto loop =
       helper.createLoop(c10, [&](fir::FirOpBuilder &, mlir::Value index) {});
   checkConstantValue(loop.lowerBound(), 0);
   EXPECT_TRUE(mlir::isa<arith::SubIOp>(loop.upperBound().getDefiningOp()));
   auto subOp = dyn_cast<arith::SubIOp>(loop.upperBound().getDefiningOp());
-  EXPECT_EQ(c10, subOp.lhs());
+  EXPECT_EQ(c10, subOp.getLhs());
   checkConstantValue(subOp.getRhs(), 1);
   checkConstantValue(loop.getStep(), 1);
 }
 
 TEST_F(DoLoopHelperTest, createLoopWithLowerAndUpperBound) {
   auto firBuilder = getBuilder();
   fir::factory::DoLoopHelper helper(firBuilder, firBuilder.getUnknownLoc());
 

flang/unittests/Optimizer/Builder/Runtime/CharacterTest.cpp

void checkCharCompare2(
   mlir::Value rhsBuff = builder.create<fir::UndefOp>(loc, boxCharTy);
   mlir::Value rhsLen = builder.create<fir::UndefOp>(loc, i32Ty);
   fir::ExtendedValue lhs = charHelper.toExtendedValue(lhsBuff, lhsLen);
   fir::ExtendedValue rhs = charHelper.toExtendedValue(rhsBuff, rhsLen);
   mlir::Value res = fir::runtime::genCharCompare(
       builder, loc, mlir::arith::CmpIPredicate::eq, lhs, rhs);
   EXPECT_TRUE(mlir::isa<mlir::arith::CmpIOp>(res.getDefiningOp()));
   auto cmpOp = mlir::dyn_cast<mlir::arith::CmpIOp>(res.getDefiningOp());
-  checkCallOp(cmpOp.lhs().getDefiningOp(), fctName, 4, /*addLocArgs=*/false);
+  checkCallOp(cmpOp.getLhs().getDefiningOp(), fctName, 4, /*addLocArgs=*/false);
   auto allocas = res.getParentBlock()->getOps<fir::AllocaOp>();
   EXPECT_TRUE(llvm::empty(allocas));
 }
 
 TEST_F(RuntimeCallTest, genCharCompare2Test) {
   checkCharCompare2(*firBuilder, "_FortranACharacterCompareScalar1", 1);
   checkCharCompare2(*firBuilder, "_FortranACharacterCompareScalar2", 2);
   checkCharCompare2(*firBuilder, "_FortranACharacterCompareScalar4", 4);

flang/unittests/Optimizer/Builder/Runtime/NumericTest.cpp

void testGenNearest(fir::FirOpBuilder &builder, mlir::Type xType,
   mlir::Value x = builder.create<fir::UndefOp>(loc, xType);
   mlir::Value s = builder.create<fir::UndefOp>(loc, sType);
   mlir::Value nearest = fir::runtime::genNearest(builder, loc, x, s);
   checkCallOp(nearest.getDefiningOp(), fctName, 2, /*addLocArg=*/false);
   auto callOp = mlir::dyn_cast<fir::CallOp>(nearest.getDefiningOp());
   mlir::Value select = callOp.getOperands()[1];
   EXPECT_TRUE(mlir::isa<mlir::SelectOp>(select.getDefiningOp()));
   auto selectOp = mlir::dyn_cast<mlir::SelectOp>(select.getDefiningOp());
-  mlir::Value cmp = selectOp.condition();
+  mlir::Value cmp = selectOp.getCondition();
   EXPECT_TRUE(mlir::isa<mlir::arith::CmpFOp>(cmp.getDefiningOp()));
   auto cmpOp = mlir::dyn_cast<mlir::arith::CmpFOp>(cmp.getDefiningOp());
   EXPECT_EQ(s, cmpOp.getLhs());
 }
 
 TEST_F(RuntimeCallTest, genNearestTest) {
   testGenNearest(*firBuilder, f32Ty, f32Ty, "_FortranANearest4");
   testGenNearest(*firBuilder, f64Ty, f32Ty, "_FortranANearest8");

mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticBase.td

def Arithmetic_Dialect : Dialect {
   let description = [{
     The arithmetic dialect is intended to hold basic integer and floating point
     mathematical operations. This includes unary, binary, and ternary arithmetic
     ops, bitwise and shift ops, cast ops, and compare ops. Operations in this
     dialect also accept vectors and tensors of integers or floats.
   }];
 
   let hasConstantMaterializer = 1;
-  let emitAccessorPrefix = kEmitAccessorPrefix_Both;
+  let emitAccessorPrefix = kEmitAccessorPrefix_Prefixed;
 }
 
 // The predicate indicates the type of the comparison to perform:
 // (un)orderedness, (in)equality and less/greater than (or equal to) as
 // well as predicates that are always true or false.
 def Arith_CmpFPredicateAttr : I64EnumAttr<
     "CmpFPredicate", "",
     [

mlir/include/mlir/Dialect/LLVMIR/LLVMOpBase.td

let extraClassDeclaration = [{
     /// Uses `reportError` to report errors.
     static LogicalResult verifyDataLayoutString(
         StringRef descr, llvm::function_ref<void (const Twine &)> reportError);
 
     /// Name of the target triple attribute.
     static StringRef getTargetTripleAttrName() { return "llvm.target_triple"; }
   }];
 
-  let emitAccessorPrefix = kEmitAccessorPrefix_Both;
+  let emitAccessorPrefix = kEmitAccessorPrefix_Prefixed;
 }
 
 //===----------------------------------------------------------------------===//
 // LLVM dialect type constraints.
 //===----------------------------------------------------------------------===//
 
 // LLVM dialect type.
 def LLVM_Type : DialectType<LLVM_Dialect,

mlir/include/mlir/Dialect/Math/IR/MathBase.td

 include "mlir/IR/OpBase.td"
 def Math_Dialect : Dialect {
   let name = "math";
   let cppNamespace = "::mlir::math";
   let description = [{
     The math dialect is intended to hold mathematical operations on integer and
     floating type beyond simple arithmetics.
   }];
-  let emitAccessorPrefix = kEmitAccessorPrefix_Both;
+  let emitAccessorPrefix = kEmitAccessorPrefix_Prefixed;
 }
 #endif // MATH_BASE

mlir/include/mlir/Dialect/Shape/IR/ShapeBase.td

let description = [{
     concatting etc. on how to combine them).
   }];
 
   let cppNamespace = "::mlir::shape";
   let dependentDialects = ["arith::ArithmeticDialect", "tensor::TensorDialect"];
 
   let hasConstantMaterializer = 1;
   let hasOperationAttrVerify = 1;
-  let emitAccessorPrefix = kEmitAccessorPrefix_Both;
+  let emitAccessorPrefix = kEmitAccessorPrefix_Prefixed;
 }
 
 def Shape_ShapeType : DialectType<ShapeDialect,
     CPred<"$_self.isa<::mlir::shape::ShapeType>()">, "shape">,
     BuildableType<"$_builder.getType<::mlir::shape::ShapeType>()"> {
   let description = [{
     `shape.shape` represents either an unranked shape, a ranked shape with
     possibly unknown dimensions or an invalid shape. The rank is of type

mlir/include/mlir/Dialect/StandardOps/IR/Ops.td

 include "mlir/Interfaces/SideEffectInterfaces.td"
 include "mlir/Interfaces/VectorInterfaces.td"
 
 def StandardOps_Dialect : Dialect {
   let name = "std";
   let cppNamespace = "::mlir";
   let dependentDialects = ["arith::ArithmeticDialect"];
   let hasConstantMaterializer = 1;
-  let emitAccessorPrefix = kEmitAccessorPrefix_Both;
+  let emitAccessorPrefix = kEmitAccessorPrefix_Prefixed;
 }
 
 // Base class for Standard dialect ops.
 class Std_Op<string mnemonic, list<OpTrait> traits = []> :
     Op<StandardOps_Dialect, mnemonic, traits> {
   // For every standard op, there needs to be a:
   //   * void print(OpAsmPrinter &p, ${C++ class of Op} op)
   //   * LogicalResult verify(${C++ class of Op} op)