Restore CodeGen/LowLevelType from `Support`

[chapuni]

Summary

This is rework of;

• D30046 (LLT)

Since I have introduced llvm-min-tblgen as D146352, llvm-tblgen
may depend on CodeGen.

LowLevlType.h originally belonged to CodeGen. Almost all userse are
still under CodeGen or Target. I think CodeGen is the right place
to put LowLevelType.h.

MachineValueType.h may be moved as well. (later, D149024)

I have made many modules depend on CodeGen. It is consistent but
inefficient. It will be split out later, D148769

Besides, I had to isolate MVT and LLT in modmap, since
llvm::PredicateInfo clashes between TableGen/CodeGenSchedule.h
and Transforms/Utils/PredicateInfo.h.
(I think better to introduce namespace llvm::TableGen)

Depends on D145937, D146352, and D148768.

[chapuni]

• Isolate rename changes to D148768

[chapuni]

• Update CMake deps
• s/LowLevelType/LowLevelTypeUtils/
• modmap: Prune LLVM_intrinsic_gen

[chapuni]

• Split out

[chapuni]

• Rebase

[MaskRay]

This is rework of;

D30046 (LLT)

Add some information why this is restored? Assume that people may not read the depended patches (Depends on D145937, D146352, and D148768.).

[barannikov88]

Adding CodeGen dependency to MCTargetDesc/AsmParser/Disassembler does not seem right. Why is it necessary?

[chapuni]

In D148767#4311529, @MaskRay wrote:

Add some information why this is restored? Assume that people may not read the depended patches (Depends on D145937, D146352, and D148768.).

Yes sure. This was just an isolated diff with similar changes at first.

In D148767#4311564, @barannikov88 wrote:

Adding CodeGen dependency to MCTargetDesc/AsmParser/Disassembler does not seem right. Why is it necessary?

This commit shows they may depend on CodeGen theoretically and actually (but not efficient)
I will decouple again in D148769.

[chapuni]

• Rebase and update the desc

[barannikov88]

In D148767#4311589, @chapuni wrote:

In D148767#4311564, @barannikov88 wrote:

Adding CodeGen dependency to MCTargetDesc/AsmParser/Disassembler does not seem right. Why is it necessary?

This commit shows they may depend on CodeGen theoretically and actually (but not efficient)
I will decouple again in D148769.

Sorry, I don't follow. They may theoretically depend on anything. Why CodeGen/CodeGenTypes, specifically?
If they don't require it, why add it?

[jobnoorman]

Hi, this seems to have broken my bolt+debug+shared build. I don't think there are build bots for this configuration but you can reproduce it like this:

cmake -G Ninja -DCMAKE_BUILD_TYPE="Debug" \
               -DLLVM_ENABLE_PROJECTS="clang;lld;bolt" \
               -DBUILD_SHARED_LIBS=True \
               -DLLVM_BUILD_TESTS=True \
               -DLLVM_CCACHE_BUILD=ON \
               -DLLVM_ENABLE_LLD=True \
               -DLLVM_TARGETS_TO_BUILD="X86;RISCV;AArch64" \
               -DLLVM_APPEND_VC_REV=False ../llvm

And this is the linker error:

ld.lld: error: undefined symbol: llvm::LLT::print(llvm::raw_ostream&) const
>>> referenced by LowLevelType.h:269 (/.../llvm-project/llvm/include/llvm/CodeGen/LowLevelType.h:269)
>>>               tools/bolt/lib/Passes/CMakeFiles/LLVMBOLTPasses.dir/AsmDump.cpp.o:(llvm::LLT::dump() const)
collect2: error: ld returned 1 exit status

[vzakhari]

In D148767#4315667, @jobnoorman wrote:

Hi, this seems to have broken my bolt+debug+shared build. I don't think there are build bots for this configuration but you can reproduce it like this:

Same with flang+debug+shared build:

ld.lld: error: undefined symbol: llvm::LLT::print(llvm::raw_ostream&) const
>>> referenced by LowLevelType.h:269 (/llvm-project/llvm/include/llvm/CodeGen/LowLevelType.h:269)
>>>               CMakeFiles/obj.FIRTransforms.dir/SimplifyIntrinsics.cpp.o:(llvm::LLT::dump() const)

I can add CodeGenTypes link component in flang/lib/Optimizer/Transforms/CMakeLists.txt, but I am worried about the comment in llvm/lib/CodeGen/CMakeLists.txt:

# Be careful to append deps on this, since Targets' tablegens depend on this.
add_llvm_component_library(LLVMCodeGenTypes

I am not sure whether I need to be careful about adding dependencies onto LLVMCodeGenTypes (as I am planning to do) or about adding dependencies for LLVMCodeGenTypes target in llvm/lib/CodeGen/CMakeLists.txt :)

[chapuni]

In D148767#4312692, @barannikov88 wrote:

Sorry, I don't follow. They may theoretically depend on anything. Why CodeGen/CodeGenTypes, specifically?
If they don't require it, why add it?

I added deps pessimistically, "This depends on CodeGenTypes if LowLevelType.h is included".

In D148767#4315667, @jobnoorman wrote:

Hi, this seems to have broken my bolt+debug+shared build. I don't think there are build bots for this configuration but you can reproduce it like this:

Sorry for inconvenience. Could you add CodeGenTypes in LINK_COMPONENTS please?

In D148767#4315757, @vzakhari wrote:

I can add CodeGenTypes link component in flang/lib/Optimizer/Transforms/CMakeLists.txt, but I am worried about the comment in llvm/lib/CodeGen/CMakeLists.txt:

# Be careful to append deps on this, since Targets' tablegens depend on this.
add_llvm_component_library(LLVMCodeGenTypes

I am not sure whether I need to be careful about adding dependencies onto LLVMCodeGenTypes (as I am planning to do) or about adding dependencies for LLVMCodeGenTypes target in llvm/lib/CodeGen/CMakeLists.txt :)

The latter. Excuse my wrong wording.

[barannikov88]

In D148767#4316464, @chapuni wrote:

In D148767#4312692, @barannikov88 wrote:

Sorry, I don't follow. They may theoretically depend on anything. Why CodeGen/CodeGenTypes, specifically?
If they don't require it, why add it?

I added deps pessimistically, "This depends on CodeGenTypes if LowLevelType.h is included".

Sorry if I was not being clear. Dependencies are harmful and should be avoided wherever possible.
They should not be added "just in case". Now when I want to build just llvm-mc I have to build half of the whole stack.
Although D148769 improves the situation, it does not justify adding these dependencies.
Your RFC was about dependencies, so I think you understand my concern.
Please try to remove them and only keep the ones that are really necessary.

[chapuni]

Please come in; https://discourse.llvm.org/t/rfc-let-mvt-generated-and-restore-mvt-into-llvm-codegen/69547/3

[jobnoorman]

In D148767#4316464, @chapuni wrote:

In D148767#4315667, @jobnoorman wrote:

Hi, this seems to have broken my bolt+debug+shared build. I don't think there are build bots for this configuration but you can reproduce it like this:

Sorry for inconvenience. Could you add CodeGenTypes in LINK_COMPONENTS please?

No worries. It feels a bit wrong though to have to add transitive dependencies to LINK_COMPONENTS.

My build is also fixed by moving the implementation of LLT::dump to a .cpp file. Would it be an option to apply the following patch?

llt-link-fix.patch1 KBDownload

clang/lib/CodeGen/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   AggressiveInstCombine
   Analysis
   BitReader
   BitWriter
+  CodeGen
   Core
   Coroutines
   Coverage
   Demangle
   Extensions
   FrontendHLSL
   FrontendOpenMP
   IPO

llvm/include/llvm/CodeGen/LowLevelType.h

 //== llvm/CodeGen/LowLevelType.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
 //
 //===----------------------------------------------------------------------===//
 /// \file
 /// Implement a low-level type suitable for MachineInstr level instruction
 /// selection.
 ///
-/// This provides the CodeGen aspects of LowLevelType, such as Type conversion.
+/// For a type attached to a MachineInstr, we only care about 2 details: total
+/// size and the number of vector lanes (if any). Accordingly, there are 4
+/// possible valid type-kinds:
+///
+///    * `sN` for scalars and aggregates
+///    * `<N x sM>` for vectors, which must have at least 2 elements.
+///    * `pN` for pointers
+///
+/// Other information required for correct selection is expected to be carried
+/// by the opcode, or non-type flags. For example the distinction between G_ADD
+/// and G_FADD for int/float or fast-math flags.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CODEGEN_LOWLEVELTYPE_H
 #define LLVM_CODEGEN_LOWLEVELTYPE_H
 
+#include "llvm/ADT/DenseMapInfo.h"
+#include "llvm/CodeGen/MachineValueType.h"
 #include "llvm/CodeGen/ValueTypes.h"
