[GlobalISel] Split LowLevelType to a fundamental type in libSupport.

[ab]

Summary

This is an attempt at splitting LLT into a libSupport component, usable from tblgen, as discussed in D30046.

It's somewhat awkward (and ends up including MVT, which also should have been in libSupport), but it's the best solution I found so far.

WDYT?

[dsanders]

I've been trying to preserve the current style of LLT usage but having seen this I realize there's no need to do that.

I think we should make llvm::getLLT() a member of Type (see example usage below and https://reviews.llvm.org/differential/diff/88897/) but aside from that and a couple nits I think this seems like a reasonable way to fix the layering problem.

I'm inclined to leave the MVT issue as-is since that's at least a header-only class.

include/llvm/CodeGen/LowLevelType.h

24–27

LLVMContext, and raw_ostream aren't needed anymore.

lib/Target/AArch64/AArch64CallLowering.cpp

195

For example:

SplitTy->getLLT(DL)

[rovka]

In D30047#679944, @dsanders wrote:

I've been trying to preserve the current style of LLT usage but having seen this I realize there's no need to do that.

I think we should make llvm::getLLT() a member of Type (see example usage below and https://reviews.llvm.org/differential/diff/88897/) but aside from that and a couple nits I think this seems like a reasonable way to fix the layering problem.

Not sure if this has been decided yet or not, but here's my 2 cents anyway:

I find it a bit weird to have IR level types know about low level types, we usually have it the other way around (e.g. EVT::getTypeForEVT). I prefer a standalone method as defined here, but OTOH having a LowLevelTypes.h in both CodeGen and Support might be confusing. How about we move it to GlobalISel/Utils.h? Or think of a different name for it (FWIW clang uses CodeGenTypes.h for the correspondence between AST types and LLVM types).

[dsanders]

In D30047#682181, @rovka wrote:

In D30047#679944, @dsanders wrote:

I've been trying to preserve the current style of LLT usage but having seen this I realize there's no need to do that.

I think we should make llvm::getLLT() a member of Type (see example usage below and https://reviews.llvm.org/differential/diff/88897/) but aside from that and a couple nits I think this seems like a reasonable way to fix the layering problem.

Not sure if this has been decided yet or not, but here's my 2 cents anyway:

I don't think we've reached a conclusion yet.

I find it a bit weird to have IR level types know about low level types, we usually have it the other way around (e.g. EVT::getTypeForEVT).

EVT can do it that way around because libLLVMCodeGen depends on libLLVMCore. If we move LLT to libLLVMSupport then we can't depend on Type from libLLVMCore (because libLLVMCore depends on libLLVMSupport). We could declare the function in libLLVMSupport and implement it in libLLVMCodeGen but I'm not sure that's an improvement on just having tablegen include the header from libLLVMCodeGen.

I prefer a standalone method as defined here, but OTOH having a LowLevelTypes.h in both CodeGen and Support might be confusing. How about we move it to GlobalISel/Utils.h? Or think of a different name for it (FWIW clang uses CodeGenTypes.h for the correspondence between AST types and LLVM types).

Ok, let's go with the standalone method. I'd like to give it a more descriptive name though seeing as it's in the llvm namespace. How about getLLTForType()?

For the header name, I agree with not having LowLevelTypes.h in both libraries. Let's go with GlobalISel/Utils.h.

[rovka]

In D30047#682820, @dsanders wrote:

Ok, let's go with the standalone method. I'd like to give it a more descriptive name though seeing as it's in the llvm namespace. How about getLLTForType()?

For the header name, I agree with not having LowLevelTypes.h in both libraries. Let's go with GlobalISel/Utils.h.

That sounds good to me. @ab, what do you think?

[ab]

In D30047#683232, @rovka wrote:

In D30047#682820, @dsanders wrote:

Ok, let's go with the standalone method. I'd like to give it a more descriptive name though seeing as it's in the llvm namespace. How about getLLTForType()?

getLLTForType SGTM

For the header name, I agree with not having LowLevelTypes.h in both libraries. Let's go with GlobalISel/Utils.h.

That sounds good to me. @ab, what do you think?

Yeah, using the same name is weird, but here's the rationale: almost every single user of LLT should use CodeGen/LowLevelTypes.h; for them, that's the way to use LLT. But I guess that illusion breaks down pretty quickly when they find the header almost completely empty... Maybe we can rename Support/LowLevelTypes.h Support/LowLevelTypeImpl.h or something? Not that it sounds much better ;)

But specifically regarding Utils.h: I'm not a big fan of catch-all headers; maybe we can keep it single-purpose and call it CodeGen/LowLevelTypeUtils.h, or CodeGen/CodeGenLowLevelTypes.h, or something like that?

Not a big deal either way; if we don't have a better idea I'll stick to Utils.h.

[dsanders]

Unfortunately, this approach introduces a circular dependency when LLVM_ENABLE_MODULES=1. The failure was in http://lab.llvm.org:8011/builders/clang-x86_64-linux-selfhost-modules-2/builds/4942 and was caused by the following dependency loop:

LLVM_Utils -> LLVM_CodeGen_MachineValueType -> LLVM_Utils

To write it another way, we have these dependencies:

• TableGen -> Support
• CodeGen -> Support
• Support -> CodeGen

I can see two ways forward:

• We use the original version of D30046 (https://reviews.llvm.org/D30046?id=88737) so that we continue to have the following dependencies:
  • TableGen -> Support
  • TableGen -> CodeGen
  • CodeGen -> Support
• We also move the MVT type to Support so we remove the TableGen->CodeGen dependency and are left with:
  • TableGen -> Support
  • CodeGen -> Support

Which would you prefer?

[ab]

In D30047#688544, @dsanders wrote:

Unfortunately, this approach introduces a circular dependency when LLVM_ENABLE_MODULES=1. The failure was in http://lab.llvm.org:8011/builders/clang-x86_64-linux-selfhost-modules-2/builds/4942 and was caused by the following dependency loop:

LLVM_Utils -> LLVM_CodeGen_MachineValueType -> LLVM_Utils

Oh boy..

To write it another way, we have these dependencies:

• TableGen -> Support
• CodeGen -> Support
• Support -> CodeGen

None of these are new, right? Looking at the log, none of the failures are related to LLT.

I can see two ways forward:

• We use the original version of D30046 (https://reviews.llvm.org/D30046?id=88737) so that we continue to have the following dependencies:
  • TableGen -> Support
  • TableGen -> CodeGen
  • CodeGen -> Support
• We also move the MVT type to Support so we remove the TableGen->CodeGen dependency and are left with:
  • TableGen -> Support
  • CodeGen -> Support

How about a lazy variant of this: move MVT to the Utils module, without changing its path on disk. It's already in its own special little module anyway.

Honestly, I'd love for us to finally tackle MVT, but right in the middle of branches is going to add a lot of merge pain..

[dsanders]

In D30047#689257, @ab wrote:

In D30047#688544, @dsanders wrote:

Unfortunately, this approach introduces a circular dependency when LLVM_ENABLE_MODULES=1. The failure was in http://lab.llvm.org:8011/builders/clang-x86_64-linux-selfhost-modules-2/builds/4942 and was caused by the following dependency loop:

LLVM_Utils -> LLVM_CodeGen_MachineValueType -> LLVM_Utils

Oh boy..

To write it another way, we have these dependencies:

• TableGen -> Support
• CodeGen -> Support
• Support -> CodeGen

None of these are new, right?

Support -> CodeGen is new. It's the include of MachineValueType.h in LowLevelTypeImpl.h that introduces it.

Before this patch the dependencies were:

• TableGen -> Support
• TableGen -> CodeGen
• CodeGen -> Support

and this patch changed 'TableGen -> CodeGen' into 'TableGen -> Support -> CodeGen'.

Looking at the log, none of the failures are related to LLT.

LLT is mentioned in the 'While building ...' lines:

While building module 'LLVM_Utils' imported from /home/buildbot/modules-slave-2/clang-x86_64-linux-selfhost-modules-2/llvm.src/lib/TableGen/StringMatcher.cpp:14:
While building module 'LLVM_CodeGen_MachineValueType' imported from /home/buildbot/modules-slave-2/clang-x86_64-linux-selfhost-modules-2/llvm.src/include/llvm/Support/LowLevelTypeImpl.h:32:
In file included from <module-includes>:1:
/home/buildbot/modules-slave-2/clang-x86_64-linux-selfhost-modules-2/llvm.src/include/llvm/CodeGen/MachineValueType.h:18:10: fatal error: cyclic dependency in module 'LLVM_Utils': LLVM_Utils -> LLVM_CodeGen_MachineValueType -> LLVM_Utils

I can see two ways forward:

• We use the original version of D30046 (https://reviews.llvm.org/D30046?id=88737) so that we continue to have the following dependencies:
  • TableGen -> Support
  • TableGen -> CodeGen
  • CodeGen -> Support
• We also move the MVT type to Support so we remove the TableGen->CodeGen dependency and are left with:
  • TableGen -> Support
  • CodeGen -> Support

How about a lazy variant of this: move MVT to the Utils module, without changing its path on disk. It's already in its own special little module anyway.

I'll give it a go. I'll also try removing the MVT dependency since the relevant constructor isn't used very often as far as I can tell. We might be able to switch it for something like getLLTForType().

[ab]

Ah, you're right, I completely forgot about the MVT ctor. Yeah, it's probably better to add a getLLTForMVT() in the CodeGen header.

[ab]

By the way, I think you kept the commit message of the original patch in r296474. It's somewhat confusing; I don't even remember what it meant ;)

[dsanders]

In D30047#690852, @ab wrote:

Ah, you're right, I completely forgot about the MVT ctor. Yeah, it's probably better to add a getLLTForMVT() in the CodeGen header.

I've ended up going with the modulemap approach since TableGen's MVTToLLT() should eventually use that constructor.

In D30047#690854, @ab wrote:

By the way, I think you kept the commit message of the original patch in r296474. It's somewhat confusing; I don't even remember what it meant ;)

MVTToLLT() used to convert MVT's into strings containing calls to the LLT constructor. It now converts MVT's into LLTCodeGen objects which know how to build that string from an LLT and also allows tablegen to inspect the LLT.

[ab]

Daniel committed this in rL297177.

include/llvm/CodeGen/LowLevelType.h

-//== llvm/CodeGen/GlobalISel/LowLevelType.h -------------------- -*- C++ -*-==//
+//== llvm/CodeGen/LowLevelType.h ------------------------------- -*- C++ -*-==//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 /// 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.
+/// This provides the CodeGen aspects of LowLevelType, such as Type conversion.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_CODEGEN_GLOBALISEL_LOWLEVELTYPE_H
-#define LLVM_CODEGEN_GLOBALISEL_LOWLEVELTYPE_H
+#ifndef LLVM_CODEGEN_LOWLEVELTYPE_H
+#define LLVM_CODEGEN_LOWLEVELTYPE_H
 
-#include <cassert>
-#include "llvm/ADT/DenseMapInfo.h"
-#include "llvm/CodeGen/ValueTypes.h"
+#include "llvm/Support/LowLevelType.h"
 
 namespace llvm {
 
 class DataLayout;
 class LLVMContext;
 class Type;
 class raw_ostream;
 
-class LLT {
-public:
-  enum TypeKind : uint16_t {
-    Invalid,
-    Scalar,
-    Pointer,
-    Vector,
-  };
-
-  /// Get a low-level scalar or aggregate "bag of bits".
-  static LLT scalar(unsigned SizeInBits) {
-    assert(SizeInBits > 0 && "invalid scalar size");
-    return LLT{Scalar, 1, SizeInBits};
-  }
-
-  /// Get a low-level pointer in the given address space (defaulting to 0).
-  static LLT pointer(uint16_t AddressSpace, unsigned SizeInBits) {
-    return LLT{Pointer, AddressSpace, SizeInBits};
-  }
-
-  /// Get a low-level vector of some number of elements and element width.
-  /// \p NumElements must be at least 2.
-  static LLT vector(uint16_t NumElements, unsigned ScalarSizeInBits) {
-    assert(NumElements > 1 && "invalid number of vector elements");
-    return LLT{Vector, NumElements, ScalarSizeInBits};
-  }
-
-  /// Get a low-level vector of some number of elements and element type.
-  static LLT vector(uint16_t NumElements, LLT ScalarTy) {
-    assert(NumElements > 1 && "invalid number of vector elements");
-    assert(ScalarTy.isScalar() && "invalid vector element type");
-    return LLT{Vector, NumElements, ScalarTy.getSizeInBits()};
-  }
-
-  explicit LLT(TypeKind Kind, uint16_t NumElements, unsigned SizeInBits)
-    : SizeInBits(SizeInBits), ElementsOrAddrSpace(NumElements), Kind(Kind) {
-    assert((Kind != Vector || ElementsOrAddrSpace > 1) &&
-           "invalid number of vector elements");
-  }
-
-  explicit LLT() : SizeInBits(0), ElementsOrAddrSpace(0), Kind(Invalid) {}
-
-  /// Construct a low-level type based on an LLVM type.
-  explicit LLT(Type &Ty, const DataLayout &DL);
-
-  explicit LLT(MVT VT);
-
-  bool isValid() const { return Kind != Invalid; }
-
-  bool isScalar() const { return Kind == Scalar; }
-
-  bool isPointer() const { return Kind == Pointer; }
-
-  bool isVector() const { return Kind == Vector; }
-
-  /// Returns the number of elements in a vector LLT. Must only be called on
-  /// vector types.
-  uint16_t getNumElements() const {
-    assert(isVector() && "cannot get number of elements on scalar/aggregate");
-    return ElementsOrAddrSpace;
-  }
-
-  /// Returns the total size of the type. Must only be called on sized types.
-  unsigned getSizeInBits() const {
-    if (isPointer() || isScalar())
-      return SizeInBits;
-    return SizeInBits * ElementsOrAddrSpace;
-  }
-
-  unsigned getScalarSizeInBits() const {
-    return SizeInBits;
-  }
-
-  unsigned getAddressSpace() const {
-    assert(isPointer() && "cannot get address space of non-pointer type");
-    return ElementsOrAddrSpace;
-  }
-
-  /// Returns the vector's element type. Only valid for vector types.
-  LLT getElementType() const {
-    assert(isVector() && "cannot get element type of scalar/aggregate");
-    return scalar(SizeInBits);
-  }
-
-  /// Get a low-level type with half the size of the original, by halving the
-  /// size of the scalar type involved. For example `s32` will become `s16`,
-  /// `<2 x s32>` will become `<2 x s16>`.
-  LLT halfScalarSize() const {
-    assert(!isPointer() && getScalarSizeInBits() > 1 &&
-           getScalarSizeInBits() % 2 == 0 && "cannot half size of this type");
-    return LLT{Kind, ElementsOrAddrSpace, SizeInBits / 2};
-  }
-
-  /// Get a low-level type with twice the size of the original, by doubling the
-  /// size of the scalar type involved. For example `s32` will become `s64`,
-  /// `<2 x s32>` will become `<2 x s64>`.
-  LLT doubleScalarSize() const {
-    assert(!isPointer() && "cannot change size of this type");
-    return LLT{Kind, ElementsOrAddrSpace, SizeInBits * 2};
-  }
-
-  /// Get a low-level type with half the size of the original, by halving the
-  /// number of vector elements of the scalar type involved. The source must be
-  /// a vector type with an even number of elements. For example `<4 x s32>`
-  /// will become `<2 x s32>`, `<2 x s32>` will become `s32`.
-  LLT halfElements() const {
-    assert(isVector() && ElementsOrAddrSpace % 2 == 0 &&
-           "cannot half odd vector");
-    if (ElementsOrAddrSpace == 2)
-      return scalar(SizeInBits);
-
-    return LLT{Vector, static_cast<uint16_t>(ElementsOrAddrSpace / 2),
-               SizeInBits};
-  }
-
-  /// Get a low-level type with twice the size of the original, by doubling the
-  /// number of vector elements of the scalar type involved. The source must be
-  /// a vector type. For example `<2 x s32>` will become `<4 x s32>`. Doubling
-  /// the number of elements in sN produces <2 x sN>.
-  LLT doubleElements() const {
-    assert(!isPointer() && "cannot double elements in pointer");
-    return LLT{Vector, static_cast<uint16_t>(ElementsOrAddrSpace * 2),
-               SizeInBits};
-  }
-
-  void print(raw_ostream &OS) const;
-
-  bool operator==(const LLT &RHS) const {
-    return Kind == RHS.Kind && SizeInBits == RHS.SizeInBits &&
-           ElementsOrAddrSpace == RHS.ElementsOrAddrSpace;
-  }
-
-  bool operator!=(const LLT &RHS) const { return !(*this == RHS); }
-
-  friend struct DenseMapInfo<LLT>;
-private:
-  unsigned SizeInBits;
-  uint16_t ElementsOrAddrSpace;
-  TypeKind Kind;
-};
-
-inline raw_ostream& operator<<(raw_ostream &OS, const LLT &Ty) {
-  Ty.print(OS);
-  return OS;
-}
-
-template<> struct DenseMapInfo<LLT> {
-  static inline LLT getEmptyKey() {
-    return LLT{LLT::Invalid, 0, -1u};
-  }
-  static inline LLT getTombstoneKey() {
-    return LLT{LLT::Invalid, 0, -2u};
-  }
-  static inline unsigned getHashValue(const LLT &Ty) {
-    uint64_t Val = ((uint64_t)Ty.SizeInBits << 32) |
-                   ((uint64_t)Ty.ElementsOrAddrSpace << 16) | (uint64_t)Ty.Kind;
-    return DenseMapInfo<uint64_t>::getHashValue(Val);
-  }
-  static bool isEqual(const LLT &LHS, const LLT &RHS) {
-    return LHS == RHS;
-  }
-};
+LLT getLLT(Type &Ty, const DataLayout &DL);
 
 }
 
 #endif

include/llvm/Support/LowLevelType.h

-//== llvm/CodeGen/GlobalISel/LowLevelType.h -------------------- -*- C++ -*-==//
+//== llvm/Support/LowLevelType.h ------------------------------- -*- C++ -*-==//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //

 ///    * `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_GLOBALISEL_LOWLEVELTYPE_H
-#define LLVM_CODEGEN_GLOBALISEL_LOWLEVELTYPE_H
+#ifndef LLVM_SUPPORT_LOWLEVELTYPE_H
+#define LLVM_SUPPORT_LOWLEVELTYPE_H
 
 #include <cassert>
 #include "llvm/ADT/DenseMapInfo.h"
-#include "llvm/CodeGen/ValueTypes.h"
+#include "llvm/CodeGen/MachineValueType.h"
 
 namespace llvm {
 
 class DataLayout;
-class LLVMContext;
 class Type;
 class raw_ostream;
 
 class LLT {
 public:
   enum TypeKind : uint16_t {
     Invalid,
     Scalar,
public:
   explicit LLT(TypeKind Kind, uint16_t NumElements, unsigned SizeInBits)
     : SizeInBits(SizeInBits), ElementsOrAddrSpace(NumElements), Kind(Kind) {
     assert((Kind != Vector || ElementsOrAddrSpace > 1) &&
            "invalid number of vector elements");
   }
 
   explicit LLT() : SizeInBits(0), ElementsOrAddrSpace(0), Kind(Invalid) {}
 
-  /// Construct a low-level type based on an LLVM type.
-  explicit LLT(Type &Ty, const DataLayout &DL);
-
   explicit LLT(MVT VT);
 
   bool isValid() const { return Kind != Invalid; }
 
   bool isScalar() const { return Kind == Scalar; }
 
   bool isPointer() const { return Kind == Pointer; }
 

lib/CodeGen/GlobalISel/IRTranslator.cpp

unsigned IRTranslator::getOrCreateVReg(const Value &Val) {
 
   if (ValReg)
     return ValReg;
 
   // Fill ValRegsSequence with the sequence of registers
   // we need to concat together to produce the value.
   assert(Val.getType()->isSized() &&
          "Don't know how to create an empty vreg");
-  unsigned VReg = MRI->createGenericVirtualRegister(LLT{*Val.getType(), *DL});
+  unsigned VReg =
+      MRI->createGenericVirtualRegister(getLLT(*Val.getType(), *DL));
   ValReg = VReg;
 
   if (auto CV = dyn_cast<Constant>(&Val)) {
     bool Success = translate(*CV, VReg);
     if (!Success) {
       if (!TPC->isGlobalISelAbortEnabled()) {
         MF->getProperties().set(
             MachineFunctionProperties::Property::FailedISel);
bool IRTranslator::translateSwitch(const User &U,
   // At first sight, it seems most of the logic in there is independent of
   // SelectionDAG-specifics and a lot of work went in to optimize switch
   // lowering in there.
 
   const SwitchInst &SwInst = cast<SwitchInst>(U);
   const unsigned SwCondValue = getOrCreateVReg(*SwInst.getCondition());
   const BasicBlock *OrigBB = SwInst.getParent();
 
-  LLT LLTi1 = LLT(*Type::getInt1Ty(U.getContext()), *DL);
+  LLT LLTi1 = getLLT(*Type::getInt1Ty(U.getContext()), *DL);
   for (auto &CaseIt : SwInst.cases()) {
     const unsigned CaseValueReg = getOrCreateVReg(*CaseIt.getCaseValue());
     const unsigned Tst = MRI->createGenericVirtualRegister(LLTi1);
     MIRBuilder.buildICmp(CmpInst::ICMP_EQ, Tst, CaseValueReg, SwCondValue);
     MachineBasicBlock &CurMBB = MIRBuilder.getMBB();
     const BasicBlock *TrueBB = CaseIt.getCaseSuccessor();
     MachineBasicBlock &TrueMBB = getOrCreateBB(*TrueBB);
 
bool IRTranslator::translateLoad(const User &U, MachineIRBuilder &MIRBuilder) {
   const LoadInst &LI = cast<LoadInst>(U);
 
   auto Flags = LI.isVolatile() ? MachineMemOperand::MOVolatile
                                : MachineMemOperand::MONone;
   Flags |= MachineMemOperand::MOLoad;
 
   unsigned Res = getOrCreateVReg(LI);
   unsigned Addr = getOrCreateVReg(*LI.getPointerOperand());
-  LLT VTy{*LI.getType(), *DL}, PTy{*LI.getPointerOperand()->getType(), *DL};
+
   MIRBuilder.buildLoad(
       Res, Addr,
       *MF->getMachineMemOperand(MachinePointerInfo(LI.getPointerOperand()),
                                 Flags, DL->getTypeStoreSize(LI.getType()),
                                 getMemOpAlignment(LI), AAMDNodes(), nullptr,
                                 LI.getSynchScope(), LI.getOrdering()));
   return true;
 }
 
 bool IRTranslator::translateStore(const User &U, MachineIRBuilder &MIRBuilder) {
   const StoreInst &SI = cast<StoreInst>(U);
   auto Flags = SI.isVolatile() ? MachineMemOperand::MOVolatile
                                : MachineMemOperand::MONone;
   Flags |= MachineMemOperand::MOStore;
 
   unsigned Val = getOrCreateVReg(*SI.getValueOperand());
   unsigned Addr = getOrCreateVReg(*SI.getPointerOperand());
-  LLT VTy{*SI.getValueOperand()->getType(), *DL},
-      PTy{*SI.getPointerOperand()->getType(), *DL};
 
   MIRBuilder.buildStore(
       Val, Addr,
       *MF->getMachineMemOperand(
           MachinePointerInfo(SI.getPointerOperand()), Flags,
           DL->getTypeStoreSize(SI.getValueOperand()->getType()),
           getMemOpAlignment(SI), AAMDNodes(), nullptr, SI.getSynchScope(),
           SI.getOrdering()));
bool IRTranslator::translateSelect(const User &U,
   MIRBuilder.buildSelect(getOrCreateVReg(U), getOrCreateVReg(*U.getOperand(0)),
                          getOrCreateVReg(*U.getOperand(1)),
                          getOrCreateVReg(*U.getOperand(2)));
   return true;
 }
 
 bool IRTranslator::translateBitCast(const User &U,
                                     MachineIRBuilder &MIRBuilder) {
-  if (LLT{*U.getOperand(0)->getType(), *DL} == LLT{*U.getType(), *DL}) {
+  if (getLLT(*U.getOperand(0)->getType(), *DL) == getLLT(*U.getType(), *DL)) {
     unsigned &Reg = ValToVReg[&U];
     if (Reg)
       MIRBuilder.buildCopy(Reg, getOrCreateVReg(*U.getOperand(0)));
     else
       Reg = getOrCreateVReg(*U.getOperand(0));
     return true;
   }
   return translateCast(TargetOpcode::G_BITCAST, U, MIRBuilder);

 bool IRTranslator::translateGetElementPtr(const User &U,
                                           MachineIRBuilder &MIRBuilder) {
   // FIXME: support vector GEPs.
   if (U.getType()->isVectorTy())
     return false;
 
   Value &Op0 = *U.getOperand(0);
   unsigned BaseReg = getOrCreateVReg(Op0);
-  LLT PtrTy{*Op0.getType(), *DL};
+  LLT PtrTy = getLLT(*Op0.getType(), *DL);
   unsigned PtrSize = DL->getPointerSizeInBits(PtrTy.getAddressSpace());
   LLT OffsetTy = LLT::scalar(PtrSize);
 
   int64_t Offset = 0;
   for (gep_type_iterator GTI = gep_type_begin(&U), E = gep_type_end(&U);
        GTI != E; ++GTI) {
     const Value *Idx = GTI.getOperand();
     if (StructType *StTy = GTI.getStructTypeOrNull()) {
bool IRTranslator::translateGetElementPtr(const User &U,
 
   MIRBuilder.buildCopy(getOrCreateVReg(U), BaseReg);
   return true;
 }
 
 bool IRTranslator::translateMemfunc(const CallInst &CI,
                                     MachineIRBuilder &MIRBuilder,
                                     unsigned ID) {
-  LLT SizeTy{*CI.getArgOperand(2)->getType(), *DL};
+  LLT SizeTy = getLLT(*CI.getArgOperand(2)->getType(), *DL);
   Type *DstTy = CI.getArgOperand(0)->getType();
   if (cast<PointerType>(DstTy)->getAddressSpace() != 0 ||
       SizeTy.getSizeInBits() != DL->getPointerSizeInBits(0))
     return false;
 
   SmallVector<CallLowering::ArgInfo, 8> Args;
   for (int i = 0; i < 3; ++i) {
     const auto &Arg = CI.getArgOperand(i);
void IRTranslator::getStackGuard(unsigned DstReg,
   *MemRefs =
       MF->getMachineMemOperand(MPInfo, Flags, DL->getPointerSizeInBits() / 8,
                                DL->getPointerABIAlignment());
   MIB.setMemRefs(MemRefs, MemRefs + 1);
 }
 
 bool IRTranslator::translateOverflowIntrinsic(const CallInst &CI, unsigned Op,
                                               MachineIRBuilder &MIRBuilder) {
-  LLT Ty{*CI.getOperand(0)->getType(), *DL};
+  LLT Ty = getLLT(*CI.getOperand(0)->getType(), *DL);
   LLT s1 = LLT::scalar(1);
   unsigned Width = Ty.getSizeInBits();
   unsigned Res = MRI->createGenericVirtualRegister(Ty);
   unsigned Overflow = MRI->createGenericVirtualRegister(s1);
   auto MIB = MIRBuilder.buildInstr(Op)
                  .addDef(Res)
                  .addDef(Overflow)
                  .addUse(getOrCreateVReg(*CI.getOperand(0)))
case Intrinsic::objectsize: {
 
     MIRBuilder.buildConstant(getOrCreateVReg(CI), Min->isZero() ? -1ULL : 0);
     return true;
   }
   case Intrinsic::stackguard:
     getStackGuard(getOrCreateVReg(CI), MIRBuilder);
     return true;
   case Intrinsic::stackprotector: {
-    LLT PtrTy{*CI.getArgOperand(0)->getType(), *DL};
+    LLT PtrTy = getLLT(*CI.getArgOperand(0)->getType(), *DL);
     unsigned GuardVal = MRI->createGenericVirtualRegister(PtrTy);
     getStackGuard(GuardVal, MIRBuilder);
 
     AllocaInst *Slot = cast<AllocaInst>(CI.getArgOperand(1));
     MIRBuilder.buildStore(
         GuardVal, getOrCreateVReg(*Slot),
         *MF->getMachineMemOperand(
             MachinePointerInfo::getFixedStack(*MF,
bool IRTranslator::translateLandingPad(const User &U,
 
   // Add a label to mark the beginning of the landing pad.  Deletion of the
   // landing pad can thus be detected via the MachineModuleInfo.
   MIRBuilder.buildInstr(TargetOpcode::EH_LABEL)
     .addSym(MF->addLandingPad(&MBB));
 
   SmallVector<LLT, 2> Tys;
   for (Type *Ty : cast<StructType>(LP.getType())->elements())
-    Tys.push_back(LLT{*Ty, *DL});
+    Tys.push_back(getLLT(*Ty, *DL));
   assert(Tys.size() == 2 && "Only two-valued landingpads are supported");
 
   // Mark exception register as live in.
   SmallVector<unsigned, 2> Regs;
   SmallVector<uint64_t, 2> Offsets;
   if (unsigned Reg = TLI.getExceptionPointerRegister(PersonalityFn)) {
     MBB.addLiveIn(Reg);
     unsigned VReg = MRI->createGenericVirtualRegister(Tys[0]);
if (MRI->getType(NumElts) != IntPtrTy) {
     NumElts = ExtElts;
   }
 
   unsigned AllocSize = MRI->createGenericVirtualRegister(IntPtrTy);
   unsigned TySize = MRI->createGenericVirtualRegister(IntPtrTy);
   MIRBuilder.buildConstant(TySize, -DL->getTypeAllocSize(Ty));
   MIRBuilder.buildMul(AllocSize, NumElts, TySize);
 
-  LLT PtrTy = LLT{*AI.getType(), *DL};
+  LLT PtrTy = getLLT(*AI.getType(), *DL);
   auto &TLI = *MF->getSubtarget().getTargetLowering();
   unsigned SPReg = TLI.getStackPointerRegisterToSaveRestore();
 
   unsigned SPTmp = MRI->createGenericVirtualRegister(PtrTy);
   MIRBuilder.buildCopy(SPTmp, SPReg);
 
   unsigned AllocTmp = MRI->createGenericVirtualRegister(PtrTy);
   MIRBuilder.buildGEP(AllocTmp, SPTmp, AllocSize);

lib/CodeGen/LowLevelType.cpp

-//===-- llvm/CodeGen/GlobalISel/LowLevelType.cpp --------------------------===//
+//===-- llvm/CodeGen/LowLevelType.cpp -------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 /// \file This file implements the more header-heavy bits of the LLT class to
 /// avoid polluting users' namespaces.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/CodeGen/LowLevelType.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/Support/raw_ostream.h"
 using namespace llvm;
 
-LLT::LLT(Type &Ty, const DataLayout &DL) {
+LLT llvm::getLLT(Type &Ty, const DataLayout &DL) {
   if (auto VTy = dyn_cast<VectorType>(&Ty)) {
-    SizeInBits = VTy->getElementType()->getPrimitiveSizeInBits();
-    ElementsOrAddrSpace = VTy->getNumElements();
-    Kind = ElementsOrAddrSpace == 1 ? Scalar : Vector;
+    auto NumElements = VTy->getNumElements();
+    auto ScalarSizeInBits = VTy->getElementType()->getPrimitiveSizeInBits();
+    if (NumElements == 1)
+      return LLT::scalar(ScalarSizeInBits);
+    return LLT::vector(NumElements, ScalarSizeInBits);
   } else if (auto PTy = dyn_cast<PointerType>(&Ty)) {
-    Kind = Pointer;
-    SizeInBits = DL.getTypeSizeInBits(&Ty);
-    ElementsOrAddrSpace = PTy->getAddressSpace();
+    return LLT::pointer(PTy->getAddressSpace(), DL.getTypeSizeInBits(&Ty));
   } else if (Ty.isSized()) {
     // Aggregates are no different from real scalars as far as GlobalISel is
     // concerned.
-    Kind = Scalar;
-    SizeInBits = DL.getTypeSizeInBits(&Ty);
-    ElementsOrAddrSpace = 1;
+    auto SizeInBits = DL.getTypeSizeInBits(&Ty);
     assert(SizeInBits != 0 && "invalid zero-sized type");
-  } else {
-    Kind = Invalid;
-    SizeInBits = ElementsOrAddrSpace = 0;
+    return LLT::scalar(SizeInBits);
   }
-}
-
-LLT::LLT(MVT VT) {
-  if (VT.isVector()) {
-    SizeInBits = VT.getVectorElementType().getSizeInBits();
-    ElementsOrAddrSpace = VT.getVectorNumElements();
-    Kind = ElementsOrAddrSpace == 1 ? Scalar : Vector;
-  } else if (VT.isValid()) {
-    // Aggregates are no different from real scalars as far as GlobalISel is
-    // concerned.
-    Kind = Scalar;
-    SizeInBits = VT.getSizeInBits();
-    ElementsOrAddrSpace = 1;
-    assert(SizeInBits != 0 && "invalid zero-sized type");
-  } else {
-    Kind = Invalid;
-    SizeInBits = ElementsOrAddrSpace = 0;
-  }
-}
-
-void LLT::print(raw_ostream &OS) const {
-  if (isVector())
-    OS << "<" << ElementsOrAddrSpace << " x s" << SizeInBits << ">";
-  else if (isPointer())
-    OS << "p" << getAddressSpace();
-  else if (isValid()) {
-    assert(isScalar() && "unexpected type");
-    OS << "s" << getScalarSizeInBits();
-  } else
-    llvm_unreachable("trying to print an invalid type");
+  return LLT();
 }

lib/Support/CMakeLists.txt

add_llvm_library(LLVMSupport
   Hashing.cpp
   IntEqClasses.cpp
   IntervalMap.cpp
   JamCRC.cpp
   LEB128.cpp
   LineIterator.cpp
   Locale.cpp
   LockFileManager.cpp
+  LowLevelType.cpp
   ManagedStatic.cpp
   MathExtras.cpp
   MemoryBuffer.cpp
   MD5.cpp
   NativeFormatting.cpp
   Options.cpp
   PluginLoader.cpp
   PrettyStackTrace.cpp

lib/Support/LowLevelType.cpp

-//===-- llvm/CodeGen/GlobalISel/LowLevelType.cpp --------------------------===//
+//===-- llvm/Support/LowLevelType.cpp -------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 /// \file This file implements the more header-heavy bits of the LLT class to
 /// avoid polluting users' namespaces.
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/CodeGen/LowLevelType.h"
-#include "llvm/IR/DataLayout.h"
-#include "llvm/IR/DerivedTypes.h"
+#include "llvm/Support/LowLevelType.h"
 #include "llvm/Support/raw_ostream.h"
 using namespace llvm;
 
-LLT::LLT(Type &Ty, const DataLayout &DL) {
-  if (auto VTy = dyn_cast<VectorType>(&Ty)) {
-    SizeInBits = VTy->getElementType()->getPrimitiveSizeInBits();
-    ElementsOrAddrSpace = VTy->getNumElements();
-    Kind = ElementsOrAddrSpace == 1 ? Scalar : Vector;
-  } else if (auto PTy = dyn_cast<PointerType>(&Ty)) {
-    Kind = Pointer;
-    SizeInBits = DL.getTypeSizeInBits(&Ty);
-    ElementsOrAddrSpace = PTy->getAddressSpace();
-  } else if (Ty.isSized()) {
-    // Aggregates are no different from real scalars as far as GlobalISel is
-    // concerned.
-    Kind = Scalar;
-    SizeInBits = DL.getTypeSizeInBits(&Ty);
-    ElementsOrAddrSpace = 1;
-    assert(SizeInBits != 0 && "invalid zero-sized type");
-  } else {
-    Kind = Invalid;
-    SizeInBits = ElementsOrAddrSpace = 0;
-  }
-}
-
 LLT::LLT(MVT VT) {
   if (VT.isVector()) {
     SizeInBits = VT.getVectorElementType().getSizeInBits();
     ElementsOrAddrSpace = VT.getVectorNumElements();
     Kind = ElementsOrAddrSpace == 1 ? Scalar : Vector;
   } else if (VT.isValid()) {
     // Aggregates are no different from real scalars as far as GlobalISel is
     // concerned.

lib/Target/AArch64/AArch64CallLowering.cpp

if (SplitVTs.size() == 1) {
     return;
   }
 
   unsigned FirstRegIdx = SplitArgs.size();
   for (auto SplitVT : SplitVTs) {
     // FIXME: set split flags if they're actually used (e.g. i128 on AAPCS).
     Type *SplitTy = SplitVT.getTypeForEVT(Ctx);
     SplitArgs.push_back(
-        ArgInfo{MRI.createGenericVirtualRegister(LLT{*SplitTy, DL}), SplitTy,
+        ArgInfo{MRI.createGenericVirtualRegister(getLLT(*SplitTy, DL)), SplitTy,
                 OrigArg.Flags, OrigArg.IsFixed});
   }
 
   SmallVector<uint64_t, 4> BitOffsets;
   for (auto Offset : Offsets)
     BitOffsets.push_back(Offset * 8);
 
   SmallVector<unsigned, 8> SplitRegs;

lib/Target/X86/X86CallLowering.cpp

void X86CallLowering::splitToValueTypes(const ArgInfo &OrigArg,
 
   SmallVector<uint64_t, 4> BitOffsets;
   SmallVector<unsigned, 8> SplitRegs;
 
   EVT PartVT = TLI.getRegisterType(Context, VT);
   Type *PartTy = PartVT.getTypeForEVT(Context);
 
   for (unsigned i = 0; i < NumParts; ++i) {
-    ArgInfo Info = ArgInfo{MRI.createGenericVirtualRegister(LLT{*PartTy, DL}),
-                           PartTy, OrigArg.Flags};
+    ArgInfo Info =
+        ArgInfo{MRI.createGenericVirtualRegister(getLLT(*PartTy, DL)), PartTy,
+                OrigArg.Flags};
     SplitArgs.push_back(Info);
     BitOffsets.push_back(PartVT.getSizeInBits() * i);
     SplitRegs.push_back(Info.Reg);
   }
 
   PerformArgSplit(SplitRegs, BitOffsets);
 }