[flang][fir] Upstream FIR support changes

[schweitz]

Summary

FIR support changes.

1. Adds context information to describe properties such as the target triple.
2. Adds an error handler.
3. Support for Fortran type codes.
4. Fixes various bugs.

A history of all these sources, including all contributors, previous reviews and revisions, etc., can be found at https://github.com/flang-compiler/f18-llvm-project/

These diffs depend upon D95399.

[schweitz]

Updating diff chain for buildability.

[kiranchandramohan]

A few minor comments.

flang/include/flang/Optimizer/Support/FIRContext.h

13

Is this stray or a directive to some tool?

flang/include/flang/Optimizer/Support/InternalNames.h

45

Nit: Was this previously in alphabetical order?

flang/lib/Optimizer/Support/InternalNames.cpp

102

Did we have tests for all these?

flang/lib/Optimizer/Support/KindMapping.cpp

310

Should this be 'd'?

[schweitz]

flang/include/flang/Optimizer/Support/FIRContext.h

13

It's a doxygen directive. Not sure it is needed though.

flang/include/flang/Optimizer/Support/InternalNames.h

45

Good catch. Thanks.

flang/lib/Optimizer/Support/InternalNames.cpp

102

No. I don't think we do.

flang/lib/Optimizer/Support/KindMapping.cpp

310

Another good catch. Thanks again.

[mehdi_amini]

flang/lib/Optimizer/Support/FIRContext.cpp

25

The triple seems fairly fundamental to processing a Module, it isn't clear to me that this can be an OpaqueAttr (i.e. something that should be implicitly dropped freely with no consequence). How do you manage this?

[schweitz]

flang/lib/Optimizer/Support/FIRContext.cpp

25

It is definitely important, actually essential, for conversion to LLVM IR.

Prior to that, the IR is abstract enough that it can be reasoned about without knowing the target triple precisely.

The trick here is that the driver of the code gen bridge will supply a triple. Thus, we can keep the IR and the triple loosely coupled.

I know that Alex is looking at solutions to this on the MLIR side. So it could be the case that solution can just be substituted.

[mehdi_amini]

flang/lib/Optimizer/Support/FIRContext.cpp

25

Even here why don't you set it as a string attribute which can round-trip and not be an opaque attribute?

[schweitz]

changes per review comments

flang/include/flang/Optimizer/OptPasses.h

+//===-- Optimizer/Transforms/Passes.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 OPTIMIZER_OPTPASSES_H
+#define OPTIMIZER_OPTPASSES_H
+
+#include "flang/Optimizer/CodeGen/CodeGen.h"
+#include "flang/Optimizer/Transforms/Passes.h"
+
+namespace fir {
+inline void registerOptPasses() {
+  registerOptCodeGenPasses();
+}
+} // namespace fir
+
+#endif // OPTIMIZER_OPTPASSES_H

flang/include/flang/Optimizer/Support/FIRContext.h

+//===-- Optimizer/Support/FIRContext.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
+//
+//===----------------------------------------------------------------------===//
+//
+// Coding style: https://mlir.llvm.org/getting_started/DeveloperGuide/
+//
+//===----------------------------------------------------------------------===//
+/// Setters and getters for associating context with an instance of a ModuleOp.
+/// The context is typically set by the tool and needed in later stages to
+/// determine how to correctly generate code.
+//===----------------------------------------------------------------------===//
+
+#ifndef OPTIMIZER_SUPPORT_FIRCONTEXT_H
+#define OPTIMIZER_SUPPORT_FIRCONTEXT_H
+
+#include "llvm/ADT/Triple.h"
+
+namespace mlir {
+class ModuleOp;
+}
+
+namespace fir {
+class KindMapping;
+struct NameUniquer;
+
+/// Set the target triple for the module. `triple` must not be deallocated while
+/// module `mod` is still live.
+void setTargetTriple(mlir::ModuleOp mod, llvm::Triple &triple);
+
+/// Get a pointer to the Triple instance from the Module. If none was set,
+/// returns a nullptr.
+llvm::Triple *getTargetTriple(mlir::ModuleOp mod);
+
+/// Set the name uniquer for the module. `uniquer` must not be deallocated while
+/// module `mod` is still live.
+void setNameUniquer(mlir::ModuleOp mod, NameUniquer &uniquer);
+
+/// Get a pointer to the NameUniquer instance from the Module. If none was set,
+/// returns a nullptr.
+NameUniquer *getNameUniquer(mlir::ModuleOp mod);
+
+/// Set the kind mapping for the module. `kindMap` must not be deallocated while
+/// module `mod` is still live.
+void setKindMapping(mlir::ModuleOp mod, KindMapping &kindMap);
+
+/// Get a pointer to the KindMapping instance from the Module. If none was set,
+/// returns a nullptr.
+KindMapping *getKindMapping(mlir::ModuleOp mod);
+
+/// Helper for determining the target from the host, etc. Tools may use this
+/// function to provide a consistent interpretation of the `--target=<string>`
+/// command-line option.
+/// An empty string ("") or "default" will specify that the default triple
+/// should be used. "native" will specify that the host machine be used to
+/// construct the triple.
+std::string determineTargetTriple(llvm::StringRef triple);
+
+} // namespace fir
+
+#endif // OPTIMIZER_SUPPORT_FIRCONTEXT_H

