[flang] Break circular dependency between FIR dialect and utilities

[Renaud-K]

Summary

flang/Optimizer/Support/Utils.h has header file dependency on the FIRDialect. It also specifies that dependency in the cmake file with

DEPENDS
FIROpsIncGen
HLFIROpsIncGen

However FIRDialect links with FIRSupport which causes a circular dependency exposed by https://reviews.llvm.org/D145530 and summarily fixed by
https://reviews.llvm.org/D145602

This patch breaks up the utility libraries into 2 parts:

1. libDialectSupport is a utility library the FIR dialect depends on and has no dependency on the dialect itself
2. libSupport remains a utility library that depends and operates on the FIR dialect but that the dialect does not depend on.

There are some clean-ups of the DEPENDS attribute when it is redundant with link_libs

[PeteSteinfeld]

All builds and tests correctly and looks good.

[Renaud-K]

Submitted without the Differential message. My bad.

flang/include/flang/Lower/Bridge.h

 #define FORTRAN_LOWER_BRIDGE_H
 
 #include "flang/Common/Fortran.h"
 #include "flang/Lower/AbstractConverter.h"
 #include "flang/Lower/EnvironmentDefault.h"
 #include "flang/Lower/LoweringOptions.h"
 #include "flang/Lower/StatementContext.h"
 #include "flang/Optimizer/Builder/FIRBuilder.h"
