intel/llvm
1
0
Fork 0
mirror of https://github.com/intel/llvm.git synced 2026-02-04 11:38:04 +08:00
Code Issues Packages Projects Releases Wiki Activity

Switch llvm/CodeGen/MachineValueType.h to the generated one

Browse Source 
Prune `SupportTests/MVTTest` since it is no longer needed.

Depends on D148769

Differential Revision: https://reviews.llvm.org/D148770
This commit is contained in:
NAKAMURA Takumi
2023-04-17 23:46:47 +09:00
parent 5d71ec6e44
commit 631bfdbee5
13 changed files with 104 additions and 1811 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
llvm/include/llvm/CMakeLists.txt
View File

@@ -2,6 +2,7 @@
# LLVM_HEADERS_TABLEGEN points to `llvm-min-tblgen`
set(LLVM_TABLEGEN_PROJECT LLVM_HEADERS)
add_subdirectory(CodeGen)
add_subdirectory(IR)
add_subdirectory(Support)
add_subdirectory(Frontend)

3
llvm/include/llvm/CodeGen/CMakeLists.txt Normal file
View File

@@ -0,0 +1,3 @@
set(LLVM_TARGET_DEFINITIONS ${PROJECT_SOURCE_DIR}/include/llvm/CodeGen/ValueTypes.td)
tablegen(LLVM GenVT.inc -gen-vt)
add_public_tablegen_target(vt_gen)

1211
llvm/include/llvm/CodeGen/MachineValueType.h
View File

File diff suppressed because it is too large Load Diff

1
llvm/include/llvm/module.extern.modulemap
View File

@@ -1,3 +1,4 @@
module LLVM_Extern_CodeGenTypes_Gen {}
module LLVM_Extern_Config_Def {}
module LLVM_Extern_IR_Attributes_Gen {}
module LLVM_Extern_IR_Intrinsics_Gen {}

4
llvm/include/llvm/module.install.modulemap
View File

@@ -1,4 +1,8 @@
module LLVM_Extern_CodeGenTypes_Gen {
textual header "CodeGen/GenVT.inc"
}
module LLVM_Extern_Config_Def {
textual header "Config/AsmParsers.def"
textual header "Config/AsmPrinters.def"

1
llvm/include/llvm/module.modulemap
View File

@@ -23,6 +23,7 @@ module LLVM_CodeGenTypes {
}
module MVT {
header "CodeGen/MachineValueType.h" export *
extern module LLVM_Extern_CodeGenTypes_Gen "module.extern.modulemap"
}
}

3
llvm/lib/CodeGen/CMakeLists.txt
View File

@@ -28,6 +28,9 @@ add_llvm_component_library(LLVMCodeGenTypes
LowLevelType.cpp
PARTIAL_SOURCES_INTENDED
DEPENDS
vt_gen
LINK_COMPONENTS
Support
)

6
llvm/unittests/Support/CMakeLists.txt
View File