flang/include/flang/Optimizer/Support/FatalError.h

+//===-- Optimizer/Support/FatalError.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
+//
+//===----------------------------------------------------------------------===//
+//
+// Coding style: https://mlir.llvm.org/getting_started/DeveloperGuide/
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef OPTIMIZER_SUPPORT_FATALERROR_H
+#define OPTIMIZER_SUPPORT_FATALERROR_H
+
+#include "mlir/IR/Diagnostics.h"
+#include "llvm/Support/ErrorHandling.h"
+
+namespace fir {
+
+/// Fatal error reporting helper. Report a fatal error with a source location
+/// and immediately abort flang.
+LLVM_ATTRIBUTE_NORETURN inline void emitFatalError(mlir::Location loc,
+                                                   const llvm::Twine &message) {
+  mlir::emitError(loc, message);
+  llvm::report_fatal_error("aborting");
+}
+
+/// Fatal error reporting helper. Report a fatal error without a source location
+/// and immediately abort flang.
+LLVM_ATTRIBUTE_NORETURN inline void emitFatalError(const llvm::Twine &message) {
+  llvm::report_fatal_error(message);
+}
+
+} // namespace fir
+
+#endif // OPTIMIZER_SUPPORT_FATALERROR_H

flang/include/flang/Optimizer/Support/InternalNames.h

 /// uniqued name, we can return the symbol parse name, type of the symbol, and
 /// any scope-like information for that symbol.
 struct NameUniquer {
   enum class IntrinsicType { CHARACTER, COMPLEX, INTEGER, LOGICAL, REAL };
 
   /// The sort of the unique name
   enum class NameKind {
     NOT_UNIQUED,
+    BLOCK_DATA_NAME,
     COMMON,
     CONSTANT,
     DERIVED_TYPE,
     DISPATCH_TABLE,
     GENERATED,
     INTRINSIC_TYPE_DESC,
     PROCEDURE,
     TYPE_DESC,
     VARIABLE
   };
 
   /// Components of an unparsed unique name
   struct DeconstructedName {
     DeconstructedName(llvm::StringRef name) : name{name} {}
     DeconstructedName(llvm::ArrayRef<std::string> modules,
                       llvm::Optional<std::string> host, llvm::StringRef name,
                       llvm::ArrayRef<std::int64_t> kinds)
         : modules{modules.begin(), modules.end()}, host{host}, name{name},
           kinds{kinds.begin(), kinds.end()} {}
 
     llvm::SmallVector<std::string, 2> modules;
     llvm::Optional<std::string> host;
     std::string name;
     llvm::SmallVector<std::int64_t, 4> kinds;
   };
 
   NameUniquer() = default;
 
   /// Unique a common block name
   std::string doCommonBlock(llvm::StringRef name);
 
+  /// Unique a block data unit name
+  std::string doBlockData(llvm::StringRef name);
+
   /// Unique a (global) constant name
   std::string doConstant(llvm::ArrayRef<llvm::StringRef> modules,
                          llvm::Optional<llvm::StringRef> host,
                          llvm::StringRef name);
 
   /// Unique a dispatch table name
   std::string doDispatchTable(llvm::ArrayRef<llvm::StringRef> modules,
                               llvm::Optional<llvm::StringRef> host,

flang/include/flang/Optimizer/Support/KindMapping.h

 //===-- Optimizer/Support/KindMapping.h -- support kind mapping -*- 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
 //
 //===----------------------------------------------------------------------===//
+//
+// Coding style: https://mlir.llvm.org/getting_started/DeveloperGuide/
+//
+//===----------------------------------------------------------------------===//
 
 #ifndef OPTIMIZER_SUPPORT_KINDMAPPING_H
 #define OPTIMIZER_SUPPORT_KINDMAPPING_H
 
 #include "mlir/IR/OpDefinition.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/IR/Type.h"
 

 /// intrinsic-key is a single character for the intrinsic type.
 ///   'i' : INTEGER   (size in bits)
 ///   'l' : LOGICAL   (size in bits)
 ///   'a' : CHARACTER (size in bits)
 ///   'r' : REAL    (encoding value)
 ///   'c' : COMPLEX (encoding value)
 ///
 /// kind-value is either an unsigned integer (for 'i', 'l', and 'a') or one of
-/// 'Half', 'Float', 'Double', 'X86_FP80', or 'FP128' (for 'r' and 'c').
+/// 'Half', 'BFloat', 'Float', 'Double', 'X86_FP80', or 'FP128' (for 'r' and
+/// 'c').
 ///
 /// If LLVM adds support for new floating-point types, the final list should be
 /// extended.
 class KindMapping {
 public:
   using KindTy = unsigned;
   using Bitsize = unsigned;
   using LLVMTypeID = llvm::Type::TypeID;
   using MatchResult = mlir::ParseResult;
 
-  explicit KindMapping(mlir::MLIRContext *context);
-  explicit KindMapping(mlir::MLIRContext *context, llvm::StringRef map);
+  explicit KindMapping(mlir::MLIRContext *context,
+                       llvm::ArrayRef<KindTy> defs = llvm::None);
+  explicit KindMapping(mlir::MLIRContext *context, llvm::StringRef map,
+                       llvm::ArrayRef<KindTy> defs = llvm::None);
 
   /// Get the size in bits of !fir.char<kind>
   Bitsize getCharacterBitsize(KindTy kind) const;
 
   /// Get the size in bits of !fir.int<kind>
   Bitsize getIntegerBitsize(KindTy kind) const;
 
   /// Get the size in bits of !fir.logical<kind>
   Bitsize getLogicalBitsize(KindTy kind) const;
 
   /// Get the size in bits of !fir.real<kind>
   Bitsize getRealBitsize(KindTy kind) const;
 
   /// Get the LLVM Type::TypeID of !fir.real<kind>
   LLVMTypeID getRealTypeID(KindTy kind) const;
 
   /// Get the LLVM Type::TypeID of !fir.complex<kind>
   LLVMTypeID getComplexTypeID(KindTy kind) const;
 
   mlir::MLIRContext *getContext() const { return context; }
 
   /// Get the float semantics of !fir.real<kind>
   const llvm::fltSemantics &getFloatSemantics(KindTy kind) const;
 
+  //===--------------------------------------------------------------------===//
+  // Default kinds of intrinsic types
+  //===--------------------------------------------------------------------===//
+
+  KindTy defaultCharacterKind() const;
+  KindTy defaultComplexKind() const;
+  KindTy defaultDoubleKind() const;
+  KindTy defaultIntegerKind() const;
+  KindTy defaultLogicalKind() const;
+  KindTy defaultRealKind() const;
+
 private:
   MatchResult badMapString(const llvm::Twine &ptr);
   MatchResult parse(llvm::StringRef kindMap);
+  mlir::LogicalResult setDefaultKinds(llvm::ArrayRef<KindTy> defs);
 
   mlir::MLIRContext *context;
   llvm::DenseMap<std::pair<char, KindTy>, Bitsize> intMap;
   llvm::DenseMap<std::pair<char, KindTy>, LLVMTypeID> floatMap;
+  llvm::DenseMap<char, KindTy> defaultMap;
 };
 
 } // namespace fir
 
 #endif // OPTIMIZER_SUPPORT_KINDMAPPING_H

flang/include/flang/Optimizer/Support/Matcher.h

+//===-- Optimizer/Support/Matcher.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
+//
+//===----------------------------------------------------------------------===//
+//
+// Coding style: https://mlir.llvm.org/getting_started/DeveloperGuide/
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef OPTIMIZER_SUPPORT_MATCHER_H
+#define OPTIMIZER_SUPPORT_MATCHER_H
+
+#include <variant>
+
+// Boilerplate CRTP class for a simplified type-casing syntactic sugar. This
+// lets one write pattern matchers using a more compact syntax.
+namespace fir::details {
+// clang-format off
+template<class... Ts> struct matches : Ts... { using Ts::operator()...; };
+template<class... Ts> matches(Ts...) -> matches<Ts...>;
+template<typename N> struct matcher {
+  template<typename... Ts> auto match(Ts... ts) {
+    return std::visit(matches{ts...}, static_cast<N*>(this)->matchee());
+  }
+  template<typename... Ts> auto match(Ts... ts) const {
+    return std::visit(matches{ts...}, static_cast<N const*>(this)->matchee());
+  }
+};
+// clang-format on
+} // namespace fir::details
+
+#endif // OPTIMIZER_SUPPORT_MATCHER_H

flang/include/flang/Optimizer/Support/TypeCode.h

+//===-- Optimizer/Support/TypeCode.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
+//
+//===----------------------------------------------------------------------===//
+//
+// Coding style: https://mlir.llvm.org/getting_started/DeveloperGuide/
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef OPTIMIZER_SUPPORT_TYPECODE_H
+#define OPTIMIZER_SUPPORT_TYPECODE_H
+
+#include "flang/ISO_Fortran_binding.h"
+#include "llvm/Support/ErrorHandling.h"
+
+namespace fir {
+
+//===----------------------------------------------------------------------===//
+// Translations of category and bitwidths to the type codes defined in flang's
+// ISO_Fortran_binding.h.
+//===----------------------------------------------------------------------===//
+
+inline int characterBitsToTypeCode(unsigned bits) {
+  // clang-format off
+  switch (bits) {
+  case 8:  return CFI_type_char;
+  case 16: return CFI_type_char16_t;
+  case 32: return CFI_type_char32_t;
+  default: llvm_unreachable("unsupported character size");
+  }
+  // clang-format on
+}
+
+inline int complexBitsToTypeCode(unsigned bits) {
+  // clang-format off
+  switch (bits) {
+  case 32:  return CFI_type_float_Complex;
+  case 64:  return CFI_type_double_Complex;
+  case 80:
+  case 128: return CFI_type_long_double_Complex;
+  default:  llvm_unreachable("unsupported complex size");
+  }
+  // clang-format on
+}
+
+inline int integerBitsToTypeCode(unsigned bits) {
+  // clang-format off
+  switch (bits) {
+  case 8:   return CFI_type_int8_t;
+  case 16:  return CFI_type_int16_t;
+  case 32:  return CFI_type_int32_t;
+  case 64:  return CFI_type_int64_t;
+  case 128: return CFI_type_int128_t;
+  default:  llvm_unreachable("unsupported integer size");
+  }
+  // clang-format on
+}
+
+// Always use CFI_type_Bool and let the rest get sorted out by the elem_size.
+// NB: do *not* use the CFI_type_intN_t codes. The flang runtime will choke.
+inline int logicalBitsToTypeCode(unsigned bits) {
+  // clang-format off
+  switch (bits) {
+  case 8:
+  case 16:
+  case 32:
+  case 64: return CFI_type_Bool;
+  default: llvm_unreachable("unsupported logical size");
+  }
+  // clang-format on
+}
+
+inline int realBitsToTypeCode(unsigned bits) {
+  // clang-format off
+  switch (bits) {
+  case 32:  return CFI_type_float;
+  case 64:  return CFI_type_double;
+  case 80:
+  case 128: return CFI_type_long_double;
+  default:  llvm_unreachable("unsupported real size");
+  }
+  // clang-format on
+}
+
+static constexpr int derivedToTypeCode() {
+  return CFI_type_struct;
+}
+
+} // namespace fir
+
+#endif // OPTIMIZER_SUPPORT_TYPECODE_H

flang/lib/Optimizer/Support/FIRContext.cpp

+//===-- KindMapping.cpp ---------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Coding style: https://mlir.llvm.org/getting_started/DeveloperGuide/
+//
+//===----------------------------------------------------------------------===//
+
+#include "flang/Optimizer/Support/FIRContext.h"
+#include "flang/Optimizer/Dialect/FIRAttr.h"
+#include "flang/Optimizer/Support/InternalNames.h"
+#include "flang/Optimizer/Support/KindMapping.h"
+#include "mlir/IR/BuiltinOps.h"
+#include "llvm/Support/Host.h"
+
+static constexpr const char *tripleName = "fir.triple";
+
+void fir::setTargetTriple(mlir::ModuleOp mod, llvm::Triple &triple) {
+  mod->setAttr(tripleName, fir::OpaqueAttr::get(mod.getContext(), &triple));
+}
+
+llvm::Triple *fir::getTargetTriple(mlir::ModuleOp mod) {
+  if (auto triple = mod->getAttrOfType<fir::OpaqueAttr>(tripleName))
+    return static_cast<llvm::Triple *>(triple.getPointer());
+  return nullptr;
+}
+
+static constexpr const char *uniquerName = "fir.uniquer";
+
+void fir::setNameUniquer(mlir::ModuleOp mod, fir::NameUniquer &uniquer) {
+  mod->setAttr(uniquerName, fir::OpaqueAttr::get(mod.getContext(), &uniquer));
+}
+
+fir::NameUniquer *fir::getNameUniquer(mlir::ModuleOp mod) {
+  if (auto triple = mod->getAttrOfType<fir::OpaqueAttr>(uniquerName))
+    return static_cast<fir::NameUniquer *>(triple.getPointer());
+  return nullptr;
+}
+
+static constexpr const char *kindMapName = "fir.kindmap";
+
+void fir::setKindMapping(mlir::ModuleOp mod, fir::KindMapping &kindMap) {
+  mod->setAttr(kindMapName, fir::OpaqueAttr::get(mod.getContext(), &kindMap));
+}
+
+fir::KindMapping *fir::getKindMapping(mlir::ModuleOp mod) {
+  if (auto triple = mod->getAttrOfType<fir::OpaqueAttr>(kindMapName))
+    return static_cast<fir::KindMapping *>(triple.getPointer());
+  return nullptr;
+}
+
+std::string fir::determineTargetTriple(llvm::StringRef triple) {
+  // Treat "" or "default" as stand-ins for the default machine.
+  if (triple.empty() || triple == "default")
+    return llvm::sys::getDefaultTargetTriple();
+  // Treat "native" as stand-in for the host machine.
+  if (triple == "native")
+    return llvm::sys::getProcessTriple();
+  // TODO: normalize the triple?
+  return triple.str();
+}

flang/lib/Optimizer/Support/InternalNames.cpp

 //===-- InternalNames.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/Optimizer/Support/InternalNames.h"
+#include "flang/Optimizer/Dialect/FIRType.h"
 #include "mlir/IR/Diagnostics.h"
+#include "mlir/IR/BuiltinTypes.h"
 #include "llvm/Support/CommandLine.h"
 
 static llvm::cl::opt<std::string> mainEntryName(
     "main-entry-name",
     llvm::cl::desc("override the name of the default PROGRAM entry (may be "
                    "helpful for using other runtimes)"));
 
 constexpr std::int64_t BAD_VALUE = -1;
std::string fir::NameUniquer::doKinds(llvm::ArrayRef<std::int64_t> kinds) {
   return result;
 }
 
 std::string fir::NameUniquer::doCommonBlock(llvm::StringRef name) {
   std::string result = prefix();
   return result.append("B").append(toLower(name));
 }
 
+std::string fir::NameUniquer::doBlockData(llvm::StringRef name) {
+  std::string result = prefix();
+  return result.append("L").append(toLower(name));
+}
+
 std::string
 fir::NameUniquer::doConstant(llvm::ArrayRef<llvm::StringRef> modules,
                              llvm::Optional<llvm::StringRef> host,
                              llvm::StringRef name) {
   std::string result = prefix();
   result.append(doModulesHost(modules, host)).append("EC");
   return result.append(toLower(name));
 }
for (std::size_t i = 2, end{uniq.size()}; i != end;) {
         if (uniq[i + 1] == 'C') {
           nk = NameKind::CONSTANT;
           name = readName(uniq, i, i + 2, end);
         } else {
           nk = NameKind::VARIABLE;
           name = readName(uniq, i, i + 1, end);
         }
         break;
+      case 'L':
+        nk = NameKind::BLOCK_DATA_NAME;
+        name = readName(uniq, i, i + 1, end);
+        break;
       case 'P':
         nk = NameKind::PROCEDURE;
         name = readName(uniq, i, i + 1, end);
         break;
       case 'Q':
         nk = NameKind::GENERATED;
         name = uniq;
         i = end;

flang/lib/Optimizer/Support/KindMapping.cpp

 //===-- KindMapping.cpp ---------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
+//
+// Coding style: https://mlir.llvm.org/getting_started/DeveloperGuide/
+//
+//===----------------------------------------------------------------------===//
 
 #include "flang/Optimizer/Support/KindMapping.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "llvm/Support/CommandLine.h"
 
 /// Allow the user to set the FIR intrinsic type kind value to LLVM type
 /// mappings.  Note that these are not mappings from kind values to any
 /// other MLIR dialect, only to LLVM IR. The default values follow the f18

 /// Integral types default to the kind value being the size of the value in
 /// bytes. The default is to scale from bytes to bits.
 static Bitsize defaultScalingKind(KindTy kind) {
   const unsigned BITS_IN_BYTE = 8;
   return kind * BITS_IN_BYTE;
 }
 
 /// Floating-point types default to the kind value being the size of the value
-/// in bytes. The default is to translate kinds of 2, 4, 8, 10, and 16 to a
+/// in bytes. The default is to translate kinds of 2, 3, 4, 8, 10, and 16 to a
 /// valid llvm::Type::TypeID value. Otherwise, the default is FloatTyID.
 static LLVMTypeID defaultRealKind(KindTy kind) {
   switch (kind) {
   case 2:
     return LLVMTypeID::HalfTyID;
+  case 3:
+    return LLVMTypeID::BFloatTyID;
   case 4:
     return LLVMTypeID::FloatTyID;
   case 8:
     return LLVMTypeID::DoubleTyID;
   case 10:
     return LLVMTypeID::X86_FP80TyID;
   case 16:
     return LLVMTypeID::FP128TyID;

 }
 
 template <char KEY, typename MAP>
 static const llvm::fltSemantics &getFloatSemanticsOfKind(KindTy kind,
                                                          const MAP &map) {
   switch (doLookup<LLVMTypeID, KEY>(defaultRealKind, map, kind)) {
   case LLVMTypeID::HalfTyID:
     return llvm::APFloat::IEEEhalf();
+  case LLVMTypeID::BFloatTyID:
+    return llvm::APFloat::BFloat();
   case LLVMTypeID::FloatTyID:
     return llvm::APFloat::IEEEsingle();
   case LLVMTypeID::DoubleTyID:
     return llvm::APFloat::IEEEdouble();
   case LLVMTypeID::X86_FP80TyID:
     return llvm::APFloat::x87DoubleExtended();
   case LLVMTypeID::FP128TyID:
     return llvm::APFloat::IEEEquad();
static mlir::LogicalResult matchString(const char *&ptr,
   return mlir::failure();
 }
 
 static MatchResult parseTypeID(LLVMTypeID &result, const char *&ptr) {
   if (mlir::succeeded(matchString(ptr, "Half"))) {
     result = LLVMTypeID::HalfTyID;
     return mlir::success();
   }
+  if (mlir::succeeded(matchString(ptr, "BFloat"))) {
+    result = LLVMTypeID::BFloatTyID;
+    return mlir::success();
+  }
   if (mlir::succeeded(matchString(ptr, "Float"))) {
     result = LLVMTypeID::FloatTyID;
     return mlir::success();
   }
   if (mlir::succeeded(matchString(ptr, "Double"))) {
     result = LLVMTypeID::DoubleTyID;
     return mlir::success();
   }
   if (mlir::succeeded(matchString(ptr, "X86_FP80"))) {
     result = LLVMTypeID::X86_FP80TyID;
     return mlir::success();
   }
   if (mlir::succeeded(matchString(ptr, "FP128"))) {
     result = LLVMTypeID::FP128TyID;
     return mlir::success();
   }
   if (mlir::succeeded(matchString(ptr, "PPC_FP128"))) {
     result = LLVMTypeID::PPC_FP128TyID;
     return mlir::success();
   }
   return mlir::failure();
 }
 
-fir::KindMapping::KindMapping(mlir::MLIRContext *context, llvm::StringRef map)
+fir::KindMapping::KindMapping(mlir::MLIRContext *context, llvm::StringRef map,
+                              llvm::ArrayRef<KindTy> defs)
     : context{context} {
+  if (mlir::failed(setDefaultKinds(defs))) {
+    mlir::emitError(mlir::UnknownLoc::get(context), "bad default kinds");
+    return;
+  }
   if (mlir::failed(parse(map))) {
+    mlir::emitError(mlir::UnknownLoc::get(context), "could not parse kind map");
     intMap.clear();
     floatMap.clear();
   }
 }
 
-fir::KindMapping::KindMapping(mlir::MLIRContext *context)
-    : KindMapping{context, clKindMapping} {}
+fir::KindMapping::KindMapping(mlir::MLIRContext *context,
+                              llvm::ArrayRef<KindTy> defs)
+    : KindMapping{context, clKindMapping, defs} {}
 
 MatchResult fir::KindMapping::badMapString(const llvm::Twine &ptr) {
   auto unknown = mlir::UnknownLoc::get(context);
   mlir::emitError(unknown, ptr);
   return mlir::failure();
 }
 
 MatchResult fir::KindMapping::parse(llvm::StringRef kindMap) {
Bitsize fir::KindMapping::getRealBitsize(KindTy kind) const {
   llvm::LLVMContext llCtxt; // FIXME
   return llvm::Type::getPrimitiveType(llCtxt, typeId)->getPrimitiveSizeInBits();
 }
 
 const llvm::fltSemantics &
 fir::KindMapping::getFloatSemantics(KindTy kind) const {
   return getFloatSemanticsOfKind<'r'>(kind, floatMap);
 }
+
+mlir::LogicalResult
+fir::KindMapping::setDefaultKinds(llvm::ArrayRef<KindTy> defs) {
+  if (defs.size() == 0) {
+    // generic front-end defaults
+    const KindTy genericKind = 4;
+    defaultMap.insert({'a', 1});
+    defaultMap.insert({'c', genericKind});
+    defaultMap.insert({'d', 2 * genericKind});
+    defaultMap.insert({'i', genericKind});
+    defaultMap.insert({'l', genericKind});
+    defaultMap.insert({'r', genericKind});
+    return mlir::success();
+  }
+  if (defs.size() != 6)
+    return mlir::failure();
+
+  // defaults determined after command-line processing
+  defaultMap.insert({'a', defs[0]});
+  defaultMap.insert({'c', defs[1]});
+  defaultMap.insert({'d', defs[2]});
+  defaultMap.insert({'i', defs[3]});
+  defaultMap.insert({'l', defs[4]});
+  defaultMap.insert({'r', defs[5]});
+  return mlir::success();
+}
+
+KindTy fir::KindMapping::defaultCharacterKind() const {
+  auto iter = defaultMap.find('a');
+  assert(iter != defaultMap.end());
+  return iter->second;
+}
+
+KindTy fir::KindMapping::defaultComplexKind() const {
+  auto iter = defaultMap.find('c');
+  assert(iter != defaultMap.end());
+  return iter->second;
+}
+
+KindTy fir::KindMapping::defaultDoubleKind() const {
+  auto iter = defaultMap.find('d');
+  assert(iter != defaultMap.end());
+  return iter->second;
+}
+
+KindTy fir::KindMapping::defaultIntegerKind() const {
+  auto iter = defaultMap.find('i');
+  assert(iter != defaultMap.end());
+  return iter->second;
+}
+
+KindTy fir::KindMapping::defaultLogicalKind() const {
+  auto iter = defaultMap.find('l');
+  assert(iter != defaultMap.end());
+  return iter->second;
+}
+
+KindTy fir::KindMapping::defaultRealKind() const {
+  auto iter = defaultMap.find('r');
+  assert(iter != defaultMap.end());
+  return iter->second;
+}