LLVM 22.0.0git
LoongArchISelDAGToDAG.cpp
Go to the documentation of this file.
1//=- LoongArchISelDAGToDAG.cpp - A dag to dag inst selector for LoongArch -===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file defines an instruction selector for the LoongArch target.
10//
11//===----------------------------------------------------------------------===//
12
19
20using namespace llvm;
21
22#define DEBUG_TYPE "loongarch-isel"
23#define PASS_NAME "LoongArch DAG->DAG Pattern Instruction Selection"
24
26
30 ID, std::make_unique<LoongArchDAGToDAGISel>(TM, OptLevel)) {}
31
33 false)
34
36 // If we have a custom node, we have already selected.
37 if (Node->isMachineOpcode()) {
38 LLVM_DEBUG(dbgs() << "== "; Node->dump(CurDAG); dbgs() << "\n");
39 Node->setNodeId(-1);
40 return;
41 }
42
43 // Instruction Selection not handled by the auto-generated tablegen selection
44 // should be handled here.
45 unsigned Opcode = Node->getOpcode();
46 MVT GRLenVT = Subtarget->getGRLenVT();
47 SDLoc DL(Node);
48 MVT VT = Node->getSimpleValueType(0);
49
50 switch (Opcode) {
51 default:
52 break;
53 case ISD::Constant: {
54 int64_t Imm = cast<ConstantSDNode>(Node)->getSExtValue();
55 if (Imm == 0 && VT == GRLenVT) {
56 SDValue New = CurDAG->getCopyFromReg(CurDAG->getEntryNode(), DL,
57 LoongArch::R0, GRLenVT);
58 ReplaceNode(Node, New.getNode());
59 return;
60 }
61 SDNode *Result = nullptr;
62 SDValue SrcReg = CurDAG->getRegister(LoongArch::R0, GRLenVT);
63 // The instructions in the sequence are handled here.
65 SDValue SDImm = CurDAG->getSignedTargetConstant(Inst.Imm, DL, GRLenVT);
66 switch (Inst.Opc) {
67 case LoongArch::LU12I_W:
68 Result = CurDAG->getMachineNode(Inst.Opc, DL, GRLenVT, SDImm);
69 break;
70 case LoongArch::ADDI_W:
71 case LoongArch::ORI:
72 case LoongArch::LU32I_D:
73 case LoongArch::LU52I_D:
74 Result = CurDAG->getMachineNode(Inst.Opc, DL, GRLenVT, SrcReg, SDImm);
75 break;
76 case LoongArch::BSTRINS_D:
77 Result = CurDAG->getMachineNode(
78 Inst.Opc, DL, GRLenVT,
79 {SrcReg, SrcReg,
80 CurDAG->getSignedTargetConstant(Inst.Imm >> 32, DL, GRLenVT),
81 CurDAG->getTargetConstant(Inst.Imm & 0xFF, DL, GRLenVT)});
82 break;
83 default:
84 llvm_unreachable("unexpected opcode generated by LoongArchMatInt");
85 }
86 SrcReg = SDValue(Result, 0);
87 }
88
89 ReplaceNode(Node, Result);
90 return;
91 }
92 case ISD::FrameIndex: {
93 SDValue Imm = CurDAG->getTargetConstant(0, DL, GRLenVT);
94 int FI = cast<FrameIndexSDNode>(Node)->getIndex();
95 SDValue TFI = CurDAG->getTargetFrameIndex(FI, VT);
96 unsigned ADDIOp =
97 Subtarget->is64Bit() ? LoongArch::ADDI_D : LoongArch::ADDI_W;
98 ReplaceNode(Node, CurDAG->getMachineNode(ADDIOp, DL, VT, TFI, Imm));
99 return;
100 }
101 case ISD::BITCAST: {
102 if (VT.is128BitVector() || VT.is256BitVector()) {
103 ReplaceUses(SDValue(Node, 0), Node->getOperand(0));
104 CurDAG->RemoveDeadNode(Node);
105 return;
106 }
107 break;
108 }
109 case ISD::BUILD_VECTOR: {
110 // Select appropriate [x]vrepli.[bhwd] instructions for constant splats of
111 // 128/256-bit when LSX/LASX is enabled.
112 BuildVectorSDNode *BVN = cast<BuildVectorSDNode>(Node);
113 APInt SplatValue, SplatUndef;
114 unsigned SplatBitSize;
115 bool HasAnyUndefs;
116 unsigned Op;
117 EVT ViaVecTy;
118 bool Is128Vec = BVN->getValueType(0).is128BitVector();
119 bool Is256Vec = BVN->getValueType(0).is256BitVector();
120
121 if (!Subtarget->hasExtLSX() || (!Is128Vec && !Is256Vec))
122 break;
123 if (!BVN->isConstantSplat(SplatValue, SplatUndef, SplatBitSize,
124 HasAnyUndefs, 8))
125 break;
126
127 switch (SplatBitSize) {
128 default:
129 break;
130 case 8:
131 Op = Is256Vec ? LoongArch::PseudoXVREPLI_B : LoongArch::PseudoVREPLI_B;
132 ViaVecTy = Is256Vec ? MVT::v32i8 : MVT::v16i8;
133 break;
134 case 16:
135 Op = Is256Vec ? LoongArch::PseudoXVREPLI_H : LoongArch::PseudoVREPLI_H;
136 ViaVecTy = Is256Vec ? MVT::v16i16 : MVT::v8i16;
137 break;
138 case 32:
139 Op = Is256Vec ? LoongArch::PseudoXVREPLI_W : LoongArch::PseudoVREPLI_W;
140 ViaVecTy = Is256Vec ? MVT::v8i32 : MVT::v4i32;
141 break;
142 case 64:
143 Op = Is256Vec ? LoongArch::PseudoXVREPLI_D : LoongArch::PseudoVREPLI_D;
144 ViaVecTy = Is256Vec ? MVT::v4i64 : MVT::v2i64;
145 break;
146 }
147
148 SDNode *Res;
149 // If we have a signed 10 bit integer, we can splat it directly.
150 if (SplatValue.isSignedIntN(10)) {
151 SDValue Imm = CurDAG->getTargetConstant(SplatValue, DL,
152 ViaVecTy.getVectorElementType());
153 Res = CurDAG->getMachineNode(Op, DL, ViaVecTy, Imm);
154 ReplaceNode(Node, Res);
155 return;
156 }
157 break;
158 }
159 }
160
161 // Select the default instruction.
162 SelectCode(Node);
163}
164
166 const SDValue &Op, InlineAsm::ConstraintCode ConstraintID,
167 std::vector<SDValue> &OutOps) {
168 SDValue Base = Op;
170 CurDAG->getTargetConstant(0, SDLoc(Op), Subtarget->getGRLenVT());
171 switch (ConstraintID) {
172 default:
173 llvm_unreachable("unexpected asm memory constraint");
174 // Reg+Reg addressing.
176 Base = Op.getOperand(0);
177 Offset = Op.getOperand(1);
178 break;
179 // Reg+simm12 addressing.
182 ConstantSDNode *CN = dyn_cast<ConstantSDNode>(Op.getOperand(1));
183 if (isIntN(12, CN->getSExtValue())) {
184 Base = Op.getOperand(0);
186 Op.getValueType());
187 }
188 }
189 break;
190 // Reg+0 addressing.
192 break;
193 // Reg+(simm14<<2) addressing.
196 ConstantSDNode *CN = dyn_cast<ConstantSDNode>(Op.getOperand(1));
197 if (isIntN(16, CN->getSExtValue()) &&
198 isAligned(Align(4ULL), CN->getZExtValue())) {
199 Base = Op.getOperand(0);
201 Op.getValueType());
202 }
203 }
204 break;
205 }
206 OutOps.push_back(Base);
207 OutOps.push_back(Offset);
208 return false;
209}
210
212 // If this is FrameIndex, select it directly. Otherwise just let it get
213 // selected to a register independently.
214 if (auto *FIN = dyn_cast<FrameIndexSDNode>(Addr))
215 Base =
216 CurDAG->getTargetFrameIndex(FIN->getIndex(), Subtarget->getGRLenVT());
217 else
218 Base = Addr;
219 return true;
220}
221
222// Fold constant addresses.
224 SDValue &Offset) {
225 SDLoc DL(Addr);
226 MVT VT = Addr.getSimpleValueType();
227
228 if (!isa<ConstantSDNode>(Addr))
229 return false;
230
231 // If the constant is a simm12, we can fold the whole constant and use R0 as
232 // the base.
233 int64_t CVal = cast<ConstantSDNode>(Addr)->getSExtValue();
234 if (!isInt<12>(CVal))
235 return false;
236 Base = CurDAG->getRegister(LoongArch::R0, VT);
237 Offset = CurDAG->getSignedTargetConstant(SignExtend64<12>(CVal), DL, VT);
238 return true;
239}
240
242 // If this is FrameIndex, don't select it.
243 if (isa<FrameIndexSDNode>(Addr))
244 return false;
245 Base = Addr;
246 return true;
247}
248
250 SDValue &Offset) {
251 SDLoc DL(Addr);
252 MVT VT = Addr.getSimpleValueType();
253
254 // The address is the result of an ADD. Here we only consider reg+simm12.
256 int64_t Imm = cast<ConstantSDNode>(Addr.getOperand(1))->getSExtValue();
257 if (isInt<12>(Imm)) {
258 Base = Addr.getOperand(0);
259 Offset = CurDAG->getSignedTargetConstant(SignExtend64<12>(Imm), DL, VT);
260 return true;
261 }
262 }
263
264 // Otherwise, we assume Addr as the base address and use constant 0 as the
265 // offset.
266 Base = Addr;
268 return true;
269}
270
272 SDValue &ShAmt) {
273 // Shift instructions on LoongArch only read the lower 5 or 6 bits of the
274 // shift amount. If there is an AND on the shift amount, we can bypass it if
275 // it doesn't affect any of those bits.
276 if (N.getOpcode() == ISD::AND && isa<ConstantSDNode>(N.getOperand(1))) {
277 const APInt &AndMask = N->getConstantOperandAPInt(1);
278
279 // Since the max shift amount is a power of 2 we can subtract 1 to make a
280 // mask that covers the bits needed to represent all shift amounts.
281 assert(isPowerOf2_32(ShiftWidth) && "Unexpected max shift amount!");
282 APInt ShMask(AndMask.getBitWidth(), ShiftWidth - 1);
283
284 if (ShMask.isSubsetOf(AndMask)) {
285 ShAmt = N.getOperand(0);
286 return true;
287 }
288
289 // SimplifyDemandedBits may have optimized the mask so try restoring any
290 // bits that are known zero.
291 KnownBits Known = CurDAG->computeKnownBits(N->getOperand(0));
292 if (ShMask.isSubsetOf(AndMask | Known.Zero)) {
293 ShAmt = N.getOperand(0);
294 return true;
295 }
296 } else if (N.getOpcode() == LoongArchISD::BSTRPICK) {
297 // Similar to the above AND, if there is a BSTRPICK on the shift amount, we
298 // can bypass it.
299 assert(isPowerOf2_32(ShiftWidth) && "Unexpected max shift amount!");
300 assert(isa<ConstantSDNode>(N.getOperand(1)) && "Illegal msb operand!");
301 assert(isa<ConstantSDNode>(N.getOperand(2)) && "Illegal lsb operand!");
302 uint64_t msb = N.getConstantOperandVal(1), lsb = N.getConstantOperandVal(2);
303 if (lsb == 0 && Log2_32(ShiftWidth) <= msb + 1) {
304 ShAmt = N.getOperand(0);
305 return true;
306 }
307 } else if (N.getOpcode() == ISD::SUB &&
308 isa<ConstantSDNode>(N.getOperand(0))) {
309 uint64_t Imm = N.getConstantOperandVal(0);
310 // If we are shifting by N-X where N == 0 mod Size, then just shift by -X to
311 // generate a NEG instead of a SUB of a constant.
312 if (Imm != 0 && Imm % ShiftWidth == 0) {
313 SDLoc DL(N);
314 EVT VT = N.getValueType();
315 SDValue Zero =
316 CurDAG->getCopyFromReg(CurDAG->getEntryNode(), DL, LoongArch::R0, VT);
317 unsigned NegOpc = VT == MVT::i64 ? LoongArch::SUB_D : LoongArch::SUB_W;
318 MachineSDNode *Neg =
319 CurDAG->getMachineNode(NegOpc, DL, VT, Zero, N.getOperand(1));
320 ShAmt = SDValue(Neg, 0);
321 return true;
322 }
323 }
324
325 ShAmt = N;
326 return true;
327}
328
330 if (N.getOpcode() == ISD::SIGN_EXTEND_INREG &&
331 cast<VTSDNode>(N.getOperand(1))->getVT() == MVT::i32) {
332 Val = N.getOperand(0);
333 return true;
334 }
335 if (N.getOpcode() == LoongArchISD::BSTRPICK &&
336 N.getConstantOperandVal(1) < UINT64_C(0X1F) &&
337 N.getConstantOperandVal(2) == UINT64_C(0)) {
338 Val = N;
339 return true;
340 }
341 MVT VT = N.getSimpleValueType();
342 if (CurDAG->ComputeNumSignBits(N) > (VT.getSizeInBits() - 32)) {
343 Val = N;
344 return true;
345 }
346
347 return false;
348}
349
351 if (N.getOpcode() == ISD::AND) {
352 auto *C = dyn_cast<ConstantSDNode>(N.getOperand(1));
353 if (C && C->getZExtValue() == UINT64_C(0xFFFFFFFF)) {
354 Val = N.getOperand(0);
355 return true;
356 }
357 }
358 MVT VT = N.getSimpleValueType();
360 if (CurDAG->MaskedValueIsZero(N, Mask)) {
361 Val = N;
362 return true;
363 }
364
365 return false;
366}
367
369 unsigned MinSizeInBits) const {
370 if (!Subtarget->hasExtLSX())
371 return false;
372
373 BuildVectorSDNode *Node = dyn_cast<BuildVectorSDNode>(N);
374
375 if (!Node)
376 return false;
377
378 APInt SplatValue, SplatUndef;
379 unsigned SplatBitSize;
380 bool HasAnyUndefs;
381
382 if (!Node->isConstantSplat(SplatValue, SplatUndef, SplatBitSize, HasAnyUndefs,
383 MinSizeInBits, /*IsBigEndian=*/false))
384 return false;
385
386 Imm = SplatValue;
387
388 return true;
389}
390
391template <unsigned ImmBitSize, bool IsSigned>
393 APInt ImmValue;
394 EVT EltTy = N->getValueType(0).getVectorElementType();
395
396 if (N->getOpcode() == ISD::BITCAST)
397 N = N->getOperand(0);
398
399 if (selectVSplat(N.getNode(), ImmValue, EltTy.getSizeInBits()) &&
400 ImmValue.getBitWidth() == EltTy.getSizeInBits()) {
401 if (IsSigned && ImmValue.isSignedIntN(ImmBitSize)) {
403 ImmValue.getSExtValue(), SDLoc(N), Subtarget->getGRLenVT());
404 return true;
405 }
406 if (!IsSigned && ImmValue.isIntN(ImmBitSize)) {
407 SplatVal = CurDAG->getTargetConstant(ImmValue.getZExtValue(), SDLoc(N),
408 Subtarget->getGRLenVT());
409 return true;
410 }
411 }
412
413 return false;
414}
415
417 SDValue &SplatImm) const {
418 APInt ImmValue;
419 EVT EltTy = N->getValueType(0).getVectorElementType();
420
421 if (N->getOpcode() == ISD::BITCAST)
422 N = N->getOperand(0);
423
424 if (selectVSplat(N.getNode(), ImmValue, EltTy.getSizeInBits()) &&
425 ImmValue.getBitWidth() == EltTy.getSizeInBits()) {
426 int32_t Log2 = (~ImmValue).exactLogBase2();
427
428 if (Log2 != -1) {
429 SplatImm = CurDAG->getSignedTargetConstant(Log2, SDLoc(N), EltTy);
430 return true;
431 }
432 }
433
434 return false;
435}
436
438 SDValue &SplatImm) const {
439 APInt ImmValue;
440 EVT EltTy = N->getValueType(0).getVectorElementType();
441
442 if (N->getOpcode() == ISD::BITCAST)
443 N = N->getOperand(0);
444
445 if (selectVSplat(N.getNode(), ImmValue, EltTy.getSizeInBits()) &&
446 ImmValue.getBitWidth() == EltTy.getSizeInBits()) {
447 int32_t Log2 = ImmValue.exactLogBase2();
448
449 if (Log2 != -1) {
450 SplatImm = CurDAG->getSignedTargetConstant(Log2, SDLoc(N), EltTy);
451 return true;
452 }
453 }
454
455 return false;
456}
457
458// This pass converts a legalized DAG into a LoongArch-specific DAG, ready
459// for instruction scheduling.
461 CodeGenOptLevel OptLevel) {
462 return new LoongArchDAGToDAGISelLegacy(TM, OptLevel);
463}
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
AMDGPU Register Bank Select
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
uint64_t Addr
#define DEBUG_TYPE
#define INITIALIZE_PASS(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:56
#define LLVM_DEBUG(...)
Definition: Debug.h:119
#define PASS_NAME
DEMANGLE_DUMP_METHOD void dump() const
Class for arbitrary precision integers.
Definition: APInt.h:78
uint64_t getZExtValue() const
Get zero extended value.
Definition: APInt.h:1540
unsigned getBitWidth() const
Return the number of bits in the APInt.
Definition: APInt.h:1488
int32_t exactLogBase2() const
Definition: APInt.h:1783
bool isSignedIntN(unsigned N) const
Check if this APInt has an N-bits signed integer value.
Definition: APInt.h:435
bool isSubsetOf(const APInt &RHS) const
This operation checks that all bits set in this APInt are also set in RHS.
Definition: APInt.h:1257
static APInt getHighBitsSet(unsigned numBits, unsigned hiBitsSet)
Constructs an APInt value that has the top hiBitsSet bits set.
Definition: APInt.h:296
bool isIntN(unsigned N) const
Check if this APInt has an N-bits unsigned integer value.
Definition: APInt.h:432
int64_t getSExtValue() const
Get sign extended value.
Definition: APInt.h:1562
A "pseudo-class" with methods for operating on BUILD_VECTORs.
LLVM_ABI bool isConstantSplat(APInt &SplatValue, APInt &SplatUndef, unsigned &SplatBitSize, bool &HasAnyUndefs, unsigned MinSplatBits=0, bool isBigEndian=false) const
Check if this is a constant splat, and if so, find the smallest element size that splats the vector.
uint64_t getZExtValue() const
int64_t getSExtValue() const
This class represents an Operation in the Expression.
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:314
LoongArchDAGToDAGISelLegacy(LoongArchTargetMachine &TM, CodeGenOptLevel OptLevel)
bool selectNonFIBaseAddr(SDValue Addr, SDValue &Base)
bool selectSExti32(SDValue N, SDValue &Val)
bool SelectInlineAsmMemoryOperand(const SDValue &Op, InlineAsm::ConstraintCode ConstraintID, std::vector< SDValue > &OutOps) override
SelectInlineAsmMemoryOperand - Select the specified address as a target addressing mode,...
bool selectVSplatUimmPow2(SDValue N, SDValue &SplatImm) const
bool selectShiftMask(SDValue N, unsigned ShiftWidth, SDValue &ShAmt)
bool selectZExti32(SDValue N, SDValue &Val)
bool SelectAddrRegImm12(SDValue Addr, SDValue &Base, SDValue &Offset)
bool SelectAddrConstant(SDValue Addr, SDValue &Base, SDValue &Offset)
bool selectVSplat(SDNode *N, APInt &Imm, unsigned MinSizeInBits) const
bool selectVSplatImm(SDValue N, SDValue &SplatVal)
bool selectVSplatUimmInvPow2(SDValue N, SDValue &SplatImm) const
bool SelectBaseAddr(SDValue Addr, SDValue &Base)
Machine Value Type.
bool is128BitVector() const
Return true if this is a 128-bit vector type.
TypeSize getSizeInBits() const
Returns the size of the specified MVT in bits.
bool is256BitVector() const
Return true if this is a 256-bit vector type.
An SDNode that represents everything that will be needed to construct a MachineInstr.
Wrapper class for IR location info (IR ordering and DebugLoc) to be passed into SDNode creation funct...
Represents one node in the SelectionDAG.
EVT getValueType(unsigned ResNo) const
Return the type of a specified result.
Unlike LLVM values, Selection DAG nodes may return multiple values as the result of a computation.
LLVM_ABI MachineSDNode * getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT)
These are used for target selectors to create a new node with specified return type(s),...
LLVM_ABI SDValue getRegister(Register Reg, EVT VT)
SDValue getCopyFromReg(SDValue Chain, const SDLoc &dl, Register Reg, EVT VT)
Definition: SelectionDAG.h:839
SDValue getTargetFrameIndex(int FI, EVT VT)
Definition: SelectionDAG.h:763
SDValue getSignedTargetConstant(int64_t Val, const SDLoc &DL, EVT VT, bool isOpaque=false)
Definition: SelectionDAG.h:719
SDValue getTargetConstant(uint64_t Val, const SDLoc &DL, EVT VT, bool isOpaque=false)
Definition: SelectionDAG.h:707
LLVM_ABI unsigned ComputeNumSignBits(SDValue Op, unsigned Depth=0) const
Return the number of times the sign bit of the register is replicated into the other bits.
LLVM_ABI bool isBaseWithConstantOffset(SDValue Op) const
Return true if the specified operand is an ISD::ADD with a ConstantSDNode on the right-hand side,...
LLVM_ABI KnownBits computeKnownBits(SDValue Op, unsigned Depth=0) const
Determine which bits of Op are known to be either zero or one and return them in Known.
LLVM_ABI bool MaskedValueIsZero(SDValue Op, const APInt &Mask, unsigned Depth=0) const
Return true if 'Op & Mask' is known to be zero.
SDValue getEntryNode() const
Return the token chain corresponding to the entry of the function.
Definition: SelectionDAG.h:581
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
@ BITCAST
BITCAST - This operator converts between integer, vector and FP values, as if the value was stored to...
Definition: ISDOpcodes.h:975
@ FrameIndex
Definition: ISDOpcodes.h:90
@ SIGN_EXTEND_INREG
SIGN_EXTEND_INREG - This operator atomically performs a SHL/SRA pair to sign extend a small value in ...
Definition: ISDOpcodes.h:870
@ AND
Bitwise operators - logical and, logical or, logical xor.
Definition: ISDOpcodes.h:730
@ BUILD_VECTOR
BUILD_VECTOR(ELT0, ELT1, ELT2, ELT3,...) - Return a fixed-width vector with the specified,...
Definition: ISDOpcodes.h:543
InstSeq generateInstSeq(int64_t Val)
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:477
bool isAligned(Align Lhs, uint64_t SizeInBytes)
Checks that SizeInBytes is a multiple of the alignment.
Definition: Alignment.h:145
unsigned Log2_32(uint32_t Value)
Return the floor log base 2 of the specified value, -1 if the value is zero.
Definition: MathExtras.h:336
constexpr bool isPowerOf2_32(uint32_t Value)
Return true if the argument is a power of two > 0.
Definition: MathExtras.h:288
LLVM_ABI raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:207
CodeGenOptLevel
Code generation optimization level.
Definition: CodeGen.h:82
FunctionPass * createLoongArchISelDag(LoongArchTargetMachine &TM, CodeGenOptLevel OptLevel)
DWARFExpression::Operation Op
constexpr bool isIntN(unsigned N, int64_t x)
Checks if an signed integer fits into the given (dynamic) bit width.
Definition: MathExtras.h:257
unsigned Log2(Align A)
Returns the log2 of the alignment.
Definition: Alignment.h:208
Implement std::hash so that hash_code can be used in STL containers.
Definition: BitVector.h:856
#define N
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
Extended Value Type.
Definition: ValueTypes.h:35
TypeSize getSizeInBits() const
Return the size of the specified value type in bits.
Definition: ValueTypes.h:368
bool is128BitVector() const
Return true if this is a 128-bit vector type.
Definition: ValueTypes.h:207
bool is256BitVector() const
Return true if this is a 256-bit vector type.
Definition: ValueTypes.h:212
EVT getVectorElementType() const
Given a vector type, return the type of each element.
Definition: ValueTypes.h:323