Revert "[fir] Add fir.extract_value and fir.insert_value conversion"

This reverts commit ea55503.

Author: clementval

flang/lib/Optimizer/CodeGen/CodeGen.cpp

@@ -296,105 +296,6 @@ struct ZeroOpConversion : public FIROpConversion<fir::ZeroOp> {
   }
 };
 
-// Code shared between insert_value and extract_value Ops.
-struct ValueOpCommon {
-  // Translate the arguments pertaining to any multidimensional array to
-  // row-major order for LLVM-IR.
-  static void toRowMajor(SmallVectorImpl<mlir::Attribute> &attrs,
-                         mlir::Type ty) {
-    assert(ty && "type is null");
-    const auto end = attrs.size();
-    for (std::remove_const_t<decltype(end)> i = 0; i < end; ++i) {
-      if (auto seq = ty.dyn_cast<mlir::LLVM::LLVMArrayType>()) {
-        const auto dim = getDimension(seq);
-        if (dim > 1) {
-          auto ub = std::min(i + dim, end);
-          std::reverse(attrs.begin() + i, attrs.begin() + ub);
-          i += dim - 1;
-        }
-        ty = getArrayElementType(seq);
-      } else if (auto st = ty.dyn_cast<mlir::LLVM::LLVMStructType>()) {
-        ty = st.getBody()[attrs[i].cast<mlir::IntegerAttr>().getInt()];
-      } else {
-        llvm_unreachable("index into invalid type");
-      }
-    }
-  }
-
-  static llvm::SmallVector<mlir::Attribute>
-  collectIndices(mlir::ConversionPatternRewriter &rewriter,
-                 mlir::ArrayAttr arrAttr) {
-    llvm::SmallVector<mlir::Attribute> attrs;
-    for (auto i = arrAttr.begin(), e = arrAttr.end(); i != e; ++i) {
-      if (i->isa<mlir::IntegerAttr>()) {
-        attrs.push_back(*i);
-      } else {
-        auto fieldName = i->cast<mlir::StringAttr>().getValue();
-        ++i;
-        auto ty = i->cast<mlir::TypeAttr>().getValue();
-        auto index = ty.cast<fir::RecordType>().getFieldIndex(fieldName);
-        attrs.push_back(mlir::IntegerAttr::get(rewriter.getI32Type(), index));
-      }
-    }
-    return attrs;
-  }
-
-private:
-  static unsigned getDimension(mlir::LLVM::LLVMArrayType ty) {
-    unsigned result = 1;
-    for (auto eleTy = ty.getElementType().dyn_cast<mlir::LLVM::LLVMArrayType>();
-         eleTy;
-         eleTy = eleTy.getElementType().dyn_cast<mlir::LLVM::LLVMArrayType>())
-      ++result;
-    return result;
-  }
-
-  static mlir::Type getArrayElementType(mlir::LLVM::LLVMArrayType ty) {
-    auto eleTy = ty.getElementType();
-    while (auto arrTy = eleTy.dyn_cast<mlir::LLVM::LLVMArrayType>())
-      eleTy = arrTy.getElementType();
-    return eleTy;
-  }
-};
-
-/// Extract a subobject value from an ssa-value of aggregate type
-struct ExtractValueOpConversion
-    : public FIROpAndTypeConversion<fir::ExtractValueOp>,
-      public ValueOpCommon {
-  using FIROpAndTypeConversion::FIROpAndTypeConversion;
-
-  mlir::LogicalResult
-  doRewrite(fir::ExtractValueOp extractVal, mlir::Type ty, OpAdaptor adaptor,
-            mlir::ConversionPatternRewriter &rewriter) const override {
-    auto attrs = collectIndices(rewriter, extractVal.coor());
-    toRowMajor(attrs, adaptor.getOperands()[0].getType());
-    auto position = mlir::ArrayAttr::get(extractVal.getContext(), attrs);
-    rewriter.replaceOpWithNewOp<mlir::LLVM::ExtractValueOp>(
-        extractVal, ty, adaptor.getOperands()[0], position);
-    return success();
-  }
-};
-
-/// InsertValue is the generalized instruction for the composition of new
-/// aggregate type values.
-struct InsertValueOpConversion
-    : public FIROpAndTypeConversion<fir::InsertValueOp>,
-      public ValueOpCommon {
-  using FIROpAndTypeConversion::FIROpAndTypeConversion;
-
-  mlir::LogicalResult
-  doRewrite(fir::InsertValueOp insertVal, mlir::Type ty, OpAdaptor adaptor,
-            mlir::ConversionPatternRewriter &rewriter) const override {
-    auto attrs = collectIndices(rewriter, insertVal.coor());
-    toRowMajor(attrs, adaptor.getOperands()[0].getType());
-    auto position = mlir::ArrayAttr::get(insertVal.getContext(), attrs);
-    rewriter.replaceOpWithNewOp<mlir::LLVM::InsertValueOp>(
-        insertVal, ty, adaptor.getOperands()[0], adaptor.getOperands()[1],
-        position);
-    return success();
-  }
-};
-
 /// InsertOnRange inserts a value into a sequence over a range of offsets.
 struct InsertOnRangeOpConversion
     : public FIROpAndTypeConversion<fir::InsertOnRangeOp> {
@@ -488,11 +389,10 @@ class FIRToLLVMLowering : public fir::FIRToLLVMLoweringBase<FIRToLLVMLowering> {
     auto *context = getModule().getContext();
     fir::LLVMTypeConverter typeConverter{getModule()};
     mlir::OwningRewritePatternList pattern(context);
-    pattern.insert<
-        AddrOfOpConversion, ExtractValueOpConversion, HasValueOpConversion,
-        GlobalOpConversion, InsertOnRangeOpConversion, InsertValueOpConversion,
-        SelectOpConversion, SelectRankOpConversion, UndefOpConversion,
-        UnreachableOpConversion, ZeroOpConversion>(typeConverter);
+    pattern.insert<AddrOfOpConversion, HasValueOpConversion, GlobalOpConversion,
+                   InsertOnRangeOpConversion, SelectOpConversion,
+                   SelectRankOpConversion, UnreachableOpConversion,
+                   ZeroOpConversion, UndefOpConversion>(typeConverter);
     mlir::populateStdToLLVMConversionPatterns(typeConverter, pattern);
     mlir::arith::populateArithmeticToLLVMConversionPatterns(typeConverter,
                                                             pattern);

flang/lib/Optimizer/CodeGen/DescriptorModel.h

@@ -13,9 +13,6 @@
 #ifndef FORTRAN_OPTIMIZER_CODEGEN_TYPECONVERTER_H
 #define FORTRAN_OPTIMIZER_CODEGEN_TYPECONVERTER_H
 
-#include "DescriptorModel.h"
-#include "flang/Lower/Todo.h" // remove when TODO's are done
-#include "llvm/ADT/StringMap.h"
 #include "llvm/Support/Debug.h"
 
 namespace fir {
@@ -29,35 +26,10 @@ class LLVMTypeConverter : public mlir::LLVMTypeConverter {
     LLVM_DEBUG(llvm::dbgs() << "FIR type converter\n");
 
     // Each conversion should return a value of type mlir::Type.
-    addConversion(
-        [&](fir::RecordType derived) { return convertRecordType(derived); });
     addConversion(
         [&](fir::ReferenceType ref) { return convertPointerLike(ref); });
     addConversion(
         [&](SequenceType sequence) { return convertSequenceType(sequence); });
-    addConversion([&](mlir::TupleType tuple) {
-      LLVM_DEBUG(llvm::dbgs() << "type convert: " << tuple << '\n');
-      llvm::SmallVector<mlir::Type> inMembers;
-      tuple.getFlattenedTypes(inMembers);
-      llvm::SmallVector<mlir::Type> members;
-      for (auto mem : inMembers)
-        members.push_back(convertType(mem).cast<mlir::Type>());
-      return mlir::LLVM::LLVMStructType::getLiteral(&getContext(), members,
-                                                    /*isPacked=*/false);
-    });
-  }
-
-  // fir.type<name(p : TY'...){f : TY...}>  -->  llvm<"%name = { ty... }">
-  mlir::Type convertRecordType(fir::RecordType derived) {
-    auto name = derived.getName();
-    auto st = mlir::LLVM::LLVMStructType::getIdentified(&getContext(), name);
-    llvm::SmallVector<mlir::Type> members;
-    for (auto mem : derived.getTypeList()) {
-      members.push_back(convertType(mem.second).cast<mlir::Type>());
-    }
-    if (mlir::succeeded(st.setBody(members, /*isPacked=*/false)))
-      return st;
-    return mlir::Type();
   }
 
   template <typename A>

flang/lib/Optimizer/CodeGen/TypeConverter.h

@@ -259,67 +259,3 @@ func @select_rank(%arg : i32, %arg2 : i32) -> i32 {
 // CHECK:           3: ^bb3(%[[ARG1]], %[[C2]] : i32, i32),
 // CHECK:           4: ^bb4(%[[C1]] : i32)
 // CHECK:         ]
-
-// -----
-
-// Test fir.extract_value operation conversion with derived type.
-
-func @extract_derived_type() -> f32 {
-  %0 = fir.undefined !fir.type<derived{f:f32}>
-  %1 = fir.extract_value %0, ["f", !fir.type<derived{f:f32}>] : (!fir.type<derived{f:f32}>) -> f32
-  return %1 : f32
-}
-
-// CHECK-LABEL: llvm.func @extract_derived_type
-// CHECK:         %[[STRUCT:.*]] = llvm.mlir.undef : !llvm.struct<"derived", (f32)>
-// CHECK:         %[[VALUE:.*]] = llvm.extractvalue %[[STRUCT]][0 : i32] : !llvm.struct<"derived", (f32)>
-// CHECK:         llvm.return %[[VALUE]] : f32
-
-// -----
-
-// Test fir.extract_value operation conversion with a multi-dimensional array
-// of tuple.
-
-func @extract_array(%a : !fir.array<10x10xtuple<i32, f32>>) -> f32 {
-  %0 = fir.extract_value %a, [5 : index, 4 : index, 1 : index] : (!fir.array<10x10xtuple<i32, f32>>) -> f32
-  return %0 : f32
-}
-
-// CHECK-LABEL: llvm.func @extract_array(
-// CHECK-SAME:                           %[[ARR:.*]]: !llvm.array<10 x array<10 x struct<(i32, f32)>>>
-// CHECK:         %[[VALUE:.*]] = llvm.extractvalue %[[ARR]][4 : index, 5 : index, 1 : index] : !llvm.array<10 x array<10 x struct<(i32, f32)>>>
-// CHECK:         llvm.return %[[VALUE]] : f32
-
-// -----
-
-// Test fir.insert_value operation conversion with a multi-dimensional array
-// of tuple.
-
-func @extract_array(%a : !fir.array<10x10xtuple<i32, f32>>) {
-  %f = arith.constant 2.0 : f32
-  %i = arith.constant 1 : i32
-  %0 = fir.insert_value %a, %i, [5 : index, 4 : index, 0 : index] : (!fir.array<10x10xtuple<i32, f32>>, i32) -> !fir.array<10x10xtuple<i32, f32>>
-  %1 = fir.insert_value %a, %f, [5 : index, 4 : index, 1 : index] : (!fir.array<10x10xtuple<i32, f32>>, f32) -> !fir.array<10x10xtuple<i32, f32>>
-  return
-}
-
-// CHECK-LABEL: llvm.func @extract_array(
-// CHECK-SAME:                           %[[ARR:.*]]: !llvm.array<10 x array<10 x struct<(i32, f32)>>>
-// CHECK:         %{{.*}} = llvm.insertvalue %{{.*}}, %[[ARR]][4 : index, 5 : index, 0 : index] : !llvm.array<10 x array<10 x struct<(i32, f32)>>>
-// CHECK:         %{{.*}} = llvm.insertvalue %{{.*}}, %[[ARR]][4 : index, 5 : index, 1 : index] : !llvm.array<10 x array<10 x struct<(i32, f32)>>>
-// CHECK:         llvm.return
-
-// -----
-
-// Test fir.insert_value operation conversion with derived type.
-
-func @insert_tuple(%a : tuple<i32, f32>) {
-  %f = arith.constant 2.0 : f32
-  %1 = fir.insert_value %a, %f, [1 : index] : (tuple<i32, f32>, f32) -> tuple<i32, f32>
-  return
-}
-
-// CHECK-LABEL: func @insert_tuple(
-// CHECK-SAME:                     %[[TUPLE:.*]]: !llvm.struct<(i32, f32)>
-// CHECK:         %{{.*}} = llvm.insertvalue %{{.*}}, %[[TUPLE]][1 : index] : !llvm.struct<(i32, f32)>
-// CHECK:         llvm.return