-#include "flang/Optimizer/Support/KindMapping.h"
+#include "flang/Optimizer/Dialect/Support/KindMapping.h"
 #include "mlir/IR/BuiltinOps.h"
 
 namespace Fortran {
 namespace common {
 class IntrinsicTypeDefaultKinds;
 } // namespace common
 namespace evaluate {
 class IntrinsicProcTable;

flang/include/flang/Optimizer/Builder/FIRBuilder.h

 
 #ifndef FORTRAN_OPTIMIZER_BUILDER_FIRBUILDER_H
 #define FORTRAN_OPTIMIZER_BUILDER_FIRBUILDER_H
 
 #include "flang/Common/MathOptionsBase.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Dialect/FIROpsSupport.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
-#include "flang/Optimizer/Support/KindMapping.h"
+#include "flang/Optimizer/Dialect/Support/KindMapping.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "llvm/ADT/DenseMap.h"
 #include <optional>
 
 namespace fir {
 class AbstractArrayBox;
 class ExtendedValue;

flang/include/flang/Optimizer/Dialect/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 FORTRAN_OPTIMIZER_SUPPORT_FIRCONTEXT_H
+#define FORTRAN_OPTIMIZER_SUPPORT_FIRCONTEXT_H
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/TargetParser/Triple.h"
+
+namespace mlir {
+class ModuleOp;
+} // namespace mlir
+
+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::StringRef triple);
+
+/// Get the Triple instance from the Module or return the default Triple.
+llvm::Triple getTargetTriple(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 the KindMapping instance from the Module. If none was set, returns a
+/// default.
+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 // FORTRAN_OPTIMIZER_SUPPORT_FIRCONTEXT_H

flang/include/flang/Optimizer/Dialect/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 FORTRAN_OPTIMIZER_SUPPORT_KINDMAPPING_H
+#define FORTRAN_OPTIMIZER_SUPPORT_KINDMAPPING_H
+
+#include "mlir/IR/OpDefinition.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/IR/Type.h"
+
+namespace llvm {
+struct fltSemantics;
+} // namespace llvm
+
+namespace fir {
+
+/// The kind mapping is an encoded string that informs FIR how the Fortran KIND
+/// values from the front-end should be converted to LLVM IR types.  This
+/// encoding allows the mapping from front-end KIND values to backend LLVM IR
+/// types to be customized by the front-end.
+///
+/// The provided string uses the following syntax.
+///
+///   intrinsic-key `:` kind-value (`,` intrinsic-key `:` kind-value)*
+///
+/// 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', '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;
+
+  /// KindMapping constructor with both the kind map and default kinds read from
+  /// command-line options.
+  explicit KindMapping(mlir::MLIRContext *context);
+  /// KindMapping constructor taking a `defs` argument to specify the default
+  /// kinds for intrinsic types. To set the default kinds, an ArrayRef of 6
+  /// KindTy must be passed. The kinds must be the given in the following order:
+  /// CHARACTER, COMPLEX, DOUBLE PRECISION, INTEGER, LOGICAL, and REAL.  The
+  /// kind map is read from command-line options, if given.
+  explicit KindMapping(mlir::MLIRContext *context, llvm::ArrayRef<KindTy> defs);
+  /// KindMapping constructor taking an optional `defs` argument to specify the
+  /// default kinds for intrinsic types. To set the default kinds, an ArrayRef
+  /// of 6 KindTy must be passed. The kinds must be the given in the following
+  /// order: CHARACTER, COMPLEX, DOUBLE PRECISION, INTEGER, LOGICAL, and REAL.
+  explicit KindMapping(mlir::MLIRContext *context, llvm::StringRef map,
+                       llvm::ArrayRef<KindTy> defs = std::nullopt);
+  explicit KindMapping(mlir::MLIRContext *context, llvm::StringRef map,
+                       llvm::StringRef defs)
+      : KindMapping{context, map, toDefaultKinds(defs)} {}
+
+  /// 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;
+
+  /// Get the default kind map as a string.
+  static constexpr const char *getDefaultMap() { return ""; }
+
+  /// Convert the current kind map to a string.
+  std::string mapToString() const;
+
+  //===--------------------------------------------------------------------===//
+  // Default kinds of intrinsic types
+  //===--------------------------------------------------------------------===//
+
+  KindTy defaultCharacterKind() const;
+  KindTy defaultComplexKind() const;
+  KindTy defaultDoubleKind() const;
+  KindTy defaultIntegerKind() const;
+  KindTy defaultLogicalKind() const;
+  KindTy defaultRealKind() const;
+
+  /// Get the default kinds as a string.
+  static constexpr const char *getDefaultKinds() { return "a1c4d8i4l4r4"; }
+
+  /// Convert the current default kinds to a string.
+  std::string defaultsToString() const;
+
+  /// Translate a default kinds string into a default kind vector. This vector
+  /// can be passed to the KindMapping ctor.
+  static std::vector<KindTy> toDefaultKinds(llvm::StringRef defs);
+
+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 // FORTRAN_OPTIMIZER_SUPPORT_KINDMAPPING_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 FORTRAN_OPTIMIZER_SUPPORT_FIRCONTEXT_H
-#define FORTRAN_OPTIMIZER_SUPPORT_FIRCONTEXT_H
-
-#include "llvm/ADT/StringRef.h"
-#include "llvm/TargetParser/Triple.h"
-
-namespace mlir {
-class ModuleOp;
-} // namespace mlir
-
-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::StringRef triple);
-
-/// Get the Triple instance from the Module or return the default Triple.
-llvm::Triple getTargetTriple(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 the KindMapping instance from the Module. If none was set, returns a
-/// default.
-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 // FORTRAN_OPTIMIZER_SUPPORT_FIRCONTEXT_H

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 FORTRAN_OPTIMIZER_SUPPORT_KINDMAPPING_H
-#define FORTRAN_OPTIMIZER_SUPPORT_KINDMAPPING_H
-
-#include "mlir/IR/OpDefinition.h"
-#include "llvm/ADT/DenseMap.h"
-#include "llvm/IR/Type.h"
-
-namespace llvm {
-struct fltSemantics;
-} // namespace llvm
-
-namespace fir {
-
-/// The kind mapping is an encoded string that informs FIR how the Fortran KIND
-/// values from the front-end should be converted to LLVM IR types.  This
-/// encoding allows the mapping from front-end KIND values to backend LLVM IR
-/// types to be customized by the front-end.
-///
-/// The provided string uses the following syntax.
-///
-///   intrinsic-key `:` kind-value (`,` intrinsic-key `:` kind-value)*
-///
-/// 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', '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;
-
-  /// KindMapping constructor with both the kind map and default kinds read from
-  /// command-line options.
-  explicit KindMapping(mlir::MLIRContext *context);
-  /// KindMapping constructor taking a `defs` argument to specify the default
-  /// kinds for intrinsic types. To set the default kinds, an ArrayRef of 6
-  /// KindTy must be passed. The kinds must be the given in the following order:
-  /// CHARACTER, COMPLEX, DOUBLE PRECISION, INTEGER, LOGICAL, and REAL.  The
-  /// kind map is read from command-line options, if given.
-  explicit KindMapping(mlir::MLIRContext *context, llvm::ArrayRef<KindTy> defs);
-  /// KindMapping constructor taking an optional `defs` argument to specify the
-  /// default kinds for intrinsic types. To set the default kinds, an ArrayRef
-  /// of 6 KindTy must be passed. The kinds must be the given in the following
-  /// order: CHARACTER, COMPLEX, DOUBLE PRECISION, INTEGER, LOGICAL, and REAL.
-  explicit KindMapping(mlir::MLIRContext *context, llvm::StringRef map,
-                       llvm::ArrayRef<KindTy> defs = std::nullopt);
-  explicit KindMapping(mlir::MLIRContext *context, llvm::StringRef map,
-                       llvm::StringRef defs)
-      : KindMapping{context, map, toDefaultKinds(defs)} {}
-
-  /// 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;
-
-  /// Get the default kind map as a string.
-  static constexpr const char *getDefaultMap() { return ""; }
-
-  /// Convert the current kind map to a string.
-  std::string mapToString() const;
-
-  //===--------------------------------------------------------------------===//
-  // Default kinds of intrinsic types
-  //===--------------------------------------------------------------------===//
-
-  KindTy defaultCharacterKind() const;
-  KindTy defaultComplexKind() const;
-  KindTy defaultDoubleKind() const;
-  KindTy defaultIntegerKind() const;
-  KindTy defaultLogicalKind() const;
-  KindTy defaultRealKind() const;
-
-  /// Get the default kinds as a string.
-  static constexpr const char *getDefaultKinds() { return "a1c4d8i4l4r4"; }
-
-  /// Convert the current default kinds to a string.
-  std::string defaultsToString() const;
-
-  /// Translate a default kinds string into a default kind vector. This vector
-  /// can be passed to the KindMapping ctor.
-  static std::vector<KindTy> toDefaultKinds(llvm::StringRef defs);
-
-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 // FORTRAN_OPTIMIZER_SUPPORT_KINDMAPPING_H

flang/lib/Frontend/CMakeLists.txt

 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
 
 add_flang_library(flangFrontend
   CompilerInstance.cpp
   CompilerInvocation.cpp
   CodeGenOptions.cpp
   FrontendAction.cpp
   FrontendActions.cpp
   FrontendOptions.cpp
   LangOptions.cpp
   TextDiagnosticPrinter.cpp
   TextDiagnosticBuffer.cpp
   TextDiagnostic.cpp
 
   DEPENDS
-  FIRBuilder
   FIRDialect
-  FIRSupport
   FIROptTransformsPassIncGen
   HLFIRDialect
   MLIRIR
   ${dialect_libs}
 
   LINK_LIBS
   FortranParser
   FortranSemantics
   FortranEvaluate
   FortranCommon
   FortranLower
   FIRDialect
+  FIRDialectSupport
   FIRSupport
   FIRBuilder
   FIRCodeGen
   FIRTransforms
   HLFIRDialect
   HLFIRTransforms
   MLIRTransforms
   MLIRLLVMToLLVMIRTranslation

flang/lib/Frontend/FrontendActions.cpp

 #include "flang/Frontend/FrontendActions.h"
 #include "flang/Common/default-kinds.h"
 #include "flang/Frontend/CompilerInstance.h"
 #include "flang/Frontend/FrontendOptions.h"
 #include "flang/Frontend/PreprocessorOptions.h"
 #include "flang/Lower/Bridge.h"
 #include "flang/Lower/PFTBuilder.h"
 #include "flang/Lower/Support/Verifier.h"
-#include "flang/Optimizer/Support/FIRContext.h"
+#include "flang/Optimizer/Dialect/Support/FIRContext.h"
+#include "flang/Optimizer/Dialect/Support/KindMapping.h"
 #include "flang/Optimizer/Support/InitFIR.h"
-#include "flang/Optimizer/Support/KindMapping.h"
 #include "flang/Optimizer/Support/Utils.h"
 #include "flang/Parser/dump-parse-tree.h"
 #include "flang/Parser/parsing.h"
 #include "flang/Parser/provenance.h"
 #include "flang/Parser/source.h"
 #include "flang/Parser/unparse.h"
 #include "flang/Semantics/runtime-type-info.h"
 #include "flang/Semantics/semantics.h"

flang/lib/Lower/Bridge.cpp

 #include "flang/Optimizer/Builder/Runtime/Character.h"
 #include "flang/Optimizer/Builder/Runtime/Derived.h"
 #include "flang/Optimizer/Builder/Runtime/EnvironmentDefaults.h"
 #include "flang/Optimizer/Builder/Runtime/Ragged.h"
 #include "flang/Optimizer/Builder/Todo.h"
 #include "flang/Optimizer/Dialect/FIRAttr.h"
 #include "flang/Optimizer/Dialect/FIRDialect.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
+#include "flang/Optimizer/Dialect/Support/FIRContext.h"
 #include "flang/Optimizer/HLFIR/HLFIROps.h"
-#include "flang/Optimizer/Support/FIRContext.h"
 #include "flang/Optimizer/Support/FatalError.h"
 #include "flang/Optimizer/Support/InternalNames.h"
 #include "flang/Optimizer/Transforms/Passes.h"
 #include "flang/Parser/parse-tree.h"
 #include "flang/Runtime/iostat.h"
 #include "flang/Semantics/runtime-type-info.h"
 #include "flang/Semantics/tools.h"
 #include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"

flang/lib/Lower/CMakeLists.txt

add_flang_library(FortranLower
   LoweringOptions.cpp
   Mangler.cpp
   OpenACC.cpp
   OpenMP.cpp
   PFTBuilder.cpp
   Runtime.cpp
   SymbolMap.cpp
   VectorSubscripts.cpp
   
   DEPENDS
   FIRDialect
-  FIRBuilder
-  FIRSupport
   FIRTransforms
   HLFIRDialect
   ${dialect_libs}
 
   LINK_LIBS
   FIRDialect
+  FIRDialectSupport
   FIRBuilder
   FIRSupport
   FIRTransforms
   HLFIRDialect
   ${dialect_libs}
   FortranCommon
   FortranParser
   FortranEvaluate

flang/lib/Lower/ConvertVariable.cpp

 #include "flang/Optimizer/Builder/FIRBuilder.h"
 #include "flang/Optimizer/Builder/HLFIRTools.h"
 #include "flang/Optimizer/Builder/IntrinsicCall.h"
 #include "flang/Optimizer/Builder/Runtime/Derived.h"
 #include "flang/Optimizer/Builder/Todo.h"
 #include "flang/Optimizer/Dialect/FIRAttr.h"
 #include "flang/Optimizer/Dialect/FIRDialect.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
+#include "flang/Optimizer/Dialect/Support/FIRContext.h"
 #include "flang/Optimizer/HLFIR/HLFIROps.h"
-#include "flang/Optimizer/Support/FIRContext.h"
 #include "flang/Optimizer/Support/FatalError.h"
 #include "flang/Optimizer/Support/InternalNames.h"
 #include "flang/Semantics/runtime-type-info.h"
 #include "flang/Semantics/tools.h"
 #include "llvm/Support/Debug.h"
 #include <optional>
 
 #define DEBUG_TYPE "flang-lower-variable"

flang/lib/Lower/IO.cpp

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

flang/lib/Optimizer/Analysis/CMakeLists.txt

 add_flang_library(FIRAnalysis
   AliasAnalysis.cpp
 
   DEPENDS
-  FIRBuilder
   FIRDialect
-  FIRSupport
+  MLIRIR
 
   LINK_LIBS
   FIRBuilder
   FIRDialect
   MLIRFuncDialect
   MLIRLLVMDialect
   MLIRMathTransforms
   FIRSupport
 )

flang/lib/Optimizer/Builder/CMakeLists.txt

add_flang_library(FIRBuilder
   Runtime/Numeric.cpp
   Runtime/Ragged.cpp
   Runtime/Reduction.cpp
   Runtime/Stop.cpp
   Runtime/Transformational.cpp
 
   DEPENDS
   FIRDialect
-  FIRSupport
   HLFIRDialect
   ${dialect_libs}
 
   LINK_LIBS
   FIRDialect
+  FIRDialectSupport
   FIRSupport
   HLFIRDialect
   ${dialect_libs}
 )

flang/lib/Optimizer/Builder/IntrinsicCall.cpp

 #include "flang/Optimizer/Builder/Runtime/Intrinsics.h"
 #include "flang/Optimizer/Builder/Runtime/Numeric.h"
 #include "flang/Optimizer/Builder/Runtime/RTBuilder.h"
 #include "flang/Optimizer/Builder/Runtime/Reduction.h"
 #include "flang/Optimizer/Builder/Runtime/Stop.h"
 #include "flang/Optimizer/Builder/Runtime/Transformational.h"
 #include "flang/Optimizer/Builder/Todo.h"
 #include "flang/Optimizer/Dialect/FIROpsSupport.h"
-#include "flang/Optimizer/Support/FIRContext.h"
+#include "flang/Optimizer/Dialect/Support/FIRContext.h"
 #include "flang/Optimizer/Support/FatalError.h"
 #include "flang/Optimizer/Support/Utils.h"
 #include "flang/Runtime/entry-names.h"
 #include "mlir/Dialect/Complex/IR/Complex.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/Math/IR/Math.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"

flang/lib/Optimizer/CodeGen/BoxedProcedure.cpp

 //===-- BoxedProcedure.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/CodeGen/CodeGen.h"
 
 #include "flang/Optimizer/Builder/FIRBuilder.h"
 #include "flang/Optimizer/Builder/LowLevelIntrinsics.h"
 #include "flang/Optimizer/Dialect/FIRDialect.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
-#include "flang/Optimizer/Support/FIRContext.h"
+#include "flang/Optimizer/Dialect/Support/FIRContext.h"
 #include "flang/Optimizer/Support/FatalError.h"
 #include "flang/Optimizer/Support/InternalNames.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
 
 namespace fir {
 #define GEN_PASS_DEF_BOXEDPROCEDUREPASS

flang/lib/Optimizer/CodeGen/CMakeLists.txt

 add_flang_library(FIRCodeGen
   BoxedProcedure.cpp
   CGOps.cpp
   CodeGen.cpp
   PreCGRewrite.cpp
   TBAABuilder.cpp
   Target.cpp
   TargetRewrite.cpp
 
   DEPENDS
-  FIRBuilder
   FIRDialect
-  FIRSupport
   FIROptCodeGenPassIncGen
   CGOpsIncGen
 
   LINK_LIBS
   FIRBuilder
   FIRDialect
+  FIRDialectSupport
   FIRSupport
   MLIRComplexToLLVM
   MLIRComplexToStandard
   MLIRMathToFuncs
   MLIRMathToLLVM
   MLIRMathToLibm
   MLIROpenMPToLLVM
   MLIRLLVMToLLVMIRTranslation
   MLIRTargetLLVMIRExport
 
   LINK_COMPONENTS
   AsmParser
   AsmPrinter
   Remarks
   TargetParser
 )

flang/lib/Optimizer/CodeGen/PreCGRewrite.cpp

 
 #include "flang/Optimizer/CodeGen/CodeGen.h"
 
 #include "CGOps.h"
 #include "flang/Optimizer/Builder/Todo.h" // remove when TODO's are done
 #include "flang/Optimizer/Dialect/FIRDialect.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
-#include "flang/Optimizer/Support/FIRContext.h"
+#include "flang/Optimizer/Dialect/Support/FIRContext.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "mlir/Transforms/RegionUtils.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/Debug.h"
 
 namespace fir {
 #define GEN_PASS_DEF_CODEGENREWRITE
 #include "flang/Optimizer/CodeGen/CGPasses.h.inc"

flang/lib/Optimizer/CodeGen/Target.h

 //===- Target.h - target specific details -----------------------*- 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 FORTRAN_OPTMIZER_CODEGEN_TARGET_H
 #define FORTRAN_OPTMIZER_CODEGEN_TARGET_H
 
-#include "flang/Optimizer/Support/KindMapping.h"
+#include "flang/Optimizer/Dialect/Support/KindMapping.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "llvm/TargetParser/Triple.h"
 #include <memory>
 #include <tuple>
 #include <vector>
 
 namespace fir {
 

flang/lib/Optimizer/CodeGen/Target.cpp

 //===-- Target.cpp --------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Coding style: https://mlir.llvm.org/getting_started/DeveloperGuide/
 //
 //===----------------------------------------------------------------------===//
 
 #include "Target.h"
 #include "flang/Optimizer/Builder/Todo.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
+#include "flang/Optimizer/Dialect/Support/KindMapping.h"
 #include "flang/Optimizer/Support/FatalError.h"
-#include "flang/Optimizer/Support/KindMapping.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/TypeRange.h"
 
 #define DEBUG_TYPE "flang-codegen-target"
 
 using namespace fir;
 
 namespace fir::details {

flang/lib/Optimizer/CodeGen/TargetRewrite.cpp

 #include "Target.h"
 #include "flang/Optimizer/Builder/Character.h"
 #include "flang/Optimizer/Builder/FIRBuilder.h"
 #include "flang/Optimizer/Builder/Todo.h"
 #include "flang/Optimizer/Dialect/FIRDialect.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Dialect/FIROpsSupport.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
-#include "flang/Optimizer/Support/FIRContext.h"
+#include "flang/Optimizer/Dialect/Support/FIRContext.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/TypeSwitch.h"
 #include "llvm/Support/Debug.h"
 #include <optional>
 
 namespace fir {
 #define GEN_PASS_DEF_TARGETREWRITEPASS

flang/lib/Optimizer/CodeGen/TypeConverter.h

 #ifndef FORTRAN_OPTIMIZER_CODEGEN_TYPECONVERTER_H
 #define FORTRAN_OPTIMIZER_CODEGEN_TYPECONVERTER_H
 
 #include "DescriptorModel.h"
 #include "TBAABuilder.h"
 #include "Target.h"
 #include "flang/Optimizer/Builder/Todo.h" // remove when TODO's are done
 #include "flang/Optimizer/Dialect/FIRType.h"
-#include "flang/Optimizer/Support/FIRContext.h"
-#include "flang/Optimizer/Support/KindMapping.h"
+#include "flang/Optimizer/Dialect/Support/FIRContext.h"
+#include "flang/Optimizer/Dialect/Support/KindMapping.h"
 #include "mlir/Conversion/LLVMCommon/TypeConverter.h"
 #include "llvm/Support/Debug.h"
 
 // Position of the different values in a `fir.box`.
 static constexpr unsigned kAddrPosInBox = 0;
 static constexpr unsigned kElemLenPosInBox = 1;
 static constexpr unsigned kVersionPosInBox = 2;
 static constexpr unsigned kRankPosInBox = 3;

flang/lib/Optimizer/Dialect/CMakeLists.txt

+add_subdirectory(Support)
+
 add_flang_library(FIRDialect
   FIRAttr.cpp
   FIRDialect.cpp
   FIROps.cpp
   FIRType.cpp
   FortranVariableInterface.cpp
   Inliner.cpp
 
   DEPENDS
   CanonicalizationPatternsIncGen
-  FIRSupport
+  MLIRIR
   FIROpsIncGen
 
   LINK_LIBS
-  FIRSupport
+  FIRDialectSupport
   MLIRArithDialect
   MLIROpenMPToLLVM
   MLIRLLVMToLLVMIRTranslation
   MLIRTargetLLVMIRExport
 
   LINK_COMPONENTS
   AsmParser
   AsmPrinter
   Remarks
 )

flang/lib/Optimizer/Dialect/FIRAttr.cpp

 //===-- FIRAttr.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/Dialect/FIRAttr.h"
 #include "flang/Optimizer/Dialect/FIRDialect.h"
-#include "flang/Optimizer/Support/KindMapping.h"
+#include "flang/Optimizer/Dialect/Support/KindMapping.h"
 #include "mlir/IR/AttributeSupport.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/DialectImplementation.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/TypeSwitch.h"
 
 #include "flang/Optimizer/Dialect/FIREnumAttr.cpp.inc"

flang/lib/Optimizer/Dialect/FIROps.cpp

 //===-- FIROps.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/Dialect/FIROps.h"
 #include "flang/Optimizer/Dialect/FIRAttr.h"
 #include "flang/Optimizer/Dialect/FIROpsSupport.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
-#include "flang/Optimizer/Support/FIRContext.h"
-#include "flang/Optimizer/Support/KindMapping.h"
+#include "flang/Optimizer/Dialect/Support/FIRContext.h"
+#include "flang/Optimizer/Dialect/Support/KindMapping.h"
 #include "flang/Optimizer/Support/Utils.h"
 #include "mlir/Dialect/CommonFolders.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/IR/BuiltinAttributes.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/IR/OpDefinition.h"

flang/lib/Optimizer/Dialect/FIRType.cpp

 //===-- FIRType.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/Dialect/FIRType.h"
 #include "flang/Optimizer/Dialect/FIRDialect.h"
-#include "flang/Optimizer/Support/KindMapping.h"
+#include "flang/Optimizer/Dialect/Support/KindMapping.h"
 #include "flang/Tools/PointerModels.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinDialect.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/DialectImplementation.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/ADT/TypeSwitch.h"

flang/lib/Optimizer/Dialect/Support/CMakeLists.txt

+get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
+
+add_flang_library(FIRDialectSupport
+  KindMapping.cpp
+  FIRContext.cpp
+
+  DEPENDS
+  MLIRIR
+
+  LINK_LIBS
+  ${dialect_libs}
+)

flang/lib/Optimizer/Dialect/Support/FIRContext.cpp

+//===-- FIRContext.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/Dialect/Support/FIRContext.h"
+#include "flang/Optimizer/Dialect/Support/KindMapping.h"
+#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
+#include "mlir/IR/BuiltinAttributes.h"
+#include "mlir/IR/BuiltinOps.h"
+#include "llvm/TargetParser/Host.h"
+
+void fir::setTargetTriple(mlir::ModuleOp mod, llvm::StringRef triple) {
+  auto target = fir::determineTargetTriple(triple);
+  mod->setAttr(mlir::LLVM::LLVMDialect::getTargetTripleAttrName(),
+               mlir::StringAttr::get(mod.getContext(), target));
+}
+
+llvm::Triple fir::getTargetTriple(mlir::ModuleOp mod) {
+  if (auto target = mod->getAttrOfType<mlir::StringAttr>(
+          mlir::LLVM::LLVMDialect::getTargetTripleAttrName()))
+    return llvm::Triple(target.getValue());
+  return llvm::Triple(llvm::sys::getDefaultTargetTriple());
+}
+
+static constexpr const char *kindMapName = "fir.kindmap";
+static constexpr const char *defKindName = "fir.defaultkind";
+
+void fir::setKindMapping(mlir::ModuleOp mod, fir::KindMapping &kindMap) {
+  auto *ctx = mod.getContext();
+  mod->setAttr(kindMapName, mlir::StringAttr::get(ctx, kindMap.mapToString()));
+  auto defs = kindMap.defaultsToString();
+  mod->setAttr(defKindName, mlir::StringAttr::get(ctx, defs));
+}
+
+fir::KindMapping fir::getKindMapping(mlir::ModuleOp mod) {
+  auto *ctx = mod.getContext();
+  if (auto defs = mod->getAttrOfType<mlir::StringAttr>(defKindName)) {
+    auto defVals = fir::KindMapping::toDefaultKinds(defs.getValue());
+    if (auto maps = mod->getAttrOfType<mlir::StringAttr>(kindMapName))
+      return fir::KindMapping(ctx, maps.getValue(), defVals);
+    return fir::KindMapping(ctx, defVals);
+  }
+  return fir::KindMapping(ctx);
+}
+
+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/Dialect/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/Dialect/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
+/// front-end kind mappings.
+
+using Bitsize = fir::KindMapping::Bitsize;
+using KindTy = fir::KindMapping::KindTy;
+using LLVMTypeID = fir::KindMapping::LLVMTypeID;
+using MatchResult = fir::KindMapping::MatchResult;
+
+static llvm::cl::opt<std::string>
+    clKindMapping("kind-mapping",
+                  llvm::cl::desc("kind mapping string to set kind precision"),
+                  llvm::cl::value_desc("kind-mapping-string"),
+                  llvm::cl::init(fir::KindMapping::getDefaultMap()));
+
+static llvm::cl::opt<std::string>
+    clDefaultKinds("default-kinds",
+                   llvm::cl::desc("string to set default kind values"),
+                   llvm::cl::value_desc("default-kind-string"),
+                   llvm::cl::init(fir::KindMapping::getDefaultKinds()));
+
+// Keywords for the floating point types.
+
+static constexpr const char *kwHalf = "Half";
+static constexpr const char *kwBFloat = "BFloat";
+static constexpr const char *kwFloat = "Float";
+static constexpr const char *kwDouble = "Double";
+static constexpr const char *kwX86FP80 = "X86_FP80";
+static constexpr const char *kwFP128 = "FP128";
+static constexpr const char *kwPPCFP128 = "PPC_FP128";
+
+/// 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 bitsInByte = 8;
+  return kind * bitsInByte;
+}
+
+/// Floating-point types default to the kind value being the size of the value
+/// 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;
+  default:
+    return LLVMTypeID::FloatTyID;
+  }
+}
+
+// lookup the kind-value given the defaults, the mappings, and a KIND key
+template <typename RT, char KEY>
+static RT doLookup(std::function<RT(KindTy)> def,
+                   const llvm::DenseMap<std::pair<char, KindTy>, RT> &map,
+                   KindTy kind) {
+  std::pair<char, KindTy> key{KEY, kind};
+  auto iter = map.find(key);
+  if (iter != map.end())
+    return iter->second;
+  return def(kind);
+}
+
+// do a lookup for INTEGER, LOGICAL, or CHARACTER
+template <char KEY, typename MAP>
+static Bitsize getIntegerLikeBitsize(KindTy kind, const MAP &map) {
+  return doLookup<Bitsize, KEY>(defaultScalingKind, map, kind);
+}
+
+// do a lookup for REAL or COMPLEX
+template <char KEY, typename MAP>
+static LLVMTypeID getFloatLikeTypeID(KindTy kind, const MAP &map) {
+  return doLookup<LLVMTypeID, KEY>(defaultRealKind, map, kind);
+}
+
+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();
+  case LLVMTypeID::PPC_FP128TyID:
+    return llvm::APFloat::PPCDoubleDouble();
+  default:
+    llvm_unreachable("Invalid floating type");
+  }
+}
+
+/// Parse an intrinsic type code. The codes are ('a', CHARACTER), ('c',
+/// COMPLEX), ('i', INTEGER), ('l', LOGICAL), and ('r', REAL).
+static MatchResult parseCode(char &code, const char *&ptr, const char *endPtr) {
+  if (ptr >= endPtr)
+    return mlir::failure();
+  if (*ptr != 'a' && *ptr != 'c' && *ptr != 'i' && *ptr != 'l' && *ptr != 'r')
+    return mlir::failure();
+  code = *ptr++;
+  return mlir::success();
+}
+
+/// Same as `parseCode` but adds the ('d', DOUBLE PRECISION) code.
+static MatchResult parseDefCode(char &code, const char *&ptr,
+                                const char *endPtr) {
+  if (ptr >= endPtr)
+    return mlir::failure();
+  if (*ptr == 'd') {
+    code = *ptr++;
+    return mlir::success();
+  }
+  return parseCode(code, ptr, endPtr);
+}
+
+template <char ch>
+static MatchResult parseSingleChar(const char *&ptr, const char *endPtr) {
+  if (ptr >= endPtr || *ptr != ch)
+    return mlir::failure();
+  ++ptr;
+  return mlir::success();
+}
+
+static MatchResult parseColon(const char *&ptr, const char *endPtr) {
+  return parseSingleChar<':'>(ptr, endPtr);
+}
+
+static MatchResult parseComma(const char *&ptr, const char *endPtr) {
+  return parseSingleChar<','>(ptr, endPtr);
+}
+
+/// Recognize and parse an unsigned integer.
+static MatchResult parseInt(unsigned &result, const char *&ptr,
+                            const char *endPtr) {
+  const char *beg = ptr;
+  while (ptr < endPtr && *ptr >= '0' && *ptr <= '9')
+    ptr++;
+  if (beg == ptr)
+    return mlir::failure();
+  llvm::StringRef ref(beg, ptr - beg);
+  int temp;
+  if (ref.consumeInteger(10, temp))
+    return mlir::failure();
+  result = temp;
+  return mlir::success();
+}
+
+static mlir::LogicalResult matchString(const char *&ptr, const char *endPtr,
+                                       llvm::StringRef literal) {
+  llvm::StringRef s(ptr, endPtr - ptr);
+  if (s.startswith(literal)) {
+    ptr += literal.size();
+    return mlir::success();
+  }
+  return mlir::failure();
+}
+
+/// Recognize and parse the various floating-point keywords. These follow the
+/// LLVM naming convention.
+static MatchResult parseTypeID(LLVMTypeID &result, const char *&ptr,
+                               const char *endPtr) {
+  if (mlir::succeeded(matchString(ptr, endPtr, kwHalf))) {
+    result = LLVMTypeID::HalfTyID;
+    return mlir::success();
+  }
+  if (mlir::succeeded(matchString(ptr, endPtr, kwBFloat))) {
+    result = LLVMTypeID::BFloatTyID;
+    return mlir::success();
+  }
+  if (mlir::succeeded(matchString(ptr, endPtr, kwFloat))) {
+    result = LLVMTypeID::FloatTyID;
+    return mlir::success();
+  }
+  if (mlir::succeeded(matchString(ptr, endPtr, kwDouble))) {
+    result = LLVMTypeID::DoubleTyID;
+    return mlir::success();
+  }
+  if (mlir::succeeded(matchString(ptr, endPtr, kwX86FP80))) {
+    result = LLVMTypeID::X86_FP80TyID;
+    return mlir::success();
+  }
+  if (mlir::succeeded(matchString(ptr, endPtr, kwFP128))) {
+    result = LLVMTypeID::FP128TyID;
+    return mlir::success();
+  }
+  if (mlir::succeeded(matchString(ptr, endPtr, kwPPCFP128))) {
+    result = LLVMTypeID::PPC_FP128TyID;
+    return mlir::success();
+  }
+  return mlir::failure();
+}
+
+fir::KindMapping::KindMapping(mlir::MLIRContext *context, llvm::StringRef map,
+                              llvm::ArrayRef<KindTy> defs)
+    : context{context} {
+  if (mlir::failed(setDefaultKinds(defs)))
+    llvm::report_fatal_error("bad default kinds");
+  if (mlir::failed(parse(map)))
+    llvm::report_fatal_error("could not parse kind map");
+}
+
+fir::KindMapping::KindMapping(mlir::MLIRContext *context,
+                              llvm::ArrayRef<KindTy> defs)
+    : KindMapping{context, clKindMapping, defs} {}
+
+fir::KindMapping::KindMapping(mlir::MLIRContext *context)
+    : KindMapping{context, clKindMapping, clDefaultKinds} {}
+
+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) {
+  if (kindMap.empty())
+    return mlir::success();
+  const char *srcPtr = kindMap.begin();
+  const char *endPtr = kindMap.end();
+  while (true) {
+    char code = '\0';
+    KindTy kind = 0;
+    if (parseCode(code, srcPtr, endPtr) || parseInt(kind, srcPtr, endPtr))
+      return badMapString(srcPtr);
+    if (code == 'a' || code == 'i' || code == 'l') {
+      Bitsize bits = 0;
+      if (parseColon(srcPtr, endPtr) || parseInt(bits, srcPtr, endPtr))
+        return badMapString(srcPtr);
+      intMap[std::pair<char, KindTy>{code, kind}] = bits;
+    } else if (code == 'r' || code == 'c') {
+      LLVMTypeID id{};
+      if (parseColon(srcPtr, endPtr) || parseTypeID(id, srcPtr, endPtr))
+        return badMapString(srcPtr);
+      floatMap[std::pair<char, KindTy>{code, kind}] = id;
+    } else {
+      return badMapString(srcPtr);
+    }
+    if (parseComma(srcPtr, endPtr))
+      break;
+  }
+  if (srcPtr > endPtr)
+    return badMapString(srcPtr);
+  return mlir::success();
+}
+
+Bitsize fir::KindMapping::getCharacterBitsize(KindTy kind) const {
+  return getIntegerLikeBitsize<'a'>(kind, intMap);
+}
+
+Bitsize fir::KindMapping::getIntegerBitsize(KindTy kind) const {
+  return getIntegerLikeBitsize<'i'>(kind, intMap);
+}
+
+Bitsize fir::KindMapping::getLogicalBitsize(KindTy kind) const {
+  return getIntegerLikeBitsize<'l'>(kind, intMap);
+}
+
+LLVMTypeID fir::KindMapping::getRealTypeID(KindTy kind) const {
+  return getFloatLikeTypeID<'r'>(kind, floatMap);
+}
+
+LLVMTypeID fir::KindMapping::getComplexTypeID(KindTy kind) const {
+  return getFloatLikeTypeID<'c'>(kind, floatMap);
+}
+
+Bitsize fir::KindMapping::getRealBitsize(KindTy kind) const {
+  auto typeId = getFloatLikeTypeID<'r'>(kind, floatMap);
+  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);
+}
+
+std::string fir::KindMapping::mapToString() const {
+  std::string result;
+  bool addComma = false;
+  for (auto [k, v] : intMap) {
+    if (addComma)
+      result.append(",");
+    else
+      addComma = true;
+    result += k.first + std::to_string(k.second) + ":" + std::to_string(v);
+  }
+  for (auto [k, v] : floatMap) {
+    if (addComma)
+      result.append(",");
+    else
+      addComma = true;
+    result.append(k.first + std::to_string(k.second) + ":");
+    switch (v) {
+    default:
+      llvm_unreachable("unhandled type-id");
+    case LLVMTypeID::HalfTyID:
+      result.append(kwHalf);
+      break;
+    case LLVMTypeID::BFloatTyID:
+      result.append(kwBFloat);
+      break;
+    case LLVMTypeID::FloatTyID:
+      result.append(kwFloat);
+      break;
+    case LLVMTypeID::DoubleTyID:
+      result.append(kwDouble);
+      break;
+    case LLVMTypeID::X86_FP80TyID:
+      result.append(kwX86FP80);
+      break;
+    case LLVMTypeID::FP128TyID:
+      result.append(kwFP128);
+      break;
+    case LLVMTypeID::PPC_FP128TyID:
+      result.append(kwPPCFP128);
+      break;
+    }
+  }
+  return result;
+}
+
+mlir::LogicalResult
+fir::KindMapping::setDefaultKinds(llvm::ArrayRef<KindTy> defs) {
+  if (defs.empty()) {
+    // 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();
+}
+
+std::string fir::KindMapping::defaultsToString() const {
+  return std::string("a") + std::to_string(defaultMap.find('a')->second) +
+         std::string("c") + std::to_string(defaultMap.find('c')->second) +
+         std::string("d") + std::to_string(defaultMap.find('d')->second) +
+         std::string("i") + std::to_string(defaultMap.find('i')->second) +
+         std::string("l") + std::to_string(defaultMap.find('l')->second) +
+         std::string("r") + std::to_string(defaultMap.find('r')->second);
+}
+
+/// Convert a default intrinsic code into the proper position in the array. The
+/// default kinds have a precise ordering.
+static int codeToIndex(char code) {
+  switch (code) {
+  case 'a':
+    return 0;
+  case 'c':
+    return 1;
+  case 'd':
+    return 2;
+  case 'i':
+    return 3;
+  case 'l':
+    return 4;
+  case 'r':
+    return 5;
+  }
+  llvm_unreachable("invalid default kind intrinsic code");
+}
+
+std::vector<KindTy> fir::KindMapping::toDefaultKinds(llvm::StringRef defs) {
+  std::vector<KindTy> result(6);
+  char code;
+  KindTy kind;
+  if (defs.empty())
+    defs = clDefaultKinds;
+  const char *srcPtr = defs.begin();
+  const char *endPtr = defs.end();
+  while (srcPtr < endPtr) {
+    if (parseDefCode(code, srcPtr, endPtr) || parseInt(kind, srcPtr, endPtr))
+      llvm::report_fatal_error("invalid default kind code");
+    result[codeToIndex(code)] = kind;
+  }
+  assert(srcPtr == endPtr);
+  return result;
+}
+
+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;
+}

flang/lib/Optimizer/HLFIR/Transforms/BufferizeHLFIR.cpp

 #include "flang/Optimizer/Builder/HLFIRTools.h"
 #include "flang/Optimizer/Builder/IntrinsicCall.h"
 #include "flang/Optimizer/Builder/MutableBox.h"
 #include "flang/Optimizer/Builder/Runtime/Assign.h"
 #include "flang/Optimizer/Builder/Todo.h"
 #include "flang/Optimizer/Dialect/FIRDialect.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
+#include "flang/Optimizer/Dialect/Support/FIRContext.h"
 #include "flang/Optimizer/HLFIR/HLFIRDialect.h"
 #include "flang/Optimizer/HLFIR/HLFIROps.h"
 #include "flang/Optimizer/HLFIR/Passes.h"
-#include "flang/Optimizer/Support/FIRContext.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include <mlir/Support/LogicalResult.h>
 #include <optional>
 
 namespace hlfir {

flang/lib/Optimizer/HLFIR/Transforms/CMakeLists.txt

 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
 
 add_flang_library(HLFIRTransforms
   BufferizeHLFIR.cpp
   ConvertToFIR.cpp
 
   DEPENDS
   FIRDialect
   HLFIROpsIncGen
   ${dialect_libs}
 
   LINK_LIBS
   FIRDialect
   FIRBuilder
+  FIRDialectSupport
   FIRSupport
   HLFIRDialect
   MLIRIR
   ${dialect_libs}
 
   LINK_COMPONENTS
   AsmParser
   AsmPrinter
   Remarks
 )

flang/lib/Optimizer/HLFIR/Transforms/ConvertToFIR.cpp

 #include "flang/Optimizer/Builder/HLFIRTools.h"
 #include "flang/Optimizer/Builder/MutableBox.h"
 #include "flang/Optimizer/Builder/Runtime/Assign.h"
 #include "flang/Optimizer/Builder/Runtime/Inquiry.h"
 #include "flang/Optimizer/Builder/Todo.h"
 #include "flang/Optimizer/Dialect/FIRDialect.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
+#include "flang/Optimizer/Dialect/Support/FIRContext.h"
 #include "flang/Optimizer/HLFIR/HLFIROps.h"
 #include "flang/Optimizer/HLFIR/Passes.h"
-#include "flang/Optimizer/Support/FIRContext.h"
 #include "mlir/Transforms/DialectConversion.h"
 
 namespace hlfir {
 #define GEN_PASS_DEF_CONVERTHLFIRTOFIR
 #include "flang/Optimizer/HLFIR/Passes.h.inc"
 } // namespace hlfir
 
 using namespace mlir;

flang/lib/Optimizer/Support/CMakeLists.txt

 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
 
 add_flang_library(FIRSupport
-  FIRContext.cpp
   InitFIR.cpp
   InternalNames.cpp
-  KindMapping.cpp
 
   DEPENDS
   FIROpsIncGen
   HLFIROpsIncGen
   MLIRIR
   ${dialect_libs}
 
   LINK_LIBS
   ${dialect_libs}
   MLIROpenMPToLLVMIRTranslation
   MLIRLLVMToLLVMIRTranslation
   MLIRTargetLLVMIRExport
 
   LINK_COMPONENTS
   TargetParser
 )

flang/lib/Optimizer/Support/FIRContext.cpp

-//===-- FIRContext.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/Support/KindMapping.h"
-#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
-#include "mlir/IR/BuiltinAttributes.h"
-#include "mlir/IR/BuiltinOps.h"
-#include "llvm/TargetParser/Host.h"
-
-void fir::setTargetTriple(mlir::ModuleOp mod, llvm::StringRef triple) {
-  auto target = fir::determineTargetTriple(triple);
-  mod->setAttr(mlir::LLVM::LLVMDialect::getTargetTripleAttrName(),
-               mlir::StringAttr::get(mod.getContext(), target));
-}
-
-llvm::Triple fir::getTargetTriple(mlir::ModuleOp mod) {
-  if (auto target = mod->getAttrOfType<mlir::StringAttr>(
-          mlir::LLVM::LLVMDialect::getTargetTripleAttrName()))
-    return llvm::Triple(target.getValue());
-  return llvm::Triple(llvm::sys::getDefaultTargetTriple());
-}
-
-static constexpr const char *kindMapName = "fir.kindmap";
-static constexpr const char *defKindName = "fir.defaultkind";
-
-void fir::setKindMapping(mlir::ModuleOp mod, fir::KindMapping &kindMap) {
-  auto *ctx = mod.getContext();
-  mod->setAttr(kindMapName, mlir::StringAttr::get(ctx, kindMap.mapToString()));
-  auto defs = kindMap.defaultsToString();
-  mod->setAttr(defKindName, mlir::StringAttr::get(ctx, defs));
-}
-
-fir::KindMapping fir::getKindMapping(mlir::ModuleOp mod) {
-  auto *ctx = mod.getContext();
-  if (auto defs = mod->getAttrOfType<mlir::StringAttr>(defKindName)) {
-    auto defVals = fir::KindMapping::toDefaultKinds(defs.getValue());
-    if (auto maps = mod->getAttrOfType<mlir::StringAttr>(kindMapName))
-      return fir::KindMapping(ctx, maps.getValue(), defVals);
-    return fir::KindMapping(ctx, defVals);
-  }
-  return fir::KindMapping(ctx);
-}
-
-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/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
-/// front-end kind mappings.
-
-using Bitsize = fir::KindMapping::Bitsize;
-using KindTy = fir::KindMapping::KindTy;
-using LLVMTypeID = fir::KindMapping::LLVMTypeID;
-using MatchResult = fir::KindMapping::MatchResult;
-
-static llvm::cl::opt<std::string>
-    clKindMapping("kind-mapping",
-                  llvm::cl::desc("kind mapping string to set kind precision"),
-                  llvm::cl::value_desc("kind-mapping-string"),
-                  llvm::cl::init(fir::KindMapping::getDefaultMap()));
-
-static llvm::cl::opt<std::string>
-    clDefaultKinds("default-kinds",
-                   llvm::cl::desc("string to set default kind values"),
-                   llvm::cl::value_desc("default-kind-string"),
-                   llvm::cl::init(fir::KindMapping::getDefaultKinds()));
-
-// Keywords for the floating point types.
-
-static constexpr const char *kwHalf = "Half";
-static constexpr const char *kwBFloat = "BFloat";
-static constexpr const char *kwFloat = "Float";
-static constexpr const char *kwDouble = "Double";
-static constexpr const char *kwX86FP80 = "X86_FP80";
-static constexpr const char *kwFP128 = "FP128";
-static constexpr const char *kwPPCFP128 = "PPC_FP128";
-
-/// 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 bitsInByte = 8;
-  return kind * bitsInByte;
-}
-
-/// Floating-point types default to the kind value being the size of the value
-/// 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;
-  default:
-    return LLVMTypeID::FloatTyID;
-  }
-}
-
-// lookup the kind-value given the defaults, the mappings, and a KIND key
-template <typename RT, char KEY>
-static RT doLookup(std::function<RT(KindTy)> def,
-                   const llvm::DenseMap<std::pair<char, KindTy>, RT> &map,
-                   KindTy kind) {
-  std::pair<char, KindTy> key{KEY, kind};
-  auto iter = map.find(key);
-  if (iter != map.end())
-    return iter->second;
-  return def(kind);
-}
-
-// do a lookup for INTEGER, LOGICAL, or CHARACTER
-template <char KEY, typename MAP>
-static Bitsize getIntegerLikeBitsize(KindTy kind, const MAP &map) {
-  return doLookup<Bitsize, KEY>(defaultScalingKind, map, kind);
-}
-
-// do a lookup for REAL or COMPLEX
-template <char KEY, typename MAP>
-static LLVMTypeID getFloatLikeTypeID(KindTy kind, const MAP &map) {
-  return doLookup<LLVMTypeID, KEY>(defaultRealKind, map, kind);
-}
-
-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();
-  case LLVMTypeID::PPC_FP128TyID:
-    return llvm::APFloat::PPCDoubleDouble();
-  default:
-    llvm_unreachable("Invalid floating type");
-  }
-}
-
-/// Parse an intrinsic type code. The codes are ('a', CHARACTER), ('c',
-/// COMPLEX), ('i', INTEGER), ('l', LOGICAL), and ('r', REAL).
-static MatchResult parseCode(char &code, const char *&ptr, const char *endPtr) {
-  if (ptr >= endPtr)
-    return mlir::failure();
-  if (*ptr != 'a' && *ptr != 'c' && *ptr != 'i' && *ptr != 'l' && *ptr != 'r')
-    return mlir::failure();
-  code = *ptr++;
-  return mlir::success();
-}
-
-/// Same as `parseCode` but adds the ('d', DOUBLE PRECISION) code.
-static MatchResult parseDefCode(char &code, const char *&ptr,
-                                const char *endPtr) {
-  if (ptr >= endPtr)
-    return mlir::failure();
-  if (*ptr == 'd') {
-    code = *ptr++;
-    return mlir::success();
-  }
-  return parseCode(code, ptr, endPtr);
-}
-
-template <char ch>
-static MatchResult parseSingleChar(const char *&ptr, const char *endPtr) {
-  if (ptr >= endPtr || *ptr != ch)
-    return mlir::failure();
-  ++ptr;
-  return mlir::success();
-}
-
-static MatchResult parseColon(const char *&ptr, const char *endPtr) {
-  return parseSingleChar<':'>(ptr, endPtr);
-}
-
-static MatchResult parseComma(const char *&ptr, const char *endPtr) {
-  return parseSingleChar<','>(ptr, endPtr);
-}
-
-/// Recognize and parse an unsigned integer.
-static MatchResult parseInt(unsigned &result, const char *&ptr,
-                            const char *endPtr) {
-  const char *beg = ptr;
-  while (ptr < endPtr && *ptr >= '0' && *ptr <= '9')
-    ptr++;
-  if (beg == ptr)
-    return mlir::failure();
-  llvm::StringRef ref(beg, ptr - beg);
-  int temp;
-  if (ref.consumeInteger(10, temp))
-    return mlir::failure();
-  result = temp;
-  return mlir::success();
-}
-
-static mlir::LogicalResult matchString(const char *&ptr, const char *endPtr,
-                                       llvm::StringRef literal) {
-  llvm::StringRef s(ptr, endPtr - ptr);
-  if (s.startswith(literal)) {
-    ptr += literal.size();
-    return mlir::success();
-  }
-  return mlir::failure();
-}
-
-/// Recognize and parse the various floating-point keywords. These follow the
-/// LLVM naming convention.
-static MatchResult parseTypeID(LLVMTypeID &result, const char *&ptr,
-                               const char *endPtr) {
-  if (mlir::succeeded(matchString(ptr, endPtr, kwHalf))) {
-    result = LLVMTypeID::HalfTyID;
-    return mlir::success();
-  }
-  if (mlir::succeeded(matchString(ptr, endPtr, kwBFloat))) {
-    result = LLVMTypeID::BFloatTyID;
-    return mlir::success();
-  }
-  if (mlir::succeeded(matchString(ptr, endPtr, kwFloat))) {
-    result = LLVMTypeID::FloatTyID;
-    return mlir::success();
-  }
-  if (mlir::succeeded(matchString(ptr, endPtr, kwDouble))) {
-    result = LLVMTypeID::DoubleTyID;
-    return mlir::success();
-  }
-  if (mlir::succeeded(matchString(ptr, endPtr, kwX86FP80))) {
-    result = LLVMTypeID::X86_FP80TyID;
-    return mlir::success();
-  }
-  if (mlir::succeeded(matchString(ptr, endPtr, kwFP128))) {
-    result = LLVMTypeID::FP128TyID;
-    return mlir::success();
-  }
-  if (mlir::succeeded(matchString(ptr, endPtr, kwPPCFP128))) {
-    result = LLVMTypeID::PPC_FP128TyID;
-    return mlir::success();
-  }
-  return mlir::failure();
-}
-
-fir::KindMapping::KindMapping(mlir::MLIRContext *context, llvm::StringRef map,
-                              llvm::ArrayRef<KindTy> defs)
-    : context{context} {
-  if (mlir::failed(setDefaultKinds(defs)))
-    llvm::report_fatal_error("bad default kinds");
-  if (mlir::failed(parse(map)))
-    llvm::report_fatal_error("could not parse kind map");
-}
-
-fir::KindMapping::KindMapping(mlir::MLIRContext *context,
-                              llvm::ArrayRef<KindTy> defs)
-    : KindMapping{context, clKindMapping, defs} {}
-
-fir::KindMapping::KindMapping(mlir::MLIRContext *context)
-    : KindMapping{context, clKindMapping, clDefaultKinds} {}
-
-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) {
-  if (kindMap.empty())
-    return mlir::success();
-  const char *srcPtr = kindMap.begin();
-  const char *endPtr = kindMap.end();
-  while (true) {
-    char code = '\0';
-    KindTy kind = 0;
-    if (parseCode(code, srcPtr, endPtr) || parseInt(kind, srcPtr, endPtr))
-      return badMapString(srcPtr);
-    if (code == 'a' || code == 'i' || code == 'l') {
-      Bitsize bits = 0;
-      if (parseColon(srcPtr, endPtr) || parseInt(bits, srcPtr, endPtr))
-        return badMapString(srcPtr);
-      intMap[std::pair<char, KindTy>{code, kind}] = bits;
-    } else if (code == 'r' || code == 'c') {
-      LLVMTypeID id{};
-      if (parseColon(srcPtr, endPtr) || parseTypeID(id, srcPtr, endPtr))
-        return badMapString(srcPtr);
-      floatMap[std::pair<char, KindTy>{code, kind}] = id;
-    } else {
-      return badMapString(srcPtr);
-    }
-    if (parseComma(srcPtr, endPtr))
-      break;
-  }
-  if (srcPtr > endPtr)
-    return badMapString(srcPtr);
-  return mlir::success();
-}
-
-Bitsize fir::KindMapping::getCharacterBitsize(KindTy kind) const {
-  return getIntegerLikeBitsize<'a'>(kind, intMap);
-}
-
-Bitsize fir::KindMapping::getIntegerBitsize(KindTy kind) const {
-  return getIntegerLikeBitsize<'i'>(kind, intMap);
-}
-
-Bitsize fir::KindMapping::getLogicalBitsize(KindTy kind) const {
-  return getIntegerLikeBitsize<'l'>(kind, intMap);
-}
-
-LLVMTypeID fir::KindMapping::getRealTypeID(KindTy kind) const {
-  return getFloatLikeTypeID<'r'>(kind, floatMap);
-}
-
-LLVMTypeID fir::KindMapping::getComplexTypeID(KindTy kind) const {
-  return getFloatLikeTypeID<'c'>(kind, floatMap);
-}
-
-Bitsize fir::KindMapping::getRealBitsize(KindTy kind) const {
-  auto typeId = getFloatLikeTypeID<'r'>(kind, floatMap);
-  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);
-}
-
-std::string fir::KindMapping::mapToString() const {
-  std::string result;
-  bool addComma = false;
-  for (auto [k, v] : intMap) {
-    if (addComma)
-      result.append(",");
-    else
-      addComma = true;
-    result += k.first + std::to_string(k.second) + ":" + std::to_string(v);
-  }
-  for (auto [k, v] : floatMap) {
-    if (addComma)
-      result.append(",");
-    else
-      addComma = true;
-    result.append(k.first + std::to_string(k.second) + ":");
-    switch (v) {
-    default:
-      llvm_unreachable("unhandled type-id");
-    case LLVMTypeID::HalfTyID:
-      result.append(kwHalf);
-      break;
-    case LLVMTypeID::BFloatTyID:
-      result.append(kwBFloat);
-      break;
-    case LLVMTypeID::FloatTyID:
-      result.append(kwFloat);
-      break;
-    case LLVMTypeID::DoubleTyID:
-      result.append(kwDouble);
-      break;
-    case LLVMTypeID::X86_FP80TyID:
-      result.append(kwX86FP80);
-      break;
-    case LLVMTypeID::FP128TyID:
-      result.append(kwFP128);
-      break;
-    case LLVMTypeID::PPC_FP128TyID:
-      result.append(kwPPCFP128);
-      break;
-    }
-  }
-  return result;
-}
-
-mlir::LogicalResult
-fir::KindMapping::setDefaultKinds(llvm::ArrayRef<KindTy> defs) {
-  if (defs.empty()) {
-    // 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();
-}
-
-std::string fir::KindMapping::defaultsToString() const {
-  return std::string("a") + std::to_string(defaultMap.find('a')->second) +
-         std::string("c") + std::to_string(defaultMap.find('c')->second) +
-         std::string("d") + std::to_string(defaultMap.find('d')->second) +
-         std::string("i") + std::to_string(defaultMap.find('i')->second) +
-         std::string("l") + std::to_string(defaultMap.find('l')->second) +
-         std::string("r") + std::to_string(defaultMap.find('r')->second);
-}
-
-/// Convert a default intrinsic code into the proper position in the array. The
-/// default kinds have a precise ordering.
-static int codeToIndex(char code) {
-  switch (code) {
-  case 'a':
-    return 0;
-  case 'c':
-    return 1;
-  case 'd':
-    return 2;
-  case 'i':
-    return 3;
-  case 'l':
-    return 4;
-  case 'r':
-    return 5;
-  }
-  llvm_unreachable("invalid default kind intrinsic code");
-}
-
-std::vector<KindTy> fir::KindMapping::toDefaultKinds(llvm::StringRef defs) {
-  std::vector<KindTy> result(6);
-  char code;
-  KindTy kind;
-  if (defs.empty())
-    defs = clDefaultKinds;
-  const char *srcPtr = defs.begin();
-  const char *endPtr = defs.end();
-  while (srcPtr < endPtr) {
-    if (parseDefCode(code, srcPtr, endPtr) || parseInt(kind, srcPtr, endPtr))
-      llvm::report_fatal_error("invalid default kind code");
-    result[codeToIndex(code)] = kind;
-  }
-  assert(srcPtr == endPtr);
-  return result;
-}
-
-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;
-}

