[flang] Establish a single source of target information for semantics

[klausler]

Summary

Create a TargetCharacteristics class to centralize the few items of
target specific information that are relevant to semantics. Use the
new class for all target queries, including derived type component layout
modeling.

Future work will initialize this class with target information
provided or forwarded by the drivers, and use it to fold layout-dependent
intrinsic functions like TRANSFER().

[tschuett]

From a design point, I would have expected an abstract base class. Targets can implement it in any way they wish. Maybe the driver is better place for target-specific information. Then you can have a factory method with the target target triple.

There was a discussion that Flang should have used comdats:
https://reviews.llvm.org/D127455

[klausler]

In D129018#3626741, @tschuett wrote:

From a design point, I would have expected an abstract base class. Targets can implement it in any way they wish. Maybe the driver is better place for target-specific information. Then you can have a factory method with the target target triple.

There was a discussion that Flang should have used comdats:
https://reviews.llvm.org/D127455

This patch collects into one place the few items of target information that are relevant to f18 semantics (not optimization or lowering!), which were scattered around various data structures or undefined, and puts them behind a sensible API that suffices for the needs of f18 semantics, which really just needs to know the available types and how to lay them out in derived types so that semantics can build the derived type information tables and fold some layout-dependent intrinsic functions. How that type information is acquired and installed is another concern not within the scope of this patch. The next step will be to use this API in semantics to guide the folding of the TRANSFER intrinsic function and see whether it is a good fit, adjusting it if it is not.

We always welcome new contributors to the LLVM Fortran effort; see flang/docs/GettingInvolved.md for more information. Thank you for your interest.

[jeanPerier]

Targets can implement it in any way they wish

@tschuett, the plan is to avoid re-implementing target information in flang. We wish to plug into the existing target description in llvm (probably from using the infrastructure in llvm/include/llvm/Target). What this patch does is to centralize the target dependent info in semantics into one class that has an interface in terms of Fortran types (which is not the case of llvm generic infrastructure). The next steps that will probably have to be taken to be able to configure the target data are:

• let the driver select the target triple (either command line or host), and get the LLVM representation for it (llvm::TargetMachine ? llvm::DataLayout ? ... ).
• to let the driver use relevant information from this target to set up the TargetCharacteristics representation (whose ctor or member functions might have to be adapted to do that).
• ensure the driver passes the triple to lowering (the comdat point might require using it when selecting linkage if windows LLVM target does not fulfill the target independent LLVM linkonce attribute description from the manual).

Anyone is more than welcome to launch an RFC to precisely define how this target dependent configuration should occur.

So you should see the TargetCharacteristics class as a generic wrapper to translate LLVM target info into something meaningful in terms of Fortran.

[klausler]

Attempt to work around build problems on Windows.

[tschuett]

The Clang community was discussing on Discourse to move to MLIR codegen. It ended with an invitation to a meeting. Maybe it is a win for you to cooperate on ugly stuff like, e.g., comdats.

[jeanPerier]

In D129018#3628786, @tschuett wrote:

The Clang community was discussing on Discourse to move to MLIR codegen. It ended with an invitation to a meeting. Maybe it is a win for you to cooperate on ugly stuff like, e.g., comdats.

I suppose you are mentioning this thread: https://discourse.llvm.org/t/rfc-an-mlir-based-clang-ir-cir/63319/73 ?

For the BIND(C) and runtime interface parts at least, having a C/C++ ABI for the target available in MLIR could be useful. If it brings COMDAT support in MLIR, that may be a good way to share read only data between compilation units for the targets that supports it (linkonce/linkonce_odr gets us there on linux, but without any possible sanity checks at linktime that the data is indeed equivalent, although my understanding is that ExactMatch COMDAT flag support is low (i.e: not supported in ELF)).

[tschuett]

Exactly. Comdats were just one example. There are more challenges with ABIs, e.g., https://github.com/rust-lang/rust/issues/97463

[klausler]

Another tweak to appease MSVC. Did you know that MSVC does not predefine x86_64?

[klausler]

Defer tuning of enabled type kinds to the target for now, to try to get through the MSVC build.

[klausler]

ping now that MSVC build succeeds

[klausler]

ping

[jeanPerier]

LGTM

flang/include/flang/Evaluate/common.h

 #include <string>
 
 namespace Fortran::semantics {
 class DerivedTypeSpec;
 }
 
 namespace Fortran::evaluate {
 class IntrinsicProcTable;
+class TargetCharacteristics;
 
 using common::ConstantSubscript;
 using common::RelationalOperator;
 
 // Integers are always ordered; reals may not be.
 ENUM_CLASS(Ordering, Less, Equal, Greater)
 ENUM_CLASS(Relation, Less, Equal, Greater, Unordered)
 
template <typename A> struct ValueWithRealFlags {
   A AccumulateFlags(RealFlags &f) {
     f |= flags;
     return value;
   }
   A value;
   RealFlags flags{};
 };
 
-struct Rounding {
-  common::RoundingMode mode{common::RoundingMode::TiesToEven};
-  // When set, emulate status flag behavior peculiar to x86
-  // (viz., fail to set the Underflow flag when an inexact product of a
-  // multiplication is rounded up to a normal number from a subnormal
-  // in some rounding modes)
-#if __x86_64__
-  bool x86CompatibleBehavior{true};
-#else
-  bool x86CompatibleBehavior{false};
-#endif
-};
-
-static constexpr Rounding defaultRounding;
-
 #if FLANG_BIG_ENDIAN
 constexpr bool isHostLittleEndian{false};
 #elif FLANG_LITTLE_ENDIAN
 constexpr bool isHostLittleEndian{true};
 #else
 #error host endianness is not known
 #endif
 
#define EVALUATE_UNION_CLASS_BOILERPLATE(t) \
   bool operator==(const t &) const;
 
 // Forward definition of Expr<> so that it can be indirectly used in its own
 // definition
 template <typename A> class Expr;
 
 class FoldingContext {
 public:
-  FoldingContext(
-      const common::IntrinsicTypeDefaultKinds &d, const IntrinsicProcTable &t)
-      : defaults_{d}, intrinsics_{t} {}
+  FoldingContext(const common::IntrinsicTypeDefaultKinds &d,
+      const IntrinsicProcTable &t, const TargetCharacteristics &c)
+      : defaults_{d}, intrinsics_{t}, targetCharacteristics_{c} {}
   FoldingContext(const parser::ContextualMessages &m,
       const common::IntrinsicTypeDefaultKinds &d, const IntrinsicProcTable &t,
-      Rounding round = defaultRounding, bool flush = false)
-      : messages_{m}, defaults_{d}, intrinsics_{t}, rounding_{round},
-        flushSubnormalsToZero_{flush} {}
+      const TargetCharacteristics &c)
+      : messages_{m}, defaults_{d}, intrinsics_{t}, targetCharacteristics_{c} {}
   FoldingContext(const FoldingContext &that)
       : messages_{that.messages_}, defaults_{that.defaults_},
-        intrinsics_{that.intrinsics_}, rounding_{that.rounding_},
-        flushSubnormalsToZero_{that.flushSubnormalsToZero_},
+        intrinsics_{that.intrinsics_},
+        targetCharacteristics_{that.targetCharacteristics_},
         pdtInstance_{that.pdtInstance_}, impliedDos_{that.impliedDos_} {}
   FoldingContext(
       const FoldingContext &that, const parser::ContextualMessages &m)
-      : messages_{m}, defaults_{that.defaults_},
-        intrinsics_{that.intrinsics_}, rounding_{that.rounding_},
-        flushSubnormalsToZero_{that.flushSubnormalsToZero_},
+      : messages_{m}, defaults_{that.defaults_}, intrinsics_{that.intrinsics_},
+        targetCharacteristics_{that.targetCharacteristics_},
         pdtInstance_{that.pdtInstance_}, impliedDos_{that.impliedDos_} {}
 
   parser::ContextualMessages &messages() { return messages_; }
   const parser::ContextualMessages &messages() const { return messages_; }
   const common::IntrinsicTypeDefaultKinds &defaults() const {
     return defaults_;
   }
-  Rounding rounding() const { return rounding_; }
-  bool flushSubnormalsToZero() const { return flushSubnormalsToZero_; }
-  bool bigEndian() const { return bigEndian_; }
-  std::size_t maxAlignment() const { return maxAlignment_; }
   const semantics::DerivedTypeSpec *pdtInstance() const { return pdtInstance_; }
   const IntrinsicProcTable &intrinsics() const { return intrinsics_; }
+  const TargetCharacteristics &targetCharacteristics() const {
+    return targetCharacteristics_;
+  }
   bool inModuleFile() const { return inModuleFile_; }
   FoldingContext &set_inModuleFile(bool yes = true) {
     inModuleFile_ = yes;
     return *this;
   }
 
   ConstantSubscript &StartImpliedDo(parser::CharBlock, ConstantSubscript = 1);
   std::optional<ConstantSubscript> GetImpliedDo(parser::CharBlock) const;
   void EndImpliedDo(parser::CharBlock);
 
   std::map<parser::CharBlock, ConstantSubscript> &impliedDos() {
     return impliedDos_;
   }
 
   common::Restorer<const semantics::DerivedTypeSpec *> WithPDTInstance(
       const semantics::DerivedTypeSpec &spec) {
     return common::ScopedSet(pdtInstance_, &spec);
   }
 
 private:
   parser::ContextualMessages messages_;
   const common::IntrinsicTypeDefaultKinds &defaults_;
   const IntrinsicProcTable &intrinsics_;
-  Rounding rounding_{defaultRounding};
-  bool flushSubnormalsToZero_{false};
-  static constexpr bool bigEndian_{false}; // TODO: configure for target
-  static constexpr std::size_t maxAlignment_{8}; // TODO: configure for target
+  const TargetCharacteristics &targetCharacteristics_;
   const semantics::DerivedTypeSpec *pdtInstance_{nullptr};
   bool inModuleFile_{false};
   std::map<parser::CharBlock, ConstantSubscript> impliedDos_;
 };
 
 void RealFlagWarnings(FoldingContext &, const RealFlags &, const char *op);
 } // namespace Fortran::evaluate
 #endif // FORTRAN_EVALUATE_COMMON_H_

flang/include/flang/Evaluate/complex.h

constexpr bool IsNotANumber() const {
     return re_.IsNotANumber() || im_.IsNotANumber();
   }
 
   constexpr bool IsSignalingNaN() const {
     return re_.IsSignalingNaN() || im_.IsSignalingNaN();
   }
 
   template <typename INT>
