[flang][NFC] Move TypeConverter.h header file to include dir

[clementval]

Summary

After the extraction of the TypeConverter, move the header files
to the include dir so the shared library build is fine.

[PeteSteinfeld]

All builds and tests correctly and looks good.

flang/include/flang/Optimizer/CodeGen/TBAABuilder.h

 //===-- TBAABuilder.h -- TBAA builder declarations --------------*- 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_CODEGEN_TBAABUILDER_H
 #define FORTRAN_OPTIMIZER_CODEGEN_TBAABUILDER_H
 
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/IR/BuiltinAttributes.h"
 
 namespace fir {
 
 // TBAA builder provides mapping between FIR types and their TBAA type
 // descriptors, and methods to populate that mapping during FIR to LLVM
 // type conversion and to attach llvm.tbaa attributes to memory access
 // instructions.
 //
 // TBAA type information is represented with LLVM::MetadataOp operation
 // with specific symbol name `TBAABuilder::tbaaMetaOpName`. The basic
 // TBAA tree used for Flang consists of the following nodes:
 //   llvm.metadata @__flang_tbaa {
 //     llvm.tbaa_root @root_0 {id = "Flang Type TBAA Root"}
 //     llvm.tbaa_type_desc @type_desc_1 {id = "any access",
 //                                       members = {<@root_0, 0>}}
 //     llvm.tbaa_type_desc @type_desc_2 {id = "any data access",
 //                                       members = {<@type_desc_1, 0>}}
 //     llvm.tbaa_type_desc @type_desc_3 {id = "descriptor member",
 //                                       members = {<@type_desc_1, 0>}}
 //   }
 //
 // The `<any data access>` and `<descriptor member>` type descriptors
 // are two sub-roots of the basic TBAA tree, and they allow representing
 // box and non-box accesses, which can never alias in the current Flang
 // implementation. The `<any access>` type descriptor is their common parent
 // that can be used for representing accesses that may alias box and non-box
 // accesses if an access cannot be classified strictly as box or non-box.
 // In the current implementation `<any access>` is not used by TBAA access tags,
 // because it is always known whether an operation accesses box or non-box.
 //
 // Given this basic TBAA tree structure, the box/descriptor types may
 // be represented like this:
 //   llvm.tbaa_type_desc @type_desc_4 {
 //       id = "CFI_cdesc_t_dim0",
 //       members = {<@type_desc_3, 0>, // base_addr
 //                  <@type_desc_3, 8>, // elem_len
 //                  <@type_desc_3, 16>, // version
 //                  <@type_desc_3, 20>, // rank
 //                  <@type_desc_3, 21>, // type
 //                  <@type_desc_3, 22>, // attribute
 //                  <@type_desc_3, 23>} // f18Addendum
 //   }
 //   llvm.tbaa_type_desc @type_desc_5 {
 //       id = "CFI_cdesc_t_dim1",
 //       members = {<@type_desc_3, 0>, // base_addr
 //                  <@type_desc_3, 8>, // elem_len
 //                  <@type_desc_3, 16>, // version
 //                  <@type_desc_3, 20>, // rank
 //                  <@type_desc_3, 21>, // type
 //                  <@type_desc_3, 22>, // attribute
 //                  <@type_desc_3, 23>, // f18Addendum
 //                  <@type_desc_3, 24>, // dim[0].lower_bound
 //                  <@type_desc_3, 32>, // dim[0].extent
 //                  <@type_desc_3, 40>} // dim[0].sm
 //   }
 //   llvm.tbaa_type_desc @type_desc_6 {
 //       id = "CFI_cdesc_t_dim2",
 //       members = {<@type_desc_3, 0>, // base_addr
 //                  <@type_desc_3, 8>, // elem_len
 //                  <@type_desc_3, 16>, // version
 //                  <@type_desc_3, 20>, // rank
 //                  <@type_desc_3, 21>, // type
 //                  <@type_desc_3, 22>, // attribute
 //                  <@type_desc_3, 23>, // f18Addendum
 //                  <@type_desc_3, 24>, // dim[0].lower_bound
 //                  <@type_desc_3, 32>, // dim[0].extent
 //                  <@type_desc_3, 40>, // dim[0].sm
 //                  <@type_desc_3, 48>, // dim[1].lower_bound
 //                  <@type_desc_3, 56>, // dim[1].extent
 //                  <@type_desc_3, 64>} // dim[1].sm
 //   }
 // etc.
 //
 // Note that the TBAA type descriptors cannot represent array members
 // of structures, so the `dim` array in the descriptor structure
 // has to be represented as linear set of members.
 //
 // We can use the same TBAA type descriptor for all members of the F18
 // descriptor structure, because the actual accesses of the F18 descriptor
 // members will be disambiguated based on their offset off the beginning
 // of the descriptor. Thus, all members have the same `<descriptor member>`
 // type in the TBAA graph.
 //
 // The TBAA type descriptors have to be created during FIR to LLVM type
 // conversion, so fir::LLVMTypeConverter has to provide the member offsets
 // to TBAABuilder - the offsets must be computed based on the LLVM type
 // to which the FIR type is being converted.
 //
 // TBAABuilder keeps a map between the FIR type and its TBAA type descriptor.
 // The map is used when a TBAA tag needs to be attached to a memory accessing
 // operation given the FIR types identifying the access's base and access type
 // and the offset within the base type, e.g. an access of one dimensional
 // descriptor's `base_addr` member may be defined by:
 //   * base FIR type: !fir.box<!fir.array<?xf32>> - the resulting
 //     access tag will use `<CFI_cdesc_t_dim1>` type descriptor for the base
 //     type.
 //   * access FIR type: <undefined> - all accesses within descriptors
 //     are always represented with `<descriptor member>` type descriptor.
 //   * offset:
 //       llvm.getelementptr %arg0[0, 0] :
 //           (!llvm.ptr<struct<(ptr<f32>, i64, i32, i8, i8, i8, i8,
 //                              array<1 x array<3 x i64>>)>>) ->
 //           !llvm.ptr<ptr<f32>>
 //     The offset is computed based on the LLVM::GEPOp's indices and the LLVM
 //     type layout.
 //
 // Detailed representation of the layout of the F18 descriptors is required
 // to disambiguate accesses of the different members of the descriptors,
 // e.g. a read of `base_addr` member (of one box) can never alias with
 // a write of `rank` member (of another box).
 //
 // TODO: define handling of assumed-rank arrays' boxes (they can always
 // be represented with a conservative tag:
 //   < `<descriptor member>`, `<descriptor member>`, 0 >
 // so that they alias with any other box accesses.
 //
 // The same representation can be used for user-defined types, though,
 // strict type aliasing cannot be applied for Fortran programs without
 // additional guarantees from the user. Fortran's storage association
 // constructs provide a way to alias data of different types, so using
 // TBAA would be incorrect, e.g.:
 //   subroutine test()
 //     real :: a
 //     integer :: b
 //     equivalence (a, b)
 //     a = 1.0
 //     call test2(b)
 //   end subroutine test
 //
 // The store operation for `a = 1.0` has the base/access type `f32`,
 // while a load from `b` inside `test2` will have base/access type
 // `i32`. Due to the storage association the store and the load alias,
 // so using the access types to create TBAA access tags may result
 // in an incorrect result if `test2` was inlined. Moreover, in the scope
 // of `test2` Flang is not able to indentify whether `b` is part
 // of an equivalence.
 //
 // TBAA may still be applied for programs not using storage association
 // for objects of different data types (e.g. under an opt-in compiler option).
 //
 // The initial implementation does not create detailed type descriptors
 // for box types and always uses the conservative box access tag:
 //   < `<descriptor member>`, `<descriptor member>`, 0 >
 //
 // Given the storage association, all non-box accesses are represented
 // with the conservative data access tag:
 //   < `<any data access>`, `<any data access>`, 0 >
 class TBAABuilder {
 public:
   TBAABuilder(mlir::ModuleOp module, bool applyTBAA);
   TBAABuilder(TBAABuilder const &) = delete;
   TBAABuilder &operator=(TBAABuilder const &) = delete;
 
   // Attach the llvm.tbaa attribute to the given memory accessing operation
   // based on the provided base/access FIR types and the GEPOp.
   void attachTBAATag(mlir::LLVM::AliasAnalysisOpInterface op,
                      mlir::Type baseFIRType, mlir::Type accessFIRType,
                      mlir::LLVM::GEPOp gep);
 
 private:
   // Return unique string name based on `basename`.
   std::string getNewTBAANodeName(llvm::StringRef basename);
 
   // Find or create TBAATagOp operation (TBAA access tag) with the specified
   // components and return the symbol it defines.
   mlir::SymbolRefAttr getAccessTag(mlir::SymbolRefAttr baseTypeDesc,
                                    mlir::SymbolRefAttr accessTypeDesc,
                                    int64_t offset);
   // Returns symbol of TBAATagOp representing access tag:
   //   < <descriptor member>, <descriptor member>, 0 >
   mlir::SymbolRefAttr getAnyBoxAccessTag();
   // Returns symbol of TBAATagOp representing access tag:
   //   < <any data access>, <any data access>, 0 >
   mlir::SymbolRefAttr getAnyDataAccessTag();
 
   // Returns symbol of TBAATagOp representing access tag
   // described by the base and access FIR types and the LLVM::GepOp
   // representing the access in terms of the FIR types converted
   // to LLVM types. The base type must be derivative of fir::BaseBoxType.
   mlir::SymbolRefAttr getBoxAccessTag(mlir::Type baseFIRType,
                                       mlir::Type accessFIRType,
                                       mlir::LLVM::GEPOp gep);
 
   // Returns symbol of TBAATagOp representing access tag
   // described by the base and access FIR types and the LLVM::GepOp
   // representing the access in terms of the FIR types converted
   // to LLVM types. The FIR types must describe the "data" access,
   // i.e. not an access of any box/descriptor member.
   mlir::SymbolRefAttr getDataAccessTag(mlir::Type baseFIRType,
                                        mlir::Type accessFIRType,
                                        mlir::LLVM::GEPOp gep);
 
   // Set to true, if TBAA builder is active, otherwise, all public
   // methods are no-ops.
   bool enableTBAA;
 
   // LLVM::MetadataOp holding the TBAA operations.
   mlir::LLVM::MetadataOp tbaaMetaOp;
   // Symbol name of tbaaMetaOp.
   static constexpr llvm::StringRef tbaaMetaOpName = "__flang_tbaa";
 
   // Base names for TBAA operations:
   //   TBAARootMetadataOp:
   static constexpr llvm::StringRef kRootSymBasename = "root";
   //   TBAATypeDescriptorOp:
   static constexpr llvm::StringRef kTypeDescSymBasename = "type_desc";
   //   TBAATagOp:
   static constexpr llvm::StringRef kTagSymBasename = "tag";
 
   // Symbol defined by the LLVM::TBAARootMetadataOp identifying
   // Flang's TBAA root.
   mlir::SymbolRefAttr flangTBAARoot;
   // Identity string for Flang's TBAA root.
   static constexpr llvm::StringRef flangTBAARootId = "Flang Type TBAA Root";
 
   // Symbol defined by LLVM::TBAATypeDescriptorOp identifying
   // "any access".
   mlir::SymbolRefAttr anyAccessTypeDesc;
   // Identity string for "any access" type descriptor.
   static constexpr llvm::StringRef anyAccessTypeDescId = "any access";
 
   // Symbol defined by LLVM::TBAATypeDescriptorOp identifying
   // "any data access" (i.e. non-box memory access).
   mlir::SymbolRefAttr anyDataAccessTypeDesc;
   // Identity string for "any data access" type descriptor.
   static constexpr llvm::StringRef anyDataAccessTypeDescId = "any data access";
 
   // Symbol defined by LLVM::TBAATypeDescriptorOp identifying
   // "descriptor member" access, i.e. any access within the bounds
   // of a box/descriptor.
   mlir::SymbolRefAttr boxMemberTypeDesc;
   // Identity string for "descriptor member" type descriptor.
   static constexpr llvm::StringRef boxMemberTypeDescId = "descriptor member";
 
   // Counter for unique naming of TBAA operations' symbols.
   unsigned tbaaNodeCounter = 0;
 
   // Number of attached TBAA tags (used for debugging).
   unsigned tagAttachmentCounter = 0;
 
   // Mapping from a FIR type to the symbol defined by the corresponding
   // TBAATypeDescriptorOp. It must be populated during the type conversion.
   // Currently unused.
   llvm::DenseMap<mlir::Type, mlir::SymbolRefAttr> typeDescMap;
 
   // Each TBAA tag is a tuple of <baseTypeSym, accessTypeSym, offset>.
   // This map holds TBAATagOp symbol for each unique tuple.
   llvm::DenseMap<std::tuple<mlir::SymbolRefAttr, mlir::SymbolRefAttr, int64_t>,
                  mlir::SymbolRefAttr>
       tagsMap;
 };
 
 } // namespace fir
 
 #endif // FORTRAN_OPTIMIZER_CODEGEN_TBAABUILDER_H

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