-#include "llvm/Support/LowLevelTypeImpl.h"
+#include "llvm/Support/Debug.h"
+#include <cassert>
 
 namespace llvm {
 
 class DataLayout;
 class Type;
 struct fltSemantics;
+class raw_ostream;
+
+class LLT {
+public:
+  /// Get a low-level scalar or aggregate "bag of bits".
+  static constexpr LLT scalar(unsigned SizeInBits) {
+    return LLT{/*isPointer=*/false, /*isVector=*/false, /*isScalar=*/true,
+               ElementCount::getFixed(0), SizeInBits,
+               /*AddressSpace=*/0};
+  }
+
+  /// Get a low-level pointer in the given address space.
+  static constexpr LLT pointer(unsigned AddressSpace, unsigned SizeInBits) {
+    assert(SizeInBits > 0 && "invalid pointer size");
+    return LLT{/*isPointer=*/true, /*isVector=*/false, /*isScalar=*/false,
+               ElementCount::getFixed(0), SizeInBits, AddressSpace};
+  }
+
+  /// Get a low-level vector of some number of elements and element width.
+  static constexpr LLT vector(ElementCount EC, unsigned ScalarSizeInBits) {
+    assert(!EC.isScalar() && "invalid number of vector elements");
+    return LLT{/*isPointer=*/false, /*isVector=*/true, /*isScalar=*/false,
+               EC, ScalarSizeInBits, /*AddressSpace=*/0};
+  }
+
+  /// Get a low-level vector of some number of elements and element type.
+  static constexpr LLT vector(ElementCount EC, LLT ScalarTy) {
+    assert(!EC.isScalar() && "invalid number of vector elements");
+    assert(!ScalarTy.isVector() && "invalid vector element type");
+    return LLT{ScalarTy.isPointer(),
+               /*isVector=*/true,
+               /*isScalar=*/false,
+               EC,
+               ScalarTy.getSizeInBits().getFixedValue(),
+               ScalarTy.isPointer() ? ScalarTy.getAddressSpace() : 0};
+  }
+
+  /// Get a low-level fixed-width vector of some number of elements and element
+  /// width.
+  static constexpr LLT fixed_vector(unsigned NumElements,
+                                    unsigned ScalarSizeInBits) {
+    return vector(ElementCount::getFixed(NumElements), ScalarSizeInBits);
+  }
+
+  /// Get a low-level fixed-width vector of some number of elements and element
+  /// type.
+  static constexpr LLT fixed_vector(unsigned NumElements, LLT ScalarTy) {
+    return vector(ElementCount::getFixed(NumElements), ScalarTy);
+  }
+
+  /// Get a low-level scalable vector of some number of elements and element
+  /// width.
+  static constexpr LLT scalable_vector(unsigned MinNumElements,
+                                       unsigned ScalarSizeInBits) {
+    return vector(ElementCount::getScalable(MinNumElements), ScalarSizeInBits);
+  }
+
+  /// Get a low-level scalable vector of some number of elements and element
+  /// type.
+  static constexpr LLT scalable_vector(unsigned MinNumElements, LLT ScalarTy) {
+    return vector(ElementCount::getScalable(MinNumElements), ScalarTy);
+  }
+
+  static constexpr LLT scalarOrVector(ElementCount EC, LLT ScalarTy) {
+    return EC.isScalar() ? ScalarTy : LLT::vector(EC, ScalarTy);
+  }
+
+  static constexpr LLT scalarOrVector(ElementCount EC, uint64_t ScalarSize) {
+    assert(ScalarSize <= std::numeric_limits<unsigned>::max() &&
+           "Not enough bits in LLT to represent size");
+    return scalarOrVector(EC, LLT::scalar(static_cast<unsigned>(ScalarSize)));
+  }
+
+  explicit constexpr LLT(bool isPointer, bool isVector, bool isScalar,
+                         ElementCount EC, uint64_t SizeInBits,
+                         unsigned AddressSpace)
+      : LLT() {
+    init(isPointer, isVector, isScalar, EC, SizeInBits, AddressSpace);
+  }
+  explicit constexpr LLT()
+      : IsScalar(false), IsPointer(false), IsVector(false), RawData(0) {}
+
+  explicit LLT(MVT VT);
+
+  constexpr bool isValid() const { return IsScalar || RawData != 0; }
+
+  constexpr bool isScalar() const { return IsScalar; }
+
+  constexpr bool isPointer() const {
+    return isValid() && IsPointer && !IsVector;
+  }
+
+  constexpr bool isVector() const { return isValid() && IsVector; }
+
+  /// Returns the number of elements in a vector LLT. Must only be called on
+  /// vector types.
+  constexpr uint16_t getNumElements() const {
+    if (isScalable())
+      llvm::reportInvalidSizeRequest(
+          "Possible incorrect use of LLT::getNumElements() for "
+          "scalable vector. Scalable flag may be dropped, use "
+          "LLT::getElementCount() instead");
+    return getElementCount().getKnownMinValue();
+  }
+
+  /// Returns true if the LLT is a scalable vector. Must only be called on
+  /// vector types.
+  constexpr bool isScalable() const {
+    assert(isVector() && "Expected a vector type");
+    return IsPointer ? getFieldValue(PointerVectorScalableFieldInfo)
+                     : getFieldValue(VectorScalableFieldInfo);
+  }
+
+  constexpr ElementCount getElementCount() const {
+    assert(IsVector && "cannot get number of elements on scalar/aggregate");
+    return ElementCount::get(IsPointer
+                                 ? getFieldValue(PointerVectorElementsFieldInfo)
+                                 : getFieldValue(VectorElementsFieldInfo),
+                             isScalable());
+  }
+
+  /// Returns the total size of the type. Must only be called on sized types.
+  constexpr TypeSize getSizeInBits() const {
+    if (isPointer() || isScalar())
+      return TypeSize::Fixed(getScalarSizeInBits());
+    auto EC = getElementCount();
+    return TypeSize(getScalarSizeInBits() * EC.getKnownMinValue(),
+                    EC.isScalable());
+  }
+
+  /// Returns the total size of the type in bytes, i.e. number of whole bytes
+  /// needed to represent the size in bits. Must only be called on sized types.
+  constexpr TypeSize getSizeInBytes() const {
+    TypeSize BaseSize = getSizeInBits();
+    return {(BaseSize.getKnownMinValue() + 7) / 8, BaseSize.isScalable()};
+  }
+
+  constexpr LLT getScalarType() const {
+    return isVector() ? getElementType() : *this;
+  }
+
+  /// If this type is a vector, return a vector with the same number of elements
+  /// but the new element type. Otherwise, return the new element type.
+  constexpr LLT changeElementType(LLT NewEltTy) const {
+    return isVector() ? LLT::vector(getElementCount(), NewEltTy) : NewEltTy;
+  }
+
+  /// If this type is a vector, return a vector with the same number of elements
+  /// but the new element size. Otherwise, return the new element type. Invalid
+  /// for pointer types. For pointer types, use changeElementType.
+  constexpr LLT changeElementSize(unsigned NewEltSize) const {
+    assert(!getScalarType().isPointer() &&
+           "invalid to directly change element size for pointers");
+    return isVector() ? LLT::vector(getElementCount(), NewEltSize)
+                      : LLT::scalar(NewEltSize);
+  }
+
+  /// Return a vector or scalar with the same element type and the new element
+  /// count.
+  constexpr LLT changeElementCount(ElementCount EC) const {
+    return LLT::scalarOrVector(EC, getScalarType());
+  }
+
+  /// Return a type that is \p Factor times smaller. Reduces the number of
+  /// elements if this is a vector, or the bitwidth for scalar/pointers. Does
+  /// not attempt to handle cases that aren't evenly divisible.
+  constexpr LLT divide(int Factor) const {
+    assert(Factor != 1);
+    assert((!isScalar() || getScalarSizeInBits() != 0) &&
+           "cannot divide scalar of size zero");
+    if (isVector()) {
+      assert(getElementCount().isKnownMultipleOf(Factor));
+      return scalarOrVector(getElementCount().divideCoefficientBy(Factor),
+                            getElementType());
+    }
+
+    assert(getScalarSizeInBits() % Factor == 0);
+    return scalar(getScalarSizeInBits() / Factor);
+  }
+
+  /// Produce a vector type that is \p Factor times bigger, preserving the
+  /// element type. For a scalar or pointer, this will produce a new vector with
+  /// \p Factor elements.
+  constexpr LLT multiplyElements(int Factor) const {
+    if (isVector()) {
+      return scalarOrVector(getElementCount().multiplyCoefficientBy(Factor),
+                            getElementType());
+    }
+
+    return fixed_vector(Factor, *this);
+  }
+
+  constexpr bool isByteSized() const {
+    return getSizeInBits().isKnownMultipleOf(8);
+  }
+
+  constexpr unsigned getScalarSizeInBits() const {
+    if (IsScalar)
+      return getFieldValue(ScalarSizeFieldInfo);
+    if (IsVector) {
+      if (!IsPointer)
+        return getFieldValue(VectorSizeFieldInfo);
+      else
+        return getFieldValue(PointerVectorSizeFieldInfo);
+    } else if (IsPointer)
+      return getFieldValue(PointerSizeFieldInfo);
+    else
+      llvm_unreachable("unexpected LLT");
+  }
+
+  constexpr unsigned getAddressSpace() const {
+    assert(RawData != 0 && "Invalid Type");
+    assert(IsPointer && "cannot get address space of non-pointer type");
+    if (!IsVector)
+      return getFieldValue(PointerAddressSpaceFieldInfo);
+    else
+      return getFieldValue(PointerVectorAddressSpaceFieldInfo);
+  }
+
+  /// Returns the vector's element type. Only valid for vector types.
+  constexpr LLT getElementType() const {
+    assert(isVector() && "cannot get element type of scalar/aggregate");
+    if (IsPointer)
+      return pointer(getAddressSpace(), getScalarSizeInBits());
+    else
+      return scalar(getScalarSizeInBits());
+  }
+
+  void print(raw_ostream &OS) const;
+
+#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+  LLVM_DUMP_METHOD void dump() const {
+    print(dbgs());
+    dbgs() << '\n';
+  }
+#endif
+
+  constexpr bool operator==(const LLT &RHS) const {
+    return IsPointer == RHS.IsPointer && IsVector == RHS.IsVector &&
+           IsScalar == RHS.IsScalar && RHS.RawData == RawData;
+  }
+
+  constexpr bool operator!=(const LLT &RHS) const { return !(*this == RHS); }
+
+  friend struct DenseMapInfo<LLT>;
+  friend class GISelInstProfileBuilder;
+
+private:
+  /// LLT is packed into 64 bits as follows:
+  /// isScalar : 1
+  /// isPointer : 1
+  /// isVector  : 1
+  /// with 61 bits remaining for Kind-specific data, packed in bitfields
+  /// as described below. As there isn't a simple portable way to pack bits
+  /// into bitfields, here the different fields in the packed structure is
+  /// described in static const *Field variables. Each of these variables
+  /// is a 2-element array, with the first element describing the bitfield size
+  /// and the second element describing the bitfield offset.
+  typedef int BitFieldInfo[2];
+  ///
+  /// This is how the bitfields are packed per Kind:
+  /// * Invalid:
+  ///   gets encoded as RawData == 0, as that is an invalid encoding, since for
+  ///   valid encodings, SizeInBits/SizeOfElement must be larger than 0.
+  /// * Non-pointer scalar (isPointer == 0 && isVector == 0):
+  ///   SizeInBits: 32;
+  static const constexpr BitFieldInfo ScalarSizeFieldInfo{32, 0};
+  /// * Pointer (isPointer == 1 && isVector == 0):
+  ///   SizeInBits: 16;
+  ///   AddressSpace: 24;
+  static const constexpr BitFieldInfo PointerSizeFieldInfo{16, 0};
+  static const constexpr BitFieldInfo PointerAddressSpaceFieldInfo{
+      24, PointerSizeFieldInfo[0] + PointerSizeFieldInfo[1]};
+  static_assert((PointerAddressSpaceFieldInfo[0] +
+                 PointerAddressSpaceFieldInfo[1]) <= 61,
+                "Insufficient bits to encode all data");
+  /// * Vector-of-non-pointer (isPointer == 0 && isVector == 1):
+  ///   NumElements: 16;
+  ///   SizeOfElement: 32;
+  ///   Scalable: 1;
+  static const constexpr BitFieldInfo VectorElementsFieldInfo{16, 0};
+  static const constexpr BitFieldInfo VectorSizeFieldInfo{
+      32, VectorElementsFieldInfo[0] + VectorElementsFieldInfo[1]};
+  static const constexpr BitFieldInfo VectorScalableFieldInfo{
+      1, VectorSizeFieldInfo[0] + VectorSizeFieldInfo[1]};
+  static_assert((VectorSizeFieldInfo[0] + VectorSizeFieldInfo[1]) <= 61,
+                "Insufficient bits to encode all data");
+  /// * Vector-of-pointer (isPointer == 1 && isVector == 1):
+  ///   NumElements: 16;
+  ///   SizeOfElement: 16;
+  ///   AddressSpace: 24;
+  ///   Scalable: 1;
+  static const constexpr BitFieldInfo PointerVectorElementsFieldInfo{16, 0};
+  static const constexpr BitFieldInfo PointerVectorSizeFieldInfo{
+      16,
+      PointerVectorElementsFieldInfo[1] + PointerVectorElementsFieldInfo[0]};
+  static const constexpr BitFieldInfo PointerVectorAddressSpaceFieldInfo{
+      24, PointerVectorSizeFieldInfo[1] + PointerVectorSizeFieldInfo[0]};
+  static const constexpr BitFieldInfo PointerVectorScalableFieldInfo{
+      1, PointerVectorAddressSpaceFieldInfo[0] +
+             PointerVectorAddressSpaceFieldInfo[1]};
+  static_assert((PointerVectorAddressSpaceFieldInfo[0] +
+                 PointerVectorAddressSpaceFieldInfo[1]) <= 61,
+                "Insufficient bits to encode all data");
+
+  uint64_t IsScalar : 1;
+  uint64_t IsPointer : 1;
+  uint64_t IsVector : 1;
+  uint64_t RawData : 61;
+
+  static constexpr uint64_t getMask(const BitFieldInfo FieldInfo) {
+    const int FieldSizeInBits = FieldInfo[0];
+    return (((uint64_t)1) << FieldSizeInBits) - 1;
+  }
+  static constexpr uint64_t maskAndShift(uint64_t Val, uint64_t Mask,
+                                         uint8_t Shift) {
+    assert(Val <= Mask && "Value too large for field");
+    return (Val & Mask) << Shift;
+  }
+  static constexpr uint64_t maskAndShift(uint64_t Val,
+                                         const BitFieldInfo FieldInfo) {
+    return maskAndShift(Val, getMask(FieldInfo), FieldInfo[1]);
+  }
+
+  constexpr uint64_t getFieldValue(const BitFieldInfo FieldInfo) const {
+    return getMask(FieldInfo) & (RawData >> FieldInfo[1]);
+  }
+
+  constexpr void init(bool IsPointer, bool IsVector, bool IsScalar,
+                      ElementCount EC, uint64_t SizeInBits,
+                      unsigned AddressSpace) {
+    assert(SizeInBits <= std::numeric_limits<unsigned>::max() &&
+           "Not enough bits in LLT to represent size");
+    this->IsPointer = IsPointer;
+    this->IsVector = IsVector;
+    this->IsScalar = IsScalar;
+    if (IsScalar)
+      RawData = maskAndShift(SizeInBits, ScalarSizeFieldInfo);
+    else if (IsVector) {
+      assert(EC.isVector() && "invalid number of vector elements");
+      if (!IsPointer)
+        RawData =
+            maskAndShift(EC.getKnownMinValue(), VectorElementsFieldInfo) |
+            maskAndShift(SizeInBits, VectorSizeFieldInfo) |
+            maskAndShift(EC.isScalable() ? 1 : 0, VectorScalableFieldInfo);
+      else
+        RawData =
+            maskAndShift(EC.getKnownMinValue(),
+                         PointerVectorElementsFieldInfo) |
+            maskAndShift(SizeInBits, PointerVectorSizeFieldInfo) |
+            maskAndShift(AddressSpace, PointerVectorAddressSpaceFieldInfo) |
+            maskAndShift(EC.isScalable() ? 1 : 0,
+                         PointerVectorScalableFieldInfo);
+    } else if (IsPointer)
+      RawData = maskAndShift(SizeInBits, PointerSizeFieldInfo) |
+                maskAndShift(AddressSpace, PointerAddressSpaceFieldInfo);
+    else
+      llvm_unreachable("unexpected LLT configuration");
+  }
+
+public:
+  constexpr uint64_t getUniqueRAWLLTData() const {
+    return ((uint64_t)RawData) << 3 | ((uint64_t)IsScalar) << 2 |
+           ((uint64_t)IsPointer) << 1 | ((uint64_t)IsVector);
+  }
+};
+
+inline raw_ostream& operator<<(raw_ostream &OS, const LLT &Ty) {
+  Ty.print(OS);
+  return OS;
+}
+
+template<> struct DenseMapInfo<LLT> {
+  static inline LLT getEmptyKey() {
+    LLT Invalid;
+    Invalid.IsPointer = true;
+    return Invalid;
+  }
+  static inline LLT getTombstoneKey() {
+    LLT Invalid;
+    Invalid.IsVector = true;
+    return Invalid;
+  }
+  static inline unsigned getHashValue(const LLT &Ty) {
+    uint64_t Val = Ty.getUniqueRAWLLTData();
+    return DenseMapInfo<uint64_t>::getHashValue(Val);
+  }
+  static bool isEqual(const LLT &LHS, const LLT &RHS) {
+    return LHS == RHS;
+  }
+};
 
 /// Construct a low-level type based on an LLVM type.
 LLT getLLTForType(Type &Ty, const DataLayout &DL);
 
 /// Get a rough equivalent of an MVT for a given LLT. MVT can't distinguish
 /// pointers, so these will convert to a plain integer.
 MVT getMVTForLLT(LLT Ty);
 EVT getApproximateEVTForLLT(LLT Ty, const DataLayout &DL, LLVMContext &Ctx);