-  static ValueWithRealFlags<Complex> FromInteger(
-      const INT &n, Rounding rounding = defaultRounding) {
+  static ValueWithRealFlags<Complex> FromInteger(const INT &n,
+      Rounding rounding = TargetCharacteristics::defaultRounding) {
     ValueWithRealFlags<Complex> result;
     result.value.re_ =
         Part::FromInteger(n, rounding).AccumulateFlags(result.flags);
     return result;
   }
 
-  ValueWithRealFlags<Complex> Add(
-      const Complex &, Rounding rounding = defaultRounding) const;
-  ValueWithRealFlags<Complex> Subtract(
-      const Complex &, Rounding rounding = defaultRounding) const;
-  ValueWithRealFlags<Complex> Multiply(
-      const Complex &, Rounding rounding = defaultRounding) const;
-  ValueWithRealFlags<Complex> Divide(
-      const Complex &, Rounding rounding = defaultRounding) const;
+  ValueWithRealFlags<Complex> Add(const Complex &,
+      Rounding rounding = TargetCharacteristics::defaultRounding) const;
+  ValueWithRealFlags<Complex> Subtract(const Complex &,
+      Rounding rounding = TargetCharacteristics::defaultRounding) const;
+  ValueWithRealFlags<Complex> Multiply(const Complex &,
+      Rounding rounding = TargetCharacteristics::defaultRounding) const;
+  ValueWithRealFlags<Complex> Divide(const Complex &,
+      Rounding rounding = TargetCharacteristics::defaultRounding) const;
 
   // ABS/CABS = HYPOT(re_, imag_) = SQRT(re_**2 + im_**2)
-  ValueWithRealFlags<Part> ABS(Rounding rounding = defaultRounding) const {
+  ValueWithRealFlags<Part> ABS(
+      Rounding rounding = TargetCharacteristics::defaultRounding) const {
     return re_.HYPOT(im_, rounding);
   }
 
   constexpr Complex FlushSubnormalToZero() const {
     return {re_.FlushSubnormalToZero(), im_.FlushSubnormalToZero()};
   }
 
   static constexpr Complex NotANumber() {

flang/include/flang/Evaluate/real.h

 //===-- include/flang/Evaluate/real.h ---------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_EVALUATE_REAL_H_
 #define FORTRAN_EVALUATE_REAL_H_
 
 #include "formatting.h"
 #include "integer.h"
 #include "rounding-bits.h"
 #include "flang/Common/real.h"
-#include "flang/Evaluate/common.h"
+#include "flang/Evaluate/target.h"
 #include <cinttypes>
 #include <limits>
 #include <string>
 
 // Some environments, viz. clang on Darwin, allow the macro HUGE
 // to leak out of <math.h> even when it is never directly included.
 #undef HUGE
 
if (toNegative) {
       return ABS();
     }
   }
   constexpr Real SIGN(const Real &x) const { return SetSign(x.IsSignBitSet()); }
 
   constexpr Real Negate() const { return {word_.IEOR(word_.MASKL(1))}; }
 
   Relation Compare(const Real &) const;
-  ValueWithRealFlags<Real> Add(
-      const Real &, Rounding rounding = defaultRounding) const;
-  ValueWithRealFlags<Real> Subtract(
-      const Real &y, Rounding rounding = defaultRounding) const {
+  ValueWithRealFlags<Real> Add(const Real &,
+      Rounding rounding = TargetCharacteristics::defaultRounding) const;
+  ValueWithRealFlags<Real> Subtract(const Real &y,
+      Rounding rounding = TargetCharacteristics::defaultRounding) const {
     return Add(y.Negate(), rounding);
   }
-  ValueWithRealFlags<Real> Multiply(
-      const Real &, Rounding rounding = defaultRounding) const;
-  ValueWithRealFlags<Real> Divide(
-      const Real &, Rounding rounding = defaultRounding) const;
+  ValueWithRealFlags<Real> Multiply(const Real &,
+      Rounding rounding = TargetCharacteristics::defaultRounding) const;
+  ValueWithRealFlags<Real> Divide(const Real &,
+      Rounding rounding = TargetCharacteristics::defaultRounding) const;
 
-  ValueWithRealFlags<Real> SQRT(Rounding rounding = defaultRounding) const;
+  ValueWithRealFlags<Real> SQRT(
+      Rounding rounding = TargetCharacteristics::defaultRounding) const;
   // NEAREST(), IEEE_NEXT_AFTER(), IEEE_NEXT_UP(), and IEEE_NEXT_DOWN()
   ValueWithRealFlags<Real> NEAREST(bool upward) const;
   // HYPOT(x,y)=SQRT(x**2 + y**2) computed so as to avoid spurious
   // intermediate overflows.
-  ValueWithRealFlags<Real> HYPOT(
-      const Real &, Rounding rounding = defaultRounding) const;
+  ValueWithRealFlags<Real> HYPOT(const Real &,
+      Rounding rounding = TargetCharacteristics::defaultRounding) const;
   // DIM(X,Y) = MAX(X-Y, 0)
-  ValueWithRealFlags<Real> DIM(
-      const Real &, Rounding rounding = defaultRounding) const;
+  ValueWithRealFlags<Real> DIM(const Real &,
+      Rounding rounding = TargetCharacteristics::defaultRounding) const;
   // MOD(x,y) = x - AINT(x/y)*y
   // MODULO(x,y) = x - FLOOR(x/y)*y
-  ValueWithRealFlags<Real> MOD(
-      const Real &, Rounding rounding = defaultRounding) const;
-  ValueWithRealFlags<Real> MODULO(
-      const Real &, Rounding rounding = defaultRounding) const;
+  ValueWithRealFlags<Real> MOD(const Real &,
+      Rounding rounding = TargetCharacteristics::defaultRounding) const;
+  ValueWithRealFlags<Real> MODULO(const Real &,
+      Rounding rounding = TargetCharacteristics::defaultRounding) const;
 
   template <typename INT> constexpr INT EXPONENT() const {
     if (Exponent() == maxExponent) {
       return INT::HUGE();
     } else if (IsZero()) {
       return {0};
     } else {
       return {UnbiasedExponent() + 1};
public:
   static constexpr int RANGE{Details::decimalRange};
   static constexpr int MAXEXPONENT{maxExponent - exponentBias};
   static constexpr int MINEXPONENT{2 - exponentBias};
   Real RRSPACING() const;
   Real SPACING() const;
 
   // SCALE(); also known as IEEE_SCALB and (in IEEE-754 '08) ScaleB.
   template <typename INT>
-  ValueWithRealFlags<Real> SCALE(
-      const INT &by, Rounding rounding = defaultRounding) const {
+  ValueWithRealFlags<Real> SCALE(const INT &by,
+      Rounding rounding = TargetCharacteristics::defaultRounding) const {
     auto expo{exponentBias + by.ToInt64()};
     if (IsZero()) {
       expo = exponentBias; // ignore by, don't overflow
     } else if (by > INT{maxExponent}) {
       expo = maxExponent;
     } else if (by < INT{-exponentBias}) {
       expo = -1;
     }
static constexpr Real Infinity(bool negative) {
     infinity = infinity.SHIFTL(significandBits);
     if (negative) {
       infinity = infinity.IBSET(infinity.bits - 1);
     }
     return {infinity};
   }
 
   template <typename INT>
-  static ValueWithRealFlags<Real> FromInteger(
-      const INT &n, Rounding rounding = defaultRounding) {
+  static ValueWithRealFlags<Real> FromInteger(const INT &n,
+      Rounding rounding = TargetCharacteristics::defaultRounding) {
     bool isNegative{n.IsNegative()};
     INT absN{n};
     if (isNegative) {
       absN = n.Negate().value; // overflow is safe to ignore
     }
     int leadz{absN.LEADZ()};
     if (leadz >= absN.bits) {
       return {}; // all bits zero -> +0.0
if (result.flags.test(RealFlag::Overflow)) {
       result.value =
           IsSignBitSet() ? result.value.MASKL(1) : result.value.HUGE();
     }
     return result;
   }
 
   template <typename A>
   static ValueWithRealFlags<Real> Convert(
-      const A &x, Rounding rounding = defaultRounding) {
+      const A &x, Rounding rounding = TargetCharacteristics::defaultRounding) {
     ValueWithRealFlags<Real> result;
     if (x.IsNotANumber()) {
       result.flags.set(RealFlag::InvalidArgument);
       result.value = NotANumber();
       return result;
     }
     bool isNegative{x.IsNegative()};
     A absX{x};
public:
   constexpr int UnbiasedExponent() const {
     int exponent{Exponent() - exponentBias};
     if (IsSubnormal()) {
       ++exponent;
     }
     return exponent;
   }
 
-  static ValueWithRealFlags<Real> Read(
-      const char *&, Rounding rounding = defaultRounding);
+  static ValueWithRealFlags<Real> Read(const char *&,
+      Rounding rounding = TargetCharacteristics::defaultRounding);
   std::string DumpHexadecimal() const;
 
   // Emits a character representation for an equivalent Fortran constant
   // or parenthesized constant expression that produces this value.
   llvm::raw_ostream &AsFortran(
       llvm::raw_ostream &, int kind, bool minimal = false) const;
 
 private:
static constexpr bool NextQuotientBit(
     return greaterOrEqual;
   }
 
   // Normalizes and marshals the fields of a floating-point number in place.
   // The value is a number, and a zero fraction means a zero value (i.e.,
   // a maximal exponent and zero fraction doesn't signify infinity, although
   // this member function will detect overflow and encode infinities).
   RealFlags Normalize(bool negative, int exponent, const Fraction &fraction,
-      Rounding rounding = defaultRounding,
+      Rounding rounding = TargetCharacteristics::defaultRounding,
       RoundingBits *roundingBits = nullptr);
 
   // Rounds a result, if necessary, in place.
   RealFlags Round(Rounding, const RoundingBits &, bool multiply = false);
 
   static void NormalizeAndRound(ValueWithRealFlags<Real> &result,
       bool isNegative, int exponent, const Fraction &, Rounding, RoundingBits,
       bool multiply = false);

flang/include/flang/Evaluate/rounding-bits.h

 //===-- include/flang/Evaluate/rounding-bits.h ------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_EVALUATE_ROUNDING_BITS_H_
 #define FORTRAN_EVALUATE_ROUNDING_BITS_H_
 
+#include "flang/Evaluate/target.h"
+
 // A helper class used by Real<> to determine rounding of rational results
 // to floating-point values.  Bits lost from intermediate computations by
 // being shifted rightward are accumulated in instances of this class.
 
 namespace Fortran::evaluate::value {
 
 class RoundingBits {
 public:

flang/include/flang/Evaluate/static-data.h

StaticDataObject &set_itemBytes(int b) {
     CHECK(b >= 1);
     itemBytes_ = b;
     return *this;
   }
 
   const std::vector<std::uint8_t> &data() const { return data_; }
   std::vector<std::uint8_t> &data() { return data_; }
 
-  StaticDataObject &Push(const std::string &);
-  StaticDataObject &Push(const std::u16string &);
-  StaticDataObject &Push(const std::u32string &);
+  StaticDataObject &Push(const std::string &, bool /*ignored*/ = false);
+  StaticDataObject &Push(const std::u16string &, bool bigEndian = false);
+  StaticDataObject &Push(const std::u32string &, bool bigEndian = false);
   std::optional<std::string> AsString() const;
-  std::optional<std::u16string> AsU16String() const;
-  std::optional<std::u32string> AsU32String() const;
-  llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
-
-  static bool bigEndian;
+  std::optional<std::u16string> AsU16String(bool bigEndian = false) const;
+  std::optional<std::u32string> AsU32String(bool bigEndian = false) const;
+  llvm::raw_ostream &AsFortran(
+      llvm::raw_ostream &, bool bigEndian = false) const;
 
 private:
   StaticDataObject() {}
 
   std::string name_;
   int alignment_{1};
   int itemBytes_{1};
   std::vector<std::uint8_t> data_;
 };
 } // namespace Fortran::evaluate
 #endif // FORTRAN_EVALUATE_STATIC_DATA_H_

flang/include/flang/Evaluate/target.h

+//===-- include/flang/Evaluate/target.h -------------------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// Represents the minimal amount of target architecture information required by
+// semantics.
+
+#ifndef FORTRAN_EVALUATE_TARGET_H_
+#define FORTRAN_EVALUATE_TARGET_H_
+
+#include "flang/Common/Fortran.h"
+#include "flang/Evaluate/common.h"
+#include <cstdint>
+
+namespace Fortran::evaluate {
+
+// Floating-point rounding control
+struct Rounding {
+  common::RoundingMode mode{common::RoundingMode::TiesToEven};
+  // When set, emulate status flag behavior peculiar to x86
+  // (viz., fail to set the Underflow flag when an inexact product of a
+  // multiplication is rounded up to a normal number from a subnormal
+  // in some rounding modes)
+#if __x86_64__
+  bool x86CompatibleBehavior{true};
+#else
+  bool x86CompatibleBehavior{false};
+#endif
+};
+
+class TargetCharacteristics {
+public:
+  TargetCharacteristics();
+  TargetCharacteristics &operator=(const TargetCharacteristics &) = default;
+
+  bool isBigEndian() const { return isBigEndian_; }
+  void set_isBigEndian(bool isBig = true);
+
+  bool areSubnormalsFlushedToZero() const {
+    return areSubnormalsFlushedToZero_;
+  }
+  void set_areSubnormalsFlushedToZero(bool yes = true);
+
+  Rounding roundingMode() const { return roundingMode_; }
+  void set_roundingMode(Rounding);
+
+  std::size_t procedurePointerByteSize() const {
+    return procedurePointerByteSize_;
+  }
+  std::size_t procedurePointerAlignment() const {
+    return procedurePointerAlignment_;
+  }
+  std::size_t descriptorAlignment() const { return descriptorAlignment_; }
+  std::size_t maxByteSize() const { return maxByteSize_; }
+  std::size_t maxAlignment() const { return maxAlignment_; }
+
+  static bool CanSupportType(common::TypeCategory, std::int64_t kind);
+  bool EnableType(common::TypeCategory category, std::int64_t kind,
+      std::size_t byteSize, std::size_t align);
+  void DisableType(common::TypeCategory category, std::int64_t kind);
+
+  std::size_t GetByteSize(
+      common::TypeCategory category, std::int64_t kind) const;
+  std::size_t GetAlignment(
+      common::TypeCategory category, std::int64_t kind) const;
+  bool IsTypeEnabled(common::TypeCategory category, std::int64_t kind) const;
+
+  int SelectedIntKind(std::int64_t precision = 0) const;
+  int SelectedRealKind(std::int64_t precision = 0, std::int64_t range = 0,
+      std::int64_t radix = 2) const;
+
+  static Rounding defaultRounding;
+
+private:
+  static constexpr int maxKind{32};
+  std::uint8_t byteSize_[common::TypeCategory_enumSize][maxKind]{};
+  std::uint8_t align_[common::TypeCategory_enumSize][maxKind]{};
+  bool isBigEndian_{false};
+  bool areSubnormalsFlushedToZero_{false};
+  Rounding roundingMode_{defaultRounding};
+  std::size_t procedurePointerByteSize_{8};
+  std::size_t procedurePointerAlignment_{8};
+  std::size_t descriptorAlignment_{8};
+  std::size_t maxByteSize_{8 /*at least*/};
+  std::size_t maxAlignment_{8 /*at least*/};
+};
+
+} // namespace Fortran::evaluate
+#endif // FORTRAN_EVALUATE_TARGET_H_

flang/include/flang/Evaluate/type.h

 class ParamValue;
 class Symbol;
 bool IsDescriptor(const Symbol &);
 } // namespace Fortran::semantics
 
 namespace Fortran::evaluate {
 
 using common::TypeCategory;
+class TargetCharacteristics;
 
 // Specific intrinsic types are represented by specializations of
 // this class template Type<CATEGORY, KIND>.
 template <TypeCategory CATEGORY, int KIND = 0> class Type;
 
 using SubscriptInteger = Type<TypeCategory::Integer, 8>;
 using CInteger = Type<TypeCategory::Integer, 4>;
 using LargestInt = Type<TypeCategory::Integer, 16>;
 using LogicalResult = Type<TypeCategory::Logical, 4>;
 using LargestReal = Type<TypeCategory::Real, 16>;
 using Ascii = Type<TypeCategory::Character, 1>;
 
 // A predicate that is true when a kind value is a kind that could possibly
 // be supported for an intrinsic type category on some target instruction
 // set architecture.
-// TODO: specialize for the actual target architecture
 static constexpr bool IsValidKindOfIntrinsicType(
     TypeCategory category, std::int64_t kind) {
   switch (category) {
   case TypeCategory::Integer:
     return kind == 1 || kind == 2 || kind == 4 || kind == 8 || kind == 16;
   case TypeCategory::Real:
   case TypeCategory::Complex:
     return kind == 2 || kind == 3 || kind == 4 || kind == 8 || kind == 10 ||
#if defined(_GLIBCXX_RELEASE) && _GLIBCXX_RELEASE == 7
     if (knownLength_ < 0) {
       return std::nullopt;
     }
 #endif
     return knownLength_;
   }
   std::optional<Expr<SubscriptInteger>> GetCharLength() const;
 
-  std::size_t GetAlignment(const FoldingContext &) const;
+  std::size_t GetAlignment(const TargetCharacteristics &) const;
   std::optional<Expr<SubscriptInteger>> MeasureSizeInBytes(
       FoldingContext &, bool aligned) const;
 
   std::string AsFortran() const;
   std::string AsFortran(std::string &&charLenExpr) const;
   DynamicType ResultTypeForMultiply(const DynamicType &) const;
 
   bool IsAssumedLengthCharacter() const;
static constexpr int index{
       common::SearchMembers<Predicate, AllIntrinsicTypes>};
   using type = std::conditional_t<index >= 0,
       std::tuple_element_t<index, AllIntrinsicTypes>, void>;
 };
 
 template <typename CONST> using TypeOf = typename TypeOfHelper<CONST>::type;
 
 int SelectedCharKind(const std::string &, int defaultKind);
-int SelectedIntKind(std::int64_t precision = 0);
-int SelectedRealKind(
-    std::int64_t precision = 0, std::int64_t range = 0, std::int64_t radix = 2);
+// SelectedIntKind and SelectedRealKind are now member functions of
+// TargetCharactertics.
 
 // Given the dynamic types and kinds of two operands, determine the common
 // type to which they must be converted in order to be compared with
 // intrinsic OPERATOR(==) or .EQV.
 std::optional<DynamicType> ComparisonType(
     const DynamicType &, const DynamicType &);
 
 // For generating "[extern] template class", &c. boilerplate

flang/include/flang/Lower/Bridge.h

 #include "mlir/IR/BuiltinOps.h"
 
 namespace Fortran {
 namespace common {
 class IntrinsicTypeDefaultKinds;
 } // namespace common
 namespace evaluate {
 class IntrinsicProcTable;
+class TargetCharacteristics;
 } // namespace evaluate
 namespace parser {
 class AllCookedSources;
 struct Program;
 } // namespace parser
 namespace semantics {
 class SemanticsContext;
 } // namespace semantics
 
 namespace lower {
 
 //===----------------------------------------------------------------------===//
 // Lowering bridge
 //===----------------------------------------------------------------------===//
 
 /// The lowering bridge converts the front-end parse trees and semantics
 /// checking residual to MLIR (FIR dialect) code.
 class LoweringBridge {
 public:
   /// Create a lowering bridge instance.
   static LoweringBridge
   create(mlir::MLIRContext &ctx,
          const Fortran::common::IntrinsicTypeDefaultKinds &defaultKinds,
          const Fortran::evaluate::IntrinsicProcTable &intrinsics,
+         const Fortran::evaluate::TargetCharacteristics &targetCharacteristics,
          const Fortran::parser::AllCookedSources &allCooked,
          llvm::StringRef triple, fir::KindMapping &kindMap) {
-    return LoweringBridge(ctx, defaultKinds, intrinsics, allCooked, triple,
-                          kindMap);
+    return LoweringBridge(ctx, defaultKinds, intrinsics, targetCharacteristics,
+                          allCooked, triple, kindMap);
   }
 
   //===--------------------------------------------------------------------===//
   // Getters
   //===--------------------------------------------------------------------===//
 
   mlir::MLIRContext &getMLIRContext() { return context; }
 
   /// Get the ModuleOp. It can never be null, which is asserted in the ctor.
   mlir::ModuleOp &getModule() { return *module.get(); }
 
   const Fortran::common::IntrinsicTypeDefaultKinds &getDefaultKinds() const {
     return defaultKinds;
   }
   const Fortran::evaluate::IntrinsicProcTable &getIntrinsicTable() const {
     return intrinsics;
   }
+  const Fortran::evaluate::TargetCharacteristics &
+  getTargetCharacteristics() const {
+    return targetCharacteristics;
+  }
   const Fortran::parser::AllCookedSources *getCookedSource() const {
     return cooked;
   }
 
   /// Get the kind map.
   const fir::KindMapping &getKindMap() const { return kindMap; }
 
   /// Create a folding context. Careful: this is very expensive.
public:
   void lower(const Fortran::parser::Program &program,
              const Fortran::semantics::SemanticsContext &semanticsContext);
 
 private:
   explicit LoweringBridge(
       mlir::MLIRContext &ctx,
       const Fortran::common::IntrinsicTypeDefaultKinds &defaultKinds,
       const Fortran::evaluate::IntrinsicProcTable &intrinsics,
+      const Fortran::evaluate::TargetCharacteristics &targetCharacteristics,
       const Fortran::parser::AllCookedSources &cooked, llvm::StringRef triple,
       fir::KindMapping &kindMap);
   LoweringBridge() = delete;
   LoweringBridge(const LoweringBridge &) = delete;
 
   const Fortran::common::IntrinsicTypeDefaultKinds &defaultKinds;
   const Fortran::evaluate::IntrinsicProcTable &intrinsics;
+  const Fortran::evaluate::TargetCharacteristics &targetCharacteristics;
   const Fortran::parser::AllCookedSources *cooked;
   mlir::MLIRContext &context;
   std::unique_ptr<mlir::ModuleOp> module;
   fir::KindMapping &kindMap;
 };
 
 } // namespace lower
 } // namespace Fortran
 
 #endif // FORTRAN_LOWER_BRIDGE_H

flang/include/flang/Semantics/semantics.h

 //===-- include/flang/Semantics/semantics.h ---------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_SEMANTICS_SEMANTICS_H_
 #define FORTRAN_SEMANTICS_SEMANTICS_H_
 
 #include "scope.h"
 #include "symbol.h"
 #include "flang/Common/Fortran-features.h"
 #include "flang/Evaluate/common.h"
 #include "flang/Evaluate/intrinsics.h"
+#include "flang/Evaluate/target.h"
 #include "flang/Parser/message.h"
 #include <iosfwd>
 #include <set>
 #include <string>
 #include <vector>
 
 namespace llvm {
 class raw_ostream;
const std::vector<std::string> &intrinsicModuleDirectories() const {
     return intrinsicModuleDirectories_;
   }
   const std::string &moduleDirectory() const { return moduleDirectory_; }
   const std::string &moduleFileSuffix() const { return moduleFileSuffix_; }
   bool warnOnNonstandardUsage() const { return warnOnNonstandardUsage_; }
   bool warningsAreErrors() const { return warningsAreErrors_; }
   bool debugModuleWriter() const { return debugModuleWriter_; }
   const evaluate::IntrinsicProcTable &intrinsics() const { return intrinsics_; }
+  const evaluate::TargetCharacteristics &targetCharacteristics() const {
+    return targetCharacteristics_;
+  }
+  evaluate::TargetCharacteristics &targetCharacteristics() {
+    return targetCharacteristics_;
+  }
   Scope &globalScope() { return globalScope_; }
   Scope &intrinsicModulesScope() { return intrinsicModulesScope_; }
   parser::Messages &messages() { return messages_; }
   evaluate::FoldingContext &foldingContext() { return foldingContext_; }
   parser::AllCookedSources &allCookedSources() { return allCookedSources_; }
 
   SemanticsContext &set_location(
       const std::optional<parser::CharBlock> &location) {
private:
   std::vector<std::string> searchDirectories_;
   std::vector<std::string> intrinsicModuleDirectories_;
   std::string moduleDirectory_{"."s};
   std::string moduleFileSuffix_{".mod"};
   bool warnOnNonstandardUsage_{false};
   bool warningsAreErrors_{false};
   bool debugModuleWriter_{false};
   const evaluate::IntrinsicProcTable intrinsics_;
+  evaluate::TargetCharacteristics targetCharacteristics_;
   Scope globalScope_;
   Scope &intrinsicModulesScope_;
   parser::Messages messages_;
   evaluate::FoldingContext foldingContext_;
   ConstructStack constructStack_;
   struct IndexVarInfo {
     parser::CharBlock location;
     IndexVarKind kind;

flang/lib/Evaluate/CMakeLists.txt

add_flang_library(FortranEvaluate
   initial-image.cpp
   integer.cpp
   intrinsics.cpp
   intrinsics-library.cpp
   logical.cpp
   real.cpp
   shape.cpp
   static-data.cpp
+  target.cpp
   tools.cpp
   type.cpp
   variable.cpp
 
   LINK_LIBS
   FortranCommon
   FortranDecimal
   FortranParser
   ${LIBPGMATH}
 
   LINK_COMPONENTS
   Support
 
   DEPENDS
   acc_gen
   omp_gen
 )
-

flang/lib/Evaluate/characteristics.cpp

return omitShapeConformanceCheck ||
           .value_or(true /*fail only when nonconformance is known now*/);
 }
 
 std::optional<Expr<SubscriptInteger>> TypeAndShape::MeasureElementSizeInBytes(
     FoldingContext &foldingContext, bool align) const {
   if (LEN_) {
     CHECK(type_.category() == TypeCategory::Character);
     return Fold(foldingContext,
-        Expr<SubscriptInteger>{type_.kind()} * Expr<SubscriptInteger>{*LEN_});
+        Expr<SubscriptInteger>{
+            foldingContext.targetCharacteristics().GetByteSize(
+                type_.category(), type_.kind())} *
+            Expr<SubscriptInteger>{*LEN_});
   }
   if (auto elementBytes{type_.MeasureSizeInBytes(foldingContext, align)}) {
     return Fold(foldingContext, std::move(*elementBytes));
   }
   return std::nullopt;
 }
 
 std::optional<Expr<SubscriptInteger>> TypeAndShape::MeasureSizeInBytes(

flang/lib/Evaluate/fold-implementation.h

return common::visit(
               return ScalarConstantToExpr(std::move(converted.value));
             } else if constexpr (FromCat == TypeCategory::Real) {
               auto converted{Scalar<TO>::Convert(*value)};
               if (!converted.flags.empty()) {
                 std::snprintf(buffer, sizeof buffer,
                     "REAL(%d) to REAL(%d) conversion", Operand::kind, TO::kind);
                 RealFlagWarnings(ctx, converted.flags, buffer);
               }
-              if (ctx.flushSubnormalsToZero()) {
+              if (ctx.targetCharacteristics().areSubnormalsFlushedToZero()) {
                 converted.value = converted.value.FlushSubnormalToZero();
               }
               return ScalarConstantToExpr(std::move(converted.value));
             }
           } else if constexpr (TO::category == TypeCategory::Complex) {
             if constexpr (FromCat == TypeCategory::Complex) {
               return FoldOperation(ctx,
                   ComplexConstructor<TO::kind>{
if (auto folded{OperandsAreConstants(x)}) {
     if constexpr (T::category == TypeCategory::Integer) {
       auto sum{folded->first.AddSigned(folded->second)};
       if (sum.overflow) {
         context.messages().Say(
             "INTEGER(%d) addition overflowed"_warn_en_US, T::kind);
       }
       return Expr<T>{Constant<T>{sum.value}};
     } else {
-      auto sum{folded->first.Add(folded->second, context.rounding())};
+      auto sum{folded->first.Add(
+          folded->second, context.targetCharacteristics().roundingMode())};
       RealFlagWarnings(context, sum.flags, "addition");
-      if (context.flushSubnormalsToZero()) {
+      if (context.targetCharacteristics().areSubnormalsFlushedToZero()) {
         sum.value = sum.value.FlushSubnormalToZero();
       }
       return Expr<T>{Constant<T>{sum.value}};
     }
   }
   return Expr<T>{std::move(x)};
 }
 
 template <typename T>
 Expr<T> FoldOperation(FoldingContext &context, Subtract<T> &&x) {
   if (auto array{ApplyElementwise(context, x)}) {
     return *array;
   }
   if (auto folded{OperandsAreConstants(x)}) {
     if constexpr (T::category == TypeCategory::Integer) {
       auto difference{folded->first.SubtractSigned(folded->second)};
       if (difference.overflow) {
         context.messages().Say(
             "INTEGER(%d) subtraction overflowed"_warn_en_US, T::kind);
       }
       return Expr<T>{Constant<T>{difference.value}};
     } else {
-      auto difference{
-          folded->first.Subtract(folded->second, context.rounding())};
+      auto difference{folded->first.Subtract(
+          folded->second, context.targetCharacteristics().roundingMode())};
       RealFlagWarnings(context, difference.flags, "subtraction");
-      if (context.flushSubnormalsToZero()) {
+      if (context.targetCharacteristics().areSubnormalsFlushedToZero()) {
         difference.value = difference.value.FlushSubnormalToZero();
       }
       return Expr<T>{Constant<T>{difference.value}};
     }
   }
   return Expr<T>{std::move(x)};
 }
 
 template <typename T>
 Expr<T> FoldOperation(FoldingContext &context, Multiply<T> &&x) {
   if (auto array{ApplyElementwise(context, x)}) {
     return *array;
   }
   if (auto folded{OperandsAreConstants(x)}) {
     if constexpr (T::category == TypeCategory::Integer) {
       auto product{folded->first.MultiplySigned(folded->second)};
       if (product.SignedMultiplicationOverflowed()) {
         context.messages().Say(
             "INTEGER(%d) multiplication overflowed"_warn_en_US, T::kind);
       }
       return Expr<T>{Constant<T>{product.lower}};
     } else {
-      auto product{folded->first.Multiply(folded->second, context.rounding())};
+      auto product{folded->first.Multiply(
+          folded->second, context.targetCharacteristics().roundingMode())};
       RealFlagWarnings(context, product.flags, "multiplication");
-      if (context.flushSubnormalsToZero()) {
+      if (context.targetCharacteristics().areSubnormalsFlushedToZero()) {
         product.value = product.value.FlushSubnormalToZero();
       }
       return Expr<T>{Constant<T>{product.value}};
     }
   } else if constexpr (T::category == TypeCategory::Integer) {
     if (auto c{GetScalarConstantValue<T>(x.right())}) {
       x.right() = std::move(x.left());
       x.left() = Expr<T>{std::move(*c)};
if constexpr (T::category == TypeCategory::Integer) {
         return Expr<T>{std::move(x)};
       }
       if (quotAndRem.overflow) {
         context.messages().Say(
             "INTEGER(%d) division overflowed"_warn_en_US, T::kind);
       }
       return Expr<T>{Constant<T>{quotAndRem.quotient}};
     } else {
-      auto quotient{folded->first.Divide(folded->second, context.rounding())};
+      auto quotient{folded->first.Divide(
+          folded->second, context.targetCharacteristics().roundingMode())};
       // Don't warn about -1./0., 0./0., or 1./0. from a module file
       // they are interpreted as canonical Fortran representations of -Inf,
       // NaN, and Inf respectively.
       bool isCanonicalNaNOrInf{false};
       if constexpr (T::category == TypeCategory::Real) {
         if (folded->second.IsZero() && context.inModuleFile()) {
           using IntType = typename T::Scalar::Word;
           auto intNumerator{folded->first.template ToInteger<IntType>()};
           isCanonicalNaNOrInf = intNumerator.flags == RealFlags{} &&
               intNumerator.value >= IntType{-1} &&
               intNumerator.value <= IntType{1};
         }
       }
       if (!isCanonicalNaNOrInf) {
         RealFlagWarnings(context, quotient.flags, "division");
       }
-      if (context.flushSubnormalsToZero()) {
+      if (context.targetCharacteristics().areSubnormalsFlushedToZero()) {
         quotient.value = quotient.value.FlushSubnormalToZero();
       }
       return Expr<T>{Constant<T>{quotient.value}};
     }
   }
   return Expr<T>{std::move(x)};
 }
 
Expr<T> FoldOperation(FoldingContext &context, RealToIntPower<T> &&x) {
   if (auto array{ApplyElementwise(context, x)}) {
     return *array;
   }
   return common::visit(
       [&](auto &y) -> Expr<T> {
         if (auto folded{OperandsAreConstants(x.left(), y)}) {
           auto power{evaluate::IntPower(folded->first, folded->second)};
           RealFlagWarnings(context, power.flags, "power with INTEGER exponent");
-          if (context.flushSubnormalsToZero()) {
+          if (context.targetCharacteristics().areSubnormalsFlushedToZero()) {
             power.value = power.value.FlushSubnormalToZero();
           }
           return Expr<T>{Constant<T>{power.value}};
         } else {
           return Expr<T>{std::move(x)};
         }
       },
       x.right().u);

flang/lib/Evaluate/fold-integer.cpp

if (const auto *chCon{UnwrapExpr<Constant<TypeOf<std::string>>>(args[0])}) {
       if (std::optional<std::string> value{chCon->GetScalarValue()}) {
         int defaultKind{
             context.defaults().GetDefaultKind(TypeCategory::Character)};
         return Expr<T>{SelectedCharKind(*value, defaultKind)};
       }
     }
   } else if (name == "selected_int_kind") {
     if (auto p{GetInt64Arg(args[0])}) {
-      return Expr<T>{SelectedIntKind(*p)};
+      return Expr<T>{context.targetCharacteristics().SelectedIntKind(*p)};
     }
   } else if (name == "selected_real_kind" ||
       name == "__builtin_ieee_selected_real_kind") {
     if (auto p{GetInt64ArgOr(args[0], 0)}) {
       if (auto r{GetInt64ArgOr(args[1], 0)}) {
         if (auto radix{GetInt64ArgOr(args[2], 2)}) {
-          return Expr<T>{SelectedRealKind(*p, *r, *radix)};
+          return Expr<T>{
+              context.targetCharacteristics().SelectedRealKind(*p, *r, *radix)};
         }
       }
     }
   } else if (name == "shape") {
     if (auto shape{GetContextFreeShape(context, args[0])}) {
       if (auto shapeExpr{AsExtentArrayExpr(*shape)}) {
         return Fold(context, ConvertToType<T>(std::move(*shapeExpr)));
       }

flang/lib/Evaluate/host.cpp

if (fegetenv(&currentFenv) != 0) {
     common::die("Folding with host runtime: fegetenv() failed: %s",
         llvm::sys::StrError(errno).c_str());
     return;
   }
 #if __x86_64__
   hasSubnormalFlushingHardwareControl_ = true;
   originalMxcsr = _mm_getcsr();
   unsigned int currentMxcsr{originalMxcsr};
-  if (context.flushSubnormalsToZero()) {
+  if (context.targetCharacteristics().areSubnormalsFlushedToZero()) {
     currentMxcsr |= 0x8000;
     currentMxcsr |= 0x0040;
   } else {
     currentMxcsr &= ~0x8000;
     currentMxcsr &= ~0x0040;
   }
 #elif defined(__aarch64__)
 #if defined(__GNU_LIBRARY__)
   hasSubnormalFlushingHardwareControl_ = true;
-  if (context.flushSubnormalsToZero()) {
+  if (context.targetCharacteristics().areSubnormalsFlushedToZero()) {
     currentFenv.__fpcr |= (1U << 24); // control register
   } else {
     currentFenv.__fpcr &= ~(1U << 24); // control register
   }
 #elif defined(__BIONIC__)
   hasSubnormalFlushingHardwareControl_ = true;
-  if (context.flushSubnormalsToZero()) {
+  if (context.targetCharacteristics().areSubnormalsFlushedToZero()) {
     currentFenv.__control |= (1U << 24); // control register
   } else {
     currentFenv.__control &= ~(1U << 24); // control register
   }
 #else
   // If F18 is built with other C libraries on AArch64, software flushing will
   // be performed around host library calls if subnormal flushing is requested
 #endif
if (fesetenv(&currentFenv) != 0) {
     common::die("Folding with host runtime: fesetenv() failed: %s",
         llvm::sys::StrError(errno).c_str());
     return;
   }
 #if __x86_64__
   _mm_setcsr(currentMxcsr);
 #endif
 
-  switch (context.rounding().mode) {
+  switch (context.targetCharacteristics().roundingMode().mode) {
   case common::RoundingMode::TiesToEven:
     fesetround(FE_TONEAREST);
     break;
   case common::RoundingMode::ToZero:
     fesetround(FE_TOWARDZERO);
     break;
   case common::RoundingMode::Up:
     fesetround(FE_UPWARD);

flang/lib/Evaluate/int-power.h

 //===-- lib/Evaluate/int-power.h --------------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_EVALUATE_INT_POWER_H_
 #define FORTRAN_EVALUATE_INT_POWER_H_
 
 // Computes an integer power of a real or complex value.
 
-#include "flang/Evaluate/common.h"
+#include "flang/Evaluate/target.h"
 
 namespace Fortran::evaluate {
 
 template <typename REAL, typename INT>
 ValueWithRealFlags<REAL> TimesIntPowerOf(const REAL &factor, const REAL &base,
-    const INT &power, Rounding rounding = defaultRounding) {
+    const INT &power,
+    Rounding rounding = TargetCharacteristics::defaultRounding) {
   ValueWithRealFlags<REAL> result{factor};
   if (base.IsNotANumber()) {
     result.value = REAL::NotANumber();
     result.flags.set(RealFlag::InvalidArgument);
   } else if (power.IsZero()) {
     if (base.IsZero() || base.IsInfinite()) {
       result.flags.set(RealFlag::InvalidArgument);
     }
for (int j{0}; j < nbits; ++j) {
       squares =
           squares.Multiply(squares, rounding).AccumulateFlags(result.flags);
     }
   }
   return result;
 }
 
 template <typename REAL, typename INT>
-ValueWithRealFlags<REAL> IntPower(
-    const REAL &base, const INT &power, Rounding rounding = defaultRounding) {
+ValueWithRealFlags<REAL> IntPower(const REAL &base, const INT &power,
+    Rounding rounding = TargetCharacteristics::defaultRounding) {
   REAL one{REAL::FromInteger(INT{1}).value};
   return TimesIntPowerOf(one, base, power, rounding);
 }
 } // namespace Fortran::evaluate
 #endif // FORTRAN_EVALUATE_INT_POWER_H_

flang/lib/Evaluate/intrinsics-library.cpp

static Expr<SomeType> ApplyHostFunctionHelper(FuncType func,
     FoldingContext &context, std::vector<Expr<SomeType>> &&args,
     std::index_sequence<I...>) {
   host::HostFloatingPointEnvironment hostFPE;
   hostFPE.SetUpHostFloatingPointEnvironment(context);
   host::HostType<TR> hostResult{};
   Scalar<TR> result{};
   std::tuple<Scalar<TA>...> scalarArgs{
       GetScalarConstantValue<TA>(args[I]).value()...};
-  if (context.flushSubnormalsToZero() &&
+  if (context.targetCharacteristics().areSubnormalsFlushedToZero() &&
       !hostFPE.hasSubnormalFlushingHardwareControl()) {
     hostResult = func(host::CastFortranToHost<TA>(
         FlushSubnormals<TA>(std::move(std::get<I>(scalarArgs))))...);
     result = FlushSubnormals<TR>(host::CastHostToFortran<TR>(hostResult));
   } else {
     hostResult = func(host::CastFortranToHost<TA>(std::get<I>(scalarArgs))...);
     result = host::CastHostToFortran<TR>(hostResult);
   }

flang/lib/Evaluate/intrinsics.cpp

case KindCode::operand:
       break;
     case KindCode::effectiveKind:
       CHECK(kindDummyArg);
       CHECK(result.categorySet == CategorySet{*category});
       if (kindArg) {
         if (auto *expr{kindArg->UnwrapExpr()}) {
           CHECK(expr->Rank() == 0);
           if (auto code{ToInt64(*expr)}) {
-            if (IsValidKindOfIntrinsicType(*category, *code)) {
+            if (context.targetCharacteristics().IsTypeEnabled(
+                    *category, *code)) {
               if (*category == TypeCategory::Character) { // ACHAR & CHAR
                 resultType = DynamicType{static_cast<int>(*code), 1};
               } else {
                 resultType = DynamicType{*category, static_cast<int>(*code)};
               }
               break;
             }
           }

flang/lib/Evaluate/static-data.cpp

 //===-- lib/Evaluate/static-data.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
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Evaluate/static-data.h"
 #include "flang/Parser/characters.h"
 
 namespace Fortran::evaluate {
 
-bool StaticDataObject::bigEndian{false};
-
-llvm::raw_ostream &StaticDataObject::AsFortran(llvm::raw_ostream &o) const {
+llvm::raw_ostream &StaticDataObject::AsFortran(
+    llvm::raw_ostream &o, bool bigEndian) const {
   if (auto string{AsString()}) {
     o << parser::QuoteCharacterLiteral(*string);
-  } else if (auto string{AsU16String()}) {
+  } else if (auto string{AsU16String(bigEndian)}) {
     o << "2_" << parser::QuoteCharacterLiteral(*string);
-  } else if (auto string{AsU32String()}) {
+  } else if (auto string{AsU32String(bigEndian)}) {
     o << "4_" << parser::QuoteCharacterLiteral(*string);
   } else {
     CRASH_NO_CASE;
   }
   return o;
 }
 
-StaticDataObject &StaticDataObject::Push(const std::string &string) {
+StaticDataObject &StaticDataObject::Push(const std::string &string, bool) {
   for (auto ch : string) {
     data_.push_back(static_cast<std::uint8_t>(ch));
   }
   return *this;
 }
 
-StaticDataObject &StaticDataObject::Push(const std::u16string &string) {
-  int shift{bigEndian * 8};
+StaticDataObject &StaticDataObject::Push(
+    const std::u16string &string, bool bigEndian) {
+  int shift{bigEndian ? 8 : 0};
   for (auto ch : string) {
     data_.push_back(static_cast<std::uint8_t>(ch >> shift));
     data_.push_back(static_cast<std::uint8_t>(ch >> (shift ^ 8)));
   }
   return *this;
 }
 
-StaticDataObject &StaticDataObject::Push(const std::u32string &string) {
-  int shift{bigEndian * 24};
+StaticDataObject &StaticDataObject::Push(
+    const std::u32string &string, bool bigEndian) {
+  int shift{bigEndian ? 24 : 0};
   for (auto ch : string) {
     data_.push_back(static_cast<std::uint8_t>(ch >> shift));
     data_.push_back(static_cast<std::uint8_t>(ch >> (shift ^ 8)));
     data_.push_back(static_cast<std::uint8_t>(ch >> (shift ^ 16)));
     data_.push_back(static_cast<std::uint8_t>(ch >> (shift ^ 24)));
   }
   return *this;
 }
 
 std::optional<std::string> StaticDataObject::AsString() const {
   if (itemBytes_ <= 1) {
     std::string result;
     for (std::uint8_t byte : data_) {
       result += static_cast<char>(byte);
     }
     return {std::move(result)};
   }
   return std::nullopt;
 }
 
-std::optional<std::u16string> StaticDataObject::AsU16String() const {
+std::optional<std::u16string> StaticDataObject::AsU16String(
+    bool bigEndian) const {
   if (itemBytes_ == 2) {
-    int shift{bigEndian * 8};
+    int shift{bigEndian ? 8 : 0};
     std::u16string result;
     auto end{data_.cend()};
     for (auto byte{data_.cbegin()}; byte < end;) {
       result += static_cast<char16_t>(*byte++) << shift |
           static_cast<char16_t>(*byte++) << (shift ^ 8);
     }
     return {std::move(result)};
   }
   return std::nullopt;
 }
 
-std::optional<std::u32string> StaticDataObject::AsU32String() const {
+std::optional<std::u32string> StaticDataObject::AsU32String(
+    bool bigEndian) const {
   if (itemBytes_ == 4) {
-    int shift{bigEndian * 24};
+    int shift{bigEndian ? 24 : 0};
     std::u32string result;
     auto end{data_.cend()};
     for (auto byte{data_.cbegin()}; byte < end;) {
       result += static_cast<char32_t>(*byte++) << shift |
           static_cast<char32_t>(*byte++) << (shift ^ 8) |
           static_cast<char32_t>(*byte++) << (shift ^ 16) |
           static_cast<char32_t>(*byte++) << (shift ^ 24);
     }
     return {std::move(result)};
   }
   return std::nullopt;
 }
 } // namespace Fortran::evaluate

flang/lib/Evaluate/target.cpp

+//===-- lib/Semantics/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
+//
+//===----------------------------------------------------------------------===//
+
+#include "flang/Evaluate/target.h"
+#include "flang/Common/template.h"
+#include "flang/Evaluate/common.h"
+#include "flang/Evaluate/type.h"
+
+namespace Fortran::evaluate {
+
+Rounding TargetCharacteristics::defaultRounding;
+
+TargetCharacteristics::TargetCharacteristics() {
+  // TODO: Fill in the type information from command-line targeting information.
+  auto enableCategoryKinds{[this](TypeCategory category) {
+    for (int kind{0}; kind < maxKind; ++kind) {
+      if (CanSupportType(category, kind)) {
+        auto byteSize{static_cast<std::size_t>(kind)};
+        if (category == TypeCategory::Real ||
+            category == TypeCategory::Complex) {
+          if (kind == 3) {
+            // non-IEEE 16-bit format (truncated 32-bit)
+            byteSize = 2;
+          } else if (kind == 10) {
+            // x87 floating-point
+            // Follow gcc precedent for "long double"
+            byteSize = 16;
+          }
+        }
+        std::size_t align{byteSize};
+        if (category == TypeCategory::Complex) {
+          byteSize = 2 * byteSize;
+        }
+        EnableType(category, kind, byteSize, align);
+      }
+    }
+  }};
+  enableCategoryKinds(TypeCategory::Integer);
+  enableCategoryKinds(TypeCategory::Real);
+  enableCategoryKinds(TypeCategory::Complex);
+  enableCategoryKinds(TypeCategory::Character);
+  enableCategoryKinds(TypeCategory::Logical);
+
+  isBigEndian_ = !isHostLittleEndian;
+
+  areSubnormalsFlushedToZero_ = false;
+}
+
+bool TargetCharacteristics::CanSupportType(
+    TypeCategory category, std::int64_t kind) {
+  return IsValidKindOfIntrinsicType(category, kind);
+}
+
+bool TargetCharacteristics::EnableType(common::TypeCategory category,
+    std::int64_t kind, std::size_t byteSize, std::size_t align) {
+  if (CanSupportType(category, kind)) {
+    byteSize_[static_cast<int>(category)][kind] = byteSize;
+    align_[static_cast<int>(category)][kind] = align;
+    maxByteSize_ = std::max(maxByteSize_, byteSize);
+    maxAlignment_ = std::max(maxAlignment_, align);
+    return true;
+  } else {
+    return false;
+  }
+}
+
+void TargetCharacteristics::DisableType(
+    common::TypeCategory category, std::int64_t kind) {
+  if (kind >= 0 && kind < maxKind) {
+    align_[static_cast<int>(category)][kind] = 0;
+  }
+}
+
+std::size_t TargetCharacteristics::GetByteSize(
+    common::TypeCategory category, std::int64_t kind) const {
+  if (kind >= 0 && kind < maxKind) {
+    return byteSize_[static_cast<int>(category)][kind];
+  } else {
+    return 0;
+  }
+}
+
+std::size_t TargetCharacteristics::GetAlignment(
+    common::TypeCategory category, std::int64_t kind) const {
+  if (kind >= 0 && kind < maxKind) {
+    return align_[static_cast<int>(category)][kind];
+  } else {
+    return 0;
+  }
+}
+
+bool TargetCharacteristics::IsTypeEnabled(
+    common::TypeCategory category, std::int64_t kind) const {
+  return GetAlignment(category, kind) > 0;
+}
+
+void TargetCharacteristics::set_isBigEndian(bool isBig) {
+  isBigEndian_ = isBig;
+}
+
+void TargetCharacteristics::set_areSubnormalsFlushedToZero(bool yes) {
+  areSubnormalsFlushedToZero_ = yes;
+}
+
+void TargetCharacteristics::set_roundingMode(Rounding rounding) {
+  roundingMode_ = rounding;
+}
+
+// SELECTED_INT_KIND() -- F'2018 16.9.169
+class SelectedIntKindVisitor {
+public:
+  SelectedIntKindVisitor(
+      const TargetCharacteristics &targetCharacteristics, std::int64_t p)
+      : targetCharacteristics_{targetCharacteristics}, precision_{p} {}
+  using Result = std::optional<int>;
+  using Types = IntegerTypes;
+  template <typename T> Result Test() const {
+    if (Scalar<T>::RANGE >= precision_ &&
+        targetCharacteristics_.IsTypeEnabled(T::category, T::kind)) {
+      return T::kind;
+    } else {
+      return std::nullopt;
+    }
+  }
+
+private:
+  const TargetCharacteristics &targetCharacteristics_;
+  std::int64_t precision_;
+};
+
+int TargetCharacteristics::SelectedIntKind(std::int64_t precision) const {
+  if (auto kind{
+          common::SearchTypes(SelectedIntKindVisitor{*this, precision})}) {
+    return *kind;
+  } else {
+    return -1;
+  }
+}
+
+// SELECTED_REAL_KIND() -- F'2018 16.9.170
+class SelectedRealKindVisitor {
+public:
+  SelectedRealKindVisitor(const TargetCharacteristics &targetCharacteristics,
+      std::int64_t p, std::int64_t r)
+      : targetCharacteristics_{targetCharacteristics}, precision_{p}, range_{
+                                                                          r} {}
+  using Result = std::optional<int>;
+  using Types = RealTypes;
+  template <typename T> Result Test() const {
+    if (Scalar<T>::PRECISION >= precision_ && Scalar<T>::RANGE >= range_ &&
+        targetCharacteristics_.IsTypeEnabled(T::category, T::kind)) {
+      return {T::kind};
+    } else {
+      return std::nullopt;
+    }
+  }
+
+private:
+  const TargetCharacteristics &targetCharacteristics_;
+  std::int64_t precision_, range_;
+};
+
+int TargetCharacteristics::SelectedRealKind(
+    std::int64_t precision, std::int64_t range, std::int64_t radix) const {
+  if (radix != 2) {
+    return -5;
+  }
+  if (auto kind{common::SearchTypes(
+          SelectedRealKindVisitor{*this, precision, range})}) {
+    return *kind;
+  }
+  // No kind has both sufficient precision and sufficient range.
+  // The negative return value encodes whether any kinds exist that
+  // could satisfy either constraint independently.
+  bool pOK{common::SearchTypes(SelectedRealKindVisitor{*this, precision, 0})};
+  bool rOK{common::SearchTypes(SelectedRealKindVisitor{*this, 0, range})};
+  if (pOK) {
+    if (rOK) {
+      return -4;
+    } else {
+      return -2;
+    }
+  } else {
+    if (rOK) {
+      return -1;
+    } else {
+      return -3;
+    }
+  }
+}
+
+} // namespace Fortran::evaluate

flang/lib/Evaluate/type.cpp

 //===-- lib/Evaluate/type.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
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Evaluate/type.h"
 #include "flang/Common/idioms.h"
-#include "flang/Common/template.h"
 #include "flang/Evaluate/expression.h"
 #include "flang/Evaluate/fold.h"
+#include "flang/Evaluate/target.h"
 #include "flang/Parser/characters.h"
 #include "flang/Semantics/scope.h"
 #include "flang/Semantics/symbol.h"
 #include "flang/Semantics/tools.h"
 #include "flang/Semantics/type.h"
 #include <algorithm>
 #include <optional>
 #include <string>
if (knownLength()) {
       if (auto length{charLengthParamValue_->GetExplicit()}) {
         return ConvertToType<SubscriptInteger>(std::move(*length));
       }
     }
   }
   return std::nullopt;
 }
 
-static constexpr std::size_t RealKindBytes(int kind) {
-  switch (kind) {
-  case 3: // non-IEEE 16-bit format (truncated 32-bit)
-    return 2;
-  case 10: // 80387 80-bit extended precision
-  case 12: // possible variant spelling
-    return 16;
-  default:
-    return kind;
-  }
-}
-
-std::size_t DynamicType::GetAlignment(const FoldingContext &context) const {
-  switch (category_) {
-  case TypeCategory::Integer:
-  case TypeCategory::Character:
-  case TypeCategory::Logical:
-    return std::min<std::size_t>(kind_, context.maxAlignment());
-  case TypeCategory::Real:
-  case TypeCategory::Complex:
-    return std::min(RealKindBytes(kind_), context.maxAlignment());
-  case TypeCategory::Derived:
+std::size_t DynamicType::GetAlignment(
+    const TargetCharacteristics &targetCharacteristics) const {
+  if (category_ == TypeCategory::Derived) {
     if (derived_ && derived_->scope()) {
       return derived_->scope()->alignment().value_or(1);
     }
-    break;
+  } else {
+    return targetCharacteristics.GetAlignment(category_, kind_);
   }
   return 1; // needs to be after switch to dodge a bogus gcc warning
 }
 
 std::optional<Expr<SubscriptInteger>> DynamicType::MeasureSizeInBytes(
     FoldingContext &context, bool aligned) const {
   switch (category_) {
   case TypeCategory::Integer:
-    return Expr<SubscriptInteger>{kind_};
   case TypeCategory::Real:
-    return Expr<SubscriptInteger>{RealKindBytes(kind_)};
   case TypeCategory::Complex:
-    return Expr<SubscriptInteger>{2 * RealKindBytes(kind_)};
+  case TypeCategory::Logical:
+    return Expr<SubscriptInteger>{
+        context.targetCharacteristics().GetByteSize(category_, kind_)};
   case TypeCategory::Character:
     if (auto len{GetCharLength()}) {
-      return Fold(context, Expr<SubscriptInteger>{kind_} * std::move(*len));
+      return Fold(context,
+          Expr<SubscriptInteger>{
+              context.targetCharacteristics().GetByteSize(category_, kind_)} *
+              std::move(*len));
     }
     break;
-  case TypeCategory::Logical:
-    return Expr<SubscriptInteger>{kind_};
   case TypeCategory::Derived:
     if (derived_ && derived_->scope()) {
       auto size{derived_->scope()->size()};
       auto align{aligned ? derived_->scope()->alignment().value_or(0) : 0};
       auto alignedSize{align > 0 ? ((size + align - 1) / align) * align : size};
       return Expr<SubscriptInteger>{
           static_cast<ConstantSubscript>(alignedSize)};
     }
if (lower == "ascii") {
     return 4;
   } else if (lower == "default") {
     return defaultKind;
   } else {
     return -1;
   }
 }
 
-class SelectedIntKindVisitor {
-public:
-  explicit SelectedIntKindVisitor(std::int64_t p) : precision_{p} {}
-  using Result = std::optional<int>;
-  using Types = IntegerTypes;
-  template <typename T> Result Test() const {
-    if (Scalar<T>::RANGE >= precision_) {
-      return T::kind;
-    } else {
-      return std::nullopt;
-    }
-  }
-
-private:
-  std::int64_t precision_;
-};
-
-int SelectedIntKind(std::int64_t precision) {
-  if (auto kind{common::SearchTypes(SelectedIntKindVisitor{precision})}) {
-    return *kind;
-  } else {
-    return -1;
-  }
-}
-
-class SelectedRealKindVisitor {
-public:
-  explicit SelectedRealKindVisitor(std::int64_t p, std::int64_t r)
-      : precision_{p}, range_{r} {}
-  using Result = std::optional<int>;
-  using Types = RealTypes;
-  template <typename T> Result Test() const {
-    if (Scalar<T>::PRECISION >= precision_ && Scalar<T>::RANGE >= range_) {
-      return {T::kind};
-    } else {
-      return std::nullopt;
-    }
-  }
-
-private:
-  std::int64_t precision_, range_;
-};
-
-int SelectedRealKind(
-    std::int64_t precision, std::int64_t range, std::int64_t radix) {
-  if (radix != 2) {
-    return -5;
-  }
-  if (auto kind{
-          common::SearchTypes(SelectedRealKindVisitor{precision, range})}) {
-    return *kind;
-  }
-  // No kind has both sufficient precision and sufficient range.
-  // The negative return value encodes whether any kinds exist that
-  // could satisfy either constraint independently.
-  bool pOK{common::SearchTypes(SelectedRealKindVisitor{precision, 0})};
-  bool rOK{common::SearchTypes(SelectedRealKindVisitor{0, range})};
-  if (pOK) {
-    if (rOK) {
-      return -4;
-    } else {
-      return -2;
-    }
-  } else {
-    if (rOK) {
-      return -1;
-    } else {
-      return -3;
-    }
-  }
-}
-
 std::optional<DynamicType> ComparisonType(
     const DynamicType &t1, const DynamicType &t2) {
   switch (t1.category()) {
   case TypeCategory::Integer:
     switch (t2.category()) {
     case TypeCategory::Integer:
       return DynamicType{TypeCategory::Integer, std::max(t1.kind(), t2.kind())};
     case TypeCategory::Real:

flang/lib/Frontend/FrontendActions.cpp

bool CodeGenAction::beginSourceFileAction() {
 
   // Create a LoweringBridge
   const common::IntrinsicTypeDefaultKinds &defKinds =
       ci.getInvocation().getSemanticsContext().defaultKinds();
   fir::KindMapping kindMap(mlirCtx.get(),
       llvm::ArrayRef<fir::KindTy>{fir::fromDefaultKinds(defKinds)});
   lower::LoweringBridge lb = Fortran::lower::LoweringBridge::create(
       *mlirCtx, defKinds, ci.getInvocation().getSemanticsContext().intrinsics(),
+      ci.getInvocation().getSemanticsContext().targetCharacteristics(),
       ci.getParsing().allCooked(), ci.getInvocation().getTargetOpts().triple,
       kindMap);
 
   // Create a parse tree and lower it to FIR
   Fortran::parser::Program &parseTree{*ci.getParsing().parseTree()};
   lb.lower(parseTree, ci.getInvocation().getSemanticsContext());
   mlirModule = std::make_unique<mlir::ModuleOp>(lb.getModule());
 

flang/lib/Lower/Bridge.cpp

   /// Tuple of host assoicated variables.
   mlir::Value hostAssocTuple;
 };
 
 } // namespace
 
 Fortran::evaluate::FoldingContext
 Fortran::lower::LoweringBridge::createFoldingContext() const {
-  return {getDefaultKinds(), getIntrinsicTable()};
+  return {getDefaultKinds(), getIntrinsicTable(), getTargetCharacteristics()};
 }
 
 void Fortran::lower::LoweringBridge::lower(
     const Fortran::parser::Program &prg,
     const Fortran::semantics::SemanticsContext &semanticsContext) {
   std::unique_ptr<Fortran::lower::pft::Program> pft =
       Fortran::lower::createPFT(prg, semanticsContext);
   if (dumpBeforeFir)
     Fortran::lower::dumpPFT(llvm::errs(), *pft);
   FirConverter converter{*this};
   converter.run(*pft);
 }
 
 void Fortran::lower::LoweringBridge::parseSourceFile(llvm::SourceMgr &srcMgr) {
   mlir::OwningOpRef<mlir::ModuleOp> owningRef =
       mlir::parseSourceFile<mlir::ModuleOp>(srcMgr, &context);
   module.reset(new mlir::ModuleOp(owningRef.get().getOperation()));
   owningRef.release();
 }
 
 Fortran::lower::LoweringBridge::LoweringBridge(
     mlir::MLIRContext &context,
     const Fortran::common::IntrinsicTypeDefaultKinds &defaultKinds,
     const Fortran::evaluate::IntrinsicProcTable &intrinsics,
+    const Fortran::evaluate::TargetCharacteristics &targetCharacteristics,
     const Fortran::parser::AllCookedSources &cooked, llvm::StringRef triple,
     fir::KindMapping &kindMap)
-    : defaultKinds{defaultKinds}, intrinsics{intrinsics}, cooked{&cooked},
+    : defaultKinds{defaultKinds}, intrinsics{intrinsics},
+      targetCharacteristics{targetCharacteristics}, cooked{&cooked},
       context{context}, kindMap{kindMap} {
   // Register the diagnostic handler.
   context.getDiagEngine().registerHandler([](mlir::Diagnostic &diag) {
     llvm::raw_ostream &os = llvm::errs();
     switch (diag.getSeverity()) {
     case mlir::DiagnosticSeverity::Error:
       os << "error: ";
       break;

flang/lib/Semantics/compute-offsets.cpp

std::size_t ComputeOffsetsHelper::DoSymbol(Symbol &symbol) {
   symbol.set_offset(offset_);
   offset_ += s.size;
   alignment_ = std::max(alignment_, s.alignment);
   return padding;
 }
 
 auto ComputeOffsetsHelper::GetSizeAndAlignment(
     const Symbol &symbol, bool entire) -> SizeAndAlignment {
-  // TODO: The size of procedure pointers is not yet known
-  // and is independent of rank (and probably also the number
-  // of length type parameters).
-  auto &foldingContext{context_.foldingContext()};
-  if (IsDescriptor(symbol) || IsProcedurePointer(symbol)) {
+  auto &targetCharacteristics{context_.targetCharacteristics()};
+  if (IsDescriptor(symbol)) {
     const auto *derived{
         evaluate::GetDerivedTypeSpec(evaluate::DynamicType::From(symbol))};
     int lenParams{derived ? CountLenParameters(*derived) : 0};
     std::size_t size{runtime::Descriptor::SizeInBytes(
         symbol.Rank(), derived != nullptr, lenParams)};
-    return {size, foldingContext.maxAlignment()};
+    return {size, targetCharacteristics.descriptorAlignment()};
+  }
+  if (IsProcedurePointer(symbol)) {
+    return {targetCharacteristics.procedurePointerByteSize(),
+        targetCharacteristics.procedurePointerAlignment()};
   }
   if (IsProcedure(symbol)) {
     return {};
   }
+  auto &foldingContext{context_.foldingContext()};
   if (auto chars{evaluate::characteristics::TypeAndShape::Characterize(
           symbol, foldingContext)}) {
     if (entire) {
       if (auto size{ToInt64(chars->MeasureSizeInBytes(foldingContext))}) {
         return {static_cast<std::size_t>(*size),
-            chars->type().GetAlignment(foldingContext)};
+            chars->type().GetAlignment(targetCharacteristics)};
       }
     } else { // element size only
       if (auto size{ToInt64(chars->MeasureElementSizeInBytes(
               foldingContext, true /*aligned*/))}) {
         return {static_cast<std::size_t>(*size),
-            chars->type().GetAlignment(foldingContext)};
+            chars->type().GetAlignment(targetCharacteristics)};
       }
     }
   }
   return {};
 }
 
 // Align a size to its natural alignment, up to maxAlignment.
 std::size_t ComputeOffsetsHelper::Align(std::size_t x, std::size_t alignment) {
-  alignment = std::min(alignment, context_.foldingContext().maxAlignment());
+  alignment =
+      std::min(alignment, context_.targetCharacteristics().maxAlignment());
   return (x + alignment - 1) & -alignment;
 }
 
 void ComputeOffsets(SemanticsContext &context, Scope &scope) {
   ComputeOffsetsHelper{context}.Compute(scope);
 }
 
 } // namespace Fortran::semantics

flang/lib/Semantics/data-to-inits.cpp

static std::size_t ComputeMinElementBytes(
     evaluate::FoldingContext &foldingContext) {
   std::size_t minElementBytes{1};
   const Symbol &first{*associated.front()};
   for (const Symbol &s : associated) {
     if (auto dyType{evaluate::DynamicType::From(s)}) {
       auto size{static_cast<std::size_t>(
           evaluate::ToInt64(dyType->MeasureSizeInBytes(foldingContext, true))
               .value_or(1))};
-      if (std::size_t alignment{dyType->GetAlignment(foldingContext)}) {
+      if (std::size_t alignment{
+              dyType->GetAlignment(foldingContext.targetCharacteristics())}) {
         size = ((size + alignment - 1) / alignment) * alignment;
       }
       if (&s == &first) {
         minElementBytes = size;
       } else {
         minElementBytes = std::min(minElementBytes, size);
       }
     } else {
if (std::find_if(associated.begin(), associated.end(),
     Symbol &combinedSymbol{*emplaced.first->second};
     combinedSymbol.set(Symbol::Flag::CompilerCreated);
     inits.emplace(&combinedSymbol, std::move(combined));
     auto &details{combinedSymbol.get<ObjectEntityDetails>()};
     combinedSymbol.set_offset(first.offset());
     combinedSymbol.set_size(bytes);
     std::size_t minElementBytes{
         ComputeMinElementBytes(associated, foldingContext)};
-    if (!evaluate::IsValidKindOfIntrinsicType(
+    if (!exprAnalyzer.GetFoldingContext().targetCharacteristics().IsTypeEnabled(
             TypeCategory::Integer, minElementBytes) ||
         (bytes % minElementBytes) != 0) {
       minElementBytes = 1;
     }
     const DeclTypeSpec &typeSpec{scope.MakeNumericType(
         TypeCategory::Integer, KindExpr{minElementBytes})};
     details.set_type(typeSpec);
     ArraySpec arraySpec;

flang/lib/Semantics/expression.cpp

MaybeExpr ExpressionAnalyzer::Analyze(
   auto restorer{GetContextualMessages().SetLocation(x.source)};
   return IntLiteralConstant(x);
 }
 
 template <typename TYPE>
 Constant<TYPE> ReadRealLiteral(
     parser::CharBlock source, FoldingContext &context) {
   const char *p{source.begin()};
-  auto valWithFlags{Scalar<TYPE>::Read(p, context.rounding())};
+  auto valWithFlags{
+      Scalar<TYPE>::Read(p, context.targetCharacteristics().roundingMode())};
   CHECK(p == source.end());
   RealFlagWarnings(context, valWithFlags.flags, "conversion of REAL literal");
   auto value{valWithFlags.value};
-  if (context.flushSubnormalsToZero()) {
+  if (context.targetCharacteristics().areSubnormalsFlushedToZero()) {
     value = value.FlushSubnormalToZero();
   }
   return {value};
 }
 
 struct RealTypeVisitor {
   using Result = std::optional<Expr<SomeReal>>;
   using Types = RealTypes;
if (auto *charExpr{std::get_if<Expr<SomeCharacter>>(&string->u)}) {
       return common::visit(
           [&](auto &&ckExpr) -> MaybeExpr {
             using Result = ResultType<decltype(ckExpr)>;
             auto *cp{std::get_if<Constant<Result>>(&ckExpr.u)};
             CHECK(DEREF(cp).size() == 1);
             StaticDataObject::Pointer staticData{StaticDataObject::Create()};
             staticData->set_alignment(Result::kind)
                 .set_itemBytes(Result::kind)
-                .Push(cp->GetScalarValue().value());
+                .Push(cp->GetScalarValue().value(),
+                    foldingContext_.targetCharacteristics().isBigEndian());
             Substring substring{std::move(staticData), std::move(lower.value()),
                 std::move(upper.value())};
             return AsGenericExpr(
                 Expr<Result>{Designator<Result>{std::move(substring)}});
           },
           std::move(charExpr->u));
     }
   }

 
 DynamicType ExpressionAnalyzer::GetDefaultKindOfType(
     common::TypeCategory category) {
   return {category, GetDefaultKind(category)};
 }
 
 bool ExpressionAnalyzer::CheckIntrinsicKind(
     TypeCategory category, std::int64_t kind) {
-  if (IsValidKindOfIntrinsicType(category, kind)) { // C712, C714, C715, C727
+  if (foldingContext_.targetCharacteristics().IsTypeEnabled(
+          category, kind)) { // C712, C714, C715, C727
+    return true;
+  } else if (foldingContext_.targetCharacteristics().CanSupportType(
+                 category, kind)) {
+    Say("%s(KIND=%jd) is not an enabled type for this targe"_warn_en_US,
+        ToUpperCase(EnumToString(category)), kind);
     return true;
   } else {
     Say("%s(KIND=%jd) is not a supported type"_err_en_US,
         ToUpperCase(EnumToString(category)), kind);
     return false;
   }
 }
 
 bool ExpressionAnalyzer::CheckIntrinsicSize(
     TypeCategory category, std::int64_t size) {
+  std::int64_t kind{size};
   if (category == TypeCategory::Complex) {
     // COMPLEX*16 == COMPLEX(KIND=8)
-    if (size % 2 == 0 && IsValidKindOfIntrinsicType(category, size / 2)) {
-      return true;
+    if (size % 2 == 0) {
+      kind = size / 2;
+    } else {
+      Say("COMPLEX*%jd is not a supported type"_err_en_US, size);
+      return false;
     }
-  } else if (IsValidKindOfIntrinsicType(category, size)) {
-    return true;
   }
+  if (foldingContext_.targetCharacteristics().IsTypeEnabled(
+          category, kind)) { // C712, C714, C715, C727
+    return true;
+  } else if (foldingContext_.targetCharacteristics().CanSupportType(
+                 category, kind)) {
+    Say("%s*%jd is not an enabled type for this target"_warn_en_US,
+        ToUpperCase(EnumToString(category)), size);
+    return true;
+  } else {
     Say("%s*%jd is not a supported type"_err_en_US,
         ToUpperCase(EnumToString(category)), size);
     return false;
   }
+}
 
 bool ExpressionAnalyzer::AddImpliedDo(parser::CharBlock name, int kind) {
   return impliedDos_.insert(std::make_pair(name, kind)).second;
 }
 
 void ExpressionAnalyzer::RemoveImpliedDo(parser::CharBlock name) {
   auto iter{impliedDos_.find(name)};
   if (iter != impliedDos_.end()) {

flang/lib/Semantics/resolve-names.cpp

void DeclarationVisitor::Post(const parser::IntrinsicTypeSpec::Character &) {
   SetDeclTypeSpec(currScope().MakeCharacterType(
       std::move(*charInfo_.length), std::move(*charInfo_.kind)));
   charInfo_ = {};
 }
 void DeclarationVisitor::Post(const parser::CharSelector::LengthAndKind &x) {
   charInfo_.kind = EvaluateSubscriptIntExpr(x.kind);
   std::optional<std::int64_t> intKind{ToInt64(charInfo_.kind)};
   if (intKind &&
-      !evaluate::IsValidKindOfIntrinsicType(
+      !context().targetCharacteristics().IsTypeEnabled(
           TypeCategory::Character, *intKind)) { // C715, C719
     Say(currStmtSource().value(),
         "KIND value (%jd) not valid for CHARACTER"_err_en_US, *intKind);
     charInfo_.kind = std::nullopt; // prevent further errors
   }
   if (x.length) {
     charInfo_.length = GetParamValue(*x.length, common::TypeParamAttr::Len);
   }

flang/lib/Semantics/semantics.cpp

SemanticsContext::SemanticsContext(
     const common::IntrinsicTypeDefaultKinds &defaultKinds,
     const common::LanguageFeatureControl &languageFeatures,
     parser::AllCookedSources &allCookedSources)
     : defaultKinds_{defaultKinds}, languageFeatures_{languageFeatures},
       allCookedSources_{allCookedSources},
       intrinsics_{evaluate::IntrinsicProcTable::Configure(defaultKinds_)},
       globalScope_{*this}, intrinsicModulesScope_{globalScope_.MakeScope(
                                Scope::Kind::IntrinsicModules, nullptr)},
-      foldingContext_{
-          parser::ContextualMessages{&messages_}, defaultKinds_, intrinsics_} {}
+      foldingContext_{parser::ContextualMessages{&messages_}, defaultKinds_,
+          intrinsics_, targetCharacteristics_} {}
 
 SemanticsContext::~SemanticsContext() {}
 
 int SemanticsContext::GetDefaultKind(TypeCategory category) const {
   return defaultKinds_.GetDefaultKind(category);
 }
 
 const DeclTypeSpec &SemanticsContext::MakeNumericType(

flang/lib/Semantics/type.cpp

if (spec.category() != DeclTypeSpec::Character &&
       evaluate::IsActuallyConstant(intrinsic.kind())) {
     return spec; // KIND is already a known constant
   }
   // The expression was not originally constant, but now it must be so
   // in the context of a parameterized derived type instantiation.
   KindExpr copy{Fold(common::Clone(intrinsic.kind()))};
   int kind{context().GetDefaultKind(intrinsic.category())};
   if (auto value{evaluate::ToInt64(copy)}) {
-    if (evaluate::IsValidKindOfIntrinsicType(intrinsic.category(), *value)) {
+    if (foldingContext().targetCharacteristics().IsTypeEnabled(
+            intrinsic.category(), *value)) {
       kind = *value;
     } else {
       foldingContext().messages().Say(symbolName,
           "KIND parameter value (%jd) of intrinsic type %s "
           "did not resolve to a supported value"_err_en_US,
           *value,
           parser::ToUpperCaseLetters(EnumToString(intrinsic.category())));
     }

flang/test/Semantics/data05.f90

subroutine s10
     data xpp/arr/
   end subroutine
   integer function ifunc2(n)
     integer, intent(in) :: n
     ifunc2 = n + 1
   end function
   subroutine s11
     real, target, save :: arr(3,4) ! CHECK: arr, SAVE, TARGET size=48 offset=0: ObjectEntity type: REAL(4) shape: 1_8:3_8,1_8:4_8
-    type(t1) :: d1 = t1(1,reshape([1,2,3,4],[2,2]),(6.,7.),.false.,'ab',arr,ifunc2,rfunc,extrfunc) ! CHECK: d1 size=184 offset=48: ObjectEntity type: TYPE(t1(kind=4_1,len=1_2)) init:t1(kind=4_1,len=1_2)(j=1_4,x=reshape([REAL(4)::1._4,2._4,3._4,4._4],shape=[2,2]),z=(6._4,7._4),t=.false._4,c=[CHARACTER(KIND=1,LEN=1)::"a","a"],xp=arr,ifptr=ifunc2,rp=rfunc,xrp=extrfunc)
+    type(t1) :: d1 = t1(1,reshape([1,2,3,4],[2,2]),(6.,7.),.false.,'ab',arr,ifunc2,rfunc,extrfunc) ! CHECK: d1 size=168 offset=48: ObjectEntity type: TYPE(t1(kind=4_1,len=1_2)) init:t1(kind=4_1,len=1_2)(j=1_4,x=reshape([REAL(4)::1._4,2._4,3._4,4._4],shape=[2,2]),z=(6._4,7._4),t=.false._4,c=[CHARACTER(KIND=1,LEN=1)::"a","a"],xp=arr,ifptr=ifunc2,rp=rfunc,xrp=extrfunc)
     type(t1(4,len=1)) :: d2 = t1(4)(xrp=extrfunc,rp=rfunc,ifptr=ifunc2,xp=arr,c='a&
-      &b',t=.false.,z=(6.,7.),x=reshape([1,2,3,4],[2,2]),j=1) ! CHECK: d2 size=184 offset=232: ObjectEntity type: TYPE(t1(kind=4_1,len=1_2)) init:t1(kind=4_1,len=1_2)(j=1_4,x=reshape([REAL(4)::1._4,2._4,3._4,4._4],shape=[2,2]),z=(6._4,7._4),t=.false._4,c=[CHARACTER(KIND=1,LEN=1)::"a","a"],xp=arr,ifptr=ifunc2,rp=rfunc,xrp=extrfunc)
-    type(t1(2+2)) :: d3 ! CHECK: d3 (InDataStmt) size=184 offset=416: ObjectEntity type: TYPE(t1(kind=4_1,len=1_2)) init:t1(kind=4_1,len=1_2)(j=1_4,x=reshape([REAL(4)::1._4,2._4,3._4,4._4],shape=[2,2]),z=(6._4,7._4),t=.false._4,c=[CHARACTER(KIND=1,LEN=1)::"a","a"],xp=arr,ifptr=ifunc2,rp=rfunc,xrp=extrfunc)
+      &b',t=.false.,z=(6.,7.),x=reshape([1,2,3,4],[2,2]),j=1) ! CHECK: d2 size=168 offset=216: ObjectEntity type: TYPE(t1(kind=4_1,len=1_2)) init:t1(kind=4_1,len=1_2)(j=1_4,x=reshape([REAL(4)::1._4,2._4,3._4,4._4],shape=[2,2]),z=(6._4,7._4),t=.false._4,c=[CHARACTER(KIND=1,LEN=1)::"a","a"],xp=arr,ifptr=ifunc2,rp=rfunc,xrp=extrfunc)
+    type(t1(2+2)) :: d3 ! CHECK: d3 (InDataStmt) size=168 offset=384: ObjectEntity type: TYPE(t1(kind=4_1,len=1_2)) init:t1(kind=4_1,len=1_2)(j=1_4,x=reshape([REAL(4)::1._4,2._4,3._4,4._4],shape=[2,2]),z=(6._4,7._4),t=.false._4,c=[CHARACTER(KIND=1,LEN=1)::"a","a"],xp=arr,ifptr=ifunc2,rp=rfunc,xrp=extrfunc)
     data d3/t1(1,reshape([1,2,3,4],[2,2]),(6.,7.),.false.,'ab',arr,ifunc2,rfunc,extrfunc)/
-    type(t1) :: d4 ! CHECK: d4 (InDataStmt) size=184 offset=600: ObjectEntity type: TYPE(t1(kind=4_1,len=1_2)) init:t1(kind=4_1,len=1_2)(j=1_4,x=reshape([REAL(4)::1._4,2._4,3._4,4._4],shape=[2,2]),z=(6._4,7._4),t=.false._4,c=[CHARACTER(KIND=1,LEN=1)::"a","a"],xp=arr,ifptr=ifunc2,rp=rfunc,xrp=extrfunc)
+    type(t1) :: d4 ! CHECK: d4 (InDataStmt) size=168 offset=552: ObjectEntity type: TYPE(t1(kind=4_1,len=1_2)) init:t1(kind=4_1,len=1_2)(j=1_4,x=reshape([REAL(4)::1._4,2._4,3._4,4._4],shape=[2,2]),z=(6._4,7._4),t=.false._4,c=[CHARACTER(KIND=1,LEN=1)::"a","a"],xp=arr,ifptr=ifunc2,rp=rfunc,xrp=extrfunc)
     data d4/t1(4)(xrp=extrfunc,rp=rfunc,ifptr=ifunc2,xp=arr,c='ab',t=.false.,z=(6&
       &.,7.),x=reshape([1,2,3,4],[2,2]),j=1)/
-    type(t1) :: d5 ! CHECK: d5 (InDataStmt) size=184 offset=784: ObjectEntity type: TYPE(t1(kind=4_1,len=1_2)) init:t1(kind=4_1,len=1_2)(j=1_4,x=reshape([REAL(4)::1._4,2._4,3._4,4._4],shape=[2,2]),z=(6._4,7._4),t=.false._4,c=[CHARACTER(KIND=1,LEN=1)::"a","b"],xp=arr,ifptr=ifunc2,rp=rfunc,xrp=extrfunc)
+    type(t1) :: d5 ! CHECK: d5 (InDataStmt) size=168 offset=720: ObjectEntity type: TYPE(t1(kind=4_1,len=1_2)) init:t1(kind=4_1,len=1_2)(j=1_4,x=reshape([REAL(4)::1._4,2._4,3._4,4._4],shape=[2,2]),z=(6._4,7._4),t=.false._4,c=[CHARACTER(KIND=1,LEN=1)::"a","b"],xp=arr,ifptr=ifunc2,rp=rfunc,xrp=extrfunc)
     data d5%j/1/,d5%x/1,2,3,4/,d5%z%re/6./,d5%z%im/7./,d5%t/.false./,d5%c(1:1)/'a'/,d5%c(2:&
       &2)/'b'/,d5%xp/arr/,d5%ifptr/ifunc2/,d5%rp/rfunc/,d5%xrp/extrfunc/
   end subroutine
   subroutine s12
     procedure(rfunc), pointer :: pp ! CHECK: pp, EXTERNAL, POINTER (Function, InDataStmt) size=24 offset=0: ProcEntity rfunc => rfunc2
     data pp/rfunc2/
   end subroutine
 end module

flang/tools/bbc/bbc.cpp

static mlir::LogicalResult convertFortranSourceToMLIR(
   mlir::DialectRegistry registry;
   fir::support::registerNonCodegenDialects(registry);
   mlir::MLIRContext ctx(registry);
   fir::support::loadNonCodegenDialects(ctx);
   auto &defKinds = semanticsContext.defaultKinds();
   fir::KindMapping kindMap(
       &ctx, llvm::ArrayRef<fir::KindTy>{fir::fromDefaultKinds(defKinds)});
   auto burnside = Fortran::lower::LoweringBridge::create(
-      ctx, defKinds, semanticsContext.intrinsics(), parsing.allCooked(), "",
+      ctx, defKinds, semanticsContext.intrinsics(),
+      semanticsContext.targetCharacteristics(), parsing.allCooked(), "",
       kindMap);
   burnside.lower(parseTree, semanticsContext);
   mlir::ModuleOp mlirModule = burnside.getModule();
   std::error_code ec;
   std::string outputName = outputFilename;
   if (!outputName.size())
     outputName = llvm::sys::path::stem(inputFilename).str().append(".mlir");
   llvm::raw_fd_ostream out(outputName, ec);

flang/unittests/Evaluate/expression.cpp

 #include "flang/Evaluate/expression.h"
 #include "testing.h"
 #include "flang/Evaluate/fold.h"
 #include "flang/Evaluate/intrinsics.h"
+#include "flang/Evaluate/target.h"
 #include "flang/Evaluate/tools.h"
 #include "flang/Parser/message.h"
 #include <cstdio>
 #include <cstdlib>
 #include <string>
 
 using namespace Fortran::evaluate;
 
 int main() {
   using DefaultIntegerExpr = Expr<Type<TypeCategory::Integer, 4>>;
   TEST(DefaultIntegerExpr::Result::AsFortran() == "INTEGER(4)");
   MATCH("666_4", DefaultIntegerExpr{666}.AsFortran());
   MATCH("-1_4", (-DefaultIntegerExpr{1}).AsFortran());
   auto ex1{
       DefaultIntegerExpr{2} + DefaultIntegerExpr{3} * -DefaultIntegerExpr{4}};
   MATCH("2_4+3_4*(-4_4)", ex1.AsFortran());
   Fortran::common::IntrinsicTypeDefaultKinds defaults;
   auto intrinsics{Fortran::evaluate::IntrinsicProcTable::Configure(defaults)};
-  FoldingContext context{
-      Fortran::parser::ContextualMessages{nullptr}, defaults, intrinsics};
+  TargetCharacteristics targetCharacteristics;
+  FoldingContext context{Fortran::parser::ContextualMessages{nullptr}, defaults,
+      intrinsics, targetCharacteristics};
   ex1 = Fold(context, std::move(ex1));
   MATCH("-10_4", ex1.AsFortran());
   MATCH("1_4/2_4", (DefaultIntegerExpr{1} / DefaultIntegerExpr{2}).AsFortran());
   DefaultIntegerExpr a{1};
   DefaultIntegerExpr b{2};
   MATCH("1_4", a.AsFortran());
   a = b;
   MATCH("2_4", a.AsFortran());
   MATCH("2_4", b.AsFortran());
   return testing::Complete();
 }

flang/unittests/Evaluate/folding.cpp

 #include "testing.h"
 #include "../../lib/Evaluate/host.h"
 #include "flang/Evaluate/call.h"
 #include "flang/Evaluate/expression.h"
 #include "flang/Evaluate/fold.h"
 #include "flang/Evaluate/intrinsics-library.h"
 #include "flang/Evaluate/intrinsics.h"
+#include "flang/Evaluate/target.h"
 #include "flang/Evaluate/tools.h"
 #include <tuple>
 
 using namespace Fortran::evaluate;
 
 // helper to call functions on all types from tuple
 template <typename... T> struct RunOnTypes {};
 template <typename Test, typename... T>

 
 void TestHostRuntimeSubnormalFlushing() {
   using R4 = Type<TypeCategory::Real, 4>;
   if constexpr (std::is_same_v<host::HostType<R4>, float>) {
     Fortran::parser::CharBlock src;
     Fortran::parser::ContextualMessages messages{src, nullptr};
     Fortran::common::IntrinsicTypeDefaultKinds defaults;
     auto intrinsics{Fortran::evaluate::IntrinsicProcTable::Configure(defaults)};
+    TargetCharacteristics flushingTargetCharacteristics;
+    flushingTargetCharacteristics.set_areSubnormalsFlushedToZero(true);
+    TargetCharacteristics noFlushingTargetCharacteristics;
+    noFlushingTargetCharacteristics.set_areSubnormalsFlushedToZero(false);
     FoldingContext flushingContext{
-        messages, defaults, intrinsics, defaultRounding, true};
+        messages, defaults, intrinsics, flushingTargetCharacteristics};
     FoldingContext noFlushingContext{
-        messages, defaults, intrinsics, defaultRounding, false};
+        messages, defaults, intrinsics, noFlushingTargetCharacteristics};
 
     DynamicType r4{R4{}.GetType()};
     // Test subnormal argument flushing
     if (auto callable{GetHostRuntimeWrapper("log", r4, {r4})}) {
       // Biggest IEEE 32bits subnormal power of two
       const Scalar<R4> x1{Scalar<R4>::Word{0x00400000}};
       Scalar<R4> y1Flushing{CallHostRt<R4>(*callable, flushingContext, x1)};
       Scalar<R4> y1NoFlushing{CallHostRt<R4>(*callable, noFlushingContext, x1)};

flang/unittests/Evaluate/fp-testing.h

 #ifndef FORTRAN_TEST_EVALUATE_FP_TESTING_H_
 #define FORTRAN_TEST_EVALUATE_FP_TESTING_H_
 
-#include "flang/Evaluate/common.h"
+#include "flang/Evaluate/target.h"
 #include <fenv.h>
 
 using Fortran::common::RoundingMode;
 using Fortran::evaluate::RealFlags;
 using Fortran::evaluate::Rounding;
 
 class ScopedHostFloatingPointEnvironment {
 public:

flang/unittests/Evaluate/intrinsics.cpp

 #include "flang/Evaluate/intrinsics.h"
 #include "testing.h"
 #include "flang/Evaluate/common.h"
 #include "flang/Evaluate/expression.h"
+#include "flang/Evaluate/target.h"
 #include "flang/Evaluate/tools.h"
 #include "flang/Parser/provenance.h"
 #include "llvm/Support/raw_ostream.h"
 #include <initializer_list>
 #include <map>
 #include <string>
 
 namespace Fortran::evaluate {
void DoCall(std::optional<DynamicType> resultType = std::nullopt,
     }
     if (sep == '(') {
       llvm::outs() << '(';
     }
     llvm::outs() << ')' << '\n';
     llvm::outs().flush();
     CallCharacteristics call{fName.ToString()};
     auto messages{strings.Messages(buffer)};
-    FoldingContext context{messages, defaults, table};
+    TargetCharacteristics targetCharacteristics;
+    FoldingContext context{messages, defaults, table, targetCharacteristics};
     std::optional<SpecificCall> si{table.Probe(call, args, context)};
     if (resultType.has_value()) {
       TEST(si.has_value());
       TEST(messages.messages() && !messages.messages()->AnyFatalError());
       if (si) {
         const auto &proc{si->specificIntrinsic.characteristics.value()};
         const auto &fr{proc.functionResult};
         TEST(fr.has_value());