flang/lib/Optimizer/Transforms/AbstractResult.cpp

 //===- AbstractResult.cpp - Conversion of Abstract Function Result --------===//
 //
 // 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/Builder/FIRBuilder.h"
 #include "flang/Optimizer/Builder/Todo.h"
 #include "flang/Optimizer/Dialect/FIRDialect.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
-#include "flang/Optimizer/Support/FIRContext.h"
+#include "flang/Optimizer/Dialect/Support/FIRContext.h"
 #include "flang/Optimizer/Transforms/Passes.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "mlir/Transforms/Passes.h"
 #include "llvm/ADT/TypeSwitch.h"
 

flang/lib/Optimizer/Transforms/AddDebugFoundation.cpp

 /// This pass populates some debug information for the module and functions.
 //===----------------------------------------------------------------------===//
 
 #include "flang/Optimizer/Builder/FIRBuilder.h"
 #include "flang/Optimizer/Builder/Todo.h"
 #include "flang/Optimizer/Dialect/FIRDialect.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
-#include "flang/Optimizer/Support/FIRContext.h"
+#include "flang/Optimizer/Dialect/Support/FIRContext.h"
 #include "flang/Optimizer/Transforms/Passes.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/IR/TypeUtilities.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"

flang/lib/Optimizer/Transforms/ArrayValueCopy.cpp

 //===-- ArrayValueCopy.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/Builder/Array.h"
 #include "flang/Optimizer/Builder/BoxValue.h"
 #include "flang/Optimizer/Builder/FIRBuilder.h"
 #include "flang/Optimizer/Builder/Factory.h"
 #include "flang/Optimizer/Builder/Runtime/Derived.h"
 #include "flang/Optimizer/Builder/Todo.h"
 #include "flang/Optimizer/Dialect/FIRDialect.h"
 #include "flang/Optimizer/Dialect/FIROpsSupport.h"