llvm/include/llvm/CodeGen/MachineValueType.h

-//===- Support/MachineValueType.h - Machine-Level types ---------*- C++ -*-===//
+//===- CodeGen/MachineValueType.h - Machine-Level types ---------*- 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 file defines the set of machine-level target independent types which
 // legal values in the code generator use.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_SUPPORT_MACHINEVALUETYPE_H
-#define LLVM_SUPPORT_MACHINEVALUETYPE_H
+#ifndef LLVM_CODEGEN_MACHINEVALUETYPE_H
+#define LLVM_CODEGEN_MACHINEVALUETYPE_H
 
 #include "llvm/ADT/Sequence.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/TypeSize.h"
 #include <cassert>
 

llvm/include/llvm/Support/LowLevelTypeImpl.h

-//== llvm/Support/LowLevelTypeImpl.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
-//
-//===----------------------------------------------------------------------===//
-/// \file
-/// Implement a low-level type suitable for MachineInstr level instruction
-/// selection.
-///
-/// For a type attached to a MachineInstr, we only care about 2 details: total
-/// size and the number of vector lanes (if any). Accordingly, there are 4
-/// possible valid type-kinds:
-///
-///    * `sN` for scalars and aggregates
-///    * `<N x sM>` for vectors, which must have at least 2 elements.
-///    * `pN` for pointers
-///
-/// Other information required for correct selection is expected to be carried
-/// by the opcode, or non-type flags. For example the distinction between G_ADD
-/// and G_FADD for int/float or fast-math flags.
-///
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_SUPPORT_LOWLEVELTYPEIMPL_H
-#define LLVM_SUPPORT_LOWLEVELTYPEIMPL_H
-
-#include "llvm/ADT/DenseMapInfo.h"
-#include "llvm/Support/Debug.h"
-#include "llvm/Support/MachineValueType.h"
-#include <cassert>
-
-namespace llvm {
-
-class Type;
-class raw_ostream;
-
-class LLT {
-public:
-  /// Get a low-level scalar or aggregate "bag of bits".
-  static constexpr LLT scalar(unsigned SizeInBits) {
-    return LLT{/*isPointer=*/false, /*isVector=*/false, /*isScalar=*/true,
-               ElementCount::getFixed(0), SizeInBits,
-               /*AddressSpace=*/0};
-  }
-
-  /// Get a low-level pointer in the given address space.
-  static constexpr LLT pointer(unsigned AddressSpace, unsigned SizeInBits) {
-    assert(SizeInBits > 0 && "invalid pointer size");
-    return LLT{/*isPointer=*/true, /*isVector=*/false, /*isScalar=*/false,
-               ElementCount::getFixed(0), SizeInBits, AddressSpace};
-  }
-
-  /// Get a low-level vector of some number of elements and element width.
-  static constexpr LLT vector(ElementCount EC, unsigned ScalarSizeInBits) {
-    assert(!EC.isScalar() && "invalid number of vector elements");
-    return LLT{/*isPointer=*/false, /*isVector=*/true, /*isScalar=*/false,
-               EC, ScalarSizeInBits, /*AddressSpace=*/0};
-  }
-
-  /// Get a low-level vector of some number of elements and element type.
-  static constexpr LLT vector(ElementCount EC, LLT ScalarTy) {
-    assert(!EC.isScalar() && "invalid number of vector elements");
-    assert(!ScalarTy.isVector() && "invalid vector element type");
-    return LLT{ScalarTy.isPointer(),
-               /*isVector=*/true,
-               /*isScalar=*/false,
-               EC,
-               ScalarTy.getSizeInBits().getFixedValue(),
-               ScalarTy.isPointer() ? ScalarTy.getAddressSpace() : 0};
-  }
-
-  /// Get a low-level fixed-width vector of some number of elements and element
-  /// width.
-  static constexpr LLT fixed_vector(unsigned NumElements,
-                                    unsigned ScalarSizeInBits) {
-    return vector(ElementCount::getFixed(NumElements), ScalarSizeInBits);
-  }
-
-  /// Get a low-level fixed-width vector of some number of elements and element
-  /// type.
-  static constexpr LLT fixed_vector(unsigned NumElements, LLT ScalarTy) {
-    return vector(ElementCount::getFixed(NumElements), ScalarTy);
-  }
-
-  /// Get a low-level scalable vector of some number of elements and element
-  /// width.
-  static constexpr LLT scalable_vector(unsigned MinNumElements,
-                                       unsigned ScalarSizeInBits) {
-    return vector(ElementCount::getScalable(MinNumElements), ScalarSizeInBits);
-  }
-
-  /// Get a low-level scalable vector of some number of elements and element
-  /// type.
-  static constexpr LLT scalable_vector(unsigned MinNumElements, LLT ScalarTy) {
-    return vector(ElementCount::getScalable(MinNumElements), ScalarTy);
-  }
-
-  static constexpr LLT scalarOrVector(ElementCount EC, LLT ScalarTy) {
-    return EC.isScalar() ? ScalarTy : LLT::vector(EC, ScalarTy);
-  }
-
-  static constexpr LLT scalarOrVector(ElementCount EC, uint64_t ScalarSize) {
-    assert(ScalarSize <= std::numeric_limits<unsigned>::max() &&
-           "Not enough bits in LLT to represent size");
-    return scalarOrVector(EC, LLT::scalar(static_cast<unsigned>(ScalarSize)));
-  }
-
-  explicit constexpr LLT(bool isPointer, bool isVector, bool isScalar,
-                         ElementCount EC, uint64_t SizeInBits,
-                         unsigned AddressSpace)
-      : LLT() {
-    init(isPointer, isVector, isScalar, EC, SizeInBits, AddressSpace);
-  }
-  explicit constexpr LLT()
-      : IsScalar(false), IsPointer(false), IsVector(false), RawData(0) {}
-
-  explicit LLT(MVT VT);
-
-  constexpr bool isValid() const { return IsScalar || RawData != 0; }
-
-  constexpr bool isScalar() const { return IsScalar; }
-
-  constexpr bool isPointer() const {
-    return isValid() && IsPointer && !IsVector;
-  }
-
-  constexpr bool isVector() const { return isValid() && IsVector; }
-
-  /// Returns the number of elements in a vector LLT. Must only be called on
-  /// vector types.
-  constexpr uint16_t getNumElements() const {
-    if (isScalable())
-      llvm::reportInvalidSizeRequest(
-          "Possible incorrect use of LLT::getNumElements() for "
-          "scalable vector. Scalable flag may be dropped, use "
-          "LLT::getElementCount() instead");
-    return getElementCount().getKnownMinValue();
-  }
-
-  /// Returns true if the LLT is a scalable vector. Must only be called on
-  /// vector types.
-  constexpr bool isScalable() const {
-    assert(isVector() && "Expected a vector type");
-    return IsPointer ? getFieldValue(PointerVectorScalableFieldInfo)
-                     : getFieldValue(VectorScalableFieldInfo);
-  }
-
-  constexpr ElementCount getElementCount() const {
-    assert(IsVector && "cannot get number of elements on scalar/aggregate");
-    return ElementCount::get(IsPointer
-                                 ? getFieldValue(PointerVectorElementsFieldInfo)
-                                 : getFieldValue(VectorElementsFieldInfo),
-                             isScalable());
-  }
-
-  /// Returns the total size of the type. Must only be called on sized types.
-  constexpr TypeSize getSizeInBits() const {
-    if (isPointer() || isScalar())
-      return TypeSize::Fixed(getScalarSizeInBits());
-    auto EC = getElementCount();
-    return TypeSize(getScalarSizeInBits() * EC.getKnownMinValue(),
-                    EC.isScalable());
-  }
-
-  /// Returns the total size of the type in bytes, i.e. number of whole bytes
-  /// needed to represent the size in bits. Must only be called on sized types.
-  constexpr TypeSize getSizeInBytes() const {
-    TypeSize BaseSize = getSizeInBits();
-    return {(BaseSize.getKnownMinValue() + 7) / 8, BaseSize.isScalable()};
-  }
-
-  constexpr LLT getScalarType() const {
-    return isVector() ? getElementType() : *this;
-  }
-
-  /// If this type is a vector, return a vector with the same number of elements
-  /// but the new element type. Otherwise, return the new element type.
-  constexpr LLT changeElementType(LLT NewEltTy) const {
-    return isVector() ? LLT::vector(getElementCount(), NewEltTy) : NewEltTy;
-  }
-
-  /// If this type is a vector, return a vector with the same number of elements
-  /// but the new element size. Otherwise, return the new element type. Invalid
-  /// for pointer types. For pointer types, use changeElementType.
-  constexpr LLT changeElementSize(unsigned NewEltSize) const {
-    assert(!getScalarType().isPointer() &&
-           "invalid to directly change element size for pointers");
-    return isVector() ? LLT::vector(getElementCount(), NewEltSize)
-                      : LLT::scalar(NewEltSize);
-  }
-
-  /// Return a vector or scalar with the same element type and the new element
-  /// count.
-  constexpr LLT changeElementCount(ElementCount EC) const {
-    return LLT::scalarOrVector(EC, getScalarType());
-  }
-
-  /// Return a type that is \p Factor times smaller. Reduces the number of
-  /// elements if this is a vector, or the bitwidth for scalar/pointers. Does
-  /// not attempt to handle cases that aren't evenly divisible.
-  constexpr LLT divide(int Factor) const {
-    assert(Factor != 1);
-    assert((!isScalar() || getScalarSizeInBits() != 0) &&
-           "cannot divide scalar of size zero");
-    if (isVector()) {
-      assert(getElementCount().isKnownMultipleOf(Factor));
-      return scalarOrVector(getElementCount().divideCoefficientBy(Factor),
-                            getElementType());
-    }
-
-    assert(getScalarSizeInBits() % Factor == 0);
-    return scalar(getScalarSizeInBits() / Factor);
-  }
-
-  /// Produce a vector type that is \p Factor times bigger, preserving the
-  /// element type. For a scalar or pointer, this will produce a new vector with
-  /// \p Factor elements.
-  constexpr LLT multiplyElements(int Factor) const {
-    if (isVector()) {
-      return scalarOrVector(getElementCount().multiplyCoefficientBy(Factor),
-                            getElementType());
-    }
-
-    return fixed_vector(Factor, *this);
-  }
-
-  constexpr bool isByteSized() const {
-    return getSizeInBits().isKnownMultipleOf(8);
-  }
-
-  constexpr unsigned getScalarSizeInBits() const {
-    if (IsScalar)
-      return getFieldValue(ScalarSizeFieldInfo);
-    if (IsVector) {
-      if (!IsPointer)
-        return getFieldValue(VectorSizeFieldInfo);
-      else
-        return getFieldValue(PointerVectorSizeFieldInfo);
-    } else if (IsPointer)
-      return getFieldValue(PointerSizeFieldInfo);
-    else
-      llvm_unreachable("unexpected LLT");
-  }
-
-  constexpr unsigned getAddressSpace() const {
-    assert(RawData != 0 && "Invalid Type");
-    assert(IsPointer && "cannot get address space of non-pointer type");
-    if (!IsVector)
-      return getFieldValue(PointerAddressSpaceFieldInfo);
-    else
-      return getFieldValue(PointerVectorAddressSpaceFieldInfo);
-  }
-
-  /// Returns the vector's element type. Only valid for vector types.
-  constexpr LLT getElementType() const {
-    assert(isVector() && "cannot get element type of scalar/aggregate");
-    if (IsPointer)
-      return pointer(getAddressSpace(), getScalarSizeInBits());
-    else
-      return scalar(getScalarSizeInBits());
-  }
-
-  void print(raw_ostream &OS) const;
-
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-  LLVM_DUMP_METHOD void dump() const {
-    print(dbgs());
-    dbgs() << '\n';
-  }
-#endif
-
-  constexpr bool operator==(const LLT &RHS) const {
-    return IsPointer == RHS.IsPointer && IsVector == RHS.IsVector &&
-           IsScalar == RHS.IsScalar && RHS.RawData == RawData;
-  }
-
-  constexpr bool operator!=(const LLT &RHS) const { return !(*this == RHS); }
-
-  friend struct DenseMapInfo<LLT>;
-  friend class GISelInstProfileBuilder;
-
-private:
-  /// LLT is packed into 64 bits as follows:
-  /// isScalar : 1
-  /// isPointer : 1
-  /// isVector  : 1
-  /// with 61 bits remaining for Kind-specific data, packed in bitfields
-  /// as described below. As there isn't a simple portable way to pack bits
-  /// into bitfields, here the different fields in the packed structure is
-  /// described in static const *Field variables. Each of these variables
-  /// is a 2-element array, with the first element describing the bitfield size
-  /// and the second element describing the bitfield offset.
-  typedef int BitFieldInfo[2];
-  ///
-  /// This is how the bitfields are packed per Kind:
-  /// * Invalid:
-  ///   gets encoded as RawData == 0, as that is an invalid encoding, since for
-  ///   valid encodings, SizeInBits/SizeOfElement must be larger than 0.
-  /// * Non-pointer scalar (isPointer == 0 && isVector == 0):
-  ///   SizeInBits: 32;
-  static const constexpr BitFieldInfo ScalarSizeFieldInfo{32, 0};
-  /// * Pointer (isPointer == 1 && isVector == 0):
-  ///   SizeInBits: 16;
-  ///   AddressSpace: 24;
-  static const constexpr BitFieldInfo PointerSizeFieldInfo{16, 0};
-  static const constexpr BitFieldInfo PointerAddressSpaceFieldInfo{
-      24, PointerSizeFieldInfo[0] + PointerSizeFieldInfo[1]};
-  static_assert((PointerAddressSpaceFieldInfo[0] +
-                 PointerAddressSpaceFieldInfo[1]) <= 61,
-                "Insufficient bits to encode all data");
-  /// * Vector-of-non-pointer (isPointer == 0 && isVector == 1):
-  ///   NumElements: 16;
-  ///   SizeOfElement: 32;
-  ///   Scalable: 1;
-  static const constexpr BitFieldInfo VectorElementsFieldInfo{16, 0};
-  static const constexpr BitFieldInfo VectorSizeFieldInfo{
-      32, VectorElementsFieldInfo[0] + VectorElementsFieldInfo[1]};
-  static const constexpr BitFieldInfo VectorScalableFieldInfo{
-      1, VectorSizeFieldInfo[0] + VectorSizeFieldInfo[1]};
-  static_assert((VectorSizeFieldInfo[0] + VectorSizeFieldInfo[1]) <= 61,
-                "Insufficient bits to encode all data");
-  /// * Vector-of-pointer (isPointer == 1 && isVector == 1):
-  ///   NumElements: 16;
-  ///   SizeOfElement: 16;
-  ///   AddressSpace: 24;
-  ///   Scalable: 1;
-  static const constexpr BitFieldInfo PointerVectorElementsFieldInfo{16, 0};
-  static const constexpr BitFieldInfo PointerVectorSizeFieldInfo{
-      16,
-      PointerVectorElementsFieldInfo[1] + PointerVectorElementsFieldInfo[0]};
-  static const constexpr BitFieldInfo PointerVectorAddressSpaceFieldInfo{
-      24, PointerVectorSizeFieldInfo[1] + PointerVectorSizeFieldInfo[0]};
-  static const constexpr BitFieldInfo PointerVectorScalableFieldInfo{
-      1, PointerVectorAddressSpaceFieldInfo[0] +
-             PointerVectorAddressSpaceFieldInfo[1]};
-  static_assert((PointerVectorAddressSpaceFieldInfo[0] +
-                 PointerVectorAddressSpaceFieldInfo[1]) <= 61,
-                "Insufficient bits to encode all data");
-
-  uint64_t IsScalar : 1;
-  uint64_t IsPointer : 1;
-  uint64_t IsVector : 1;
-  uint64_t RawData : 61;
-
-  static constexpr uint64_t getMask(const BitFieldInfo FieldInfo) {
-    const int FieldSizeInBits = FieldInfo[0];
-    return (((uint64_t)1) << FieldSizeInBits) - 1;
-  }
-  static constexpr uint64_t maskAndShift(uint64_t Val, uint64_t Mask,
-                                         uint8_t Shift) {
-    assert(Val <= Mask && "Value too large for field");
-    return (Val & Mask) << Shift;
-  }
-  static constexpr uint64_t maskAndShift(uint64_t Val,
-                                         const BitFieldInfo FieldInfo) {
-    return maskAndShift(Val, getMask(FieldInfo), FieldInfo[1]);
-  }
-
-  constexpr uint64_t getFieldValue(const BitFieldInfo FieldInfo) const {
-    return getMask(FieldInfo) & (RawData >> FieldInfo[1]);
-  }
-
-  constexpr void init(bool IsPointer, bool IsVector, bool IsScalar,
-                      ElementCount EC, uint64_t SizeInBits,
-                      unsigned AddressSpace) {
-    assert(SizeInBits <= std::numeric_limits<unsigned>::max() &&
-           "Not enough bits in LLT to represent size");
-    this->IsPointer = IsPointer;
-    this->IsVector = IsVector;
-    this->IsScalar = IsScalar;
-    if (IsScalar)
-      RawData = maskAndShift(SizeInBits, ScalarSizeFieldInfo);
-    else if (IsVector) {
-      assert(EC.isVector() && "invalid number of vector elements");
-      if (!IsPointer)
-        RawData =
-            maskAndShift(EC.getKnownMinValue(), VectorElementsFieldInfo) |
-            maskAndShift(SizeInBits, VectorSizeFieldInfo) |
-            maskAndShift(EC.isScalable() ? 1 : 0, VectorScalableFieldInfo);
-      else
-        RawData =
-            maskAndShift(EC.getKnownMinValue(),
-                         PointerVectorElementsFieldInfo) |
-            maskAndShift(SizeInBits, PointerVectorSizeFieldInfo) |
-            maskAndShift(AddressSpace, PointerVectorAddressSpaceFieldInfo) |
-            maskAndShift(EC.isScalable() ? 1 : 0,
-                         PointerVectorScalableFieldInfo);
-    } else if (IsPointer)
-      RawData = maskAndShift(SizeInBits, PointerSizeFieldInfo) |
-                maskAndShift(AddressSpace, PointerAddressSpaceFieldInfo);
-    else
-      llvm_unreachable("unexpected LLT configuration");
-  }
-
-public:
-  constexpr uint64_t getUniqueRAWLLTData() const {
-    return ((uint64_t)RawData) << 3 | ((uint64_t)IsScalar) << 2 |
-           ((uint64_t)IsPointer) << 1 | ((uint64_t)IsVector);
-  }
-};
-
-inline raw_ostream& operator<<(raw_ostream &OS, const LLT &Ty) {
-  Ty.print(OS);
-  return OS;
-}
-
-template<> struct DenseMapInfo<LLT> {
-  static inline LLT getEmptyKey() {
-    LLT Invalid;
-    Invalid.IsPointer = true;
-    return Invalid;
-  }
-  static inline LLT getTombstoneKey() {
-    LLT Invalid;
-    Invalid.IsVector = true;
-    return Invalid;
-  }
-  static inline unsigned getHashValue(const LLT &Ty) {
-    uint64_t Val = Ty.getUniqueRAWLLTData();
-    return DenseMapInfo<uint64_t>::getHashValue(Val);
-  }
-  static bool isEqual(const LLT &LHS, const LLT &RHS) {
-    return LHS == RHS;
-  }
-};
-
-}
-
-#endif // LLVM_SUPPORT_LOWLEVELTYPEIMPL_H

