[flang] Add Sparc support to Optimizer/CodeGen/Target.cpp

[ro]

Summary

As described in Issue #57642, flang currently lacks SPARC support in Optimizer/CodeGen/Target.cpp, which causes a considerable number of tests to FAIL with

error: flang/lib/Optimizer/CodeGen/Target.cpp:310: not yet implemented: target not implemented

This patch fixes this by following GCC`s documentation of the ABI described in the Issue.

Tested on sparcv9-sun-solaris2.11.

I'm not fully certain I've done this correctly, so extra scrutiny would be most welcome. Besides, I wonder why flang has to do this at all (and for complex values only) since the SPARC backend knows how to handle complex args and return values just fine.

[rovka]

This doesn't have any tests, could you please add some? If memory holds, you should be able to add some RUN/CHECK lines here: https://github.com/llvm/llvm-project/blob/main/flang/test/Fir/target-rewrite-complex.fir

[ro]

Add testcase.

[ro]

In D133561#3792286, @rovka wrote:

This doesn't have any tests, could you please add some? If memory holds, you should be able to add some RUN/CHECK lines here: https://github.com/llvm/llvm-project/blob/main/flang/test/Fir/target-rewrite-complex.fir

The new testcase PASSes on sparcv9-sun-solaris2.11 and sparc64-unknown-linux-gnu. However, for 32-bit sparc it runs into an assertion failure

Assertion failed: llvm::all_of(types, [](Type t) { return t; }) && "attempting to construct a TypeRange with null types", file /vol/llvm/src/llvm-project/local/mlir/lib/IR/TypeRange.cpp, line 20

and I don't yet see what's wrong. Any suggestions or do I need to run a full Debug build to investigate?

[rovka]

In D133561#3808337, @ro wrote:

In D133561#3792286, @rovka wrote:

This doesn't have any tests, could you please add some? If memory holds, you should be able to add some RUN/CHECK lines here: https://github.com/llvm/llvm-project/blob/main/flang/test/Fir/target-rewrite-complex.fir

The new testcase PASSes on sparcv9-sun-solaris2.11 and sparc64-unknown-linux-gnu. However, for 32-bit sparc it runs into an assertion failure

Assertion failed: llvm::all_of(types, [](Type t) { return t; }) && "attempting to construct a TypeRange with null types", file /vol/llvm/src/llvm-project/local/mlir/lib/IR/TypeRange.cpp, line 20

and I don't yet see what's wrong. Any suggestions or do I need to run a full Debug build to investigate?

Not sure what the issue is there. I'm actually a bit surprised that it works for i386. When I tried to enable flang for armv7, MLIR didn't have very good support for 32-bit platforms, so I left it at that. If you know that users of 32-bit sparc really have a great need for a Fortran compiler, then feel free to investigate further, but I'm not sure how many other 32-bit platforms have an interest in flang/mlir, so maintaining it might turn out to be a non-trivial amount of work.

Otherwise, thanks for the test, this LGTM now. However I'm not familiar with the SPARC ABI - do you know anyone that usually reviews SPARC patches and could have a look at this before it gets committed?

flang/test/Fir/target-rewrite-complex.fir

5 ↗

(On Diff #462148)

Nit: It would be nice to also test a Linux triple here (it can use the same check prefix as Solaris).

[ro]

In D133561#3817542, @rovka wrote:

In D133561#3808337, @ro wrote:

In D133561#3792286, @rovka wrote:

This doesn't have any tests, could you please add some? If memory holds, you should be able to add some RUN/CHECK lines here: https://github.com/llvm/llvm-project/blob/main/flang/test/Fir/target-rewrite-complex.fir

The new testcase PASSes on sparcv9-sun-solaris2.11 and sparc64-unknown-linux-gnu. However, for 32-bit sparc it runs into an assertion failure

[...]

Not sure what the issue is there. I'm actually a bit surprised that it works for i386. When I tried to enable flang for armv7, MLIR didn't have very good support for 32-bit platforms, so I left it at that. If you know that users of 32-bit sparc really have a great need for a Fortran compiler, then feel free to investigate further, but I'm not sure how many other 32-bit platforms have an interest in flang/mlir, so maintaining it might turn out to be a non-trivial amount of work.

I don't think there will be great need for 32-bit support, so I'll leave this 64-bit only for now. Maybe others will have the inclination to dive further and sparc can benefit ;-)

Otherwise, thanks for the test, this LGTM now. However I'm not familiar with the SPARC ABI - do you know anyone that usually reviews SPARC patches and could have a look at this before it gets committed?

I've added some of the usual suspects as reviewers. However, given that SPARC lacks maintainers in LLVM, that's always been difficult.

flang/test/Fir/target-rewrite-complex.fir

5 ↗

(On Diff #462148)

Will do. It should be helpful because Solaris and Linux differ in their long double type, although LLVM is pretty broken in that respect right now.

[ro]

Run test on Linux/sparc64, too.

[ro]

Given that there were no comments from the SPARC reviewers in more than a week, I've now committed the patch as is.

flang/lib/Optimizer/CodeGen/Target.cpp

complexReturnType(mlir::Location, mlir::Type eleTy) const override {
     // { t, t }   struct of 2 element type
     mlir::TypeRange range = {eleTy, eleTy};
     marshal.emplace_back(mlir::TupleType::get(eleTy.getContext(), range), AT{});
     return marshal;
   }
 };
 } // namespace
 
+//===----------------------------------------------------------------------===//
+// sparc (sparc 32 bit) target specifics.
+//===----------------------------------------------------------------------===//
+
+namespace {
+struct TargetSparc : public GenericTarget<TargetSparc> {
+  using GenericTarget::GenericTarget;
+
+  static constexpr int defaultWidth = 32;
+
+  CodeGenSpecifics::Marshalling
+  complexArgumentType(mlir::Location, mlir::Type eleTy) const override {
+    assert(fir::isa_real(eleTy));
+    CodeGenSpecifics::Marshalling marshal;
+    // Use a type that will be translated into LLVM as:
+    // { t, t }   struct of 2 eleTy
+    mlir::TypeRange range = {eleTy, eleTy};
+    auto structTy = mlir::TupleType::get(eleTy.getContext(), range);
+    marshal.emplace_back(fir::ReferenceType::get(structTy), AT{});
+    return marshal;
+  }
+
+  CodeGenSpecifics::Marshalling
+  complexReturnType(mlir::Location loc, mlir::Type eleTy) const override {
+    assert(fir::isa_real(eleTy));
+    CodeGenSpecifics::Marshalling marshal;
+    // Use a type that will be translated into LLVM as:
+    // { t, t }   struct of 2 eleTy, byval
+    mlir::TypeRange range = {eleTy, eleTy};
+    auto structTy = mlir::TupleType::get(eleTy.getContext(), range);
+    marshal.emplace_back(fir::ReferenceType::get(structTy),
+                         AT{/*alignment=*/0, /*byval=*/true});
+    return marshal;
+  }
+};
+} // namespace
+
+//===----------------------------------------------------------------------===//
+// sparcv9 (sparc 64 bit) target specifics.
+//===----------------------------------------------------------------------===//
+
+namespace {
+struct TargetSparcV9 : public GenericTarget<TargetSparcV9> {
+  using GenericTarget::GenericTarget;
+
+  static constexpr int defaultWidth = 64;
+
+  CodeGenSpecifics::Marshalling
+  complexArgumentType(mlir::Location loc, mlir::Type eleTy) const override {
+    CodeGenSpecifics::Marshalling marshal;
+    const auto *sem = &floatToSemantics(kindMap, eleTy);
+    if (sem == &llvm::APFloat::IEEEsingle() ||
+        sem == &llvm::APFloat::IEEEdouble()) {
+      // two distinct float, double arguments
+      marshal.emplace_back(eleTy, AT{});
+      marshal.emplace_back(eleTy, AT{});
+    } else if (sem == &llvm::APFloat::IEEEquad()) {
+      // Use a type that will be translated into LLVM as:
+      // { fp128, fp128 }   struct of 2 fp128, byval, align 16
+      mlir::TypeRange range = {eleTy, eleTy};
+      marshal.emplace_back(fir::ReferenceType::get(
+                               mlir::TupleType::get(eleTy.getContext(), range)),
+                           AT{/*align=*/16, /*byval=*/true});
+    } else {
+      TODO(loc, "complex for this precision");
+    }
+    return marshal;
+  }
+
+  CodeGenSpecifics::Marshalling
+  complexReturnType(mlir::Location loc, mlir::Type eleTy) const override {
+    CodeGenSpecifics::Marshalling marshal;
+    // Use a type that will be translated into LLVM as:
+    // { eleTy, eleTy }   struct of 2 eleTy
+    mlir::TypeRange range = {eleTy, eleTy};
+    marshal.emplace_back(mlir::TupleType::get(eleTy.getContext(), range), AT{});
+    return marshal;
+  }
+};
+} // namespace
+
 // Instantiate the overloaded target instance based on the triple value.
 // TODO: Add other targets to this file as needed.
 std::unique_ptr<fir::CodeGenSpecifics>
 fir::CodeGenSpecifics::get(mlir::MLIRContext *ctx, llvm::Triple &&trp,
                            KindMapping &&kindMap) {
   switch (trp.getArch()) {
   default:
     break;
case llvm::Triple::ArchType::ppc64le:
     switch (trp.getOS()) {
     default:
       break;
     case llvm::Triple::OSType::Linux:
       return std::make_unique<TargetPPC64le>(ctx, std::move(trp),
                                              std::move(kindMap));
     }
     break;
+  case llvm::Triple::ArchType::sparc:
+    switch (trp.getOS()) {
+    default:
+      break;
+    case llvm::Triple::OSType::Linux:
+    case llvm::Triple::OSType::Solaris:
+      return std::make_unique<TargetSparc>(ctx, std::move(trp),
+                                           std::move(kindMap));
+    }
+    break;
+  case llvm::Triple::ArchType::sparcv9:
+    switch (trp.getOS()) {
+    default:
+      break;
+    case llvm::Triple::OSType::Linux:
+    case llvm::Triple::OSType::Solaris:
+      return std::make_unique<TargetSparcV9>(ctx, std::move(trp),
+                                             std::move(kindMap));
+    }
+    break;
   }
   TODO(mlir::UnknownLoc::get(ctx), "target not implemented");
 }