[flang] Use proper attributes for runtime calls with 'i1' arguments/returns.

[vzakhari]

Summary

Clang uses signext/zeroext attributes for integer arguments shorter than
the default 'int' type on a target. So Flang has to match this for functions
from Fortran runtime and also for BIND(C) routines. This patch implements
ABI adjustments only for Fortran runtime calls. BIND(C) part will be done
separately.

This resolves https://github.com/llvm/llvm-project/issues/58579

[vzakhari]

flang/lib/Optimizer/CodeGen/Target.cpp

216

I've been chasing segfaults caused by this commit in Windows ARM buildbot (e.g. https://lab.llvm.org/buildbot/#/builders/65/builds/7378).

It seems that the piece of code below is not working correctly:

mlir::TypeRange range = {eleTy, eleTy};
mlir::Type tupleTy = mlir::TupleType::get(eleTy.getContext(), range);
eleTy.dump();
tupleTy.dump();
mlir::Type newTy = mlir::TupleType::get(eleTy.getContext(), range);
newTy.dump();
marshal.emplace_back(newTy, AT{});

The printout is:

!fir.real<8>
tuple<!fir.real<8>, !fir.real<8>>
tuple<tuple<!fir.real<8>, !fir.real<8>>, !fir.real<8>>

Note the 3rd dump: it means the newTy was created as if the range held tupleTy and eleTy. So range is obviously pointing to the stack in a wrong way. Without my modifications we end up creating a TupleType with junk component types - this breaks everything after that.

I do not think the lifetime extension for the temporary underlying array of the initializer_list applies in this case, so all these range uses in the file seem to be invalid. I am not sure why my changes trigger the error. My only guess is that adding more virtual methods into the base class somehow affected optimizations.

I can get clean check-flang after fixing all instances of such TypeRange usage, so this is what I am going to do to finally make progress with this commit.

[vzakhari]

• rebase

[vzakhari]

• Fixed TypeRange usage.

[clementval]

flang/lib/Lower/IntrinsicCall.cpp

38 ↗