-#include "flang/Optimizer/Support/FIRContext.h"
+#include "flang/Optimizer/Dialect/Support/FIRContext.h"
 #include "flang/Optimizer/Transforms/Passes.h"
 #include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "llvm/Support/Debug.h"
 
 namespace fir {
 #define GEN_PASS_DEF_ARRAYVALUECOPY

flang/lib/Optimizer/Transforms/CMakeLists.txt

add_flang_library(FIRTransforms
   MemRefDataFlowOpt.cpp
   SimplifyRegionLite.cpp
   AlgebraicSimplification.cpp
   SimplifyIntrinsics.cpp
   AddDebugFoundation.cpp
   PolymorphicOpConversion.cpp
 
   DEPENDS
-  FIRBuilder
   FIRDialect
-  FIRSupport
   FIROptTransformsPassIncGen
 
   LINK_LIBS
   FIRBuilder
   FIRDialect
+  FIRDialectSupport
   FIRSupport
   HLFIRDialect
   MLIRAffineUtils
   MLIRFuncDialect
   MLIRLLVMDialect
   MLIRMathTransforms
   MLIROpenACCDialect
   MLIROpenMPDialect
 )

flang/lib/Optimizer/Transforms/CharacterConversion.cpp

 //===- CharacterConversion.cpp -- convert between character encodings -----===//
 //
 // 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/Dialect/FIRDialect.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
-#include "flang/Optimizer/Support/FIRContext.h"
-#include "flang/Optimizer/Support/KindMapping.h"
+#include "flang/Optimizer/Dialect/Support/FIRContext.h"
+#include "flang/Optimizer/Dialect/Support/KindMapping.h"
 #include "flang/Optimizer/Transforms/Passes.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "llvm/Support/Debug.h"
 

flang/lib/Optimizer/Transforms/ControlFlowConverter.cpp

 //===-- ControlFlowConverter.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/Dialect/FIRDialect.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Dialect/FIROpsSupport.h"
-#include "flang/Optimizer/Support/FIRContext.h"
+#include "flang/Optimizer/Dialect/Support/FIRContext.h"
+#include "flang/Optimizer/Dialect/Support/KindMapping.h"
 #include "flang/Optimizer/Support/InternalNames.h"
-#include "flang/Optimizer/Support/KindMapping.h"
 #include "flang/Optimizer/Support/TypeCode.h"
 #include "flang/Optimizer/Transforms/Passes.h"
 #include "flang/Runtime/derived-api.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"

flang/lib/Optimizer/Transforms/PolymorphicOpConversion.cpp

 //===-- PolymorphicOpConversion.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/Dialect/FIRDialect.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Dialect/FIROpsSupport.h"
-#include "flang/Optimizer/Support/FIRContext.h"
+#include "flang/Optimizer/Dialect/Support/FIRContext.h"
+#include "flang/Optimizer/Dialect/Support/KindMapping.h"
 #include "flang/Optimizer/Support/InternalNames.h"
-#include "flang/Optimizer/Support/KindMapping.h"
 #include "flang/Optimizer/Support/TypeCode.h"
 #include "flang/Optimizer/Transforms/Passes.h"
 #include "flang/Runtime/derived-api.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"

flang/lib/Optimizer/Transforms/SimplifyIntrinsics.cpp

 
 #include "flang/Common/Fortran.h"
 #include "flang/Optimizer/Builder/BoxValue.h"
 #include "flang/Optimizer/Builder/FIRBuilder.h"
 #include "flang/Optimizer/Builder/LowLevelIntrinsics.h"
 #include "flang/Optimizer/Builder/Todo.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
+#include "flang/Optimizer/Dialect/Support/FIRContext.h"
 #include "flang/Optimizer/HLFIR/HLFIRDialect.h"
-#include "flang/Optimizer/Support/FIRContext.h"
 #include "flang/Optimizer/Transforms/Passes.h"
 #include "flang/Runtime/entry-names.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"

flang/lib/Optimizer/Transforms/StackArrays.cpp

 //===- StackArrays.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/Builder/FIRBuilder.h"
 #include "flang/Optimizer/Builder/LowLevelIntrinsics.h"
 #include "flang/Optimizer/Dialect/FIRAttr.h"
 #include "flang/Optimizer/Dialect/FIRDialect.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
-#include "flang/Optimizer/Support/FIRContext.h"
+#include "flang/Optimizer/Dialect/Support/FIRContext.h"
 #include "flang/Optimizer/Transforms/Passes.h"
 #include "mlir/Analysis/DataFlow/ConstantPropagationAnalysis.h"
 #include "mlir/Analysis/DataFlow/DeadCodeAnalysis.h"
 #include "mlir/Analysis/DataFlow/DenseAnalysis.h"
 #include "mlir/Analysis/DataFlowFramework.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/OpenMP/OpenMPDialect.h"
 #include "mlir/IR/Builders.h"

flang/tools/bbc/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
 Passes
 TargetParser
 )
 
 add_flang_tool(bbc bbc.cpp
 DEPENDS
 FIROptCodeGenPassIncGen
 )
 
 llvm_update_compile_flags(bbc)
 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
 target_link_libraries(bbc PRIVATE
 FIRDialect
+FIRDialectSupport
 FIRSupport
 FIRTransforms
 FIRBuilder
 HLFIRDialect
 HLFIRTransforms
 ${dialect_libs}
 MLIRAffineToStandard
 MLIRSCFToControlFlow
 FortranCommon
 FortranParser
 FortranEvaluate
 FortranSemantics
 FortranLower
 )

