ValueTypes.h Source File (original) (raw)

15#ifndef LLVM_CODEGEN_VALUETYPES_H

16#define LLVM_CODEGEN_VALUETYPES_H

22#include

23#include

24#include

26namespace llvm {

28 class LLVMContext;

30 struct fltSemantics;

36 private:

38 Type *LLVMTy = nullptr;

40 public:

41 constexpr EVT() = default;

43 constexpr EVT(MVT S) : V(S) {}

46 return !(*this != VT);

47 }

49 if (V.SimpleTy != VT.V.SimpleTy)

50 return true;

52 return LLVMTy != VT.LLVMTy;

53 return false;

54 }

61 }

68 return M;

69 return getExtendedIntegerVT(Context, BitWidth);

70 }

75 bool IsScalable = false) {

78 return M;

79 return getExtendedVectorVT(Context, VT, NumElements, IsScalable);

80 }

87 return M;

88 return getExtendedVectorVT(Context, VT, EC);

89 }

97 return changeExtendedVectorElementTypeToInteger();

98 }

100

101

105 "Can't change simple vector VT to have extended element VT");

107 }

108 return changeExtendedVectorElementType(EltVT);

109 }

110

111

112

116 }

117

118

119

120

124

127 return changeExtendedTypeToInteger();

128 }

129

130

131

134 }

135

136

139 }

140

141

144 }

145

146

148 return isSimple() ? V.isFloatingPoint() : isExtendedFloatingPoint();

149 }

150

151

153 return isSimple() ? V.isInteger() : isExtendedInteger();

154 }

155

156

158 return isSimple() ? V.isScalarInteger() : isExtendedScalarInteger();

159 }

160

161

162

164 return isSimple() && V.isScalableTargetExtVT();

165 }

166

167

169 return isSimple() ? V.isVector() : isExtendedVector();

170 }

171

172

173

175 return isSimple() ? V.isScalableVector() : isExtendedScalableVector();

176 }

177

178

180

182 return isSimple() ? V.isFixedLengthVector()

183 : isExtendedFixedLengthVector();

184 }

185

186

189 }

190

191

193 return isSimple() ? V.is16BitVector() : isExtended16BitVector();

194 }

195

196

198 return isSimple() ? V.is32BitVector() : isExtended32BitVector();

199 }

200

201

203 return isSimple() ? V.is64BitVector() : isExtended64BitVector();

204 }

205

206

208 return isSimple() ? V.is128BitVector() : isExtended128BitVector();

209 }

210

211

213 return isSimple() ? V.is256BitVector() : isExtended256BitVector();

214 }

215

216

218 return isSimple() ? V.is512BitVector() : isExtended512BitVector();

219 }

220

221

223 return isSimple() ? V.is1024BitVector() : isExtended1024BitVector();

224 }

225

226

228 return isSimple() ? V.is2048BitVector() : isExtended2048BitVector();

229 }

230

231

233 return (V == MVT::iAny || V == MVT::fAny || V == MVT::vAny ||

234 V == MVT::pAny);

235 }

236

237

240 }

241

242

245 return false;

247 return BitSize >= 8 && !(BitSize & (BitSize - 1));

248 }

249

250

252 if (EVT::operator==(VT)) return true;

254 }

255

256

259 }

260

261

262

265 }

266

267

270 }

271

272

273

276 }

277

278

280 if (EVT::operator==(VT)) return false;

282 "Comparison between scalable and fixed types");

284 }

285

286

288 if (EVT::operator==(VT)) return true;

290 "Comparison between scalable and fixed types");

292 }

293

294

296 if (EVT::operator==(VT)) return false;

298 "Comparison between scalable and fixed types");

300 }

301

302

304 if (EVT::operator==(VT)) return true;

306 "Comparison between scalable and fixed types");

308 }

309

310

313 return V;

314 }

315

316

317

320 }

321

322

326 return V.getVectorElementType();

327 return getExtendedVectorElementType();

328 }

329

330

333

336 "Possible incorrect use of EVT::getVectorNumElements() for "

337 "scalable vector. Scalable flag may be dropped, use "

338 "EVT::getVectorElementCount() instead");

339

340 return isSimple() ? V.getVectorNumElements()

341 : getExtendedVectorNumElements();

342 }

343

344

348 return V.getVectorElementCount();

349

350 return getExtendedVectorElementCount();

351 }

352

353

356 }

357

358

360 return V.getRISCVVectorTupleNumFields();

361 }

362

363

364

365

366

367

370 return V.getSizeInBits();

371 return getExtendedSizeInBits();

372 }

373

374

375

378 }

