ValueTypes.cpp Source File (original) (raw)

18using namespace llvm;

20EVT EVT::changeExtendedTypeToInteger() const {

22 LLVMContext &Context = LLVMTy->getContext();

24}

26EVT EVT::changeExtendedVectorElementTypeToInteger() const {

28 LLVMContext &Context = LLVMTy->getContext();

31}

33EVT EVT::changeExtendedVectorElementType(EVT EltVT) const {

35 LLVMContext &Context = LLVMTy->getContext();

37}

43 return VT;

44}

47 bool IsScalable) {

48 EVT ResultVT;

49 ResultVT.LLVMTy =

52 return ResultVT;

53}

56 EVT ResultVT;

59 return ResultVT;

60}

62bool EVT::isExtendedFloatingPoint() const {

64 return LLVMTy->isFPOrFPVectorTy();

65}

67bool EVT::isExtendedInteger() const {

69 return LLVMTy->isIntOrIntVectorTy();

70}

72bool EVT::isExtendedScalarInteger() const {

74 return LLVMTy->isIntegerTy();

75}

77bool EVT::isExtendedVector() const {

79 return LLVMTy->isVectorTy();

80}

82bool EVT::isExtended16BitVector() const {

83 return isExtendedVector() &&

85}

87bool EVT::isExtended32BitVector() const {

88 return isExtendedVector() &&

90}

92bool EVT::isExtended64BitVector() const {

93 return isExtendedVector() &&

95}

97bool EVT::isExtended128BitVector() const {

98 return isExtendedVector() &&

100}

101

102bool EVT::isExtended256BitVector() const {

103 return isExtendedVector() &&

105}

106

107bool EVT::isExtended512BitVector() const {

108 return isExtendedVector() &&

110}

111

112bool EVT::isExtended1024BitVector() const {

113 return isExtendedVector() &&

115}

116

117bool EVT::isExtended2048BitVector() const {

118 return isExtendedVector() &&

120}

121

122bool EVT::isExtendedFixedLengthVector() const {

124}

125

126bool EVT::isExtendedScalableVector() const {

128}

129

130EVT EVT::getExtendedVectorElementType() const {

133}

134

135unsigned EVT::getExtendedVectorNumElements() const {

138 if (EC.isScalable()) {

140 << "The code that requested the fixed number of elements has made the "

141 "assumption that this vector is not scalable. This assumption was "

142 "not correct, and this may lead to broken code\n";

143 }

144 return EC.getKnownMinValue();

145}

146

147ElementCount EVT::getExtendedVectorElementCount() const {

150}

151

152TypeSize EVT::getExtendedSizeInBits() const {

157 return VTy->getPrimitiveSizeInBits();

159}

160

161

163 switch (V.SimpleTy) {

164 default:

168 unsigned MinNumElts = Sz / (NF * 8);

169 return "riscv_nxv" + utostr(MinNumElts) + "i8x" + utostr(NF);

170 }

182 case MVT::bf16: return "bf16";

183 case MVT::ppcf128: return "ppcf128";

184 case MVT::isVoid: return "isVoid";

185 case MVT::Other: return "ch";

186 case MVT::Glue: return "glue";

187 case MVT::x86mmx: return "x86mmx";

188 case MVT::x86amx: return "x86amx";

189 case MVT::i64x8: return "i64x8";

190 case MVT::Metadata: return "Metadata";

191 case MVT::Untyped: return "Untyped";

192 case MVT::funcref: return "funcref";

193 case MVT::exnref: return "exnref";

194 case MVT::externref: return "externref";

195 case MVT::aarch64svcount:

196 return "aarch64svcount";

197 case MVT::spirvbuiltin:

198 return "spirvbuiltin";

199 case MVT::amdgpuBufferFatPointer:

200 return "amdgpuBufferFatPointer";

201 case MVT::amdgpuBufferStridedPointer:

202 return "amdgpuBufferStridedPointer";

203 case MVT::aarch64mfp8:

204 return "aarch64mfp8";

205 }

206}

207

208#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)

213#endif

214

215

216

217

219