flang/include/flang/Optimizer/CodeGen/TypeConverter.h

 //===-- TypeConverter.h -- type conversion ----------------------*- 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_CODEGEN_TYPECONVERTER_H
 #define FORTRAN_OPTIMIZER_CODEGEN_TYPECONVERTER_H
 
-#include "TBAABuilder.h"
-#include "Target.h"
 #include "flang/Optimizer/Builder/Todo.h" // remove when TODO's are done
+#include "flang/Optimizer/CodeGen/TBAABuilder.h"
+#include "flang/Optimizer/CodeGen/Target.h"
 #include "flang/Optimizer/Dialect/FIRType.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;

flang/lib/Optimizer/CodeGen/CodeGen.cpp

 namespace fir {
 #define GEN_PASS_DEF_FIRTOLLVMLOWERING
 #include "flang/Optimizer/CodeGen/CGPasses.h.inc"
 } // namespace fir
 
 #define DEBUG_TYPE "flang-codegen"
 
 // fir::LLVMTypeConverter for converting to LLVM IR dialect types.
-#include "TypeConverter.h"
+#include "flang/Optimizer/CodeGen/TypeConverter.h"
 
 // TODO: This should really be recovered from the specified target.
 static constexpr unsigned defaultAlign = 8;
 
 /// `fir.box` attribute values as defined for CFI_attribute_t in
 /// flang/ISO_Fortran_binding.h.
 static constexpr unsigned kAttrPointer = CFI_attribute_pointer;
 static constexpr unsigned kAttrAllocatable = CFI_attribute_allocatable;