379

382 }

383

384

385

386

387

388

389

393 }

394

395

396

399 }

400

401

402

403

404

405

406

409 }

410

411

412

413

418 return EVT(MVT::i8);

420 }

421

422

423

424

428 for (unsigned IntVT = MVT::FIRST_INTEGER_VALUETYPE;

429 IntVT <= MVT::LAST_INTEGER_VALUETYPE; ++IntVT) {

432 return HalfVT;

433 }

434 return getIntegerVT(Context, (EVTSize + 1) / 2);

435 }

436

437

438

443 }

444

445

446

447

451 assert(EltCnt.isKnownEven() && "Splitting vector, but not in half!");

452 return EVT::getVectorVT(Context, EltVT, EltCnt.divideCoefficientBy(2));

453 }

454

455

456

457

462 }

463

464

467 return !(NElts & (NElts - 1));

468 }

469

470

471

478 }

479 else {

480 return *this;

481 }

482 }

483

484

486

487

488 void dump() const;

489

490

493 }

494

495

496

497

499

500

501

502

503

504

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

506

509 return V.SimpleTy;

510 else

511 return (intptr_t)(LLVMTy);

512 }

513

514

515

518 if (L.V.SimpleTy == R.V.SimpleTy)

519 return L.LLVMTy < R.LLVMTy;

520 else

521 return L.V.SimpleTy < R.V.SimpleTy;

522 }

523 };

524

525

526

528

529 private:

530

531

532

533 EVT changeExtendedTypeToInteger() const;

534 EVT changeExtendedVectorElementType(EVT EltVT) const;

535 EVT changeExtendedVectorElementTypeToInteger() const;

537 static EVT getExtendedVectorVT(LLVMContext &C, EVT VT, unsigned NumElements,

538 bool IsScalable);

555 EVT getExtendedVectorElementType() const;

559 };

560

562 V.print(OS);

563 return OS;

564 }

565}

566

567#endif

assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())

static constexpr ElementCount get(ScalarTy MinVal, bool Scalable)

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

static MVT getFloatingPointVT(unsigned BitWidth)

@ INVALID_SIMPLE_VALUE_TYPE

MVT changeVectorElementType(MVT EltVT) const

Return a VT for a vector type whose attributes match ourselves with the exception of the element type...

MVT changeTypeToInteger()

Return the type converted to an equivalently sized integer or vector with integer element type.

static MVT getVectorVT(MVT VT, unsigned NumElements)

static MVT getIntegerVT(unsigned BitWidth)

MVT changeVectorElementTypeToInteger() const

Return a vector with the same number of elements as this vector, but with the element type converted ...

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

constexpr bool isKnownMultipleOf(ScalarTy RHS) const

This function tells the caller whether the element count is known at compile time to be a multiple of...

constexpr ScalarTy getFixedValue() const

static constexpr bool isKnownLE(const FixedOrScalableQuantity &LHS, const FixedOrScalableQuantity &RHS)

static constexpr bool isKnownLT(const FixedOrScalableQuantity &LHS, const FixedOrScalableQuantity &RHS)

constexpr bool isScalable() const

Returns whether the quantity is scaled by a runtime quantity (vscale).

constexpr ScalarTy getKnownMinValue() const

Returns the minimum value this quantity can represent.

constexpr bool isZero() const

static constexpr bool isKnownGT(const FixedOrScalableQuantity &LHS, const FixedOrScalableQuantity &RHS)

static constexpr bool isKnownGE(const FixedOrScalableQuantity &LHS, const FixedOrScalableQuantity &RHS)

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

@ C

The default llvm calling convention, compatible with C.

This is an optimization pass for GlobalISel generic memory operations.

unsigned Log2_32_Ceil(uint32_t Value)

Return the ceil log base 2 of the specified value, 32 if the value is zero.

T bit_ceil(T Value)

Returns the smallest integral power of two no smaller than Value if Value is nonzero.

void reportInvalidSizeRequest(const char *Msg)

Reports a diagnostic message to indicate an invalid size request has been done on a scalable vector.

constexpr unsigned BitWidth

A meaningless but well-behaved order, useful for constructing containers.

bool operator()(EVT L, EVT R) const

EVT changeVectorElementTypeToInteger() const

Return a vector with the same number of elements as this vector, but with the element type converted ...

TypeSize getStoreSize() const

Return the number of bytes overwritten by a store of the specified value type.

EVT getPow2VectorType(LLVMContext &Context) const

Widens the length of the given vector EVT up to the nearest power of 2 and returns that type.

bool isSimple() const

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

constexpr EVT(MVT::SimpleValueType SVT)