220 switch (V.SimpleTy) {

221 default:

223 return LLVMTy;

226 case MVT::aarch64svcount:

228 case MVT::aarch64mfp8:

232 case MVT::amdgpuBufferFatPointer: return IntegerType::get(Context, 160);

233 case MVT::amdgpuBufferStridedPointer: return IntegerType::get(Context, 192);

237#define GET_VT_EVT(Ty, EVT) case MVT::Ty: return EVT;

238#include "llvm/CodeGen/GenVT.inc"

239#undef GET_VT_EVT

240 }

241

242}

243

244

245

246

247

248

250 assert(Ty != nullptr && "Invalid type");

251 switch (Ty->getTypeID()) {

252 default:

253 if (HandleUnknown) return MVT(MVT::Other);

256 return MVT::isVoid;

264 return MVT(MVT::f80);

267 if (TargetExtTy->getName() == "aarch64.svcount")

268 return MVT(MVT::aarch64svcount);

270 return MVT(MVT::spirvbuiltin);

271 if (TargetExtTy->getName() == "riscv.vector.tuple") {

273 ->getMinNumElements() *

274 8;

276

278 }

279 if (HandleUnknown)

280 return MVT(MVT::Other);

282 }

292 }

293 }

294}

295

296

297

298

299

300

302 switch (Ty->getTypeID()) {

303 default:

304 return MVT::getVT(Ty, HandleUnknown);

306 return MVT::Untyped;

315 }

316 }

317}

318

331

335

336#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)

341#endif

342

345 OS << "invalid";

346 else

348}

assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")

This file declares a class to represent arbitrary precision floating point values and provide a varie...

static unsigned getBitWidth(Type *Ty, const DataLayout &DL)

Returns the bitwidth of the given scalar or pointer type.

static const fltSemantics & IEEEsingle()

static const fltSemantics & BFloat()

static const fltSemantics & IEEEquad()

static const fltSemantics & IEEEdouble()

static const fltSemantics & x87DoubleExtended()

static const fltSemantics & IEEEhalf()

static const fltSemantics & PPCDoubleDouble()

static LLVM_ABI FixedVectorType * get(Type *ElementType, unsigned NumElts)

static LLVM_ABI IntegerType * get(LLVMContext &C, unsigned NumBits)

This static method is the primary way of constructing an IntegerType.

This is an important class for using LLVM in a threaded context.

LLVM_ABI void dump() const

Support for debugging, callable in GDB: VT.dump()

Definition ValueTypes.cpp:337

@ INVALID_SIMPLE_VALUE_TYPE

static MVT getRISCVVectorTupleVT(unsigned Sz, unsigned NFields)

static LLVM_ABI MVT getVT(Type *Ty, bool HandleUnknown=false)

Return the value type corresponding to the specified type.

Definition ValueTypes.cpp:249

LLVM_ABI const fltSemantics & getFltSemantics() const

Returns an APFloat semantics tag appropriate for the value type.

Definition ValueTypes.cpp:319

static MVT getVectorVT(MVT VT, unsigned NumElements)

static MVT getIntegerVT(unsigned BitWidth)

MVT getScalarType() const

If this is a vector, return the element type, otherwise return this.

LLVM_ABI void print(raw_ostream &OS) const

Implement operator<<.

Definition ValueTypes.cpp:343

bool starts_with(StringRef Prefix) const

Check if this string starts with the given Prefix.

Class to represent target extensions types, which are generally unintrospectable from target-independ...

static LLVM_ABI TargetExtType * get(LLVMContext &Context, StringRef Name, ArrayRef< Type * > Types={}, ArrayRef< unsigned > Ints={})

Return a target extension type having the specified name and optional type and integer parameters.

Type * getTypeParameter(unsigned i) const

unsigned getIntParameter(unsigned i) const

StringRef getName() const

Return the name for this target extension type.

static constexpr TypeSize getFixed(ScalarTy ExactSize)

The instances of the Type class are immutable: once they are created, they are never changed.

static LLVM_ABI Type * getX86_AMXTy(LLVMContext &C)

static LLVM_ABI Type * getWasm_ExternrefTy(LLVMContext &C)

static LLVM_ABI Type * getMetadataTy(LLVMContext &C)

@ X86_AMXTyID

AMX vectors (8192 bits, X86 specific)

@ HalfTyID

16-bit floating point type