llvm/include/llvm/module.modulemap

 }
 
 module LLVM_AsmParser {
   requires cplusplus
   umbrella "AsmParser"
   module * { export * }
 }
 
+module LLVM_CodeGenTypes {
+  requires cplusplus
+
+  module LLT {
+    header "CodeGen/LowLevelType.h" export *
+  }
+  module MVT {
+    header "CodeGen/MachineValueType.h" export *
+  }
+  module VT {
+    header "CodeGen/ValueTypes.h" export *
+  }
+}
+
 // A module covering CodeGen/ and Target/. These are intertwined
 // and codependent, and thus notionally form a single module.
 module LLVM_Backend {
   requires cplusplus
 
   module CodeGen {
     umbrella "CodeGen"
     module * { export * }

 
 module LLVM_MC {
   requires cplusplus
 
   umbrella "MC"
   module * { export * }
 }
 
-// Used by llvm-tblgen
-module LLVM_MC_TableGen {
-  requires cplusplus
-  module MC_LaneBitmask { header "MC/LaneBitmask.h" export * }
-  module MC_InstrItineraries { header "MC/MCInstrItineraries.h" export * }
-  module MC_Schedule { header "MC/MCSchedule.h" export * }
-  module MC_SubtargetFeature { header "MC/SubtargetFeature.h" export * }
-}
-
 module LLVM_Object {
   requires cplusplus
   umbrella "Object"
   module * { export * }
 }
 
 module LLVM_Option {
   requires cplusplus

llvm/lib/CodeGen/LowLevelType.cpp

 //===-- llvm/CodeGen/LowLevelType.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
 //
 //===----------------------------------------------------------------------===//
 //
case 32:
     return APFloat::IEEEsingle();
   case 64:
     return APFloat::IEEEdouble();
   case 128:
     return APFloat::IEEEquad();
   }
   llvm_unreachable("Invalid FP type size.");
 }
+
+LLT::LLT(MVT VT) {
+  if (VT.isVector()) {
+    bool asVector = VT.getVectorMinNumElements() > 1;
+    init(/*IsPointer=*/false, asVector, /*IsScalar=*/!asVector,
+         VT.getVectorElementCount(), VT.getVectorElementType().getSizeInBits(),
+         /*AddressSpace=*/0);
+  } else if (VT.isValid() && !VT.isScalableTargetExtVT()) {
+    // Aggregates are no different from real scalars as far as GlobalISel is
+    // concerned.
+    init(/*IsPointer=*/false, /*IsVector=*/false, /*IsScalar=*/true,
+         ElementCount::getFixed(0), VT.getSizeInBits(), /*AddressSpace=*/0);
+  } else {
+    IsScalar = false;
+    IsPointer = false;
+    IsVector = false;
+    RawData = 0;
+  }
+}
+
+void LLT::print(raw_ostream &OS) const {
+  if (isVector()) {
+    OS << "<";
+    OS << getElementCount() << " x " << getElementType() << ">";
+  } else if (isPointer())
+    OS << "p" << getAddressSpace();
+  else if (isValid()) {
+    assert(isScalar() && "unexpected type");
+    OS << "s" << getScalarSizeInBits();
+  } else
+    OS << "LLT_invalid";
+}
+
+const constexpr LLT::BitFieldInfo LLT::ScalarSizeFieldInfo;
+const constexpr LLT::BitFieldInfo LLT::PointerSizeFieldInfo;
+const constexpr LLT::BitFieldInfo LLT::PointerAddressSpaceFieldInfo;
+const constexpr LLT::BitFieldInfo LLT::VectorElementsFieldInfo;
+const constexpr LLT::BitFieldInfo LLT::VectorScalableFieldInfo;
+const constexpr LLT::BitFieldInfo LLT::VectorSizeFieldInfo;
+const constexpr LLT::BitFieldInfo LLT::PointerVectorElementsFieldInfo;
+const constexpr LLT::BitFieldInfo LLT::PointerVectorScalableFieldInfo;
+const constexpr LLT::BitFieldInfo LLT::PointerVectorSizeFieldInfo;
+const constexpr LLT::BitFieldInfo LLT::PointerVectorAddressSpaceFieldInfo;

llvm/lib/Support/CMakeLists.txt

add_llvm_component_library(LLVMSupport
   IntEqClasses.cpp
   IntervalMap.cpp
   JSON.cpp
   KnownBits.cpp
   LEB128.cpp
   LineIterator.cpp
   Locale.cpp
   LockFileManager.cpp
-  LowLevelType.cpp
   ManagedStatic.cpp
   MathExtras.cpp
   MemAlloc.cpp
   MemoryBuffer.cpp
   MemoryBufferRef.cpp
   MD5.cpp
   MSP430Attributes.cpp
   MSP430AttributeParser.cpp

llvm/lib/Support/LowLevelType.cpp

-//===-- llvm/Support/LowLevelType.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
-//
-//===----------------------------------------------------------------------===//
-//
-/// \file This file implements the more header-heavy bits of the LLT class to
-/// avoid polluting users' namespaces.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/Support/LowLevelTypeImpl.h"
-#include "llvm/Support/raw_ostream.h"
-using namespace llvm;
-
-LLT::LLT(MVT VT) {
-  if (VT.isVector()) {
-    bool asVector = VT.getVectorMinNumElements() > 1;
-    init(/*IsPointer=*/false, asVector, /*IsScalar=*/!asVector,
-         VT.getVectorElementCount(), VT.getVectorElementType().getSizeInBits(),
-         /*AddressSpace=*/0);
-  } else if (VT.isValid() && !VT.isScalableTargetExtVT()) {
-    // Aggregates are no different from real scalars as far as GlobalISel is
-    // concerned.
-    init(/*IsPointer=*/false, /*IsVector=*/false, /*IsScalar=*/true,
-         ElementCount::getFixed(0), VT.getSizeInBits(), /*AddressSpace=*/0);
-  } else {
-    IsScalar = false;
-    IsPointer = false;
-    IsVector = false;
-    RawData = 0;
-  }
-}
-
-void LLT::print(raw_ostream &OS) const {
-  if (isVector()) {
-    OS << "<";
-    OS << getElementCount() << " x " << getElementType() << ">";
-  } else if (isPointer())
-    OS << "p" << getAddressSpace();
-  else if (isValid()) {
-    assert(isScalar() && "unexpected type");
-    OS << "s" << getScalarSizeInBits();
-  } else
-    OS << "LLT_invalid";
-}
-
-const constexpr LLT::BitFieldInfo LLT::ScalarSizeFieldInfo;
-const constexpr LLT::BitFieldInfo LLT::PointerSizeFieldInfo;
-const constexpr LLT::BitFieldInfo LLT::PointerAddressSpaceFieldInfo;
-const constexpr LLT::BitFieldInfo LLT::VectorElementsFieldInfo;
-const constexpr LLT::BitFieldInfo LLT::VectorScalableFieldInfo;
-const constexpr LLT::BitFieldInfo LLT::VectorSizeFieldInfo;
-const constexpr LLT::BitFieldInfo LLT::PointerVectorElementsFieldInfo;
-const constexpr LLT::BitFieldInfo LLT::PointerVectorScalableFieldInfo;
-const constexpr LLT::BitFieldInfo LLT::PointerVectorSizeFieldInfo;
-const constexpr LLT::BitFieldInfo LLT::PointerVectorAddressSpaceFieldInfo;

llvm/lib/Target/AArch64/AsmParser/CMakeLists.txt

 include_directories( ${CMAKE_CURRENT_BINARY_DIR}/.. ${CMAKE_CURRENT_SOURCE_DIR}/.. )
 
 add_llvm_component_library(LLVMAArch64AsmParser
   AArch64AsmParser.cpp
 
   LINK_COMPONENTS
   AArch64Desc
   AArch64Info
   AArch64Utils
+  CodeGen
   MC
   MCParser
   Support
   TargetParser
 
   ADD_TO_COMPONENT
   AArch64
   )
 

llvm/lib/Target/AArch64/MCTargetDesc/CMakeLists.txt

add_llvm_component_library(LLVMAArch64Desc
   AArch64TargetStreamer.cpp
   AArch64WinCOFFObjectWriter.cpp
   AArch64WinCOFFStreamer.cpp
 
   LINK_COMPONENTS
   AArch64Info
   AArch64Utils
   BinaryFormat
+  CodeGen
   MC
   Support
   TargetParser
 
   ADD_TO_COMPONENT
   AArch64
   )
 
 add_dependencies(LLVMAArch64Desc AArch64CommonTableGen)
 
 # Hack: we need to include 'main' target directory to grab private headers
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/.. ${CMAKE_CURRENT_BINARY_DIR}/..)

llvm/lib/Target/AMDGPU/AsmParser/CMakeLists.txt

 add_llvm_component_library(LLVMAMDGPUAsmParser
   AMDGPUAsmParser.cpp
 
   LINK_COMPONENTS
   AMDGPUDesc
   AMDGPUInfo
   AMDGPUUtils
+  CodeGen
   MC
   MCParser
   Support
   TargetParser
 
   ADD_TO_COMPONENT
   AMDGPU
   )
 
 add_dependencies(LLVMAMDGPUAsmParser LLVMAMDGPUUtils)

llvm/lib/Target/AMDGPU/Disassembler/CMakeLists.txt

 include_directories( ${CMAKE_CURRENT_BINARY_DIR}/.. ${CMAKE_CURRENT_SOURCE_DIR}/.. )
 
 add_llvm_component_library(LLVMAMDGPUDisassembler
   AMDGPUDisassembler.cpp
 
   LINK_COMPONENTS
   AMDGPUDesc
   AMDGPUInfo
   AMDGPUUtils
+  CodeGen
   MC
   MCDisassembler
   Support
 
   ADD_TO_COMPONENT
   AMDGPU
   )
 
 add_dependencies(LLVMAMDGPUDisassembler AMDGPUCommonTableGen LLVMAMDGPUUtils)

llvm/lib/Target/AMDGPU/MCA/CMakeLists.txt

 add_llvm_component_library(LLVMAMDGPUTargetMCA
   AMDGPUCustomBehaviour.cpp
 
   LINK_COMPONENTS
   AMDGPUDesc
   AMDGPUInfo
   AMDGPUUtils
+  CodeGen
   MC
   MCA
   MCParser
   Support
   TargetParser
 
   ADD_TO_COMPONENT
   AMDGPU
   )
 
 add_dependencies(LLVMAMDGPUTargetMCA LLVMAMDGPUUtils)

llvm/lib/Target/AMDGPU/MCTargetDesc/CMakeLists.txt

add_llvm_component_library(LLVMAMDGPUDesc
   R600MCCodeEmitter.cpp
   R600MCTargetDesc.cpp
   SIMCCodeEmitter.cpp
 
   LINK_COMPONENTS
   AMDGPUInfo
   AMDGPUUtils
   BinaryFormat
+  CodeGen
   Core
   MC
   Support
   TargetParser
 
   ADD_TO_COMPONENT
   AMDGPU
   )
 
 add_dependencies(LLVMAMDGPUDesc LLVMAMDGPUUtils)

llvm/lib/Target/AMDGPU/Utils/CMakeLists.txt

 add_llvm_component_library(LLVMAMDGPUUtils
   AMDGPUAsmUtils.cpp
   AMDGPUBaseInfo.cpp
   AMDGPUMemoryUtils.cpp
   AMDGPUPALMetadata.cpp
   AMDKernelCodeTUtils.cpp
 
   LINK_COMPONENTS
   Analysis
   BinaryFormat
+  CodeGen
   Core
   MC
   Support
   TargetParser
 
   ADD_TO_COMPONENT
   AMDGPU
   )

llvm/lib/Target/ARM/AsmParser/CMakeLists.txt

 add_llvm_component_library(LLVMARMAsmParser
   ARMAsmParser.cpp
 
   LINK_COMPONENTS
   ARMDesc
   ARMInfo
   ARMUtils
+  CodeGen
   MC
   MCParser
   Support
   TargetParser
 
   ADD_TO_COMPONENT
   ARM
   )

llvm/lib/Target/ARM/Disassembler/CMakeLists.txt

 add_llvm_component_library(LLVMARMDisassembler
   ARMDisassembler.cpp
 
   LINK_COMPONENTS
   ARMDesc
   ARMInfo
   ARMUtils
+  CodeGen
   MC
   MCDisassembler
   Support
 
   ADD_TO_COMPONENT
   ARM
   )

llvm/lib/Target/ARM/MCTargetDesc/CMakeLists.txt

add_llvm_component_library(LLVMARMDesc
   ARMUnwindOpAsm.cpp
   ARMWinCOFFObjectWriter.cpp
   ARMWinCOFFStreamer.cpp
 
   LINK_COMPONENTS
   ARMInfo
   ARMUtils
   BinaryFormat
+  CodeGen
   MC
   MCDisassembler
   Support
   TargetParser
 
   ADD_TO_COMPONENT
   ARM
   )

llvm/lib/Target/AVR/AsmParser/CMakeLists.txt

 add_llvm_component_library(LLVMAVRAsmParser
   AVRAsmParser.cpp
 
   LINK_COMPONENTS
   AVRDesc
   AVRInfo
+  CodeGen
   MC
   MCParser
   Support
 
   ADD_TO_COMPONENT
   AVR
   )

llvm/lib/Target/AVR/Disassembler/CMakeLists.txt

 add_llvm_component_library(LLVMAVRDisassembler
   AVRDisassembler.cpp
 
   LINK_COMPONENTS
   AVRInfo
+  CodeGen
   MC
   MCDisassembler
   Support
 
   ADD_TO_COMPONENT
   AVR
   )
 

llvm/lib/Target/Lanai/AsmParser/CMakeLists.txt

 include_directories( ${CMAKE_CURRENT_BINARY_DIR}/.. ${CMAKE_CURRENT_SOURCE_DIR}/.. )
 
 add_llvm_component_library(LLVMLanaiAsmParser
   LanaiAsmParser.cpp
 
   LINK_COMPONENTS
+  CodeGen
   LanaiDesc
   LanaiInfo
   MC
   MCParser
   Support
 
   ADD_TO_COMPONENT
   Lanai
   )
 
 add_dependencies( LLVMLanaiAsmParser LanaiCommonTableGen )

llvm/lib/Target/Lanai/Disassembler/CMakeLists.txt

 add_llvm_component_library(LLVMLanaiDisassembler
   LanaiDisassembler.cpp
 
   LINK_COMPONENTS
+  CodeGen
   LanaiDesc
   LanaiInfo
   MC
   MCDisassembler
   Support
 
   ADD_TO_COMPONENT
   Lanai
   )

llvm/lib/Target/MSP430/AsmParser/CMakeLists.txt

 add_llvm_component_library(LLVMMSP430AsmParser
   MSP430AsmParser.cpp
 
   LINK_COMPONENTS
+  CodeGen
   MC
   MCParser
   MSP430Desc
   MSP430Info
   Support
 
   ADD_TO_COMPONENT
   MSP430
   )

llvm/lib/Target/Mips/MCTargetDesc/CMakeLists.txt

 add_llvm_component_library(LLVMMipsDesc
   MipsABIInfo.cpp
   MipsABIFlagsSection.cpp
   MipsAsmBackend.cpp
   MipsELFObjectWriter.cpp
   MipsELFStreamer.cpp
   MipsInstPrinter.cpp
   MipsMCAsmInfo.cpp
   MipsMCCodeEmitter.cpp
   MipsMCExpr.cpp
   MipsMCTargetDesc.cpp
   MipsNaClELFStreamer.cpp
   MipsOptionRecord.cpp
   MipsTargetStreamer.cpp
 
   LINK_COMPONENTS
+  CodeGen
   MC
   MipsInfo
   Support
   TargetParser
 
   ADD_TO_COMPONENT
   Mips
   )

llvm/lib/Target/PowerPC/MCTargetDesc/CMakeLists.txt

 add_llvm_component_library(LLVMPowerPCDesc
   PPCAsmBackend.cpp
   PPCInstPrinter.cpp
   PPCMCTargetDesc.cpp
   PPCMCAsmInfo.cpp
   PPCMCCodeEmitter.cpp
   PPCMCExpr.cpp
   PPCPredicates.cpp
   PPCELFObjectWriter.cpp
   PPCXCOFFObjectWriter.cpp
   PPCELFStreamer.cpp
   PPCXCOFFStreamer.cpp
 
   LINK_COMPONENTS
   BinaryFormat
+  CodeGen
   MC
   PowerPCInfo
   Support
   TargetParser
 
   ADD_TO_COMPONENT
   PowerPC
   )

llvm/lib/Target/RISCV/MCA/CMakeLists.txt

 add_llvm_component_library(LLVMRISCVTargetMCA
   RISCVCustomBehaviour.cpp
 
   LINK_COMPONENTS
+  CodeGen
   MC
   MCA
   MCParser
   RISCVDesc
   RISCVInfo
   Support
 
   ADD_TO_COMPONENT
   RISCV
   )

llvm/lib/Target/SystemZ/MCTargetDesc/CMakeLists.txt

 add_llvm_component_library(LLVMSystemZDesc
   SystemZInstPrinter.cpp
   SystemZMCAsmBackend.cpp
   SystemZMCAsmInfo.cpp
   SystemZMCCodeEmitter.cpp
   SystemZMCObjectWriter.cpp
   SystemZMCTargetDesc.cpp
 
   LINK_COMPONENTS
+  CodeGen
   MC
   Support
   SystemZInfo
 
   ADD_TO_COMPONENT
   SystemZ
   )

llvm/lib/Target/VE/AsmParser/CMakeLists.txt

 add_llvm_component_library(LLVMVEAsmParser
   VEAsmParser.cpp
 
   LINK_COMPONENTS
+  CodeGen
   MC
   MCParser
   Support
   VEDesc
   VEInfo
 
   ADD_TO_COMPONENT
   VE
   )

llvm/lib/Target/VE/Disassembler/CMakeLists.txt

 add_llvm_component_library(LLVMVEDisassembler
   VEDisassembler.cpp
 
   LINK_COMPONENTS
+  CodeGen
   MC
   MCDisassembler
   Support
   VEInfo
 
   ADD_TO_COMPONENT
   VE
   )

llvm/lib/Target/VE/MCTargetDesc/CMakeLists.txt

 add_llvm_component_library(LLVMVEDesc
   VEAsmBackend.cpp
   VEELFObjectWriter.cpp
   VEInstPrinter.cpp
   VEMCAsmInfo.cpp
   VEMCCodeEmitter.cpp
   VEMCExpr.cpp
   VEMCTargetDesc.cpp
   VETargetStreamer.cpp
 
   LINK_COMPONENTS
+  CodeGen
   MC
   Support
   TargetParser
   VEInfo
 
   ADD_TO_COMPONENT
   VE
   )

llvm/lib/Target/WebAssembly/AsmParser/CMakeLists.txt

 add_llvm_component_library(LLVMWebAssemblyAsmParser
   WebAssemblyAsmParser.cpp
   WebAssemblyAsmTypeCheck.cpp
 
   LINK_COMPONENTS
+  CodeGen
   MC
   MCParser
   Support
   TargetParser
   WebAssemblyDesc
   WebAssemblyInfo
 
   ADD_TO_COMPONENT
   WebAssembly
   )

llvm/lib/Target/WebAssembly/Disassembler/CMakeLists.txt

 add_llvm_component_library(LLVMWebAssemblyDisassembler
   WebAssemblyDisassembler.cpp
 
   LINK_COMPONENTS
+  CodeGen
   MC
   MCDisassembler
   Support
   WebAssemblyDesc
   WebAssemblyInfo
 
   ADD_TO_COMPONENT
   WebAssembly
   )

llvm/lib/Target/WebAssembly/MCTargetDesc/CMakeLists.txt

 add_llvm_component_library(LLVMWebAssemblyDesc
   WebAssemblyAsmBackend.cpp
   WebAssemblyInstPrinter.cpp
   WebAssemblyMCAsmInfo.cpp
   WebAssemblyMCCodeEmitter.cpp
   WebAssemblyMCTargetDesc.cpp
   WebAssemblyMCTypeUtilities.cpp
   WebAssemblyTargetStreamer.cpp
   WebAssemblyWasmObjectWriter.cpp
 
   LINK_COMPONENTS
+  CodeGen
   MC
   Support
   TargetParser
   WebAssemblyInfo
 
   ADD_TO_COMPONENT
   WebAssembly
   )

llvm/lib/Target/X86/MCA/CMakeLists.txt

 add_llvm_component_library(LLVMX86TargetMCA
   X86CustomBehaviour.cpp
 
   LINK_COMPONENTS
+  CodeGen
   MC
   MCA
   MCParser
   Support
   TargetParser
   X86Desc
   X86Info
 
   ADD_TO_COMPONENT
   X86
   )

llvm/lib/Target/X86/MCTargetDesc/CMakeLists.txt

add_llvm_component_library(LLVMX86Desc
   X86MnemonicTables.cpp
   X86ELFObjectWriter.cpp
   X86WinCOFFObjectWriter.cpp
   X86WinCOFFStreamer.cpp
   X86WinCOFFTargetStreamer.cpp
 
   LINK_COMPONENTS
   BinaryFormat
+  CodeGen
   MC
   MCDisassembler
   Support
   TargetParser
   X86Info
 
   ADD_TO_COMPONENT
   X86
   )

llvm/lib/Target/XCore/Disassembler/CMakeLists.txt

 add_llvm_component_library(LLVMXCoreDisassembler
   XCoreDisassembler.cpp
 
   LINK_COMPONENTS
+  CodeGen
   MC
   MCDisassembler
   Support
   XCoreInfo
 
   ADD_TO_COMPONENT
   XCore
   )

llvm/tools/llvm-dwarfutil/CMakeLists.txt

 set(LLVM_TARGET_DEFINITIONS Options.td)
 tablegen(LLVM Options.inc -gen-opt-parser-defs)
 add_public_tablegen_target(DwarfutilTableGen)
 
 set(LLVM_LINK_COMPONENTS
   AllTargetsCodeGens
   AllTargetsDescs
   AllTargetsInfos
+  CodeGen
   DWARFLinker
   DebugInfoDWARF
   MC
   ObjCopy
   Object
   Option
   Support
   Target

llvm/tools/llvm-exegesis/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   AllTargetsAsmParsers
   AllTargetsCodeGens
   AllTargetsDescs
   AllTargetsDisassemblers
   AllTargetsInfos
+  CodeGen
   MC
   MCParser
   Support
   TargetParser
   )
 
 add_llvm_tool(llvm-exegesis
   DISABLE_LLVM_LINK_LLVM_DYLIB

llvm/tools/llvm-exegesis/lib/AArch64/CMakeLists.txt

 include_directories(
   ${LLVM_MAIN_SRC_DIR}/lib/Target/AArch64
   ${LLVM_BINARY_DIR}/lib/Target/AArch64
   )
 
 set(LLVM_LINK_COMPONENTS
   AArch64
+  CodeGen
   Core
   Exegesis
   MC
   Support
   )
 
 add_llvm_library(LLVMExegesisAArch64
   DISABLE_LLVM_LINK_LLVM_DYLIB
   STATIC
   Target.cpp
 
   DEPENDS
   intrinsics_gen
   AArch64CommonTableGen
   )

llvm/tools/llvm-exegesis/lib/Mips/CMakeLists.txt

 include_directories(
   ${LLVM_MAIN_SRC_DIR}/lib/Target/Mips
   ${LLVM_BINARY_DIR}/lib/Target/Mips
   )
 
 set(LLVM_LINK_COMPONENTS
+  CodeGen
   Core
   Exegesis
   MC
   Mips
   Support
   TargetParser
   )
 

llvm/tools/llvm-exegesis/lib/PowerPC/CMakeLists.txt

 include_directories(
   ${LLVM_MAIN_SRC_DIR}/lib/Target/PowerPC
   ${LLVM_BINARY_DIR}/lib/Target/PowerPC
   )
 
 set(LLVM_LINK_COMPONENTS
+  CodeGen
   Core
   Exegesis
   MC
   PowerPC
   Support
   TargetParser
   )
 

llvm/unittests/DebugInfo/DWARF/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   ${LLVM_TARGETS_TO_BUILD}
   AsmPrinter
   BinaryFormat
+  CodeGen
   DebugInfoDWARF
   MC
   Object
   ObjectYAML
   Support
   TargetParser
   )
 

llvm/unittests/Support/MVTTest.cpp

 //===- llvm/unittest/Support/MVTTest.cpp - Test compatibility -------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Make sure the generated version of MachineValueType.h to be equivalent to
-// the constant version of llvm/Support/MachineValueType.h.
+// the constant version of llvm/CodeGen/MachineValueType.h.
 //
 //===----------------------------------------------------------------------===//
 
 #include "MachineValueType.h"
-#include "llvm/Support/MachineValueType.h"
+#include "llvm/CodeGen/MachineValueType.h"
 #include "gtest/gtest.h"
 #include <limits>
 #include <string>
 
 using namespace llvm;
 
 namespace {
 

llvm/utils/TableGen/CMakeLists.txt

add_tablegen(llvm-min-tblgen LLVM_HEADERS
   RISCVTargetDefEmitter.cpp
   SDNodeProperties.cpp
   TableGen.cpp
   VTEmitter.cpp
   PARTIAL_SOURCES_INTENDED
   )
 set_target_properties(llvm-min-tblgen PROPERTIES FOLDER "Tablegenning")
 
+set(LLVM_LINK_COMPONENTS
+  CodeGen
+  Support
+  )
+
 add_tablegen(llvm-tblgen LLVM
   DESTINATION "${LLVM_TOOLS_INSTALL_DIR}"
   EXPORT LLVM
   AsmMatcherEmitter.cpp
   AsmWriterEmitter.cpp
   AsmWriterInst.cpp
   CTagsEmitter.cpp
   CallingConvEmitter.cpp

llvm/utils/TableGen/GlobalISel/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
+  CodeGen
   Support
   TableGen
   )
 
 add_llvm_library(LLVMTableGenGlobalISel STATIC DISABLE_LLVM_LINK_LLVM_DYLIB
                  CodeExpander.cpp
                  GIMatchDag.cpp
                  GIMatchDagEdge.cpp

utils/bazel/llvm-project-overlay/llvm/BUILD.bazel

hdrs = glob([
         # `utils/TableGen` with the `strip_includes_prefix` of this library.
         # This mixture appears to be incompatible with header modules.
         "utils/TableGen/GlobalISel/*.h",
     ]),
     copts = llvm_copts,
     features = ["-header_modules"],
     strip_include_prefix = "utils/TableGen",
     deps = [
+        ":CodeGen",
         ":Support",
         ":TableGen",
         ":config",
     ],
 )
 
 cc_library(
     name = "llvm-tblgen-headers",
srcs = glob([
         # Some tablegen sources include headers from MC, so these have to be
         # listed here. MC uses headers produced by tablegen, so it cannot be a
         # regular dependency.
         "include/llvm/MC/*.h",
     ]),
     copts = llvm_copts,
     stamp = 0,
     deps = [
+        ":CodeGen",
         ":Support",
         ":TableGen",
         ":TableGenGlobalISel",
         ":config",
         ":llvm-tblgen-headers",
     ],
 )
 
[cc_library(
         srcs = glob([
             "lib/Target/" + target["name"] + "/MCA/*.cpp",
             "lib/Target/" + target["name"] + "/MCA/*.c",
             "lib/Target/" + target["name"] + "/MCA/*.h",
         ]),
         copts = llvm_copts,
         features = ["-layering_check"],
         deps = [
+            ":CodeGen",
             ":MC",
             ":MCA",
             ":MCParser",
             ":Support",
             ":" + target["name"] + "DisassemblerInternalHeaders",
             ":" + target["name"] + "Info",
             ":" + target["name"] + "UtilsAndDesc",
         ],
srcs = glob([
         "tools/llvm-dwarfutil/*.cpp",
         "tools/llvm-dwarfutil/*.h",
     ]),
     copts = llvm_copts,
     stamp = 0,
     deps = [
         ":AllTargetsAsmParsers",
         ":AllTargetsCodeGens",
+        ":CodeGen",
         ":DWARFLinker",
         ":DebugInfoDWARF",
         ":DwarfutilOptionsTableGen",
         ":MC",
         ":ObjCopy",
         ":Object",
         ":Option",
         ":Support",
srcs = [
         "tools/llvm-exegesis/llvm-exegesis.cpp",
     ],
     copts = llvm_copts,
     stamp = 0,
     deps = [
         ":AllTargetsAsmParsers",
         ":AllTargetsCodeGens",
         ":AllTargetsDisassemblers",
+        ":CodeGen",
         ":Exegesis",
         ":MC",
         ":MCParser",
         ":Object",
         ":Support",
         ":TargetParser",
         ":config",
     ],