[flang][NFC] Add source location information to report unsupported complex types

[clementval]

Summary

This patch is part of the upstreaming effort from fir-dev branch.

Co-authored-by: Eric Schweitz <[e-mail]>

[jeanPerier]

LGTM

[PeteSteinfeld]

All builds and tests correctly, but it would be better to use calls to TODO() to emit not yet implemented messages.

flang/lib/Optimizer/CodeGen/Target.cpp

112

I'd rather see a call to TODO() here.

141

Better to make this a call to TODO().

160

Same here.

186

Same here.

203

And here.

295

And here.

[clementval]

Switch to TODOs

[PeteSteinfeld]

Thanks, Valentin!

flang/lib/Optimizer/CodeGen/Target.h

public:
   virtual ~CodeGenSpecifics() {}
 
   /// Type presentation of a `complex<ele>` type value in memory.
   virtual mlir::Type complexMemoryType(mlir::Type eleTy) const = 0;
 
   /// Type representation of a `complex<eleTy>` type argument when passed by
   /// value. An argument value may need to be passed as a (safe) reference
   /// argument.
-  virtual Marshalling complexArgumentType(mlir::Type eleTy) const = 0;
+  virtual Marshalling complexArgumentType(mlir::Location loc,
+                                          mlir::Type eleTy) const = 0;
 
   /// Type representation of a `complex<eleTy>` type return value. Such a return
   /// value may need to be converted to a hidden reference argument.
-  virtual Marshalling complexReturnType(mlir::Type eleTy) const = 0;
+  virtual Marshalling complexReturnType(mlir::Location loc,
+                                        mlir::Type eleTy) const = 0;
 
   /// Type presentation of a `boxchar<n>` type value in memory.
   virtual mlir::Type boxcharMemoryType(mlir::Type eleTy) const = 0;
 
   /// Type representation of a `boxchar<n>` type argument when passed by value.
   /// An argument value may need to be passed as a (safe) reference argument.
   ///
   /// A function that returns a `boxchar<n>` type value must already have

flang/lib/Optimizer/CodeGen/Target.cpp

 //===-- Target.cpp --------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Coding style: https://mlir.llvm.org/getting_started/DeveloperGuide/
 //
 //===----------------------------------------------------------------------===//
 
 #include "Target.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