flang/lib/Optimizer/CodeGen/TBAABuilder.cpp

 //===-- TBAABuilder.cpp -- TBAA builder definitions -----------------------===//
 //
 // 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 "TBAABuilder.h"
+#include "flang/Optimizer/CodeGen/TBAABuilder.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
 #include "llvm/ADT/TypeSwitch.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 
 #define DEBUG_TYPE "flang-tbaa-builder"
 
 using namespace mlir;

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/CodeGen/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 "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/TypeRange.h"
 
 #define DEBUG_TYPE "flang-codegen-target"

flang/lib/Optimizer/CodeGen/TargetRewrite.cpp

 // triples. These distinctions are handled by this pass.
 //
 // Coding style: https://mlir.llvm.org/getting_started/DeveloperGuide/
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Optimizer/CodeGen/CodeGen.h"
 
-#include "Target.h"
 #include "flang/Optimizer/Builder/Character.h"
 #include "flang/Optimizer/Builder/FIRBuilder.h"
 #include "flang/Optimizer/Builder/Todo.h"
+#include "flang/Optimizer/CodeGen/Target.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/Dialect/Support/FIRContext.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/TypeSwitch.h"

flang/lib/Optimizer/CodeGen/TypeConverter.cpp

 //===-- TypeConverter.cpp -- type conversion --------------------*- 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/
 //
 //===----------------------------------------------------------------------===//
 
 #define DEBUG_TYPE "flang-type-conversion"
 
-#include "TypeConverter.h"
+#include "flang/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/CodeGen/TBAABuilder.h"
+#include "flang/Optimizer/CodeGen/Target.h"
 #include "flang/Optimizer/Dialect/FIRType.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"
 
 namespace fir {
 

flang/lib/Optimizer/Transforms/OpenACC/OpenACCDataOperandConversion.cpp

 #include "mlir/Pass/Pass.h"
 
 namespace fir {
 #define GEN_PASS_DEF_OPENACCDATAOPERANDCONVERSION
 #include "flang/Optimizer/Transforms/Passes.h.inc"
 } // namespace fir
 
 #define DEBUG_TYPE "flang-openacc-conversion"
-#include "../CodeGen/TypeConverter.h"
+#include "flang/Optimizer/CodeGen/TypeConverter.h"
 
 using namespace fir;
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
 // Conversion patterns
 //===----------------------------------------------------------------------===//