(On Diff #492967)

Do you still need it?

[vzakhari]

flang/lib/Lower/IntrinsicCall.cpp

38 ↗

(On Diff #492967)

It is not needed. Thanks!

[vzakhari]

• Removed redundant include.

[clementval]

Looks like there is a failure on Driver/target-cpu-features.f90. Not sure it is related.

[vzakhari]

In D142677#4091554, @clementval wrote:

Looks like there is a failure on Driver/target-cpu-features.f90. Not sure it is related.

I think it is due to D142548. I will fix it separately.

@dmgreen, FYI

[clementval]

LGTM

flang/include/flang/Optimizer/Builder/Runtime/RTBuilder.h

 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_OPTIMIZER_BUILDER_RUNTIME_RTBUILDER_H
 #define FORTRAN_OPTIMIZER_BUILDER_RUNTIME_RTBUILDER_H
 
 #include "flang/Common/Fortran.h"
 #include "flang/Common/uint128.h"
 #include "flang/Optimizer/Builder/FIRBuilder.h"
+#include "flang/Optimizer/Dialect/FIRDialect.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/MLIRContext.h"
 #include "llvm/ADT/SmallVector.h"
 #include <functional>
 
 // Incomplete type indicating C99 complex ABI in interfaces. Beware, _Complex
 // and std::complex are layout compatible, but not compatible in all ABI call
static mlir::func::FuncOp getRuntimeFunc(mlir::Location loc,
                                          fir::FirOpBuilder &builder) {
   using namespace Fortran::runtime;
   auto name = RuntimeEntry::name;
   auto func = builder.getNamedFunction(name);
   if (func)
     return func;
   auto funTy = RuntimeEntry::getTypeModel()(builder.getContext());
   func = builder.createFunction(loc, name, funTy);
-  func->setAttr("fir.runtime", builder.getUnitAttr());
+  func->setAttr(FIROpsDialect::getFirRuntimeAttrName(), builder.getUnitAttr());
   return func;
 }
 
 namespace helper {
 template <int N, typename A>
 void createArguments(llvm::SmallVectorImpl<mlir::Value> &result,
                      fir::FirOpBuilder &builder, mlir::Location loc,
                      mlir::FunctionType fTy, A arg) {

flang/include/flang/Optimizer/Dialect/FIRDialect.h

public:
   mlir::Type parseType(mlir::DialectAsmParser &parser) const override;
   void printType(mlir::Type ty, mlir::DialectAsmPrinter &p) const override;
 
   mlir::Attribute parseAttribute(mlir::DialectAsmParser &parser,
                                  mlir::Type type) const override;
   void printAttribute(mlir::Attribute attr,
                       mlir::DialectAsmPrinter &p) const override;
 
+  /// Return string name of fir.runtime attribute.
+  static constexpr llvm::StringRef getFirRuntimeAttrName() {
+    return "fir.runtime";
+  }
+
 private:
   // Register the Attributes of this dialect.
   void registerAttributes();
   // Register the Types of this dialect.
   void registerTypes();
 };
 
 /// The FIR codegen dialect is a dialect containing a small set of transient

flang/lib/Lower/IO.cpp

 #include "flang/Lower/StatementContext.h"
 #include "flang/Lower/Support/Utils.h"
 #include "flang/Lower/VectorSubscripts.h"
 #include "flang/Optimizer/Builder/Character.h"
 #include "flang/Optimizer/Builder/Complex.h"
 #include "flang/Optimizer/Builder/FIRBuilder.h"
 #include "flang/Optimizer/Builder/Runtime/RTBuilder.h"
 #include "flang/Optimizer/Builder/Todo.h"
+#include "flang/Optimizer/Dialect/FIRDialect.h"
 #include "flang/Optimizer/Support/FIRContext.h"
 #include "flang/Parser/parse-tree.h"
 #include "flang/Runtime/io-api.h"
 #include "flang/Semantics/tools.h"
 #include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
 #include "llvm/Support/Debug.h"
 #include <optional>
 

 static mlir::func::FuncOp getIORuntimeFunc(mlir::Location loc,
                                            fir::FirOpBuilder &builder) {
   llvm::StringRef name = getName<E>();
   mlir::func::FuncOp func = builder.getNamedFunction(name);
   if (func)
     return func;
   auto funTy = getTypeModel<E>()(builder.getContext());
   func = builder.createFunction(loc, name, funTy);
-  func->setAttr("fir.runtime", builder.getUnitAttr());
+  func->setAttr(fir::FIROpsDialect::getFirRuntimeAttrName(),
+                builder.getUnitAttr());
   func->setAttr("fir.io", builder.getUnitAttr());
   return func;
 }
 
 /// Generate calls to end an IO statement.  Return the IOSTAT value, if any.
 /// It is the caller's responsibility to generate branches on that value.
 static mlir::Value genEndIO(Fortran::lower::AbstractConverter &converter,
                             mlir::Location loc, mlir::Value cookie,

flang/lib/Optimizer/CodeGen/Target.h

 
 namespace details {
 /// Extra information about how to marshal an argument or return value that
 /// modifies a signature per a particular ABI's calling convention.
 /// Note: llvm::Attribute is not used directly, because its use depends on an
 /// LLVMContext.
 class Attributes {
 public:
+  enum class IntegerExtension { None, Zero, Sign };
+
   Attributes(unsigned short alignment = 0, bool byval = false,
-             bool sret = false, bool append = false)
-      : alignment{alignment}, byval{byval}, sret{sret}, append{append} {}
+             bool sret = false, bool append = false,
+             IntegerExtension intExt = IntegerExtension::None)
+      : alignment{alignment}, byval{byval}, sret{sret}, append{append},
+        intExt{intExt} {}
 
   unsigned getAlignment() const { return alignment; }
   bool hasAlignment() const { return alignment != 0; }
   bool isByVal() const { return byval; }
   bool isSRet() const { return sret; }
   bool isAppend() const { return append; }
+  bool isZeroExt() const { return intExt == IntegerExtension::Zero; }
+  bool isSignExt() const { return intExt == IntegerExtension::Sign; }
+  llvm::StringRef getIntExtensionAttrName() const;
 
 private:
   unsigned short alignment{};
   bool byval : 1;
   bool sret : 1;
   bool append : 1;
+  IntegerExtension intExt;
 };
 
 } // namespace details
 
 /// Some details of how to represent certain features depend on the target and
 /// ABI that is being used.  These specifics are captured here and guide the
 /// lowering of FIR to LLVM-IR dialect.
 class CodeGenSpecifics {
public:
   /// converted that return value to a parameter decorated with the 'sret'
   /// Attribute (https://llvm.org/docs/LangRef.html#parameter-attributes).
   /// This requirement is in keeping with Fortran semantics, which require the
   /// caller to allocate the space for the return CHARACTER value and pass
   /// a pointer and the length of that space (a boxchar) to the called function.
   virtual Marshalling boxcharArgumentType(mlir::Type eleTy,
                                           bool sret = false) const = 0;
 
+  // Compute ABI rules for an integer argument of the given mlir::IntegerType
+  // \p argTy. Note that this methods is supposed to be called for
+  // arguments passed by value not via reference, e.g. the 'i1' argument here:
+  //   declare i1 @_FortranAioOutputLogical(ptr, i1)
+  //
+  // \p loc is the location of the operation using/specifying the argument.
+  //
+  // Currently, the only supported marshalling is whether the argument
+  // should be zero or sign extended.
+  //
+  // The zero/sign extension is especially important to comply with the ABI
+  // used by C/C++ compiler that builds Fortran runtime. As in the above
+  // example the callee will expect the caller to zero extend the second
+  // argument up to the size of the C/C++'s 'int' type.
+  // The corresponding handling in clang is done in
+  // DefaultABIInfo::classifyArgumentType(), and the logic may brielfy
+  // be explained as some sort of extension is required if the integer
+  // type is shorter than the size of 'int' for the target.
+  // The related code is located in ASTContext::isPromotableIntegerType()
+  // and ABIInfo::isPromotableIntegerTypeForABI().
+  // In particular, the latter returns 'true' for 'bool', several kinds
+  // of 'char', 'short', 'wchar' and enumerated types.
+  // The type of the extensions (zero or sign) depends on the signedness
+  // of the original language type.
+  //
+  // It is not clear how to handle signless integer types.
+  // From the point of Fortran-C interface all supported integer types
+  // seem to be signed except for CFI_type_Bool/bool that is supported
+  // via signless 'i1', but that is treated as unsigned type by clang
+  // (e.g. 'bool' arguments are using 'zeroext' ABI).
+  virtual Marshalling integerArgumentType(mlir::Location loc,
+                                          mlir::IntegerType argTy) const = 0;
+
+  // By default, integer argument and return values use the same
+  // zero/sign extension rules.
+  virtual Marshalling integerReturnType(mlir::Location loc,
+                                        mlir::IntegerType argTy) const = 0;
+
+  // Returns width in bits of C/C++ 'int' type size.
+  virtual unsigned char getCIntTypeWidth() const = 0;
+
 protected:
   mlir::MLIRContext &context;
   llvm::Triple triple;
   KindMapping kindMap;
 };
 
 } // namespace fir
 
 #endif // FORTRAN_OPTMIZER_CODEGEN_TARGET_H

flang/lib/Optimizer/CodeGen/Target.cpp

 #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 fir::details {
+llvm::StringRef Attributes::getIntExtensionAttrName() const {
+  // The attribute names are available via LLVM dialect interfaces
+  // like getZExtAttrName(), getByValAttrName(), etc., so we'd better
+  // use them than literals.
+  if (isZeroExt())
+    return "llvm.zeroext";
+  else if (isSignExt())
+    return "llvm.signext";
+  return {};
+}
+} // namespace fir::details
+
 // Reduce a REAL/float type to the floating point semantics.
 static const llvm::fltSemantics &floatToSemantics(const KindMapping &kindMap,
                                                   mlir::Type type) {
   assert(isa_real(type));
   if (auto ty = type.dyn_cast<fir::RealType>())
     return kindMap.getFloatSemantics(ty.getFKind());
   return type.cast<mlir::FloatType>().getFloatSemantics();
 }
 
 namespace {
 template <typename S>
 struct GenericTarget : public CodeGenSpecifics {
   using CodeGenSpecifics::CodeGenSpecifics;
   using AT = CodeGenSpecifics::Attributes;
 
   mlir::Type complexMemoryType(mlir::Type eleTy) const override {
     assert(fir::isa_real(eleTy));
     // Use a type that will be translated into LLVM as:
     // { t, t }   struct of 2 eleTy
-    mlir::TypeRange range = {eleTy, eleTy};
-    return mlir::TupleType::get(eleTy.getContext(), range);
+    return mlir::TupleType::get(eleTy.getContext(),
+                                mlir::TypeRange{eleTy, eleTy});
   }
 
   mlir::Type boxcharMemoryType(mlir::Type eleTy) const override {
     auto idxTy = mlir::IntegerType::get(eleTy.getContext(), S::defaultWidth);
     auto ptrTy = fir::ReferenceType::get(eleTy);
     // Use a type that will be translated into LLVM as:
     // { t*, index }
-    mlir::TypeRange range = {ptrTy, idxTy};
-    return mlir::TupleType::get(eleTy.getContext(), range);
+    return mlir::TupleType::get(eleTy.getContext(),
+                                mlir::TypeRange{ptrTy, idxTy});
   }
 
   Marshalling boxcharArgumentType(mlir::Type eleTy, bool sret) const override {
     CodeGenSpecifics::Marshalling marshal;
     auto idxTy = mlir::IntegerType::get(eleTy.getContext(), S::defaultWidth);
     auto ptrTy = fir::ReferenceType::get(eleTy);
     marshal.emplace_back(ptrTy, AT{});
     // Return value arguments are grouped as a pair. Others are passed in a
     // split format with all pointers first (in the declared position) and all
     // LEN arguments appended after all of the dummy arguments.
     // NB: Other conventions/ABIs can/should be supported via options.
     marshal.emplace_back(idxTy, AT{/*alignment=*/0, /*byval=*/false,
                                    /*sret=*/sret, /*append=*/!sret});
     return marshal;
   }
+
+  CodeGenSpecifics::Marshalling
+  integerArgumentType(mlir::Location loc,
+                      mlir::IntegerType argTy) const override {
+    CodeGenSpecifics::Marshalling marshal;
+    AT::IntegerExtension intExt = AT::IntegerExtension::None;
+    if (argTy.getWidth() < getCIntTypeWidth()) {
+      // isSigned() and isUnsigned() branches below are dead code currently.
+      // If needed, we can generate calls with signed/unsigned argument types
+      // to more precisely match C side (e.g. for Fortran runtime functions
+      // with 'unsigned short' arguments).
+      if (argTy.isSigned())
+        intExt = AT::IntegerExtension::Sign;
+      else if (argTy.isUnsigned())
+        intExt = AT::IntegerExtension::Zero;
+      else if (argTy.isSignless()) {
+        // Zero extend for 'i1' and sign extend for other types.
+        if (argTy.getWidth() == 1)
+          intExt = AT::IntegerExtension::Zero;
+        else
+          intExt = AT::IntegerExtension::Sign;
+      }
+    }
+
+    marshal.emplace_back(argTy, AT{/*alignment=*/0, /*byval=*/false,
+                                   /*sret=*/false, /*append=*/false,
+                                   /*intExt=*/intExt});
+    return marshal;
+  }
+
+  CodeGenSpecifics::Marshalling
+  integerReturnType(mlir::Location loc,
+                    mlir::IntegerType argTy) const override {
+    return integerArgumentType(loc, argTy);
+  }
+
+  // Width of 'int' type is 32-bits for almost all targets, except
+  // for AVR and MSP430 (see TargetInfo initializations
+  // in clang/lib/Basic/Targets).
+  unsigned char getCIntTypeWidth() const override { return 32; }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // i386 (x86 32 bit) linux target specifics.
 //===----------------------------------------------------------------------===//
 
 namespace {
 struct TargetI386 : public GenericTarget<TargetI386> {
   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, byval, align 4
-    mlir::TypeRange range = {eleTy, eleTy};
-    auto structTy = mlir::TupleType::get(eleTy.getContext(), range);
+    auto structTy =
+        mlir::TupleType::get(eleTy.getContext(), mlir::TypeRange{eleTy, eleTy});
     marshal.emplace_back(fir::ReferenceType::get(structTy),
                          AT{/*alignment=*/4, /*byval=*/true});
     return marshal;
   }
 
   CodeGenSpecifics::Marshalling
   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);
+      auto structTy = mlir::TupleType::get(eleTy.getContext(),
+                                           mlir::TypeRange{eleTy, eleTy});
       marshal.emplace_back(fir::ReferenceType::get(structTy),
                            AT{/*alignment=*/4, /*byval=*/false, /*sret=*/true});
     } else {
       TODO(loc, "complex for this precision");
     }
     return marshal;
   }
 };