+#include "flang/Optimizer/Support/FatalError.h"
 #include "flang/Optimizer/Support/KindMapping.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/TypeRange.h"
 
 #define DEBUG_TYPE "flang-codegen-target"
 
 using namespace fir;
 

 
 namespace {
 struct TargetI386 : public GenericTarget<TargetI386> {
   using GenericTarget::GenericTarget;
 
   static constexpr int defaultWidth = 32;
 
   CodeGenSpecifics::Marshalling
-  complexArgumentType(mlir::Type eleTy) const override {
+  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, byval, align 4
     mlir::TypeRange range = {eleTy, eleTy};
     auto structTy = mlir::TupleType::get(eleTy.getContext(), range);
     marshal.emplace_back(fir::ReferenceType::get(structTy),
                          AT{/*alignment=*/4, /*byval=*/true});
     return marshal;
   }
 
   CodeGenSpecifics::Marshalling
-  complexReturnType(mlir::Type eleTy) const override {
+  complexReturnType(mlir::Location loc, mlir::Type eleTy) const override {
     assert(fir::isa_real(eleTy));
     CodeGenSpecifics::Marshalling marshal;
     const auto *sem = &floatToSemantics(kindMap, eleTy);
     if (sem == &llvm::APFloat::IEEEsingle()) {
       // i64   pack both floats in a 64-bit GPR
       marshal.emplace_back(mlir::IntegerType::get(eleTy.getContext(), 64),
                            AT{});
     } else if (sem == &llvm::APFloat::IEEEdouble()) {
       // Use a type that will be translated into LLVM as:
       // { t, t }   struct of 2 eleTy, sret, align 4
       mlir::TypeRange range = {eleTy, eleTy};
       auto structTy = mlir::TupleType::get(eleTy.getContext(), range);
       marshal.emplace_back(fir::ReferenceType::get(structTy),
                            AT{/*alignment=*/4, /*byval=*/false, /*sret=*/true});
     } else {
-      llvm::report_fatal_error("complex for this precision not implemented");
+      fir::emitFatalError(loc, "complex for this precision not implemented");
     }
     return marshal;
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // x86_64 (x86 64 bit) linux target specifics.
 //===----------------------------------------------------------------------===//
 
 namespace {
 struct TargetX86_64 : public GenericTarget<TargetX86_64> {
   using GenericTarget::GenericTarget;
 
   static constexpr int defaultWidth = 64;
 
   CodeGenSpecifics::Marshalling
-  complexArgumentType(mlir::Type eleTy) const override {
+  complexArgumentType(mlir::Location loc, mlir::Type eleTy) const override {
     CodeGenSpecifics::Marshalling marshal;
     const auto *sem = &floatToSemantics(kindMap, eleTy);
     if (sem == &llvm::APFloat::IEEEsingle()) {
       // <2 x t>   vector of 2 eleTy
       marshal.emplace_back(fir::VectorType::get(2, eleTy), AT{});
     } else if (sem == &llvm::APFloat::IEEEdouble()) {
       // two distinct double arguments
       marshal.emplace_back(eleTy, AT{});
       marshal.emplace_back(eleTy, AT{});
     } else {
-      llvm::report_fatal_error("complex for this precision not implemented");
+      fir::emitFatalError(loc, "complex for this precision not implemented");
     }
     return marshal;
   }
 
   CodeGenSpecifics::Marshalling
-  complexReturnType(mlir::Type eleTy) const override {
+  complexReturnType(mlir::Location loc, mlir::Type eleTy) const override {
     CodeGenSpecifics::Marshalling marshal;
     const auto *sem = &floatToSemantics(kindMap, eleTy);
     if (sem == &llvm::APFloat::IEEEsingle()) {
       // <2 x t>   vector of 2 eleTy
       marshal.emplace_back(fir::VectorType::get(2, eleTy), AT{});
     } else if (sem == &llvm::APFloat::IEEEdouble()) {
       // Use a type that will be translated into LLVM as:
       // { double, double }   struct of 2 double
       mlir::TypeRange range = {eleTy, eleTy};
       marshal.emplace_back(mlir::TupleType::get(eleTy.getContext(), range),
                            AT{});
     } else {
-      llvm::report_fatal_error("complex for this precision not implemented");
+      fir::emitFatalError(loc, "complex for this precision not implemented");
     }
     return marshal;
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // AArch64 linux target specifics.
 //===----------------------------------------------------------------------===//
 
 namespace {
 struct TargetAArch64 : public GenericTarget<TargetAArch64> {
   using GenericTarget::GenericTarget;
 
   static constexpr int defaultWidth = 64;
 
   CodeGenSpecifics::Marshalling
-  complexArgumentType(mlir::Type eleTy) const override {
+  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()) {
       // [2 x t]   array of 2 eleTy
       marshal.emplace_back(fir::SequenceType::get({2}, eleTy), AT{});
     } else {
-      llvm::report_fatal_error("complex for this precision not implemented");
+      fir::emitFatalError(loc, "complex for this precision not implemented");
     }
     return marshal;
   }
 
   CodeGenSpecifics::Marshalling
-  complexReturnType(mlir::Type eleTy) const override {
+  complexReturnType(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()) {
       // Use a type that will be translated into LLVM as:
       // { t, t }   struct of 2 eleTy
       mlir::TypeRange range = {eleTy, eleTy};
       marshal.emplace_back(mlir::TupleType::get(eleTy.getContext(), range),
                            AT{});
     } else {
-      llvm::report_fatal_error("complex for this precision not implemented");
+      fir::emitFatalError(loc, "complex for this precision not implemented");
     }
     return marshal;
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // PPC64le linux target specifics.
 //===----------------------------------------------------------------------===//
 
 namespace {
 struct TargetPPC64le : public GenericTarget<TargetPPC64le> {
   using GenericTarget::GenericTarget;
 
   static constexpr int defaultWidth = 64;
 
   CodeGenSpecifics::Marshalling
-  complexArgumentType(mlir::Type eleTy) const override {
+  complexArgumentType(mlir::Location, mlir::Type eleTy) const override {
     CodeGenSpecifics::Marshalling marshal;
     // two distinct element type arguments (re, im)
     marshal.emplace_back(eleTy, AT{});
     marshal.emplace_back(eleTy, AT{});
     return marshal;
   }
 
   CodeGenSpecifics::Marshalling
-  complexReturnType(mlir::Type eleTy) const override {
+  complexReturnType(mlir::Location, mlir::Type eleTy) const override {
     CodeGenSpecifics::Marshalling marshal;
     // Use a type that will be translated into LLVM as:
     // { t, t }   struct of 2 element type
     mlir::TypeRange range = {eleTy, eleTy};
     marshal.emplace_back(mlir::TupleType::get(eleTy.getContext(), range), AT{});
     return marshal;
   }
 };
case llvm::Triple::ArchType::ppc64le:
     default:
       break;
     case llvm::Triple::OSType::Linux:
       return std::make_unique<TargetPPC64le>(ctx, std::move(trp),
                                              std::move(kindMap));
     }
     break;
   }
-  llvm::report_fatal_error("target not implemented");
+  fir::emitFatalError(mlir::UnknownLoc::get(ctx), "target not implemented");
 }

flang/lib/Optimizer/CodeGen/TargetRewrite.cpp

void runOnOperation() override final {
 
     clearMembers();
   }
 
   mlir::ModuleOp getModule() { return getOperation(); }
 
   template <typename A, typename B, typename C>
   std::function<mlir::Value(mlir::Operation *)>
-  rewriteCallComplexResultType(A ty, B &newResTys, B &newInTys, C &newOpers) {
-    auto m = specifics->complexReturnType(ty.getElementType());
+  rewriteCallComplexResultType(mlir::Location loc, A ty, B &newResTys,
+                               B &newInTys, C &newOpers) {
+    auto m = specifics->complexReturnType(loc, ty.getElementType());
     // Currently targets mandate COMPLEX is a single aggregate or packed
     // scalar, including the sret case.
     assert(m.size() == 1 && "target lowering of complex return not supported");
     auto resTy = std::get<mlir::Type>(m[0]);
     auto attr = std::get<fir::CodeGenSpecifics::Attributes>(m[0]);
-    auto loc = mlir::UnknownLoc::get(resTy.getContext());
     if (attr.isSRet()) {
       assert(fir::isa_ref_type(resTy) && "must be a memory reference type");
       mlir::Value stack =
           rewriter->create<fir::AllocaOp>(loc, fir::dyn_cast_ptrEleTy(resTy));
       newInTys.push_back(resTy);
       newOpers.push_back(stack);
       return [=](mlir::Operation *) -> mlir::Value {
         auto memTy = fir::ReferenceType::get(ty);
return [=](mlir::Operation *call) -> mlir::Value {
       auto cast = rewriter->create<fir::ConvertOp>(loc, memTy, mem);
       return rewriter->create<fir::LoadOp>(loc, cast);
     };
   }
 
   template <typename A, typename B, typename C>
   void rewriteCallComplexInputType(A ty, mlir::Value oper, B &newInTys,
                                    C &newOpers) {
-    auto m = specifics->complexArgumentType(ty.getElementType());
     auto *ctx = ty.getContext();
-    auto loc = mlir::UnknownLoc::get(ctx);
+    mlir::Location loc = mlir::UnknownLoc::get(ctx);
+    if (auto *op = oper.getDefiningOp())
+      loc = op->getLoc();
+    auto m = specifics->complexArgumentType(loc, ty.getElementType());
     if (m.size() == 1) {
       // COMPLEX is a single aggregate
       auto resTy = std::get<mlir::Type>(m[0]);
       auto attr = std::get<fir::CodeGenSpecifics::Attributes>(m[0]);
       auto oldRefTy = fir::ReferenceType::get(ty);
       if (attr.isByVal()) {
         auto mem = rewriter->create<fir::AllocaOp>(loc, ty);
         rewriter->create<fir::StoreOp>(loc, oper, mem);
void convertCallOp(A callOp) {
     }
 
     // Determine the rewrite function, `wrap`, for the result value.
     llvm::Optional<std::function<mlir::Value(mlir::Operation *)>> wrap;
     if (fnTy.getResults().size() == 1) {
       mlir::Type ty = fnTy.getResult(0);
       llvm::TypeSwitch<mlir::Type>(ty)
           .template Case<fir::ComplexType>([&](fir::ComplexType cmplx) {
-            wrap = rewriteCallComplexResultType(cmplx, newResTys, newInTys,
+            wrap = rewriteCallComplexResultType(loc, cmplx, newResTys, newInTys,
                                                 newOpers);
           })
           .template Case<mlir::ComplexType>([&](mlir::ComplexType cmplx) {
-            wrap = rewriteCallComplexResultType(cmplx, newResTys, newInTys,
+            wrap = rewriteCallComplexResultType(loc, cmplx, newResTys, newInTys,
                                                 newOpers);
           })
           .Default([&](mlir::Type ty) { newResTys.push_back(ty); });
     } else if (fnTy.getResults().size() > 1) {
       TODO(loc, "multiple results not supported yet");
     }
 
     llvm::SmallVector<mlir::Type> trailingInTys;
void convertCallOp(A callOp) {
     } else {
       // A is fir::DispatchOp
       TODO(loc, "dispatch not implemented");
     }
   }
 
   // Result type fixup for fir::ComplexType and mlir::ComplexType
   template <typename A, typename B>
-  void lowerComplexSignatureRes(A cmplx, B &newResTys, B &newInTys) {
+  void lowerComplexSignatureRes(mlir::Location loc, A cmplx, B &newResTys,
+                                B &newInTys) {
     if (noComplexConversion) {
       newResTys.push_back(cmplx);
     } else {
-      for (auto &tup : specifics->complexReturnType(cmplx.getElementType())) {
+      for (auto &tup :
+           specifics->complexReturnType(loc, cmplx.getElementType())) {
         auto argTy = std::get<mlir::Type>(tup);
         if (std::get<fir::CodeGenSpecifics::Attributes>(tup).isSRet())
           newInTys.push_back(argTy);
         else
           newResTys.push_back(argTy);
       }
     }
   }
 
   // Argument type fixup for fir::ComplexType and mlir::ComplexType
   template <typename A, typename B>
-  void lowerComplexSignatureArg(A cmplx, B &newInTys) {
+  void lowerComplexSignatureArg(mlir::Location loc, A cmplx, B &newInTys) {
     if (noComplexConversion)
       newInTys.push_back(cmplx);
     else
-      for (auto &tup : specifics->complexArgumentType(cmplx.getElementType()))
+      for (auto &tup :
+           specifics->complexArgumentType(loc, cmplx.getElementType()))
         newInTys.push_back(std::get<mlir::Type>(tup));
   }
 
   /// Taking the address of a function. Modify the signature as needed.
   void convertAddrOp(fir::AddrOfOp addrOp) {
     rewriter->setInsertionPoint(addrOp);
     auto addrTy = addrOp.getType().cast<mlir::FunctionType>();
     llvm::SmallVector<mlir::Type> newResTys;
     llvm::SmallVector<mlir::Type> newInTys;
+    auto loc = addrOp.getLoc();
     for (mlir::Type ty : addrTy.getResults()) {
       llvm::TypeSwitch<mlir::Type>(ty)
           .Case<fir::ComplexType>([&](fir::ComplexType ty) {
-            lowerComplexSignatureRes(ty, newResTys, newInTys);
+            lowerComplexSignatureRes(loc, ty, newResTys, newInTys);
           })
           .Case<mlir::ComplexType>([&](mlir::ComplexType ty) {
-            lowerComplexSignatureRes(ty, newResTys, newInTys);
+            lowerComplexSignatureRes(loc, ty, newResTys, newInTys);
           })
           .Default([&](mlir::Type ty) { newResTys.push_back(ty); });
     }
     llvm::SmallVector<mlir::Type> trailingInTys;
     for (mlir::Type ty : addrTy.getInputs()) {
       llvm::TypeSwitch<mlir::Type>(ty)
           .Case<fir::BoxCharType>([&](auto box) {
             if (noCharacterConversion) {
               newInTys.push_back(box);
             } else {
               for (auto &tup : specifics->boxcharArgumentType(box.getEleTy())) {
                 auto attr = std::get<fir::CodeGenSpecifics::Attributes>(tup);
                 auto argTy = std::get<mlir::Type>(tup);
                 llvm::SmallVector<mlir::Type> &vec =
                     attr.isAppend() ? trailingInTys : newInTys;
                 vec.push_back(argTy);
               }
             }
           })
           .Case<fir::ComplexType>([&](fir::ComplexType ty) {
-            lowerComplexSignatureArg(ty, newInTys);
+            lowerComplexSignatureArg(loc, ty, newInTys);
           })
           .Case<mlir::ComplexType>([&](mlir::ComplexType ty) {
-            lowerComplexSignatureArg(ty, newInTys);
+            lowerComplexSignatureArg(loc, ty, newInTys);
           })
           .Case<mlir::TupleType>([&](mlir::TupleType tuple) {
             if (fir::isCharacterProcedureTuple(tuple)) {
               newInTys.push_back(tuple.getType(0));
               trailingInTys.push_back(tuple.getType(1));
             } else {
               newInTys.push_back(ty);
             }
public:
   /// GPR.
   template <typename A, typename B, typename C>
   void doComplexReturn(mlir::func::FuncOp func, A cmplx, B &newResTys,
                        B &newInTys, C &fixups) {
     if (noComplexConversion) {
       newResTys.push_back(cmplx);
       return;
     }
-    auto m = specifics->complexReturnType(cmplx.getElementType());
+    auto m =
+        specifics->complexReturnType(func.getLoc(), cmplx.getElementType());
     assert(m.size() == 1);
     auto &tup = m[0];
     auto attr = std::get<fir::CodeGenSpecifics::Attributes>(tup);
     auto argTy = std::get<mlir::Type>(tup);
     if (attr.isSRet()) {
       unsigned argNo = newInTys.size();
       fixups.emplace_back(
           FixupTy::Codes::ReturnAsStore, argNo, [=](mlir::func::FuncOp func) {
public:
   /// a temporary memory location or factoring the value into two distinct
   /// arguments.
   template <typename A, typename B, typename C>
   void doComplexArg(mlir::func::FuncOp func, A cmplx, B &newInTys, C &fixups) {
     if (noComplexConversion) {
       newInTys.push_back(cmplx);
       return;
     }
-    auto m = specifics->complexArgumentType(cmplx.getElementType());
+    auto m =
+        specifics->complexArgumentType(func.getLoc(), cmplx.getElementType());
     const auto fixupCode =
         m.size() > 1 ? FixupTy::Codes::Split : FixupTy::Codes::ArgumentType;
     for (auto e : llvm::enumerate(m)) {
       auto &tup = e.value();
       auto index = e.index();
       auto attr = std::get<fir::CodeGenSpecifics::Attributes>(tup);
       auto argTy = std::get<mlir::Type>(tup);
       auto argNo = newInTys.size();