@ TargetExtTyID

Target extension type.

@ VoidTyID

type with no size

@ ScalableVectorTyID

Scalable SIMD vector type.

@ FloatTyID

32-bit floating point type

@ IntegerTyID

Arbitrary bit width integers.

@ FixedVectorTyID

Fixed width SIMD vector type.

@ BFloatTyID

16-bit floating point type (7-bit significand)

@ DoubleTyID

64-bit floating point type

@ X86_FP80TyID

80-bit floating point type (X87)

@ PPC_FP128TyID

128-bit floating point type (two 64-bits, PowerPC)

@ FP128TyID

128-bit floating point type (112-bit significand)

static LLVM_ABI Type * getVoidTy(LLVMContext &C)

static LLVM_ABI Type * getWasm_FuncrefTy(LLVMContext &C)

Base class of all SIMD vector types.

ElementCount getElementCount() const

Return an ElementCount instance to represent the (possibly scalable) number of elements in the vector...

static LLVM_ABI VectorType * get(Type *ElementType, ElementCount EC)

This static method is the primary way to construct an VectorType.

Type * getElementType() const

static LLVM_ABI raw_ostream & warning()

Convenience method for printing "warning: " to stderr.

constexpr ScalarTy getKnownMinValue() const

Returns the minimum value this quantity can represent.

This class implements an extremely fast bulk output stream that can only output to a stream.

#define llvm_unreachable(msg)

Marks that the current location is not supposed to be reachable.

This is an optimization pass for GlobalISel generic memory operations.

decltype(auto) dyn_cast(const From &Val)

dyn_cast - Return the argument parameter cast to the specified type.

std::string utostr(uint64_t X, bool isNeg=false)

LLVM_ABI raw_ostream & dbgs()

dbgs() - This returns a reference to a raw_ostream for debugging messages.

bool isa(const From &Val)

isa - Return true if the parameter to the template is an instance of one of the template type argu...

constexpr unsigned BitWidth

decltype(auto) cast(const From &Val)

cast - Return the argument parameter cast to the specified type.

static EVT getVectorVT(LLVMContext &Context, EVT VT, unsigned NumElements, bool IsScalable=false)

Returns the EVT that represents a vector NumElements in length, where each element is of type VT.

bool isFloatingPoint() const

Return true if this is a FP or a vector FP type.

ElementCount getVectorElementCount() const

TypeSize getSizeInBits() const

Return the size of the specified value type in bits.

bool isCheriCapability() const

Return true if this is a capability type.

unsigned getRISCVVectorTupleNumFields() const

Given a RISCV vector tuple type, return the num_fields.

uint64_t getScalarSizeInBits() const

static LLVM_ABI EVT getEVT(Type *Ty, bool HandleUnknown=false)

Return the value type corresponding to the specified type.

Definition ValueTypes.cpp:301

MVT getSimpleVT() const

Return the SimpleValueType held in the specified simple EVT.

LLVM_ABI void dump() const

Support for debugging, callable in GDB: VT.dump()

Definition ValueTypes.cpp:209

static EVT getIntegerVT(LLVMContext &Context, unsigned BitWidth)

Returns the EVT that represents an integer with the given number of bits.

bool isRISCVVectorTuple() const

Return true if this is a vector value type.

LLVM_ABI std::string getEVTString() const

This function returns value type as a string, e.g. "i32".

Definition ValueTypes.cpp:162

bool isVector() const

Return true if this is a vector value type.

EVT getScalarType() const

If this is a vector type, return the element type, otherwise return this.

LLVM_ABI Type * getTypeForEVT(LLVMContext &Context) const

This method returns an LLVM type corresponding to the specified EVT.

Definition ValueTypes.cpp:218

bool isScalableVector() const

Return true if this is a vector type where the runtime length is machine dependent.

EVT getVectorElementType() const

Given a vector type, return the type of each element.

bool isExtended() const

Test if the given EVT is extended (as opposed to being simple).

void print(raw_ostream &OS) const

Implement operator<<.

LLVM_ABI const fltSemantics & getFltSemantics() const

Returns an APFloat semantics tag appropriate for the value type.

Definition ValueTypes.cpp:332

bool isInteger() const

Return true if this is an integer or a vector integer type.