if (sem == &llvm::APFloat::IEEEsingle()) {
       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 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});
+      marshal.emplace_back(
+          fir::ReferenceType::get(mlir::TupleType::get(
+              eleTy.getContext(), mlir::TypeRange{eleTy, eleTy})),
     } else {
       TODO(loc, "complex for this precision");
     }
     return marshal;
   }
 
   CodeGenSpecifics::Marshalling
   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),
+      marshal.emplace_back(mlir::TupleType::get(eleTy.getContext(),
+                                                mlir::TypeRange{eleTy, eleTy}),
                            AT{});
     } else if (sem == &llvm::APFloat::IEEEquad()) {
       // Use a type that will be translated into LLVM as:
       // { fp128, fp128 }   struct of 2 fp128, sret, align 16
-      mlir::TypeRange range = {eleTy, eleTy};
-      marshal.emplace_back(fir::ReferenceType::get(
-                               mlir::TupleType::get(eleTy.getContext(), range)),
-                           AT{/*align=*/16, /*byval=*/false, /*sret=*/true});
+      marshal.emplace_back(
+          fir::ReferenceType::get(mlir::TupleType::get(
+              eleTy.getContext(), mlir::TypeRange{eleTy, eleTy})),
     } else {
       TODO(loc, "complex for this precision");
     }
     return marshal;
   }
 };
 } // namespace
 