flang/tools/bbc/bbc.cpp

 ///
 //===----------------------------------------------------------------------===//
 
 #include "flang/Common/Fortran-features.h"
 #include "flang/Common/default-kinds.h"
 #include "flang/Lower/Bridge.h"
 #include "flang/Lower/PFTBuilder.h"
 #include "flang/Lower/Support/Verifier.h"
-#include "flang/Optimizer/Support/FIRContext.h"
+#include "flang/Optimizer/Dialect/Support/FIRContext.h"
+#include "flang/Optimizer/Dialect/Support/KindMapping.h"
 #include "flang/Optimizer/Support/InitFIR.h"
 #include "flang/Optimizer/Support/InternalNames.h"
-#include "flang/Optimizer/Support/KindMapping.h"
 #include "flang/Optimizer/Support/Utils.h"
 #include "flang/Optimizer/Transforms/Passes.h"
 #include "flang/Parser/characters.h"
 #include "flang/Parser/dump-parse-tree.h"
 #include "flang/Parser/message.h"
 #include "flang/Parser/parse-tree-visitor.h"
 #include "flang/Parser/parse-tree.h"
 #include "flang/Parser/parsing.h"

flang/tools/tco/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Passes
 )
 
 add_flang_tool(tco tco.cpp)
 llvm_update_compile_flags(tco)
 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
 target_link_libraries(tco PRIVATE
   FIRCodeGen
   FIRDialect
+  FIRDialectSupport
   FIRSupport
   FIRTransforms
   FIRBuilder
   HLFIRDialect
   HLFIRTransforms
   ${dialect_libs}
   MLIRIR
   MLIRLLVMDialect

flang/tools/tco/tco.cpp

 //===- tco.cpp - Tilikum Crossing Opt ---------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This is to be like LLVM's opt program, only for FIR.  Such a program is
 // required for roundtrip testing, etc.
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Optimizer/CodeGen/CodeGen.h"
-#include "flang/Optimizer/Support/FIRContext.h"
+#include "flang/Optimizer/Dialect/Support/FIRContext.h"
+#include "flang/Optimizer/Dialect/Support/KindMapping.h"
 #include "flang/Optimizer/Support/InitFIR.h"
 #include "flang/Optimizer/Support/InternalNames.h"
-#include "flang/Optimizer/Support/KindMapping.h"
 #include "flang/Optimizer/Transforms/Passes.h"
 #include "mlir/IR/AsmState.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/Parser/Parser.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Transforms/Passes.h"

flang/unittests/Optimizer/Builder/CharacterTest.cpp

 //===- CharacterTest.cpp -- CharacterExprHelper unit tests ----------------===//
 //
 // 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/Builder/Character.h"
 #include "gtest/gtest.h"
 #include "flang/Optimizer/Builder/BoxValue.h"
 #include "flang/Optimizer/Builder/FIRBuilder.h"
+#include "flang/Optimizer/Dialect/Support/KindMapping.h"
 #include "flang/Optimizer/Support/InitFIR.h"
-#include "flang/Optimizer/Support/KindMapping.h"
 
 struct CharacterTest : public testing::Test {
 public:
   void SetUp() override {
     fir::support::loadDialects(context);
 
     kindMap = std::make_unique<fir::KindMapping>(&context,
         "i10:80,l3:24,a1:8,r54:Double,c20:X86_FP80,r11:PPC_FP128,"

flang/unittests/Optimizer/Builder/ComplexTest.cpp

 //===- ComplexExprTest.cpp -- ComplexExpr unit tests ----------===//
 //
 // 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/Builder/Complex.h"
 #include "gtest/gtest.h"
 #include "flang/Optimizer/Builder/FIRBuilder.h"
+#include "flang/Optimizer/Dialect/Support/KindMapping.h"
 #include "flang/Optimizer/Support/InitFIR.h"
-#include "flang/Optimizer/Support/KindMapping.h"
 
 struct ComplexTest : public testing::Test {
 public:
   void SetUp() override {
     fir::support::loadDialects(context);
 
     mlir::OpBuilder builder(&context);
     auto loc = builder.getUnknownLoc();

flang/unittests/Optimizer/Builder/DoLoopHelperTest.cpp

 //===- DoLoopHelper.cpp -- DoLoopHelper unit tests ------------------------===//
 //
 // 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/Builder/DoLoopHelper.h"
 #include "gtest/gtest.h"
+#include "flang/Optimizer/Dialect/Support/KindMapping.h"
 #include "flang/Optimizer/Support/InitFIR.h"
-#include "flang/Optimizer/Support/KindMapping.h"
 #include <string>
 
 using namespace mlir;
 
 struct DoLoopHelperTest : public testing::Test {
 public:
   void SetUp() {
     kindMap = std::make_unique<fir::KindMapping>(&context);

flang/unittests/Optimizer/Builder/FIRBuilderTest.cpp

 //===- FIRBuilderTest.cpp -- FIRBuilder unit tests ------------------------===//
 //
 // 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/Builder/FIRBuilder.h"
 #include "gtest/gtest.h"
 #include "flang/Optimizer/Builder/BoxValue.h"
+#include "flang/Optimizer/Dialect/Support/KindMapping.h"
 #include "flang/Optimizer/Support/InitFIR.h"
-#include "flang/Optimizer/Support/KindMapping.h"
 
 using namespace mlir;
 
 struct FIRBuilderTest : public testing::Test {
 public:
   void SetUp() override {
     fir::support::loadDialects(context);
 

flang/unittests/Optimizer/Builder/HLFIRToolsTest.cpp

 //===- HLFIRToolsTest.cpp -- HLFIR tools unit tests -----------------------===//
 //
 // 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/Builder/HLFIRTools.h"
 #include "gtest/gtest.h"
 #include "flang/Optimizer/Builder/BoxValue.h"
 #include "flang/Optimizer/Builder/FIRBuilder.h"
+#include "flang/Optimizer/Dialect/Support/KindMapping.h"
 #include "flang/Optimizer/Support/InitFIR.h"
-#include "flang/Optimizer/Support/KindMapping.h"
 
 struct HLFIRToolsTest : public testing::Test {
 public:
   void SetUp() override {
     fir::support::loadDialects(context);
 
     llvm::ArrayRef<fir::KindTy> defs;
     fir::KindMapping kindMap(&context, defs);

flang/unittests/Optimizer/Builder/Runtime/RuntimeCallTestBase.h

 //===- RuntimeCallTestBase.cpp -- Base for runtime call generation tests --===//
 //
 // 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_OPTIMIZER_BUILDER_RUNTIME_RUNTIMECALLTESTBASE_H
 #define FORTRAN_OPTIMIZER_BUILDER_RUNTIME_RUNTIMECALLTESTBASE_H
 
 #include "gtest/gtest.h"
 #include "flang/Optimizer/Builder/FIRBuilder.h"
+#include "flang/Optimizer/Dialect/Support/KindMapping.h"
 #include "flang/Optimizer/Support/InitFIR.h"
-#include "flang/Optimizer/Support/KindMapping.h"
 
 struct RuntimeCallTest : public testing::Test {
 public:
   void SetUp() override {
     fir::support::loadDialects(context);
 
     mlir::OpBuilder builder(&context);
     auto loc = builder.getUnknownLoc();

flang/unittests/Optimizer/CMakeLists.txt

 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
 
 set(LIBS
   FIRBuilder
   FIRCodeGen
   FIRDialect
+  FIRDialectSupport
   FIRSupport
   HLFIRDialect
   ${dialect_libs}
   LLVMTargetParser
 )
 
 add_flang_unittest(FlangOptimizerTests
   Builder/CharacterTest.cpp

flang/unittests/Optimizer/FIRContextTest.cpp

 //===- FIRContextTest.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/FIRContext.h"
+#include "flang/Optimizer/Dialect/Support/FIRContext.h"
 #include "gtest/gtest.h"
 #include "mlir/IR/BuiltinAttributes.h"
 #include "mlir/IR/BuiltinOps.h"
-#include "flang/Optimizer/Support/KindMapping.h"
+#include "flang/Optimizer/Dialect/Support/KindMapping.h"
 #include "llvm/TargetParser/Host.h"
 #include <string>
 
 using namespace fir;
 
 struct StringAttributesTests : public testing::Test {
 public:
   void SetUp() {

flang/unittests/Optimizer/KindMappingTest.cpp

 //===- KindMappingTest.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/KindMapping.h"
+#include "flang/Optimizer/Dialect/Support/KindMapping.h"
 #include "gtest/gtest.h"
 #include <string>
 
 using namespace fir;
 namespace llvm {
 struct fltSemantics;
 } // namespace llvm