intptr_t getRawBits() const

bool knownBitsLE(EVT VT) const

Return true if we know at compile time this has fewer than or the same bits as VT.

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.

EVT changeTypeToInteger() const

Return the type converted to an equivalently sized integer or vector with integer element type.

uint64_t getScalarStoreSize() const

bool isOverloaded() const

Return true if this is an overloaded type for TableGen.

bool bitsGT(EVT VT) const

Return true if this has more bits than VT.

bool bitsLT(EVT VT) const

Return true if this has less bits than VT.

bool isFloatingPoint() const

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

ElementCount getVectorElementCount() const

EVT getDoubleNumVectorElementsVT(LLVMContext &Context) const

bool is32BitVector() const

Return true if this is a 32-bit vector type.

TypeSize getSizeInBits() const

Return the size of the specified value type in bits.

bool isByteSized() const

Return true if the bit size is a multiple of 8.

EVT changeElementType(EVT EltVT) const

Return a VT for a type whose attributes match ourselves with the exception of the element type that i...

bool is1024BitVector() const

Return true if this is a 1024-bit vector type.

bool knownBitsGT(EVT VT) const

Return true if we know at compile time this has more bits than VT.

unsigned getVectorMinNumElements() const

Given a vector type, return the minimum number of elements it contains.

unsigned getRISCVVectorTupleNumFields() const

Given a RISCV vector tuple type, return the num_fields.

uint64_t getScalarSizeInBits() const

EVT getHalfSizedIntegerVT(LLVMContext &Context) const

Finds the smallest simple value type that is greater than or equal to half the width of this EVT.

bool isPow2VectorType() const

Returns true if the given vector is a power of 2.

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

Return the value type corresponding to the specified type.

TypeSize getStoreSizeInBits() const

Return the number of bits overwritten by a store of the specified value type.

MVT getSimpleVT() const

Return the SimpleValueType held in the specified simple EVT.

void dump() const

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

bool is128BitVector() const

Return true if this is a 128-bit vector type.

static EVT getIntegerVT(LLVMContext &Context, unsigned BitWidth)

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

bool is2048BitVector() const

Return true if this is a 2048-bit vector type.

bool isRISCVVectorTuple() const

Return true if this is a vector value type.

uint64_t getFixedSizeInBits() const

Return the size of the specified fixed width value type in bits.

EVT widenIntegerVectorElementType(LLVMContext &Context) const

Return a VT for an integer vector type with the size of the elements doubled.

bool knownBitsLT(EVT VT) const

Return true if we know at compile time this has fewer bits than VT.

bool isScalableVT() const

Return true if the type is a scalable type.

bool is512BitVector() const

Return true if this is a 512-bit vector type.

bool isFixedLengthVector() const

std::string getEVTString() const

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

static EVT getFloatingPointVT(unsigned BitWidth)

Returns the EVT that represents a floating-point type with the given number of bits.

bool operator!=(EVT VT) const

EVT getRoundIntegerType(LLVMContext &Context) const

Rounds the bit-width of the given integer EVT up to the nearest power of two (and at least to eight),...

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.

bool is16BitVector() const

Return true if this is a 16-bit vector type.

bool bitsGE(EVT VT) const

Return true if this has no less bits than VT.

bool is256BitVector() const

Return true if this is a 256-bit vector type.

bool bitsEq(EVT VT) const

Return true if this has the same number of bits as VT.

Type * getTypeForEVT(LLVMContext &Context) const

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

bool isRound() const

Return true if the size is a power-of-two number of bytes.

static EVT getVectorVT(LLVMContext &Context, EVT VT, ElementCount EC)

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

bool isScalableVector() const

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

bool knownBitsGE(EVT VT) const

Return true if we know at compile time this has more than or the same bits as VT.

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<<.

bool isScalableTargetExtVT() const

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

bool isScalarInteger() const

Return true if this is an integer, but not a vector.

EVT changeVectorElementType(EVT EltVT) const

Return a VT for a vector type whose attributes match ourselves with the exception of the element type...

const fltSemantics & getFltSemantics() const

Returns an APFloat semantics tag appropriate for the value type.

unsigned getVectorNumElements() const

Given a vector type, return the number of elements it contains.

bool operator==(EVT VT) const

bool isZeroSized() const

Test if the given EVT has zero size, this will fail if called on a scalable type.

bool bitsLE(EVT VT) const

Return true if this has no more bits than VT.

EVT getHalfNumVectorElementsVT(LLVMContext &Context) const

bool isInteger() const

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

bool is64BitVector() const

Return true if this is a 64-bit vector type.