struct TargetAArch64 : public GenericTarget<TargetAArch64> {
   CodeGenSpecifics::Marshalling
   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),
+      marshal.emplace_back(mlir::TupleType::get(eleTy.getContext(),
+                                                mlir::TypeRange{eleTy, eleTy}),
                            AT{});
     } else {
       TODO(loc, "complex for this precision");
     }
     return marshal;
   }
 };
 } // namespace
complexArgumentType(mlir::Location, mlir::Type eleTy) const override {
     return marshal;
   }
 
   CodeGenSpecifics::Marshalling
   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{});
+    marshal.emplace_back(
+        mlir::TupleType::get(eleTy.getContext(), mlir::TypeRange{eleTy, eleTy}),
+        AT{});
     return marshal;
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // PPC64le linux target specifics.
 //===----------------------------------------------------------------------===//
complexArgumentType(mlir::Location, mlir::Type eleTy) const override {
     return marshal;
   }
 
   CodeGenSpecifics::Marshalling
   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{});
+    marshal.emplace_back(
+        mlir::TupleType::get(eleTy.getContext(), mlir::TypeRange{eleTy, eleTy}),
+        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);
+    auto structTy =
+        mlir::TupleType::get(eleTy.getContext(), mlir::TypeRange{eleTy, eleTy});
     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);