@@ -1,7 +1,3 @@
set(LLVM_TABLEGEN_PROJECT LLVM_HEADERS)
set(LLVM_TARGET_DEFINITIONS ${PROJECT_SOURCE_DIR}/include/llvm/CodeGen/ValueTypes.td)
tablegen(LLVM GenVT.inc -gen-vt)
set(LLVM_LINK_COMPONENTS
Support
TargetParser
@@ -58,7 +54,6 @@ add_llvm_unittest(SupportTests
LockFileManagerTest.cpp
MatchersTest.cpp
MD5Test.cpp
MVTTest.cpp
ManagedStatic.cpp
MathExtrasTest.cpp
MemoryBufferRefTest.cpp
@@ -107,7 +102,6 @@ add_llvm_unittest(SupportTests
raw_pwrite_stream_test.cpp
raw_sha1_ostream_test.cpp
xxhashTest.cpp
GenVT.inc
)
target_link_libraries(SupportTests PRIVATE LLVMTestingSupport)

106
llvm/unittests/Support/MVTTest.cpp
View File

@@ -1,106 +0,0 @@
//===- 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/CodeGen/MachineValueType.h.
//
//===----------------------------------------------------------------------===//
#include "MachineValueType.h"
#include "llvm/CodeGen/MachineValueType.h"
#include "gtest/gtest.h"
#include <limits>
#include <string>
using namespace llvm;
namespace {
TEST(MVTTest, Properties) {
for (int i = 0; i <= std::numeric_limits<uint8_t>::max(); ++i) {
SCOPED_TRACE("i=" + std::to_string(i));
auto Org = MVT(MVT::SimpleValueType(i));
auto New = tmp::MVT(tmp::MVT::SimpleValueType(i));
#define MVTTEST_EXPECT_EQ_M(LHS, RHS, M) EXPECT_EQ((LHS).M(), (RHS).M())
#define MVTTEST_EXPECT_EQ_SVT(LHS, RHS) \
EXPECT_EQ(int((LHS).SimpleTy), int((RHS).SimpleTy))
#define MVTTEST_EXPECT_EQ_SVT_M(LHS, RHS, M) \
MVTTEST_EXPECT_EQ_SVT((LHS).M(), (RHS).M())
#define MVTTEST_EXPECT_EQ_SVT_F(F, ...) \
MVTTEST_EXPECT_EQ_SVT(MVT::F(__VA_ARGS__), tmp::MVT::F(__VA_ARGS__))
MVTTEST_EXPECT_EQ_M(New, Org, isValid);
MVTTEST_EXPECT_EQ_M(New, Org, isFloatingPoint);
MVTTEST_EXPECT_EQ_M(New, Org, isInteger);
MVTTEST_EXPECT_EQ_M(New, Org, isScalarInteger);
MVTTEST_EXPECT_EQ_M(New, Org, isVector);
MVTTEST_EXPECT_EQ_M(New, Org, isScalableVector);
MVTTEST_EXPECT_EQ_M(New, Org, isScalableTargetExtVT);
MVTTEST_EXPECT_EQ_M(New, Org, isScalableVT);
MVTTEST_EXPECT_EQ_M(New, Org, isFixedLengthVector);
MVTTEST_EXPECT_EQ_M(New, Org, is16BitVector);
MVTTEST_EXPECT_EQ_M(New, Org, is32BitVector);
MVTTEST_EXPECT_EQ_M(New, Org, is64BitVector);
MVTTEST_EXPECT_EQ_M(New, Org, is128BitVector);
MVTTEST_EXPECT_EQ_M(New, Org, is256BitVector);
MVTTEST_EXPECT_EQ_M(New, Org, is512BitVector);
MVTTEST_EXPECT_EQ_M(New, Org, is1024BitVector);
MVTTEST_EXPECT_EQ_M(New, Org, is2048BitVector);
MVTTEST_EXPECT_EQ_M(New, Org, isOverloaded);
if (New.isVector()) {
MVTTEST_EXPECT_EQ_SVT_M(New, Org, changeVectorElementTypeToInteger);
MVTTEST_EXPECT_EQ_SVT_M(New, Org, changeTypeToInteger);
if (New.getVectorElementCount().isKnownEven()) {
MVTTEST_EXPECT_EQ_SVT_M(New, Org, getHalfNumVectorElementsVT);
}
MVTTEST_EXPECT_EQ_M(New, Org, isPow2VectorType);
MVTTEST_EXPECT_EQ_SVT_M(New, Org, getPow2VectorType);
MVTTEST_EXPECT_EQ_SVT_M(New, Org, getVectorElementType);
MVTTEST_EXPECT_EQ_M(New, Org, getVectorMinNumElements);
MVTTEST_EXPECT_EQ_M(New, Org, getVectorElementCount);
auto n = New.getVectorMinNumElements();
auto sc = New.isScalableVector();
auto LHS = tmp::MVT::getVectorVT(New.getVectorElementType(), n, sc);
auto RHS = MVT::getVectorVT(Org.getVectorElementType(), n, sc);
MVTTEST_EXPECT_EQ_SVT(LHS, RHS);
} else if (New.isInteger()) {
auto bw = New.getSizeInBits();
MVTTEST_EXPECT_EQ_SVT_F(getIntegerVT, bw);
} else if (New.isFloatingPoint()) {
auto bw = New.getSizeInBits();
MVTTEST_EXPECT_EQ_SVT_F(getFloatingPointVT, bw);
}
MVTTEST_EXPECT_EQ_SVT_M(New, Org, getScalarType);
if (New.isValid()) {
switch (New.SimpleTy) {
case tmp::MVT::Other:
case tmp::MVT::Glue:
case tmp::MVT::isVoid:
case tmp::MVT::Untyped:
case tmp::MVT::spirvbuiltin:
break;
case tmp::MVT::aarch64svcount:
break;
default:
MVTTEST_EXPECT_EQ_M(New, Org, getSizeInBits);
MVTTEST_EXPECT_EQ_M(New, Org, getScalarSizeInBits);
MVTTEST_EXPECT_EQ_M(New, Org, getStoreSize);
MVTTEST_EXPECT_EQ_M(New, Org, getScalarStoreSize);
MVTTEST_EXPECT_EQ_M(New, Org, getStoreSizeInBits);
MVTTEST_EXPECT_EQ_M(New, Org, isByteSized);
if (!New.isScalableVector()) {
MVTTEST_EXPECT_EQ_M(New, Org, getFixedSizeInBits);
}
break;
}
}
}
}
} // namespace

553
llvm/unittests/Support/MachineValueType.h
View File

@@ -1,553 +0,0 @@
//===- 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.
//
// Constants and properties are defined in ValueTypes.td.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_TMP_MACHINEVALUETYPE_H
#define LLVM_TMP_MACHINEVALUETYPE_H
#include "llvm/ADT/Sequence.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/MathExtras.h"
#include "llvm/Support/TypeSize.h"
#include <cassert>
#include <cstdint>
namespace llvm::tmp {
class Type;
class raw_ostream;
/// Machine Value Type. Every type that is supported natively by some
/// processor targeted by LLVM occurs here. This means that any legal value
/// type can be represented by an MVT.
class MVT {
public:
enum SimpleValueType : uint8_t {
// Simple value types that aren't explicitly part of this enumeration
// are considered extended value types.
INVALID_SIMPLE_VALUE_TYPE = 0,
#define GET_VT_ATTR(Ty, n, sz, Any, Int, FP, Vec, Sc) Ty = n,
#define GET_VT_RANGES
#include "GenVT.inc"
#undef GET_VT_ATTR
#undef GET_VT_RANGES
VALUETYPE_SIZE = LAST_VALUETYPE + 1,
// This is the current maximum for LAST_VALUETYPE.
// MVT::MAX_ALLOWED_VALUETYPE is used for asserts and to size bit vectors
// This value must be a multiple of 32.
MAX_ALLOWED_VALUETYPE = 224,
};
static_assert(FIRST_VALUETYPE > 0);
static_assert(LAST_VALUETYPE < MAX_ALLOWED_VALUETYPE);
SimpleValueType SimpleTy = INVALID_SIMPLE_VALUE_TYPE;
constexpr MVT() = default;
constexpr MVT(SimpleValueType SVT) : SimpleTy(SVT) {}
bool operator>(const MVT& S) const { return SimpleTy > S.SimpleTy; }
bool operator<(const MVT& S) const { return SimpleTy < S.SimpleTy; }
bool operator==(const MVT& S) const { return SimpleTy == S.SimpleTy; }
bool operator!=(const MVT& S) const { return SimpleTy != S.SimpleTy; }
bool operator>=(const MVT& S) const { return SimpleTy >= S.SimpleTy; }
bool operator<=(const MVT& S) const { return SimpleTy <= S.SimpleTy; }
/// Support for debugging, callable in GDB: VT.dump()
void dump() const;
/// Implement operator<<.
void print(raw_ostream &OS) const;
/// Return true if this is a valid simple valuetype.
bool isValid() const {
return (SimpleTy >= MVT::FIRST_VALUETYPE &&
SimpleTy <= MVT::LAST_VALUETYPE);
}
/// Return true if this is a FP or a vector FP type.
bool isFloatingPoint() const {
return ((SimpleTy >= MVT::FIRST_FP_VALUETYPE &&
SimpleTy <= MVT::LAST_FP_VALUETYPE) ||
(SimpleTy >= MVT::FIRST_FP_FIXEDLEN_VECTOR_VALUETYPE &&
SimpleTy <= MVT::LAST_FP_FIXEDLEN_VECTOR_VALUETYPE) ||
(SimpleTy >= MVT::FIRST_FP_SCALABLE_VECTOR_VALUETYPE &&
SimpleTy <= MVT::LAST_FP_SCALABLE_VECTOR_VALUETYPE));
}
/// Return true if this is an integer or a vector integer type.
bool isInteger() const {
return ((SimpleTy >= MVT::FIRST_INTEGER_VALUETYPE &&
SimpleTy <= MVT::LAST_INTEGER_VALUETYPE) ||
(SimpleTy >= MVT::FIRST_INTEGER_FIXEDLEN_VECTOR_VALUETYPE &&
SimpleTy <= MVT::LAST_INTEGER_FIXEDLEN_VECTOR_VALUETYPE) ||
(SimpleTy >= MVT::FIRST_INTEGER_SCALABLE_VECTOR_VALUETYPE &&
SimpleTy <= MVT::LAST_INTEGER_SCALABLE_VECTOR_VALUETYPE));
}
/// Return true if this is an integer, not including vectors.
bool isScalarInteger() const {
return (SimpleTy >= MVT::FIRST_INTEGER_VALUETYPE &&
SimpleTy <= MVT::LAST_INTEGER_VALUETYPE);
}
/// Return true if this is a vector value type.
bool isVector() const {
return (SimpleTy >= MVT::FIRST_VECTOR_VALUETYPE &&
SimpleTy <= MVT::LAST_VECTOR_VALUETYPE);
}
/// Return true if this is a vector value type where the
/// runtime length is machine dependent
bool isScalableVector() const {
return (SimpleTy >= MVT::FIRST_SCALABLE_VECTOR_VALUETYPE &&
SimpleTy <= MVT::LAST_SCALABLE_VECTOR_VALUETYPE);
}
/// Return true if this is a custom target type that has a scalable size.
bool isScalableTargetExtVT() const {
return SimpleTy == MVT::aarch64svcount;
}
/// Return true if the type is a scalable type.
bool isScalableVT() const {
return isScalableVector() || isScalableTargetExtVT();
}
bool isFixedLengthVector() const {
return (SimpleTy >= MVT::FIRST_FIXEDLEN_VECTOR_VALUETYPE &&
SimpleTy <= MVT::LAST_FIXEDLEN_VECTOR_VALUETYPE);
}
/// Return true if this is a 16-bit vector type.
bool is16BitVector() const {
return (isFixedLengthVector() && getFixedSizeInBits() == 16);
}
/// Return true if this is a 32-bit vector type.
bool is32BitVector() const {
return (isFixedLengthVector() && getFixedSizeInBits() == 32);
}
/// Return true if this is a 64-bit vector type.
bool is64BitVector() const {
return (isFixedLengthVector() && getFixedSizeInBits() == 64);
}
/// Return true if this is a 128-bit vector type.
bool is128BitVector() const {
return (isFixedLengthVector() && getFixedSizeInBits() == 128);
}
/// Return true if this is a 256-bit vector type.
bool is256BitVector() const {
return (isFixedLengthVector() && getFixedSizeInBits() == 256);
}
/// Return true if this is a 512-bit vector type.
bool is512BitVector() const {
return (isFixedLengthVector() && getFixedSizeInBits() == 512);
}
/// Return true if this is a 1024-bit vector type.
bool is1024BitVector() const {
return (isFixedLengthVector() && getFixedSizeInBits() == 1024);
}
/// Return true if this is a 2048-bit vector type.
bool is2048BitVector() const {
return (isFixedLengthVector() && getFixedSizeInBits() == 2048);
}
/// Return true if this is an overloaded type for TableGen.
bool isOverloaded() const {
switch (SimpleTy) {
#define GET_VT_ATTR(Ty, n, sz, Any, Int, FP, Vec, Sc) \
case Ty: \
return Any;
#include "GenVT.inc"
#undef GET_VT_ATTR
default:
return false;
}
}
/// Return a vector with the same number of elements as this vector, but
/// with the element type converted to an integer type with the same
/// bitwidth.
MVT changeVectorElementTypeToInteger() const {
MVT EltTy = getVectorElementType();
MVT IntTy = MVT::getIntegerVT(EltTy.getSizeInBits());
MVT VecTy = MVT::getVectorVT(IntTy, getVectorElementCount());
assert(VecTy.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE &&
"Simple vector VT not representable by simple integer vector VT!");
return VecTy;
}
/// Return a VT for a vector type whose attributes match ourselves
/// with the exception of the element type that is chosen by the caller.
MVT changeVectorElementType(MVT EltVT) const {
MVT VecTy = MVT::getVectorVT(EltVT, getVectorElementCount());
assert(VecTy.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE &&
"Simple vector VT not representable by simple integer vector VT!");
return VecTy;
}
/// Return the type converted to an equivalently sized integer or vector
/// with integer element type. Similar to changeVectorElementTypeToInteger,
/// but also handles scalars.
MVT changeTypeToInteger() {
if (isVector())
return changeVectorElementTypeToInteger();
return MVT::getIntegerVT(getSizeInBits());
}
/// Return a VT for a vector type with the same element type but
/// half the number of elements.
MVT getHalfNumVectorElementsVT() const {
MVT EltVT = getVectorElementType();
auto EltCnt = getVectorElementCount();
assert(EltCnt.isKnownEven() && "Splitting vector, but not in half!");
return getVectorVT(EltVT, EltCnt.divideCoefficientBy(2));
}
// Return a VT for a vector type with the same element type but
// double the number of elements.
MVT getDoubleNumVectorElementsVT() const {
MVT EltVT = getVectorElementType();
auto EltCnt = getVectorElementCount();
return MVT::getVectorVT(EltVT, EltCnt * 2);
}
/// Returns true if the given vector is a power of 2.
bool isPow2VectorType() const {
unsigned NElts = getVectorMinNumElements();
return !(NElts & (NElts - 1));
}
/// Widens the length of the given vector MVT up to the nearest power of 2
/// and returns that type.
MVT getPow2VectorType() const {
if (isPow2VectorType())
return *this;
ElementCount NElts = getVectorElementCount();
unsigned NewMinCount = 1 << Log2_32_Ceil(NElts.getKnownMinValue());
NElts = ElementCount::get(NewMinCount, NElts.isScalable());
return MVT::getVectorVT(getVectorElementType(), NElts);
}
/// If this is a vector, return the element type, otherwise return this.
MVT getScalarType() const {
return isVector() ? getVectorElementType() : *this;
}
MVT getVectorElementType() const {
switch (SimpleTy) {
default:
llvm_unreachable("Not a vector MVT!");
#define GET_VT_VECATTR(Ty, Sc, nElem, ElTy, ElSz) \
case Ty: \
return ElTy;
#include "GenVT.inc"
#undef GET_VT_VECATTR
}
}
/// Given a vector type, return the minimum number of elements it contains.
unsigned getVectorMinNumElements() const {
switch (SimpleTy) {
default:
llvm_unreachable("Not a vector MVT!");
#define GET_VT_VECATTR(Ty, Sc, nElem, ElTy, ElSz) \
case Ty: \
return nElem;
#include "GenVT.inc"
#undef GET_VT_VECATTR
}
}
ElementCount getVectorElementCount() const {
return ElementCount::get(getVectorMinNumElements(), isScalableVector());
}
unsigned getVectorNumElements() const {
if (isScalableVector())
llvm::reportInvalidSizeRequest(
"Possible incorrect use of MVT::getVectorNumElements() for "
"scalable vector. Scalable flag may be dropped, use "
"MVT::getVectorElementCount() instead");
return getVectorMinNumElements();
}
/// Returns the size of the specified MVT in bits.
///
/// If the value type is a scalable vector type, the scalable property will
/// be set and the runtime size will be a positive integer multiple of the
/// base size.
TypeSize getSizeInBits() const {
switch (SimpleTy) {
default:
switch (SimpleTy) {
default:
llvm_unreachable("getSizeInBits called on extended MVT.");
#define GET_VT_ATTR(Ty, N, Sz, Any, Int, FP, Vec, Sc) \
case Ty: \
return (Sc ? TypeSize::Scalable(Sz) : TypeSize::Fixed(Sz));
#include "GenVT.inc"
#undef GET_VT_ATTR
}
case Other:
llvm_unreachable("Value type is non-standard value, Other.");
case iPTR:
llvm_unreachable("Value type size is target-dependent. Ask TLI.");
case iPTRAny:
case iAny:
case fAny:
case vAny:
case Any:
llvm_unreachable("Value type is overloaded.");
case token:
llvm_unreachable("Token type is a sentinel that cannot be used "
"in codegen and has no size");
case Metadata:
llvm_unreachable("Value type is metadata.");
}
}
/// Return the size of the specified fixed width value type in bits. The
/// function will assert if the type is scalable.
uint64_t getFixedSizeInBits() const {
return getSizeInBits().getFixedValue();
}
uint64_t getScalarSizeInBits() const {
return getScalarType().getSizeInBits().getFixedValue();
}
/// Return the number of bytes overwritten by a store of the specified value
/// type.
///
/// If the value type is a scalable vector type, the scalable property will
/// be set and the runtime size will be a positive integer multiple of the
/// base size.
TypeSize getStoreSize() const {
TypeSize BaseSize = getSizeInBits();
return {(BaseSize.getKnownMinValue() + 7) / 8, BaseSize.isScalable()};
}
// Return the number of bytes overwritten by a store of this value type or
// this value type's element type in the case of a vector.
uint64_t getScalarStoreSize() const {
return getScalarType().getStoreSize().getFixedValue();
}
/// Return the number of bits overwritten by a store of the specified value
/// type.
///
/// If the value type is a scalable vector type, the scalable property will
/// be set and the runtime size will be a positive integer multiple of the
/// base size.
TypeSize getStoreSizeInBits() const {
return getStoreSize() * 8;
}
/// Returns true if the number of bits for the type is a multiple of an
/// 8-bit byte.
bool isByteSized() const { return getSizeInBits().isKnownMultipleOf(8); }
/// Return true if we know at compile time this has more bits than VT.
bool knownBitsGT(MVT VT) const {
return TypeSize::isKnownGT(getSizeInBits(), VT.getSizeInBits());
}
/// Return true if we know at compile time this has more than or the same
/// bits as VT.
bool knownBitsGE(MVT VT) const {
return TypeSize::isKnownGE(getSizeInBits(), VT.getSizeInBits());
}
/// Return true if we know at compile time this has fewer bits than VT.
bool knownBitsLT(MVT VT) const {
return TypeSize::isKnownLT(getSizeInBits(), VT.getSizeInBits());
}
/// Return true if we know at compile time this has fewer than or the same
/// bits as VT.
bool knownBitsLE(MVT VT) const {
return TypeSize::isKnownLE(getSizeInBits(), VT.getSizeInBits());
}
/// Return true if this has more bits than VT.
bool bitsGT(MVT VT) const {
assert(isScalableVector() == VT.isScalableVector() &&
"Comparison between scalable and fixed types");
return knownBitsGT(VT);
}
/// Return true if this has no less bits than VT.
bool bitsGE(MVT VT) const {
assert(isScalableVector() == VT.isScalableVector() &&
"Comparison between scalable and fixed types");
return knownBitsGE(VT);
}
/// Return true if this has less bits than VT.
bool bitsLT(MVT VT) const {
assert(isScalableVector() == VT.isScalableVector() &&
"Comparison between scalable and fixed types");
return knownBitsLT(VT);
}
/// Return true if this has no more bits than VT.
bool bitsLE(MVT VT) const {
assert(isScalableVector() == VT.isScalableVector() &&
"Comparison between scalable and fixed types");
return knownBitsLE(VT);
}
static MVT getFloatingPointVT(unsigned BitWidth) {
#define GET_VT_ATTR(Ty, n, sz, Any, Int, FP, Vec, Sc) \
if (FP == 3 && sz == BitWidth) \
return Ty;
#include "GenVT.inc"
#undef GET_VT_ATTR
llvm_unreachable("Bad bit width!");
}
static MVT getIntegerVT(unsigned BitWidth) {
#define GET_VT_ATTR(Ty, n, sz, Any, Int, FP, Vec, Sc) \
if (Int == 3 && sz == BitWidth) \
return Ty;
#include "GenVT.inc"
#undef GET_VT_ATTR
return (MVT::SimpleValueType)(MVT::INVALID_SIMPLE_VALUE_TYPE);
}
static MVT getVectorVT(MVT VT, unsigned NumElements) {
#define GET_VT_VECATTR(Ty, Sc, nElem, ElTy, ElSz) \
if (!Sc && VT.SimpleTy == ElTy && NumElements == nElem) \
return Ty;
#include "GenVT.inc"
#undef GET_VT_VECATTR
return (MVT::SimpleValueType)(MVT::INVALID_SIMPLE_VALUE_TYPE);
}
static MVT getScalableVectorVT(MVT VT, unsigned NumElements) {
#define GET_VT_VECATTR(Ty, Sc, nElem, ElTy, ElSz) \
if (Sc && VT.SimpleTy == ElTy && NumElements == nElem) \
return Ty;
#include "GenVT.inc"
#undef GET_VT_VECATTR
return (MVT::SimpleValueType)(MVT::INVALID_SIMPLE_VALUE_TYPE);
}
static MVT getVectorVT(MVT VT, unsigned NumElements, bool IsScalable) {
if (IsScalable)
return getScalableVectorVT(VT, NumElements);
return getVectorVT(VT, NumElements);
}
static MVT getVectorVT(MVT VT, ElementCount EC) {
if (EC.isScalable())
return getScalableVectorVT(VT, EC.getKnownMinValue());
return getVectorVT(VT, EC.getKnownMinValue());
}
/// Return the value type corresponding to the specified type. This returns
/// all pointers as iPTR. If HandleUnknown is true, unknown types are
/// returned as Other, otherwise they are invalid.
static MVT getVT(Type *Ty, bool HandleUnknown = false);
public:
/// SimpleValueType Iteration
/// @{
static auto all_valuetypes() {
return enum_seq_inclusive(MVT::FIRST_VALUETYPE, MVT::LAST_VALUETYPE,
force_iteration_on_noniterable_enum);
}
static auto integer_valuetypes() {
return enum_seq_inclusive(MVT::FIRST_INTEGER_VALUETYPE,
MVT::LAST_INTEGER_VALUETYPE,
force_iteration_on_noniterable_enum);
}
static auto fp_valuetypes() {
return enum_seq_inclusive(MVT::FIRST_FP_VALUETYPE, MVT::LAST_FP_VALUETYPE,
force_iteration_on_noniterable_enum);
}
static auto vector_valuetypes() {
return enum_seq_inclusive(MVT::FIRST_VECTOR_VALUETYPE,
MVT::LAST_VECTOR_VALUETYPE,
force_iteration_on_noniterable_enum);
}
static auto fixedlen_vector_valuetypes() {
return enum_seq_inclusive(MVT::FIRST_FIXEDLEN_VECTOR_VALUETYPE,
MVT::LAST_FIXEDLEN_VECTOR_VALUETYPE,
force_iteration_on_noniterable_enum);
}
static auto scalable_vector_valuetypes() {
return enum_seq_inclusive(MVT::FIRST_SCALABLE_VECTOR_VALUETYPE,
MVT::LAST_SCALABLE_VECTOR_VALUETYPE,
force_iteration_on_noniterable_enum);
}
static auto integer_fixedlen_vector_valuetypes() {
return enum_seq_inclusive(MVT::FIRST_INTEGER_FIXEDLEN_VECTOR_VALUETYPE,
MVT::LAST_INTEGER_FIXEDLEN_VECTOR_VALUETYPE,
force_iteration_on_noniterable_enum);
}
static auto fp_fixedlen_vector_valuetypes() {
return enum_seq_inclusive(MVT::FIRST_FP_FIXEDLEN_VECTOR_VALUETYPE,
MVT::LAST_FP_FIXEDLEN_VECTOR_VALUETYPE,
force_iteration_on_noniterable_enum);
}
static auto integer_scalable_vector_valuetypes() {
return enum_seq_inclusive(MVT::FIRST_INTEGER_SCALABLE_VECTOR_VALUETYPE,
MVT::LAST_INTEGER_SCALABLE_VECTOR_VALUETYPE,
force_iteration_on_noniterable_enum);
}
static auto fp_scalable_vector_valuetypes() {
return enum_seq_inclusive(MVT::FIRST_FP_SCALABLE_VECTOR_VALUETYPE,
MVT::LAST_FP_SCALABLE_VECTOR_VALUETYPE,
force_iteration_on_noniterable_enum);
}
/// @}
};
inline raw_ostream &operator<<(raw_ostream &OS, const MVT &VT) {
VT.print(OS);
return OS;
}
} // namespace llvm::tmp
#endif // LLVM_TMP_MACHINEVALUETYPE_H

3
llvm/utils/TableGen/GlobalISel/CMakeLists.txt
View File

@@ -13,6 +13,9 @@ add_llvm_library(LLVMTableGenGlobalISel STATIC DISABLE_LLVM_LINK_LLVM_DYLIB
GIMatchDagPredicate.cpp
GIMatchDagPredicateDependencyEdge.cpp
GIMatchTree.cpp
DEPENDS
vt_gen
)
# Users may include its headers as "GlobalISel/*.h"

11
utils/bazel/llvm-project-overlay/llvm/BUILD.bazel
View File

@@ -674,6 +674,16 @@ gentbl(
]),
)
gentbl(
name = "vt_gen",
tbl_outs = [("-gen-vt", "include/llvm/CodeGen/GenVT.inc")],
tblgen = ":llvm-min-tblgen",
td_file = "include/llvm/CodeGen/ValueTypes.td",
td_srcs = [
"include/llvm/CodeGen/ValueTypes.td",
],
)
# Note that the intrinsics are not currently set up so they can be pruned for
# disabled targets.
llvm_target_intrinsics_list = [
@@ -1679,6 +1689,7 @@ cc_library(
copts = llvm_copts,
deps = [
":Support",
":vt_gen",
],
)

12
utils/bazel/llvm-project-overlay/llvm/unittests/BUILD.bazel
View File

@@ -557,17 +557,6 @@ gentbl(
],
)
gentbl(
name = "vt_gen",
strip_include_prefix = "Support",
tbl_outs = [("-gen-vt", "Support/GenVT.inc")],
tblgen = "//llvm:llvm-min-tblgen",
td_file = "//llvm:include/llvm/CodeGen/ValueTypes.td",
td_srcs = [
"//llvm:include/llvm/CodeGen/ValueTypes.td",
],
)
cc_test(
name = "option_tests",
size = "small",
@@ -653,7 +642,6 @@ cc_test(
"//llvm:TargetParser",
"//llvm:TestingSupport",
"//llvm:config",
":vt_gen",
"//third-party/unittest:gmock",
"//third-party/unittest:gtest",
"//third-party/unittest:gtest_main",