+    auto structTy =
+        mlir::TupleType::get(eleTy.getContext(), mlir::TypeRange{eleTy, eleTy});
     marshal.emplace_back(fir::ReferenceType::get(structTy),
                          AT{/*alignment=*/0, /*byval=*/true});
     return marshal;
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
complexArgumentType(mlir::Location loc, mlir::Type eleTy) const override {
     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});
+      marshal.emplace_back(
+          fir::ReferenceType::get(mlir::TupleType::get(
+              eleTy.getContext(), mlir::TypeRange{eleTy, eleTy})),
     } 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{});
+    marshal.emplace_back(
+        mlir::TupleType::get(eleTy.getContext(), mlir::TypeRange{eleTy, eleTy}),
+        AT{});
     return marshal;
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // RISCV64 linux target specifics.
 //===----------------------------------------------------------------------===//
struct TargetRISCV64 : public GenericTarget<TargetRISCV64> {
   CodeGenSpecifics::Marshalling
   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, byVal
-      mlir::TypeRange range = {eleTy, eleTy};
-      marshal.emplace_back(mlir::TupleType::get(eleTy.getContext(), range),
+      marshal.emplace_back(mlir::TupleType::get(eleTy.getContext(),
+                                                mlir::TypeRange{eleTy, eleTy}),
                            AT{/*alignment=*/0, /*byval=*/true});
     } else {
       TODO(loc, "complex for this precision");
     }
     return marshal;
   }
 };
 } // namespace

flang/lib/Optimizer/CodeGen/TargetRewrite.cpp

if (mlir::failed(convertTypes(mod))) {
       mlir::emitError(mlir::UnknownLoc::get(&context),
                       "error in converting types to target abi");
       signalPassFailure();
     }
 
     // Convert ops in target-specific patterns.
     mod.walk([&](mlir::Operation *op) {
       if (auto call = mlir::dyn_cast<fir::CallOp>(op)) {
-        if (!hasPortableSignature(call.getFunctionType()))
+        if (!hasPortableSignature(call.getFunctionType(), op))
           convertCallOp(call);
       } else if (auto dispatch = mlir::dyn_cast<fir::DispatchOp>(op)) {
-        if (!hasPortableSignature(dispatch.getFunctionType()))
+        if (!hasPortableSignature(dispatch.getFunctionType(), op))
           convertCallOp(dispatch);
       } else if (auto addr = mlir::dyn_cast<fir::AddrOfOp>(op)) {
         if (addr.getType().isa<mlir::FunctionType>() &&
-            !hasPortableSignature(addr.getType()))
+            !hasPortableSignature(addr.getType(), op))
           convertAddrOp(addr);
       }
     });
 
     clearMembers();
   }
 
   mlir::ModuleOp getModule() { return getOperation(); }
for (auto fn : mod.getOps<mlir::func::FuncOp>())
       convertSignature(fn);
     return mlir::success();
   }
 
   /// If the signature does not need any special target-specific conversions,
   /// then it is considered portable for any target, and this function will
   /// return `true`. Otherwise, the signature is not portable and `false` is
   /// returned.
-  bool hasPortableSignature(mlir::Type signature) {
+  bool hasPortableSignature(mlir::Type signature, mlir::Operation *op) {
     assert(signature.isa<mlir::FunctionType>());
     auto func = signature.dyn_cast<mlir::FunctionType>();
+    bool hasFirRuntime = op->hasAttrOfType<mlir::UnitAttr>(
+        fir::FIROpsDialect::getFirRuntimeAttrName());
     for (auto ty : func.getResults())
       if ((ty.isa<fir::BoxCharType>() && !noCharacterConversion) ||
-          (fir::isa_complex(ty) && !noComplexConversion)) {
+          (fir::isa_complex(ty) && !noComplexConversion) ||
+          (ty.isa<mlir::IntegerType>() && hasFirRuntime)) {
         LLVM_DEBUG(llvm::dbgs() << "rewrite " << signature << " for target\n");
         return false;
       }
     for (auto ty : func.getInputs())
       if (((ty.isa<fir::BoxCharType>() || fir::isCharacterProcedureTuple(ty)) &&
            !noCharacterConversion) ||
-          (fir::isa_complex(ty) && !noComplexConversion)) {
+          (fir::isa_complex(ty) && !noComplexConversion) ||
+          (ty.isa<mlir::IntegerType>() && hasFirRuntime)) {
         LLVM_DEBUG(llvm::dbgs() << "rewrite " << signature << " for target\n");
         return false;
       }
     return true;
   }
 
   /// Determine if the signature has host associations. The host association
   /// argument may need special target specific rewriting.
   static bool hasHostAssociations(mlir::func::FuncOp func) {
     std::size_t end = func.getFunctionType().getInputs().size();
     for (std::size_t i = 0; i < end; ++i)
       if (func.getArgAttrOfType<mlir::UnitAttr>(i, fir::getHostAssocAttrName()))
         return true;
     return false;
   }
 
   /// Rewrite the signatures and body of the `FuncOp`s in the module for
   /// the immediately subsequent target code gen.
   void convertSignature(mlir::func::FuncOp func) {
     auto funcTy = func.getFunctionType().cast<mlir::FunctionType>();
-    if (hasPortableSignature(funcTy) && !hasHostAssociations(func))
+    if (hasPortableSignature(funcTy, func) && !hasHostAssociations(func))
       return;
     llvm::SmallVector<mlir::Type> newResTys;
     llvm::SmallVector<mlir::Type> newInTys;
     llvm::SmallVector<std::pair<unsigned, mlir::NamedAttribute>> savedAttrs;
     llvm::SmallVector<std::pair<unsigned, mlir::NamedAttribute>> extraAttrs;
     llvm::SmallVector<FixupTy> fixups;
+    llvm::SmallVector<std::pair<unsigned, mlir::NamedAttrList>, 1> resultAttrs;
 
     // Save argument attributes in case there is a shift so we can replace them
     // correctly.
     for (auto e : llvm::enumerate(funcTy.getInputs())) {
       unsigned index = e.index();
       llvm::ArrayRef<mlir::NamedAttribute> attrs =
           mlir::function_interface_impl::getArgAttrs(func, index);
       for (mlir::NamedAttribute attr : attrs) {
for (auto ty : funcTy.getResults())
               doComplexReturn(func, cmplx, newResTys, newInTys, fixups);
           })
           .Case<mlir::ComplexType>([&](mlir::ComplexType cmplx) {
             if (noComplexConversion)
               newResTys.push_back(cmplx);
             else
               doComplexReturn(func, cmplx, newResTys, newInTys, fixups);
           })
+          .Case<mlir::IntegerType>([&](mlir::IntegerType intTy) {
+            auto m = specifics->integerArgumentType(func.getLoc(), intTy);
+            assert(m.size() == 1);
+            auto attr = std::get<fir::CodeGenSpecifics::Attributes>(m[0]);
+            auto retTy = std::get<mlir::Type>(m[0]);
+            std::size_t resId = newResTys.size();
+            llvm::StringRef extensionAttrName = attr.getIntExtensionAttrName();
+            if (!extensionAttrName.empty() &&
+                // TODO: we have to do the same for BIND(C) routines.
+                func->hasAttrOfType<mlir::UnitAttr>(
+                    fir::FIROpsDialect::getFirRuntimeAttrName()))
+              resultAttrs.emplace_back(
+                  resId, rewriter->getNamedAttr(extensionAttrName,
+                                                rewriter->getUnitAttr()));
+            newResTys.push_back(retTy);
+          })
           .Default([&](mlir::Type ty) { newResTys.push_back(ty); });
 
     // Saved potential shift in argument. Handling of result can add arguments
     // at the beginning of the function signature.
     unsigned argumentShift = newInTys.size();
 
     // Convert arguments
     llvm::SmallVector<mlir::Type> trailingTys;
for (auto e : llvm::enumerate(funcTy.getInputs())) {
               fixups.emplace_back(FixupTy::Codes::TrailingCharProc,
                                   newInTys.size(), trailingTys.size());
               newInTys.push_back(tuple.getType(0));
               trailingTys.push_back(tuple.getType(1));
             } else {
               newInTys.push_back(ty);
             }
           })
+          .Case<mlir::IntegerType>([&](mlir::IntegerType intTy) {
+            auto m = specifics->integerArgumentType(func.getLoc(), intTy);
+            assert(m.size() == 1);
+            auto attr = std::get<fir::CodeGenSpecifics::Attributes>(m[0]);
+            auto argTy = std::get<mlir::Type>(m[0]);
+            auto argNo = newInTys.size();
+            llvm::StringRef extensionAttrName = attr.getIntExtensionAttrName();
+            if (!extensionAttrName.empty() &&
+                // TODO: we have to do the same for BIND(C) routines.
+                func->hasAttrOfType<mlir::UnitAttr>(
+                    fir::FIROpsDialect::getFirRuntimeAttrName())) {
+              fixups.emplace_back(FixupTy::Codes::ArgumentType, argNo,
+                                  [=](mlir::func::FuncOp func) {
+                                    func.setArgAttr(
+                                        argNo, extensionAttrName,
+                                        mlir::UnitAttr::get(func.getContext()));
+                                  });
+            }
+            newInTys.push_back(argTy);
+          })
           .Default([&](mlir::Type ty) { newInTys.push_back(ty); });
 
       if (func.getArgAttrOfType<mlir::UnitAttr>(index,
                                                 fir::getHostAssocAttrName())) {
         extraAttrs.push_back(
             {newInTys.size() - 1,
              rewriter->getNamedAttr("llvm.nest", rewriter->getUnitAttr())});
       }
if (!func.empty()) {
           auto cast = rewriter->create<fir::ConvertOp>(loc, oldArgTy, newArg);
           auto load = rewriter->create<fir::LoadOp>(loc, cast);
           func.getArgument(fixup.index + 1).replaceAllUsesWith(load);
           func.front().eraseArgument(fixup.index + 1);
         } break;
         case FixupTy::Codes::ArgumentType: {
           // Argument is pass-by-value, but its type has likely been modified to
           // suit the target ABI convention.
+          auto oldArgTy =
+              fir::ReferenceType::get(oldArgTys[fixup.index - offset]);
+          // If type did not change, keep the original argument.
+          if (newInTys[fixup.index] == oldArgTy)
+            break;
+
           auto newArg = func.front().insertArgument(fixup.index,
                                                     newInTys[fixup.index], loc);
           rewriter->setInsertionPointToStart(&func.front());
           auto mem =
               rewriter->create<fir::AllocaOp>(loc, newInTys[fixup.index]);
           rewriter->create<fir::StoreOp>(loc, newArg, mem);
-          auto oldArgTy =
-              fir::ReferenceType::get(oldArgTys[fixup.index - offset]);
           auto cast = rewriter->create<fir::ConvertOp>(loc, oldArgTy, mem);
           mlir::Value load = rewriter->create<fir::LoadOp>(loc, cast);
           func.getArgument(fixup.index + 1).replaceAllUsesWith(load);
           func.front().eraseArgument(fixup.index + 1);
           LLVM_DEBUG(llvm::dbgs()
                      << "old argument: " << oldArgTy.getEleTy()
                      << ", repl: " << load << ", new argument: "
                      << func.getArgument(fixup.index).getType() << '\n');
auto newFuncTy =
         mlir::FunctionType::get(func.getContext(), newInTys, newResTys);
     LLVM_DEBUG(llvm::dbgs() << "new func: " << newFuncTy << '\n');
     func.setType(newFuncTy);
 
     for (std::pair<unsigned, mlir::NamedAttribute> extraAttr : extraAttrs)
       func.setArgAttr(extraAttr.first, extraAttr.second.getName(),
                       extraAttr.second.getValue());
 
+    for (auto [resId, resAttrList] : resultAttrs)
+      for (mlir::NamedAttribute resAttr : resAttrList)
+        func.setResultAttr(resId, resAttr.getName(), resAttr.getValue());
+
     // Replace attributes to the correct argument if there was an argument shift
     // to the right.
     if (argumentShift > 0) {
       for (std::pair<unsigned, mlir::NamedAttribute> savedAttr : savedAttrs) {
         func.removeArgAttr(savedAttr.first, savedAttr.second.getName());
         func.setArgAttr(savedAttr.first + argumentShift,
                         savedAttr.second.getName(),
                         savedAttr.second.getValue());

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

+// RUN: fir-opt --split-input-file --target-rewrite="target=i386-unknown-linux-gnu" %s | FileCheck %s --check-prefixes=I32,ALL
+// RUN: fir-opt --split-input-file --target-rewrite="target=x86_64-unknown-linux-gnu" %s | FileCheck %s --check-prefixes=X64,ALL
+// RUN: fir-opt --split-input-file --target-rewrite="target=aarch64-unknown-linux-gnu" %s | FileCheck %s --check-prefixes=AARCH64,ALL
+// RUN: fir-opt --split-input-file --target-rewrite="target=powerpc64le-unknown-linux-gnu" %s | FileCheck %s --check-prefixes=PPC,ALL
+// RUN: fir-opt --split-input-file --target-rewrite="target=sparc64-unknown-linux-gnu" %s | FileCheck %s --check-prefixes=SPARCV9,ALL
+// RUN: fir-opt --split-input-file --target-rewrite="target=sparcv9-sun-solaris2.11" %s | FileCheck %s --check-prefixes=SPARCV9,ALL
+
+// -----
+
+// subroutine test_i1(x)
+//   logical x
+//   print *, x
+// end subroutine test_i1
+
+// ALL-LABEL: @_QPtest_i1
+// I32: func.func{{.*}}@_FortranAioOutputLogical({{.*}}i1 {llvm.zeroext}) -> (i1 {llvm.zeroext})
+// X64: func.func{{.*}}@_FortranAioOutputLogical({{.*}}i1 {llvm.zeroext}) -> (i1 {llvm.zeroext})
+// AARCH64: func.func{{.*}}@_FortranAioOutputLogical({{.*}}i1 {llvm.zeroext}) -> (i1 {llvm.zeroext})
+// PPC: func.func{{.*}}@_FortranAioOutputLogical({{.*}}i1 {llvm.zeroext}) -> (i1 {llvm.zeroext})
+// SPARCV9: func.func{{.*}}@_FortranAioOutputLogical({{.*}}i1 {llvm.zeroext}) -> (i1 {llvm.zeroext})
+func.func @_QPtest_i1(%arg0: !fir.ref<!fir.logical<4>> {fir.bindc_name = "x"}) {
+  %c3_i32 = arith.constant 3 : i32
+  %c-1_i32 = arith.constant -1 : i32
+  %0 = fir.address_of(@_QQcl.2E2F746573742E66393000) : !fir.ref<!fir.char<1,11>>
+  %1 = fir.convert %0 : (!fir.ref<!fir.char<1,11>>) -> !fir.ref<i8>
+  %2 = fir.call @_FortranAioBeginExternalListOutput(%c-1_i32, %1, %c3_i32) : (i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
+  %3 = fir.load %arg0 : !fir.ref<!fir.logical<4>>
+  %4 = fir.convert %3 : (!fir.logical<4>) -> i1
+  %5 = fir.call @_FortranAioOutputLogical(%2, %4) : (!fir.ref<i8>, i1) -> i1
+  %6 = fir.call @_FortranAioEndIoStatement(%2) : (!fir.ref<i8>) -> i32
+  return
+}
+func.func private @_FortranAioBeginExternalListOutput(i32, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+fir.global linkonce @_QQcl.2E2F746573742E66393000 constant : !fir.char<1,11> {
+  %0 = fir.string_lit "./test.f90\00"(11) : !fir.char<1,11>
+  fir.has_value %0 : !fir.char<1,11>
+}
+func.func private @_FortranAioOutputLogical(!fir.ref<i8>, i1) -> i1 attributes {fir.io, fir.runtime}
+func.func private @_FortranAioEndIoStatement(!fir.ref<i8>) -> i32 attributes {fir.io, fir.runtime}
+
+// -----
+
+// Manually created test with 'si1' argument/return type.
+// Flang does not use 'si1' type currently.
+
+// ALL-LABEL: @_QPtest_si1
+// I32: func.func{{.*}}@_SomeFunc_si1(si1 {llvm.signext}) -> (si1 {llvm.signext})
+// X64: func.func{{.*}}@_SomeFunc_si1(si1 {llvm.signext}) -> (si1 {llvm.signext})
+// AARCH64: func.func{{.*}}@_SomeFunc_si1(si1 {llvm.signext}) -> (si1 {llvm.signext})
+// PPC: func.func{{.*}}@_SomeFunc_si1(si1 {llvm.signext}) -> (si1 {llvm.signext})
+// SPARCV9: func.func{{.*}}@_SomeFunc_si1(si1 {llvm.signext}) -> (si1 {llvm.signext})
+func.func @_QPtest_si1(%arg0: !fir.ref<!fir.logical<4>> {fir.bindc_name = "x"}) {
+  %0 = fir.load %arg0 : !fir.ref<!fir.logical<4>>
+  %1 = fir.convert %0 : (!fir.logical<4>) -> si1
+  %2 = fir.call @_SomeFunc_si1(%1) : (si1) -> si1
+  return
+}
+func.func private @_SomeFunc_si1(si1) -> si1 attributes {fir.runtime}
+
+// -----
+
+// Manually created test with 'ui1' argument/return type.
+// Flang does not use 'ui1' type currently.
+
+// ALL-LABEL: @_QPtest_ui1
+// I32: func.func{{.*}}@_SomeFunc_ui1(ui1 {llvm.zeroext}) -> (ui1 {llvm.zeroext})
+// X64: func.func{{.*}}@_SomeFunc_ui1(ui1 {llvm.zeroext}) -> (ui1 {llvm.zeroext})
+// AARCH64: func.func{{.*}}@_SomeFunc_ui1(ui1 {llvm.zeroext}) -> (ui1 {llvm.zeroext})
+// PPC: func.func{{.*}}@_SomeFunc_ui1(ui1 {llvm.zeroext}) -> (ui1 {llvm.zeroext})
+// SPARCV9: func.func{{.*}}@_SomeFunc_ui1(ui1 {llvm.zeroext}) -> (ui1 {llvm.zeroext})
+func.func @_QPtest_ui1(%arg0: !fir.ref<!fir.logical<4>> {fir.bindc_name = "x"}) {
+  %0 = fir.load %arg0 : !fir.ref<!fir.logical<4>>
+  %1 = fir.convert %0 : (!fir.logical<4>) -> ui1
+  %2 = fir.call @_SomeFunc_ui1(%1) : (ui1) -> ui1
+  return
+}
+func.func private @_SomeFunc_ui1(ui1) -> ui1 attributes {fir.runtime}