|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
Declarations
include/llvm/CodeGen/Analysis.h 28 class LLT;
lib/Target/AMDGPU/AMDGPURegisterBankInfo.h 27 class LLT;
lib/Target/X86/X86RegisterBankInfo.h 23 class LLT;
References
gen/lib/Target/AArch64/AArch64GenGlobalISel.inc 144 const static LLT TypeObjects[] = {
145 LLT::scalar(16),
146 LLT::scalar(32),
147 LLT::scalar(64),
148 LLT::scalar(128),
149 LLT::vector(2, 1),
150 LLT::vector(2, 32),
151 LLT::vector(2, 64),
152 LLT::vector(4, 1),
153 LLT::vector(4, 16),
154 LLT::vector(4, 32),
155 LLT::vector(8, 1),
156 LLT::vector(8, 8),
157 LLT::vector(8, 16),
158 LLT::vector(16, 1),
159 LLT::vector(16, 8),
gen/lib/Target/AMDGPU/AMDGPUGenGlobalISel.inc 207 const static LLT TypeObjects[] = {
208 LLT::pointer(0, 64),
209 LLT::pointer(1, 64),
210 LLT::pointer(2, 32),
211 LLT::pointer(3, 32),
212 LLT::pointer(4, 64),
213 LLT::pointer(5, 32),
214 LLT::pointer(6, 32),
215 LLT::scalar(1),
216 LLT::scalar(16),
217 LLT::scalar(32),
218 LLT::scalar(64),
219 LLT::vector(2, 16),
220 LLT::vector(2, 32),
221 LLT::vector(2, 64),
222 LLT::vector(3, 32),
223 LLT::vector(4, 16),
224 LLT::vector(4, 32),
225 LLT::vector(5, 32),
226 LLT::vector(8, 32),
227 LLT::vector(16, 32),
228 LLT::vector(32, 32),
gen/lib/Target/ARM/ARMGenGlobalISel.inc 279 const static LLT TypeObjects[] = {
280 LLT::scalar(16),
281 LLT::scalar(32),
282 LLT::scalar(64),
283 LLT::vector(2, 32),
284 LLT::vector(2, 64),
285 LLT::vector(4, 1),
286 LLT::vector(4, 16),
287 LLT::vector(4, 32),
288 LLT::vector(4, 64),
289 LLT::vector(8, 1),
290 LLT::vector(8, 8),
291 LLT::vector(8, 16),
292 LLT::vector(8, 64),
293 LLT::vector(16, 1),
294 LLT::vector(16, 8),
gen/lib/Target/Mips/MipsGenGlobalISel.inc 195 const static LLT TypeObjects[] = {
196 LLT::scalar(16),
197 LLT::scalar(32),
198 LLT::scalar(64),
199 LLT::vector(2, 16),
200 LLT::vector(2, 64),
201 LLT::vector(4, 8),
202 LLT::vector(4, 32),
203 LLT::vector(8, 16),
204 LLT::vector(16, 8),
gen/lib/Target/RISCV/RISCVGenGlobalISel.inc 74 const static LLT TypeObjects[] = {
75 LLT::scalar(32),
76 LLT::scalar(64),
gen/lib/Target/X86/X86GenGlobalISel.inc 421 const static LLT TypeObjects[] = {
422 LLT::scalar(1),
423 LLT::scalar(8),
424 LLT::scalar(16),
425 LLT::scalar(32),
426 LLT::scalar(64),
427 LLT::scalar(80),
428 LLT::scalar(128),
429 LLT::vector(2, 1),
430 LLT::vector(2, 64),
431 LLT::vector(4, 1),
432 LLT::vector(4, 32),
433 LLT::vector(4, 64),
434 LLT::vector(8, 1),
435 LLT::vector(8, 16),
436 LLT::vector(8, 32),
437 LLT::vector(8, 64),
438 LLT::vector(16, 1),
439 LLT::vector(16, 8),
440 LLT::vector(16, 16),
441 LLT::vector(16, 32),
442 LLT::vector(32, 1),
443 LLT::vector(32, 8),
444 LLT::vector(32, 16),
445 LLT::vector(64, 1),
446 LLT::vector(64, 8),
include/llvm/ADT/ArrayRef.h 43 using iterator = const T *;
44 using const_iterator = const T *;
50 const T *Data = nullptr;
66 /*implicit*/ ArrayRef(const T &OneElt)
70 /*implicit*/ ArrayRef(const T *data, size_t length)
74 ArrayRef(const T *begin, const T *end)
74 ArrayRef(const T *begin, const T *end)
81 /*implicit*/ ArrayRef(const SmallVectorTemplateCommon<T, U> &Vec)
87 /*implicit*/ ArrayRef(const std::vector<T, A> &Vec)
92 /*implicit*/ constexpr ArrayRef(const std::array<T, N> &Arr)
97 /*implicit*/ constexpr ArrayRef(const T (&Arr)[N]) : Data(Arr), Length(N) {}
100 /*implicit*/ ArrayRef(const std::initializer_list<T> &Vec)
145 const T *data() const { return Data; }
151 const T &front() const {
157 const T &back() const {
163 template <typename Allocator> ArrayRef<T> copy(Allocator &A) {
178 ArrayRef<T> slice(size_t N, size_t M) const {
184 ArrayRef<T> slice(size_t N) const { return slice(N, size() - N); }
187 ArrayRef<T> drop_front(size_t N = 1) const {
193 ArrayRef<T> drop_back(size_t N = 1) const {
200 template <class PredicateT> ArrayRef<T> drop_while(PredicateT Pred) const {
206 template <class PredicateT> ArrayRef<T> drop_until(PredicateT Pred) const {
211 ArrayRef<T> take_front(size_t N = 1) const {
218 ArrayRef<T> take_back(size_t N = 1) const {
226 template <class PredicateT> ArrayRef<T> take_while(PredicateT Pred) const {
232 template <class PredicateT> ArrayRef<T> take_until(PredicateT Pred) const {
239 const T &operator[](size_t Index) const {
249 typename std::enable_if<std::is_same<U, T>::value, ArrayRef<T>>::type &
257 typename std::enable_if<std::is_same<U, T>::value, ArrayRef<T>>::type &
263 std::vector<T> vec() const {
270 operator std::vector<T>() const {
include/llvm/ADT/DenseMap.h 40 struct DenseMapPair : public std::pair<KeyT, ValueT> {
43 KeyT &getFirst() { return std::pair<KeyT, ValueT>::first; }
44 const KeyT &getFirst() const { return std::pair<KeyT, ValueT>::first; }
65 using key_type = KeyT;
69 using iterator = DenseMapIterator<KeyT, ValueT, KeyInfoT, BucketT>;
71 DenseMapIterator<KeyT, ValueT, KeyInfoT, BucketT, true>;
78 if (shouldReverseIterate<KeyT>())
145 size_type count(const_arg_type_t<KeyT> Val) const {
150 iterator find(const_arg_type_t<KeyT> Val) {
156 const_iterator find(const_arg_type_t<KeyT> Val) const {
185 ValueT lookup(const_arg_type_t<KeyT> Val) const {
195 std::pair<iterator, bool> insert(const std::pair<KeyT, ValueT> &KV) {
202 std::pair<iterator, bool> insert(std::pair<KeyT, ValueT> &&KV) {
210 std::pair<iterator, bool> try_emplace(KeyT &&Key, Ts &&... Args) {
229 std::pair<iterator, bool> try_emplace(const KeyT &Key, Ts &&... Args) {
249 std::pair<iterator, bool> insert_as(std::pair<KeyT, ValueT> &&KV,
272 bool erase(const KeyT &Val) {
291 value_type& FindAndConstruct(const KeyT &Key) {
299 ValueT &operator[](const KeyT &Key) {
303 value_type& FindAndConstruct(KeyT &&Key) {
311 ValueT &operator[](KeyT &&Key) {
334 const KeyT EmptyKey = getEmptyKey(), TombstoneKey = getTombstoneKey();
349 const KeyT EmptyKey = getEmptyKey();
351 ::new (&B->getFirst()) KeyT(EmptyKey);
369 const KeyT EmptyKey = getEmptyKey();
370 const KeyT TombstoneKey = getTombstoneKey();
392 const DenseMapBase<OtherBaseT, KeyT, ValueT, KeyInfoT, BucketT> &other) {
414 static unsigned getHashValue(const KeyT &Val) {
419 static unsigned getHashValue(const LookupKeyT &Val) {
423 static const KeyT getEmptyKey() {
429 static const KeyT getTombstoneKey() {
437 if (shouldReverseIterate<KeyT>()) {
447 if (shouldReverseIterate<KeyT>()) {
515 BucketT *InsertIntoBucket(BucketT *TheBucket, KeyArg &&Key,
525 BucketT *InsertIntoBucketWithLookup(BucketT *TheBucket, KeyT &&Key,
535 BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
535 BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
566 const KeyT EmptyKey = getEmptyKey();
578 bool LookupBucketFor(const LookupKeyT &Val,
590 const KeyT EmptyKey = getEmptyKey();
591 const KeyT TombstoneKey = getTombstoneKey();
629 bool LookupBucketFor(const LookupKeyT &Val, BucketT *&FoundBucket) {
684 class DenseMap : public DenseMapBase<DenseMap<KeyT, ValueT, KeyInfoT, BucketT>,
685 KeyT, ValueT, KeyInfoT, BucketT> {
690 using BaseT = DenseMapBase<DenseMap, KeyT, ValueT, KeyInfoT, BucketT>;
852 SmallDenseMap<KeyT, ValueT, InlineBuckets, KeyInfoT, BucketT>, KeyT,
852 SmallDenseMap<KeyT, ValueT, InlineBuckets, KeyInfoT, BucketT>, KeyT,
1023 const KeyT EmptyKey = this->getEmptyKey();
1024 const KeyT TombstoneKey = this->getTombstoneKey();
1030 ::new (&TmpEnd->getFirst()) KeyT(std::move(P->getFirst()));
1163 using ConstIterator = DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, true>;
1186 if (shouldReverseIterate<KeyT>()) {
1199 const DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, IsConstSrc> &I)
1204 if (shouldReverseIterate<KeyT>())
1210 if (shouldReverseIterate<KeyT>())
1232 if (shouldReverseIterate<KeyT>()) {
1249 const KeyT Empty = KeyInfoT::getEmptyKey();
1250 const KeyT Tombstone = KeyInfoT::getTombstoneKey();
1259 const KeyT Empty = KeyInfoT::getEmptyKey();
1260 const KeyT Tombstone = KeyInfoT::getTombstoneKey();
include/llvm/ADT/IndexedMap.h 34 using StorageT = SmallVector<T, 0>;
37 T nullVal_;
43 explicit IndexedMap(const T& val) : nullVal_(val) {}
include/llvm/ADT/SmallVector.h 75 AlignedCharArrayUnion<T> FirstEl;
114 using value_type = T;
115 using iterator = T *;
116 using const_iterator = const T *;
121 using reference = T &;
122 using const_reference = const T &;
123 using pointer = T *;
124 using const_pointer = const T *;
259 class SmallVectorTemplateBase<T, true> : public SmallVectorTemplateCommon<T> {
264 static void destroy_range(T *, T *) {}
264 static void destroy_range(T *, T *) {}
286 T1 *I, T1 *E, T2 *Dest,
286 T1 *I, T1 *E, T2 *Dest,
286 T1 *I, T1 *E, T2 *Dest,
287 typename std::enable_if<std::is_same<typename std::remove_const<T1>::type,
288 T2>::value>::type * = nullptr) {
294 memcpy(reinterpret_cast<void *>(Dest), I, (E - I) * sizeof(T));
299 void grow(size_t MinSize = 0) { this->grow_pod(MinSize, sizeof(T)); }
302 void push_back(const T &Elt) {
305 memcpy(reinterpret_cast<void *>(this->end()), &Elt, sizeof(T));
315 class SmallVectorImpl : public SmallVectorTemplateBase<T> {
316 using SuperClass = SmallVectorTemplateBase<T>;
352 new (&*I) T();
357 void resize(size_type N, const T &NV) {
374 LLVM_NODISCARD T pop_back_val() {
397 void append(size_type NumInputs, const T &Elt) {
405 void append(std::initializer_list<T> IL) {
412 void assign(size_type NumElts, const T &Elt) {
429 void assign(std::initializer_list<T> IL) {
467 iterator insert(iterator I, T &&Elt) {
497 iterator insert(iterator I, const T &Elt) {
526 iterator insert(iterator I, size_type NumToInsert, const T &Elt) {
637 void insert(iterator I, std::initializer_list<T> IL) {
820 AlignedCharArrayUnion<T> InlineElts[N];
837 class SmallVector : public SmallVectorImpl<T>, SmallVectorStorage<T, N> {
837 class SmallVector : public SmallVectorImpl<T>, SmallVectorStorage<T, N> {
846 explicit SmallVector(size_t Size, const T &Value = T())
865 SmallVector(std::initializer_list<T> IL) : SmallVectorImpl<T>(N) {
884 SmallVector(SmallVectorImpl<T> &&RHS) : SmallVectorImpl<T>(N) {
include/llvm/CodeGen/Analysis.h 92 SmallVectorImpl<LLT> &ValueTys,
include/llvm/CodeGen/GlobalISel/CSEInfo.h 176 const GISelInstProfileBuilder &addNodeIDRegType(const LLT &Ty) const;
include/llvm/CodeGen/GlobalISel/CombinerHelper.h 34 LLT Ty; // The result type of the extend.
include/llvm/CodeGen/GlobalISel/InstructionSelector.h 420 ISelInfoTy(const LLT *TypeObjects, size_t NumTypeObjects,
432 const LLT *TypeObjects;
437 SmallDenseMap<LLT, unsigned, 64> TypeIDMap;
include/llvm/CodeGen/GlobalISel/InstructionSelectorImpl.h 207 const LLT Ty = MRI.getType(MO.getReg());
545 const LLT Ty = MRI.getType(MO.getReg());
620 LLT Ty = MRI.getType(MO.getReg());
include/llvm/CodeGen/GlobalISel/LegalizationArtifactCombiner.h 81 const LLT &DstTy = MRI.getType(DstReg);
104 LLT DstTy = MRI.getType(DstReg);
109 LLT SrcTy = MRI.getType(SrcReg);
122 const LLT &DstTy = MRI.getType(DstReg);
145 LLT DstTy = MRI.getType(DstReg);
149 LLT SrcTy = MRI.getType(SrcReg);
172 const LLT &DstTy = MRI.getType(DstReg);
197 LLT DstTy = MRI.getType(DstReg);
221 LLT OpTy, LLT DestTy) {
221 LLT OpTy, LLT DestTy) {
259 LLT OpTy = MRI.getType(MI.getOperand(NumDefs).getReg());
260 LLT DestTy = MRI.getType(MI.getOperand(0).getReg());
300 LLT MergeEltTy
337 LLT MergeSrcTy = MRI.getType(MergeI->getOperand(1).getReg());
396 LLT DstTy = MRI.getType(MI.getOperand(0).getReg());
397 LLT SrcTy = MRI.getType(Src);
545 bool isConstantUnsupported(LLT Ty) const {
549 LLT EltTy = Ty.getElementType();
include/llvm/CodeGen/GlobalISel/LegalizerHelper.h 70 LegalizeResult narrowScalar(MachineInstr &MI, unsigned TypeIdx, LLT NarrowTy);
75 LegalizeResult widenScalar(MachineInstr &MI, unsigned TypeIdx, LLT WideTy);
79 LegalizeResult lower(MachineInstr &MI, unsigned TypeIdx, LLT Ty);
84 LLT NarrowTy);
89 LLT MoreTy);
103 void widenScalarSrc(MachineInstr &MI, LLT WideTy, unsigned OpIdx,
109 void narrowScalarSrc(MachineInstr &MI, LLT NarrowTy, unsigned OpIdx);
114 void widenScalarDst(MachineInstr &MI, LLT WideTy, unsigned OpIdx = 0,
120 void narrowScalarDst(MachineInstr &MI, LLT NarrowTy, unsigned OpIdx,
125 void moreElementsVectorDst(MachineInstr &MI, LLT MoreTy, unsigned OpIdx);
130 void moreElementsVectorSrc(MachineInstr &MI, LLT MoreTy, unsigned OpIdx);
133 widenScalarMergeValues(MachineInstr &MI, unsigned TypeIdx, LLT WideTy);
135 widenScalarUnmergeValues(MachineInstr &MI, unsigned TypeIdx, LLT WideTy);
137 widenScalarExtract(MachineInstr &MI, unsigned TypeIdx, LLT WideTy);
139 widenScalarInsert(MachineInstr &MI, unsigned TypeIdx, LLT WideTy);
144 void extractParts(Register Reg, LLT Ty, int NumParts,
148 bool extractParts(Register Reg, LLT RegTy, LLT MainTy,
148 bool extractParts(Register Reg, LLT RegTy, LLT MainTy,
149 LLT &LeftoverTy,
162 void insertParts(Register DstReg, LLT ResultTy,
163 LLT PartTy, ArrayRef<Register> PartRegs,
164 LLT LeftoverTy = LLT(), ArrayRef<Register> LeftoverRegs = {});
171 ArrayRef<Register> Src2Regs, LLT NarrowTy);
175 unsigned TypeIdx, LLT NarrowTy);
180 LLT NarrowTy);
186 unsigned TypeIdx, LLT NarrowTy);
189 LLT NarrowTy);
192 fewerElementsVectorCmp(MachineInstr &MI, unsigned TypeIdx, LLT NarrowTy);
195 fewerElementsVectorSelect(MachineInstr &MI, unsigned TypeIdx, LLT NarrowTy);
198 unsigned TypeIdx, LLT NarrowTy);
201 LLT MoreTy);
205 LLT NarrowTy);
208 LLT NarrowTy);
211 reduceLoadStoreWidth(MachineInstr &MI, unsigned TypeIdx, LLT NarrowTy);
214 LLT HalfTy, LLT ShiftAmtTy);
214 LLT HalfTy, LLT ShiftAmtTy);
216 LegalizeResult narrowScalarShift(MachineInstr &MI, unsigned TypeIdx, LLT Ty);
217 LegalizeResult narrowScalarMul(MachineInstr &MI, LLT Ty);
218 LegalizeResult narrowScalarExtract(MachineInstr &MI, unsigned TypeIdx, LLT Ty);
219 LegalizeResult narrowScalarInsert(MachineInstr &MI, unsigned TypeIdx, LLT Ty);
221 LegalizeResult narrowScalarBasic(MachineInstr &MI, unsigned TypeIdx, LLT Ty);
222 LegalizeResult narrowScalarSelect(MachineInstr &MI, unsigned TypeIdx, LLT Ty);
224 LegalizeResult lowerBitCount(MachineInstr &MI, unsigned TypeIdx, LLT Ty);
227 LegalizeResult lowerUITOFP(MachineInstr &MI, unsigned TypeIdx, LLT Ty);
228 LegalizeResult lowerSITOFP(MachineInstr &MI, unsigned TypeIdx, LLT Ty);
229 LegalizeResult lowerFPTOUI(MachineInstr &MI, unsigned TypeIdx, LLT Ty);
230 LegalizeResult lowerMinMax(MachineInstr &MI, unsigned TypeIdx, LLT Ty);
231 LegalizeResult lowerFCopySign(MachineInstr &MI, unsigned TypeIdx, LLT Ty);
include/llvm/CodeGen/GlobalISel/LegalizerInfo.h 105 LLT Type;
107 InstrAspect(unsigned Opcode, LLT Type) : Opcode(Opcode), Type(Type) {}
108 InstrAspect(unsigned Opcode, unsigned Idx, LLT Type)
122 ArrayRef<LLT> Types;
134 constexpr LegalityQuery(unsigned Opcode, const ArrayRef<LLT> Types,
137 constexpr LegalityQuery(unsigned Opcode, const ArrayRef<LLT> Types)
152 LLT NewType;
155 const LLT &NewType)
166 std::function<std::pair<unsigned, LLT>(const LegalityQuery &)>;
170 LLT Type0;
171 LLT Type1;
203 LegalityPredicate typeIs(unsigned TypeIdx, LLT TypesInit);
206 std::initializer_list<LLT> TypesInit);
211 std::initializer_list<std::pair<LLT, LLT>> TypesInit);
211 std::initializer_list<std::pair<LLT, LLT>> TypesInit);
266 LegalizeMutation changeTo(unsigned TypeIdx, LLT Ty);
275 LegalizeMutation changeElementTo(unsigned TypeIdx, LLT Ty);
310 std::pair<unsigned, LLT> determineMutation(const LegalityQuery &Query) const {
390 std::initializer_list<LLT> Types) {
397 std::initializer_list<LLT> Types,
406 std::initializer_list<std::pair<LLT, LLT>> Types) {
406 std::initializer_list<std::pair<LLT, LLT>> Types) {
414 std::initializer_list<std::pair<LLT, LLT>> Types,
414 std::initializer_list<std::pair<LLT, LLT>> Types,
424 std::initializer_list<LLT> Types) {
433 std::initializer_list<LLT> Types) {
444 std::initializer_list<LLT> Types0,
445 std::initializer_list<LLT> Types1) {
455 LegalizeAction Action, std::initializer_list<LLT> Types0,
456 std::initializer_list<LLT> Types1, std::initializer_list<LLT> Types2) {
456 std::initializer_list<LLT> Types1, std::initializer_list<LLT> Types2) {
484 LegalizeRuleSet &legalFor(std::initializer_list<LLT> Types) {
489 LegalizeRuleSet &legalFor(std::initializer_list<std::pair<LLT, LLT>> Types) {
489 LegalizeRuleSet &legalFor(std::initializer_list<std::pair<LLT, LLT>> Types) {
494 LegalizeRuleSet &legalForTypeWithAnyImm(std::initializer_list<LLT> Types) {
509 LegalizeRuleSet &legalForCartesianProduct(std::initializer_list<LLT> Types) {
514 LegalizeRuleSet &legalForCartesianProduct(std::initializer_list<LLT> Types0,
515 std::initializer_list<LLT> Types1) {
520 LegalizeRuleSet &legalForCartesianProduct(std::initializer_list<LLT> Types0,
521 std::initializer_list<LLT> Types1,
522 std::initializer_list<LLT> Types2) {
560 LegalizeRuleSet &lowerFor(std::initializer_list<LLT> Types) {
566 LegalizeRuleSet &lowerFor(std::initializer_list<LLT> Types,
572 LegalizeRuleSet &lowerFor(std::initializer_list<std::pair<LLT, LLT>> Types) {
572 LegalizeRuleSet &lowerFor(std::initializer_list<std::pair<LLT, LLT>> Types) {
578 LegalizeRuleSet &lowerFor(std::initializer_list<std::pair<LLT, LLT>> Types,
578 LegalizeRuleSet &lowerFor(std::initializer_list<std::pair<LLT, LLT>> Types,
584 LegalizeRuleSet &lowerForCartesianProduct(std::initializer_list<LLT> Types0,
585 std::initializer_list<LLT> Types1) {
591 LegalizeRuleSet &lowerForCartesianProduct(std::initializer_list<LLT> Types0,
592 std::initializer_list<LLT> Types1,
593 std::initializer_list<LLT> Types2) {
606 LegalizeRuleSet &libcallFor(std::initializer_list<LLT> Types) {
610 libcallFor(std::initializer_list<std::pair<LLT, LLT>> Types) {
610 libcallFor(std::initializer_list<std::pair<LLT, LLT>> Types) {
614 libcallForCartesianProduct(std::initializer_list<LLT> Types) {
618 libcallForCartesianProduct(std::initializer_list<LLT> Types0,
619 std::initializer_list<LLT> Types1) {
683 LegalizeRuleSet &customFor(std::initializer_list<LLT> Types) {
689 LegalizeRuleSet &customFor(std::initializer_list<std::pair<LLT, LLT>> Types) {
689 LegalizeRuleSet &customFor(std::initializer_list<std::pair<LLT, LLT>> Types) {
693 LegalizeRuleSet &customForCartesianProduct(std::initializer_list<LLT> Types) {
697 customForCartesianProduct(std::initializer_list<LLT> Types0,
698 std::initializer_list<LLT> Types1) {
740 LegalizeRuleSet &minScalarOrElt(unsigned TypeIdx, const LLT &Ty) {
750 unsigned TypeIdx, const LLT &Ty) {
760 LegalizeRuleSet &minScalar(unsigned TypeIdx, const LLT &Ty) {
769 LegalizeRuleSet &maxScalarOrElt(unsigned TypeIdx, const LLT &Ty) {
778 LegalizeRuleSet &maxScalar(unsigned TypeIdx, const LLT &Ty) {
790 const LLT &Ty) {
802 LegalizeRuleSet &clampScalar(unsigned TypeIdx, const LLT &MinTy,
803 const LLT &MaxTy) {
809 LegalizeRuleSet &clampScalarOrElt(unsigned TypeIdx, const LLT &MinTy,
810 const LLT &MaxTy) {
823 LLT T = Query.Types[LargeTypeIdx];
840 LLT T = Query.Types[LargeTypeIdx];
856 LegalizeRuleSet &clampMinNumElements(unsigned TypeIdx, const LLT &EltTy,
863 LLT VecTy = Query.Types[TypeIdx];
868 LLT VecTy = Query.Types[TypeIdx];
870 TypeIdx, LLT::vector(MinElements, VecTy.getElementType()));
874 LegalizeRuleSet &clampMaxNumElements(unsigned TypeIdx, const LLT &EltTy,
881 LLT VecTy = Query.Types[TypeIdx];
886 LLT VecTy = Query.Types[TypeIdx];
887 LLT NewTy = LLT::scalarOrVector(MaxElements, VecTy.getElementType());
887 LLT NewTy = LLT::scalarOrVector(MaxElements, VecTy.getElementType());
897 LegalizeRuleSet &clampNumElements(unsigned TypeIdx, const LLT &MinTy,
898 const LLT &MaxTy) {
902 const LLT &EltTy = MinTy.getElementType();
1166 std::pair<LegalizeAction, LLT>
1317 std::pair<LegalizeAction, LLT>
1321 std::pair<LegalizeAction, LLT>
1328 using TypeMap = DenseMap<LLT, LegalizeAction>;
include/llvm/CodeGen/GlobalISel/MIPatternMatch.h 135 static bool bind(const MachineRegisterInfo &MRI, LLT &Ty, unsigned Reg) {
154 Class &VR;
156 bind_ty(Class &V) : VR(V) {}
165 inline bind_ty<LLT> m_Type(LLT &Ty) { return Ty; }
165 inline bind_ty<LLT> m_Type(LLT &Ty) { return Ty; }
325 LLT Ty;
326 CheckType(const LLT &Ty) : Ty(Ty) {}
333 inline CheckType m_SpecificType(LLT Ty) { return Ty; }
include/llvm/CodeGen/GlobalISel/MachineIRBuilder.h 61 LLT LLTTy;
71 DstOp(const LLT &T) : LLTTy(T), Ty(DstType::Ty_LLT) {}
88 LLT getLLTTy(const MachineRegisterInfo &MRI) const {
159 LLT getLLTTy(const MachineRegisterInfo &MRI) const {
226 void validateTruncExt(const LLT &Dst, const LLT &Src, bool IsExtend);
226 void validateTruncExt(const LLT &Dst, const LLT &Src, bool IsExtend);
228 void validateBinaryOp(const LLT &Res, const LLT &Op0, const LLT &Op1);
228 void validateBinaryOp(const LLT &Res, const LLT &Op0, const LLT &Op1);
228 void validateBinaryOp(const LLT &Res, const LLT &Op0, const LLT &Op1);
229 void validateShiftOp(const LLT &Res, const LLT &Op0, const LLT &Op1);
229 void validateShiftOp(const LLT &Res, const LLT &Op0, const LLT &Op1);
229 void validateShiftOp(const LLT &Res, const LLT &Op0, const LLT &Op1);
231 void validateSelectOp(const LLT &ResTy, const LLT &TstTy, const LLT &Op0Ty,
231 void validateSelectOp(const LLT &ResTy, const LLT &TstTy, const LLT &Op0Ty,
231 void validateSelectOp(const LLT &ResTy, const LLT &TstTy, const LLT &Op0Ty,
232 const LLT &Op1Ty);
438 const LLT &ValueTy,
796 MachineInstrBuilder buildUnmerge(ArrayRef<LLT> Res, const SrcOp &Op);
800 MachineInstrBuilder buildUnmerge(LLT Res, const SrcOp &Op);
1470 MachineInstrBuilder buildJumpTable(const LLT PtrTy, unsigned JTI);
include/llvm/CodeGen/GlobalISel/Utils.h 172 MVT getMVTForLLT(LLT Ty);
174 LLT getLLTForMVT(MVT Ty);
include/llvm/CodeGen/LowLevelType.h 27 LLT getLLTForType(Type &Ty, const DataLayout &DL);
include/llvm/CodeGen/MachineInstr.h 1508 LLT getTypeToPrint(unsigned OpIdx, SmallBitVector &PrintedTypes,
include/llvm/CodeGen/MachineOperand.h 296 void print(raw_ostream &os, ModuleSlotTracker &MST, LLT TypeToPrint,
303 void print(raw_ostream &os, LLT TypeToPrint,
include/llvm/CodeGen/MachineRegisterInfo.h 138 using VRegToTypeMap = IndexedMap<LLT, VirtReg2IndexFunctor>;
729 LLT getType(unsigned Reg) const {
736 void setType(unsigned VReg, LLT Ty);
740 Register createGenericVirtualRegister(LLT Ty, StringRef Name = "");
include/llvm/CodeGen/TargetLowering.h 1473 LLT, unsigned AddrSpace = 0, unsigned Align = 1,
1537 virtual LLT
include/llvm/Support/AlignOf.h 30 T t;
39 template <typename T> union SizerImpl<T> { char arr[sizeof(T)]; };
50 llvm::detail::SizerImpl<T, Ts...>)];
include/llvm/Support/LowLevelTypeImpl.h 42 static LLT scalar(unsigned SizeInBits) {
49 static LLT pointer(unsigned AddressSpace, unsigned SizeInBits) {
57 static LLT vector(uint16_t NumElements, unsigned ScalarSizeInBits) {
65 static LLT vector(uint16_t NumElements, LLT ScalarTy) {
65 static LLT vector(uint16_t NumElements, LLT ScalarTy) {
73 static LLT scalarOrVector(uint16_t NumElements, LLT ScalarTy) {
73 static LLT scalarOrVector(uint16_t NumElements, LLT ScalarTy) {
74 return NumElements == 1 ? ScalarTy : LLT::vector(NumElements, ScalarTy);
77 static LLT scalarOrVector(uint16_t NumElements, unsigned ScalarSize) {
78 return scalarOrVector(NumElements, LLT::scalar(ScalarSize));
120 LLT getScalarType() const {
126 LLT changeElementType(LLT NewEltTy) const {
126 LLT changeElementType(LLT NewEltTy) const {
127 return isVector() ? LLT::vector(getNumElements(), NewEltTy) : NewEltTy;
133 LLT changeElementSize(unsigned NewEltSize) const {
136 return isVector() ? LLT::vector(getNumElements(), NewEltSize)
137 : LLT::scalar(NewEltSize);
165 LLT getElementType() const {
175 bool operator==(const LLT &RHS) const {
180 bool operator!=(const LLT &RHS) const { return !(*this == RHS); }
275 inline raw_ostream& operator<<(raw_ostream &OS, const LLT &Ty) {
281 static inline LLT getEmptyKey() {
282 LLT Invalid;
286 static inline LLT getTombstoneKey() {
287 LLT Invalid;
291 static inline unsigned getHashValue(const LLT &Ty) {
295 static bool isEqual(const LLT &LHS, const LLT &RHS) {
295 static bool isEqual(const LLT &LHS, const LLT &RHS) {
include/llvm/Support/type_traits.h 65 using type = const T &;
91 T t;
122 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<const F &>(), std::true_type{});
122 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<const F &>(), std::true_type{});
122 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<const F &>(), std::true_type{});
130 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
130 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
130 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
145 std::is_copy_constructible<detail::trivial_helper<T>>::value;
147 !std::is_copy_constructible<T>::value;
151 std::is_move_constructible<detail::trivial_helper<T>>::value;
153 !std::is_move_constructible<T>::value;
157 is_copy_assignable<detail::trivial_helper<T>>::value;
159 !is_copy_assignable<T>::value;
163 is_move_assignable<detail::trivial_helper<T>>::value;
165 !is_move_assignable<T>::value;
169 std::is_destructible<detail::trivial_helper<T>>::value;
181 static_assert(value == std::is_trivially_copyable<T>::value,
lib/CodeGen/Analysis.cpp 128 SmallVectorImpl<LLT> &ValueTys,
lib/CodeGen/GlobalISel/CSEInfo.cpp 284 GISelInstProfileBuilder::addNodeIDRegType(const LLT &Ty) const {
339 LLT Ty = MRI.getType(Reg);
lib/CodeGen/GlobalISel/CSEMIRBuilder.cpp 211 LLT Ty = Res.getLLTTy(*getMRI());
238 LLT Ty = Res.getLLTTy(*getMRI());
lib/CodeGen/GlobalISel/CallLowering.cpp 133 LLT PackedLLT = getLLTForType(*PackedTy, DL);
135 SmallVector<LLT, 8> LLTs;
158 SmallVector<LLT, 8> LLTs;
227 LLT NewLLT = getLLTForMVT(NewVT);
259 LLT SmallTy = LLT::scalar(NewVT.getSizeInBits());
259 LLT SmallTy = LLT::scalar(NewVT.getSizeInBits());
322 const LLT VATy(VAVT);
330 const LLT OrigTy(OrigVT);
456 LLT LocTy{VA.getLocVT()};
lib/CodeGen/GlobalISel/CombinerHelper.cpp 77 LLT DstTy = MRI.getType(DstReg);
78 LLT SrcTy = MRI.getType(SrcReg);
132 LLT OpType = MRI.getType(Reg);
189 LLT DstType = MRI.getType(MI.getOperand(0).getReg());
191 LLT SrcType = MRI.getType(Src1);
268 const LLT &TyForCandidate,
374 LLT LoadValueTy = MRI.getType(LoadValue.getReg());
472 const LLT &UseDstTy = MRI.getType(UseDstReg);
814 std::vector<LLT> &MemOps, unsigned Limit, uint64_t Size, unsigned DstAlign,
828 LLT Ty = TLI.getOptimalMemOpLLT(Size, DstAlign, SrcAlign, IsMemset,
835 Ty = LLT::scalar(64);
838 Ty = LLT::scalar(Ty.getSizeInBytes());
848 LLT NewTy = Ty;
852 NewTy = NewTy.getSizeInBits() > 64 ? LLT::scalar(64) : LLT::scalar(32);
852 NewTy = NewTy.getSizeInBits() > 64 ? LLT::scalar(64) : LLT::scalar(32);
853 NewTy = LLT::scalar(PowerOf2Floor(NewTy.getSizeInBits() - 1));
883 static Type *getTypeForLLT(LLT Ty, LLVMContext &C) {
891 static Register getMemsetValue(Register Val, LLT Ty, MachineIRBuilder &MIB) {
907 LLT ExtType = Ty.getScalarType();
938 std::vector<LLT> MemOps;
969 LLT LargestTy = MemOps[0];
984 LLT PtrTy = MRI.getType(Dst);
988 LLT Ty = MemOps[I];
1018 MIB.buildConstant(LLT::scalar(PtrTy.getSizeInBits()), DstOff);
1057 std::vector<LLT> MemOps;
1104 LLT PtrTy = MRI.getType(Src);
1106 for (auto CopyTy : MemOps) {
1122 Offset = MIB.buildConstant(LLT::scalar(PtrTy.getSizeInBits()), CurrOffset)
1161 std::vector<LLT> MemOps;
1209 LLT PtrTy = MRI.getType(Src);
1211 for (auto CopyTy : MemOps) {
1220 MIB.buildConstant(LLT::scalar(PtrTy.getSizeInBits()), CurrOffset);
1229 LLT CopyTy = MemOps[I];
1237 MIB.buildConstant(LLT::scalar(PtrTy.getSizeInBits()), CurrOffset);
lib/CodeGen/GlobalISel/GISelKnownBits.cpp 71 LLT Ty = MRI.getType(R);
79 LLT Ty = MRI.getType(R);
95 LLT DstTy = MRI.getType(R);
184 LLT Ty = MRI.getType(MI.getOperand(1).getReg());
351 LLT SrcTy = MRI.getType(SrcReg);
lib/CodeGen/GlobalISel/IRTranslator.cpp 165 SmallVector<LLT, 4> SplitTys;
188 SmallVector<LLT, 4> SplitTys;
193 for (auto Ty : SplitTys)
516 const LLT PtrTy = getLLTForType(*PtrIRTy, *DL);
531 const LLT SwitchTy = getLLTForType(*SValue.getType(), *DL);
539 const LLT PtrScalarTy = LLT::scalar(DL->getTypeSizeInBits(PtrIRTy));
539 const LLT PtrScalarTy = LLT::scalar(DL->getTypeSizeInBits(PtrIRTy));
556 auto Cmp = MIB.buildICmp(CmpInst::ICMP_UGT, LLT::scalar(1), Sub, Cst);
587 const LLT i1Ty = LLT::scalar(1);
587 const LLT i1Ty = LLT::scalar(1);
605 const LLT &CmpTy = MRI->getType(CmpOpReg);
874 LLT OffsetTy = getLLTForType(*OffsetIRTy, *DL);
916 LLT OffsetTy = getLLTForType(*OffsetIRTy, *DL);
1058 LLT PtrTy = getLLTForType(*PtrIRTy, *DL);
1060 LLT OffsetTy = getLLTForType(*OffsetIRTy, *DL);
1081 LLT OffsetTy = getLLTForType(*OffsetIRTy, *DL);
1421 LLT Ty = getLLTForType(*CI.getType(), *DL);
1450 LLT PtrTy = getLLTForType(*CI.getArgOperand(0)->getType(), *DL);
1509 LLT PtrTy = getLLTForType(*CI.getArgOperand(0)->getType(), *DL);
1555 LLT Ty = getLLTForType(*Arg->getType(), *DL);
1754 LLT Ty = getLLTForType(*LP.getType(), *DL);
1758 SmallVector<LLT, 2> Tys;
1810 LLT IntPtrTy = getLLTForType(*IntPtrIRTy, *DL);
1910 const LLT &VecIdxTy = LLT::scalar(PreferredVecIdxWidth);
1910 const LLT &VecIdxTy = LLT::scalar(PreferredVecIdxWidth);
2082 SmallVector<LLT, 4> SplitTys;
lib/CodeGen/GlobalISel/InstructionSelect.cpp 207 const LLT Ty = MRI.getType(VReg);
lib/CodeGen/GlobalISel/LegalityPredicates.cpp 17 LegalityPredicate LegalityPredicates::typeIs(unsigned TypeIdx, LLT Type) {
24 std::initializer_list<LLT> TypesInit) {
25 SmallVector<LLT, 4> Types = TypesInit;
33 std::initializer_list<std::pair<LLT, LLT>> TypesInit) {
33 std::initializer_list<std::pair<LLT, LLT>> TypesInit) {
34 SmallVector<std::pair<LLT, LLT>, 4> Types = TypesInit;
34 SmallVector<std::pair<LLT, LLT>, 4> Types = TypesInit;
36 std::pair<LLT, LLT> Match = {Query.Types[TypeIdx0], Query.Types[TypeIdx1]};
36 std::pair<LLT, LLT> Match = {Query.Types[TypeIdx0], Query.Types[TypeIdx1]};
78 LLT Ty = Query.Types[TypeIdx];
86 const LLT QueryTy = Query.Types[TypeIdx];
94 const LLT QueryTy = Query.Types[TypeIdx];
102 const LLT QueryTy = Query.Types[TypeIdx];
110 const LLT QueryTy = Query.Types[TypeIdx];
117 const LLT QueryTy = Query.Types[TypeIdx];
124 const LLT QueryTy = Query.Types[TypeIdx];
145 const LLT QueryTy = Query.Types[TypeIdx];
lib/CodeGen/GlobalISel/LegalizeMutations.cpp 17 LegalizeMutation LegalizeMutations::changeTo(unsigned TypeIdx, LLT Ty) {
32 const LLT OldTy = Query.Types[TypeIdx];
33 const LLT NewTy = Query.Types[FromTypeIdx];
39 LLT NewEltTy) {
41 const LLT OldTy = Query.Types[TypeIdx];
49 const LLT Ty = Query.Types[TypeIdx];
59 const LLT VecTy = Query.Types[TypeIdx];
63 LLT::vector(NewNumElements, VecTy.getElementType()));
lib/CodeGen/GlobalISel/LegalizerHelper.cpp 41 getNarrowTypeBreakDown(LLT OrigTy, LLT NarrowTy, LLT &LeftoverTy) {
41 getNarrowTypeBreakDown(LLT OrigTy, LLT NarrowTy, LLT &LeftoverTy) {
41 getNarrowTypeBreakDown(LLT OrigTy, LLT NarrowTy, LLT &LeftoverTy) {
57 LeftoverTy = LLT::scalarOrVector(LeftoverSize / EltSize, EltSize);
59 LeftoverTy = LLT::scalar(LeftoverSize);
123 void LegalizerHelper::extractParts(Register Reg, LLT Ty, int NumParts,
130 bool LegalizerHelper::extractParts(Register Reg, LLT RegTy,
131 LLT MainTy, LLT &LeftoverTy,
131 LLT MainTy, LLT &LeftoverTy,
153 LeftoverTy = LLT::scalarOrVector(LeftoverSize / EltSize, EltSize);
155 LeftoverTy = LLT::scalar(LeftoverSize);
175 static LLT getGCDType(LLT OrigTy, LLT TargetTy) {
175 static LLT getGCDType(LLT OrigTy, LLT TargetTy) {
175 static LLT getGCDType(LLT OrigTy, LLT TargetTy) {
180 return LLT::scalarOrVector(GCD, OrigTy.getElementType());
192 return LLT::scalar(GCD);
196 LLT ResultTy, LLT PartTy,
196 LLT ResultTy, LLT PartTy,
198 LLT LeftoverTy,
403 LLT OpLLT = MRI.getType(Reg);
491 LLT LLTy = MRI.getType(MI.getOperand(0).getReg());
599 LLT NarrowTy) {
629 LLT Ty = MRI.getType(MI.getOperand(0).getReg());
643 LLT LeftoverTy;
647 LeftoverTy = LLT::scalar(LeftoverBits);
665 LLT SrcTy = MRI.getType(SrcReg);
677 MIRBuilder.buildConstant(LLT::scalar(64), NarrowTy.getSizeInBits() - 1);
687 LLT SrcTy = MRI.getType(MI.getOperand(1).getReg());
734 Register CarryOut = MRI.createGenericVirtualRegister(LLT::scalar(1));
767 Register BorrowOut = MRI.createGenericVirtualRegister(LLT::scalar(1));
774 BorrowOut = MRI.createGenericVirtualRegister(LLT::scalar(1));
796 LLT DstTy = MRI.getType(DstReg);
842 LLT SrcTy = MRI.getType(SrcReg);
966 LLT ResTy = MRI.getType(MI.getOperand(0).getReg());
1081 void LegalizerHelper::widenScalarSrc(MachineInstr &MI, LLT WideTy,
1088 void LegalizerHelper::narrowScalarSrc(MachineInstr &MI, LLT NarrowTy,
1096 void LegalizerHelper::widenScalarDst(MachineInstr &MI, LLT WideTy,
1105 void LegalizerHelper::narrowScalarDst(MachineInstr &MI, LLT NarrowTy,
1114 void LegalizerHelper::moreElementsVectorDst(MachineInstr &MI, LLT WideTy,
1123 void LegalizerHelper::moreElementsVectorSrc(MachineInstr &MI, LLT MoreTy,
1127 LLT OldTy = MRI.getType(MO.getReg());
1155 LLT WideTy) {
1160 LLT DstTy = MRI.getType(DstReg);
1165 LLT SrcTy = MRI.getType(Src1);
1227 LLT GCDTy = LLT::scalar(GCD);
1227 LLT GCDTy = LLT::scalar(GCD);
1232 LLT WideDstTy = LLT::scalar(NumMerge * WideSize);
1232 LLT WideDstTy = LLT::scalar(NumMerge * WideSize);
1277 LLT WideTy) {
1283 LLT SrcTy = MRI.getType(SrcReg);
1288 LLT DstTy = MRI.getType(Dst0Reg);
1293 LLT NewSrcTy = LLT::scalar(NewSrcSize);
1293 LLT NewSrcTy = LLT::scalar(NewSrcSize);
1317 LLT WideTy) {
1320 LLT SrcTy = MRI.getType(SrcReg);
1322 LLT DstTy = MRI.getType(DstReg);
1337 LLT SrcAsIntTy = LLT::scalar(SrcTy.getSizeInBits());
1337 LLT SrcAsIntTy = LLT::scalar(SrcTy.getSizeInBits());
1354 LLT ShiftTy = SrcTy;
1396 LLT WideTy) {
1407 LegalizerHelper::widenScalar(MachineInstr &MI, unsigned TypeIdx, LLT WideTy) {
1434 LLT OrigTy = MRI.getType(MI.getOperand(0).getReg());
1463 LLT CurTy = MRI.getType(SrcReg);
1503 LLT Ty = MRI.getType(DstReg);
1519 LLT Ty = MRI.getType(DstReg);
1662 LLT Ty = MRI.getType(MI.getOperand(0).getReg());
1777 LLT VecTy = MRI.getType(VecReg);
1780 widenScalarSrc(MI, LLT::vector(VecTy.getNumElements(),
1802 LLT VecTy = MRI.getType(VecReg);
1803 LLT WideVecTy = LLT::vector(VecTy.getNumElements(), WideTy);
1803 LLT WideVecTy = LLT::vector(VecTy.getNumElements(), WideTy);
1880 const LLT WideEltTy = TypeIdx == 1 ? WideTy : WideTy.getElementType();
1909 LegalizerHelper::lower(MachineInstr &MI, unsigned TypeIdx, LLT Ty) {
2044 LLT DstTy = MRI.getType(DstReg);
2076 LLT PtrTy = MRI.getType(PtrReg);
2078 LLT AnyExtTy = LLT::scalar(AnyExtSize);
2078 LLT AnyExtTy = LLT::scalar(AnyExtSize);
2085 MIRBuilder.buildConstant(LLT::scalar(64), LargeSplitSize / 8);
2105 MRI.createGenericVirtualRegister(LLT::scalar(MMO.getSizeInBits()));
2135 LLT SrcTy = MRI.getType(SrcReg);
2145 const LLT ExtendTy = LLT::scalar(NextPowerOf2(SrcTy.getSizeInBits()));
2145 const LLT ExtendTy = LLT::scalar(NextPowerOf2(SrcTy.getSizeInBits()));
2155 LLT PtrTy = MRI.getType(PtrReg);
2157 MIRBuilder.buildConstant(LLT::scalar(64), LargeSplitSize / 8);
2228 Register LHS_EQ_RHS = MRI.createGenericVirtualRegister(LLT::scalar(1));
2229 Register LHS_ULT_RHS = MRI.createGenericVirtualRegister(LLT::scalar(1));
2265 LLT DstTy = MRI.getType(DstReg);
2286 MachineInstr &MI, unsigned TypeIdx, LLT NarrowTy) {
2315 LLT NarrowTy) {
2321 const LLT DstTy = MRI.getType(DstReg);
2324 const LLT EltTy = DstTy.getElementType();
2420 MachineInstr &MI, unsigned TypeIdx, LLT NarrowTyArg) {
2424 const LLT NarrowTy0 = NarrowTyArg;
2429 LLT DstTy = MRI.getType(DstReg);
2430 LLT LeftoverTy0;
2445 LLT LeftoverTy;
2447 LLT SrcTyI = MRI.getType(SrcReg);
2448 LLT NarrowTyI = LLT::scalarOrVector(NewNumElts, SrcTyI.getScalarType());
2448 LLT NarrowTyI = LLT::scalarOrVector(NewNumElts, SrcTyI.getScalarType());
2449 LLT LeftoverTyI;
2504 LLT NarrowTy) {
2510 LLT DstTy = MRI.getType(DstReg);
2511 LLT SrcTy = MRI.getType(SrcReg);
2513 LLT NarrowTy0 = NarrowTy;
2514 LLT NarrowTy1;
2523 NarrowTy1 = LLT::vector(NumParts, SrcTy.getElementType().getSizeInBits());
2553 LLT NarrowTy) {
2556 LLT DstTy = MRI.getType(DstReg);
2557 LLT SrcTy = MRI.getType(Src0Reg);
2560 LLT NarrowTy0, NarrowTy1;
2569 LLT::vector(NarrowTy.getNumElements(), SrcTy.getScalarSizeInBits()) :
2578 NarrowTy0 = LLT::vector(NarrowTy.getNumElements(),
2620 LLT NarrowTy) {
2625 LLT NarrowTy0, NarrowTy1;
2627 LLT DstTy = MRI.getType(DstReg);
2628 LLT CondTy = MRI.getType(CondReg);
2650 NarrowTy1 = LLT::vector(CondTy.getNumElements() / NumParts,
2692 LLT NarrowTy) {
2694 LLT PhiTy = MRI.getType(DstReg);
2695 LLT LeftoverTy;
2713 LLT Ty = I < NumParts ? NarrowTy : LeftoverTy;
2738 LLT Unused;
2760 LLT NarrowTy) {
2766 LLT SrcTy = MRI.getType(SrcReg);
2768 LLT DstTy = MRI.getType(MI.getOperand(0).getReg());
2774 LLT GCDTy = getGCDType(SrcTy, NarrowTy);
2800 LLT NarrowTy) {
2803 LLT DstTy = MRI.getType(DstReg);
2804 LLT SrcTy = DstTy.getElementType();
2809 LLT WidenedDstTy = LLT::vector(NarrowNumElts * NumConcat, SrcTy);
2809 LLT WidenedDstTy = LLT::vector(NarrowNumElts * NumConcat, SrcTy);
2858 LLT NarrowTy) {
2874 LLT ValTy = MRI.getType(ValReg);
2878 LLT LeftoverTy;
2893 const LLT OffsetTy = LLT::scalar(MRI.getType(AddrReg).getScalarSizeInBits());
2893 const LLT OffsetTy = LLT::scalar(MRI.getType(AddrReg).getScalarSizeInBits());
2945 LLT NarrowTy) {
3043 const LLT HalfTy, const LLT AmtTy) {
3043 const LLT HalfTy, const LLT AmtTy) {
3055 LLT NVT = HalfTy;
3132 LLT RequestedTy) {
3141 LLT DstTy = MRI.getType(DstReg);
3146 LLT ShiftAmtTy = MRI.getType(Amt);
3155 const LLT HalfTy = LLT::scalar(NewBitSize);
3155 const LLT HalfTy = LLT::scalar(NewBitSize);
3156 const LLT CondTy = LLT::scalar(1);
3156 const LLT CondTy = LLT::scalar(1);
3242 LLT MoreTy) {
3261 LLT MoreTy) {
3326 LLT DstTy = MRI.getType(MI.getOperand(0).getReg());
3352 LLT NarrowTy) {
3389 B.buildUAddo(NarrowTy, LLT::scalar(1), Factors[0], Factors[1]);
3394 B.buildUAddo(NarrowTy, LLT::scalar(1), FactorSum, Factors[i]);
3413 LegalizerHelper::narrowScalarMul(MachineInstr &MI, LLT NarrowTy) {
3418 LLT Ty = MRI.getType(DstReg);
3449 LLT NarrowTy) {
3496 SegReg = MRI.createGenericVirtualRegister(LLT::scalar(SegSize));
3514 LLT NarrowTy) {
3568 SegReg = MRI.createGenericVirtualRegister(LLT::scalar(SegSize));
3589 LLT NarrowTy) {
3591 LLT DstTy = MRI.getType(DstReg);
3598 LLT LeftoverTy;
3603 LLT Unused;
3630 LLT NarrowTy) {
3635 LLT CondTy = MRI.getType(CondReg);
3640 LLT DstTy = MRI.getType(DstReg);
3645 LLT LeftoverTy;
3650 LLT Unused;
3675 LegalizerHelper::lowerBitCount(MachineInstr &MI, unsigned TypeIdx, LLT Ty) {
3701 auto MIBICmp = MIRBuilder.buildICmp(CmpInst::ICMP_EQ, LLT::scalar(1),
3752 auto MIBICmp = MIRBuilder.buildICmp(CmpInst::ICMP_EQ, LLT::scalar(1),
3793 const LLT S64 = LLT::scalar(64);
3793 const LLT S64 = LLT::scalar(64);
3794 const LLT S32 = LLT::scalar(32);
3794 const LLT S32 = LLT::scalar(32);
3795 const LLT S1 = LLT::scalar(1);
3795 const LLT S1 = LLT::scalar(1);
3846 LegalizerHelper::lowerUITOFP(MachineInstr &MI, unsigned TypeIdx, LLT Ty) {
3849 LLT DstTy = MRI.getType(Dst);
3850 LLT SrcTy = MRI.getType(Src);
3852 if (SrcTy != LLT::scalar(64))
3855 if (DstTy == LLT::scalar(32)) {
3867 LegalizerHelper::lowerSITOFP(MachineInstr &MI, unsigned TypeIdx, LLT Ty) {
3870 LLT DstTy = MRI.getType(Dst);
3871 LLT SrcTy = MRI.getType(Src);
3873 const LLT S64 = LLT::scalar(64);
3873 const LLT S64 = LLT::scalar(64);
3874 const LLT S32 = LLT::scalar(32);
3874 const LLT S32 = LLT::scalar(32);
3875 const LLT S1 = LLT::scalar(1);
3875 const LLT S1 = LLT::scalar(1);
3905 LegalizerHelper::lowerFPTOUI(MachineInstr &MI, unsigned TypeIdx, LLT Ty) {
3908 LLT DstTy = MRI.getType(Dst);
3909 LLT SrcTy = MRI.getType(Src);
3910 const LLT S64 = LLT::scalar(64);
3910 const LLT S64 = LLT::scalar(64);
3911 const LLT S32 = LLT::scalar(32);
3911 const LLT S32 = LLT::scalar(32);
3962 LegalizerHelper::lowerMinMax(MachineInstr &MI, unsigned TypeIdx, LLT Ty) {
3968 LLT CmpType = MRI.getType(Dst).changeElementSize(1);
3978 LegalizerHelper::lowerFCopySign(MachineInstr &MI, unsigned TypeIdx, LLT Ty) {
3983 const LLT Src0Ty = MRI.getType(Src0);
3984 const LLT Src1Ty = MRI.getType(Src1);
4033 LLT Ty = MRI.getType(Dst);
4059 LLT Ty = MRI.getType(DstReg);
4073 LLT SrcTy = MRI.getType(SrcReg);
4076 LLT DstTy = MRI.getType(Dst0Reg);
4082 LLT IntTy = LLT::scalar(SrcTy.getSizeInBits());
4082 LLT IntTy = LLT::scalar(SrcTy.getSizeInBits());
4107 LLT Src0Ty = MRI.getType(Src0Reg);
4108 LLT DstTy = MRI.getType(DstReg);
4109 LLT IdxTy = LLT::scalar(32);
4109 LLT IdxTy = LLT::scalar(32);
4134 LLT EltTy = DstTy.getElementType();
4170 LLT PtrTy = MRI.getType(Dst);
4171 LLT IntPtrTy = LLT::scalar(PtrTy.getSizeInBits());
4171 LLT IntPtrTy = LLT::scalar(PtrTy.getSizeInBits());
4202 LLT DstTy = MRI.getType(Dst);
4203 LLT SrcTy = MRI.getType(Src);
4208 LLT SrcIntTy = SrcTy;
4210 SrcIntTy = LLT::scalar(SrcTy.getSizeInBits());
4235 LLT DstTy = MRI.getType(Src);
4236 LLT InsertTy = MRI.getType(InsertSrc);
4241 LLT IntDstTy = DstTy;
4243 IntDstTy = LLT::scalar(DstTy.getSizeInBits());
4276 LLT Ty = MRI.getType(Dst0);
4277 LLT BoolTy = MRI.getType(Dst1);
lib/CodeGen/GlobalISel/LegalizerInfo.cpp 86 for (const auto &Type : Types) {
103 const std::pair<unsigned, LLT> &Mutation) {
119 std::pair<unsigned, LLT> Mutation) {
126 const LLT OldTy = Q.Types[TypeIdx];
127 const LLT NewTy = Mutation.second;
190 std::pair<unsigned, LLT> Mutation = Rule.determineMutation(Query);
300 const LLT Type = LLT2Action.first;
378 std::pair<LegalizeAction, LLT>
390 static LLT getTypeFromTypeIdx(const MachineInstr &MI,
478 SmallVector<LLT, 2> Types;
494 LLT Ty = getTypeFromTypeIdx(MI, MRI, i, TypeIdx);
618 std::pair<LegalizeAction, LLT>
642 Aspect.Type.isScalar() ? LLT::scalar(SizeAndAction.first)
643 : LLT::pointer(Aspect.Type.getAddressSpace(),
647 std::pair<LegalizeAction, LLT>
661 LLT IntermediateType;
665 LLT::vector(Aspect.Type.getNumElements(), ElementSizeAndAction.first);
678 LLT::vector(NumElementsAndAction.first,
lib/CodeGen/GlobalISel/MachineIRBuilder.cpp 204 MachineInstrBuilder MachineIRBuilder::buildJumpTable(const LLT PtrTy,
210 void MachineIRBuilder::validateBinaryOp(const LLT &Res, const LLT &Op0,
210 void MachineIRBuilder::validateBinaryOp(const LLT &Res, const LLT &Op0,
211 const LLT &Op1) {
216 void MachineIRBuilder::validateShiftOp(const LLT &Res, const LLT &Op0,
216 void MachineIRBuilder::validateShiftOp(const LLT &Res, const LLT &Op0,
217 const LLT &Op1) {
234 const LLT &ValueTy, uint64_t Value) {
288 LLT Ty = Res.getLLTTy(*getMRI());
289 LLT EltTy = Ty.getScalarType();
316 LLT Ty = Res.getLLTTy(*getMRI());
317 LLT EltTy = Ty.getScalarType();
347 LLT DstTy = Res.getLLTTy(*getMRI());
492 LLT SrcTy = Src.getLLTTy(*getMRI());
493 LLT DstTy = Dst.getLLTTy(*getMRI());
513 LLT SrcTy = Src.getLLTTy(*getMRI());
514 LLT DstTy = Dst.getLLTTy(*getMRI());
548 LLT ResTy = getMRI()->getType(Res);
549 LLT OpTy = getMRI()->getType(Ops[0]);
590 MachineInstrBuilder MachineIRBuilder::buildUnmerge(ArrayRef<LLT> Res,
600 MachineInstrBuilder MachineIRBuilder::buildUnmerge(LLT Res,
747 LLT OldValResTy = getMRI()->getType(OldValRes);
748 LLT SuccessResTy = getMRI()->getType(SuccessRes);
749 LLT AddrTy = getMRI()->getType(Addr);
750 LLT CmpValTy = getMRI()->getType(CmpVal);
751 LLT NewValTy = getMRI()->getType(NewVal);
775 LLT OldValResTy = getMRI()->getType(OldValRes);
776 LLT AddrTy = getMRI()->getType(Addr);
777 LLT CmpValTy = getMRI()->getType(CmpVal);
778 LLT NewValTy = getMRI()->getType(NewVal);
801 LLT OldValResTy = OldValRes.getLLTTy(*getMRI());
802 LLT AddrTy = Addr.getLLTTy(*getMRI());
803 LLT ValTy = Val.getLLTTy(*getMRI());
918 void MachineIRBuilder::validateTruncExt(const LLT &DstTy, const LLT &SrcTy,
918 void MachineIRBuilder::validateTruncExt(const LLT &DstTy, const LLT &SrcTy,
937 void MachineIRBuilder::validateSelectOp(const LLT &ResTy, const LLT &TstTy,
937 void MachineIRBuilder::validateSelectOp(const LLT &ResTy, const LLT &TstTy,
938 const LLT &Op0Ty, const LLT &Op1Ty) {
938 const LLT &Op0Ty, const LLT &Op1Ty) {
lib/CodeGen/GlobalISel/RegBankSelect.cpp 173 LLT RegTy = MRI->getType(MO.getReg());
lib/CodeGen/GlobalISel/RegisterBankInfo.cpp 470 LLT OrigTy = MRI.getType(OrigReg);
471 LLT NewTy = MRI.getType(NewReg);
706 NewVReg = MRI.createGenericVirtualRegister(LLT::scalar(PartMap->Length));
lib/CodeGen/GlobalISel/Utils.cpp 306 auto DstTy = MRI.getType(DefMI->getOperand(0).getReg());
311 auto SrcTy = MRI.getType(SrcReg);
344 LLT Ty = MRI.getType(Op1);
419 LLT Ty = MRI.getType(Op1);
435 MVT llvm::getMVTForLLT(LLT Ty) {
444 LLT llvm::getLLTForMVT(MVT Ty) {
446 return LLT::scalar(Ty.getSizeInBits());
448 return LLT::vector(Ty.getVectorNumElements(),
lib/CodeGen/LowLevelType.cpp 20 LLT llvm::getLLTForType(Type &Ty, const DataLayout &DL) {
23 LLT ScalarTy = getLLTForType(*VTy->getElementType(), DL);
26 return LLT::vector(NumElements, ScalarTy);
28 return LLT::pointer(PTy->getAddressSpace(), DL.getTypeSizeInBits(&Ty));
34 return LLT::scalar(SizeInBits);
lib/CodeGen/MIRParser/MIParser.cpp 426 bool parseLowLevelType(StringRef::iterator Loc, LLT &Ty);
1430 LLT Ty;
1449 LLT Ty;
1519 bool MIParser::parseLowLevelType(StringRef::iterator Loc, LLT &Ty) {
1531 Ty = LLT::scalar(ScalarSize);
1540 Ty = LLT::pointer(AS, DL.getPointerSizeInBits(AS));
1573 Ty = LLT::scalar(ScalarSize);
1580 Ty = LLT::pointer(AS, DL.getPointerSizeInBits(AS));
1589 Ty = LLT::vector(NumElements, Ty);
lib/CodeGen/MIRPrinter.cpp 166 LLT TypeToPrint, bool PrintDef = true);
820 bool ShouldPrintRegisterTies, LLT TypeToPrint,
lib/CodeGen/MachineInstr.cpp 1423 LLT MachineInstr::getTypeToPrint(unsigned OpIdx, SmallBitVector &PrintedTypes,
1439 LLT TypeToPrint = MRI.getType(Op.getReg());
1507 LLT TypeToPrint = MRI ? getTypeToPrint(StartOp, PrintedTypes, *MRI) : LLT{};
1562 LLT TypeToPrint = MRI ? getTypeToPrint(OpIdx, PrintedTypes, *MRI) : LLT{};
1601 LLT TypeToPrint = MRI ? getTypeToPrint(i, PrintedTypes, *MRI) : LLT{};
1612 LLT TypeToPrint = MRI ? getTypeToPrint(i, PrintedTypes, *MRI) : LLT{};
1676 LLT TypeToPrint = MRI ? getTypeToPrint(i, PrintedTypes, *MRI) : LLT{};
lib/CodeGen/MachineOperand.cpp 732 void MachineOperand::print(raw_ostream &OS, LLT TypeToPrint,
743 LLT TypeToPrint, bool PrintDef, bool IsStandalone,
lib/CodeGen/MachineRegisterInfo.cpp 95 const LLT RegTy = getType(Reg);
96 const LLT ConstrainingRegTy = getType(ConstrainingReg);
182 void MachineRegisterInfo::setType(unsigned VReg, LLT Ty) {
188 MachineRegisterInfo::createGenericVirtualRegister(LLT Ty, StringRef Name) {
lib/CodeGen/MachineVerifier.cpp 234 bool verifyVectorElementMatch(LLT Ty0, LLT Ty1, const MachineInstr *MI);
234 bool verifyVectorElementMatch(LLT Ty0, LLT Ty1, const MachineInstr *MI);
247 LLT MOVRegType = LLT{});
510 unsigned MONum, LLT MOVRegType) {
897 bool MachineVerifier::verifyVectorElementMatch(LLT Ty0, LLT Ty1,
897 bool MachineVerifier::verifyVectorElementMatch(LLT Ty0, LLT Ty1,
925 SmallVector<LLT, 4> Types;
941 LLT OpTy = MRI->getType(MO->getReg());
979 LLT DstTy = MRI->getType(MI->getOperand(0).getReg());
1011 LLT ValTy = MRI->getType(MI->getOperand(0).getReg());
1012 LLT PtrTy = MRI->getType(MI->getOperand(1).getReg());
1039 LLT DstTy = MRI->getType(MI->getOperand(0).getReg());
1045 LLT Ty = MRI->getType(MO.getReg());
1056 LLT DstTy = MRI->getType(MI->getOperand(0).getReg());
1057 LLT SrcTy = MRI->getType(MI->getOperand(1).getReg());
1071 LLT DstTy = MRI->getType(MI->getOperand(0).getReg());
1072 LLT SrcTy = MRI->getType(MI->getOperand(1).getReg());
1104 LLT DstTy = MRI->getType(MI->getOperand(0).getReg());
1105 LLT PtrTy = MRI->getType(MI->getOperand(1).getReg());
1106 LLT OffsetTy = MRI->getType(MI->getOperand(2).getReg());
1131 LLT DstTy = MRI->getType(MI->getOperand(0).getReg());
1132 LLT SrcTy = MRI->getType(MI->getOperand(1).getReg());
1136 LLT DstElTy = DstTy.getScalarType();
1137 LLT SrcElTy = SrcTy.getScalarType();
1160 LLT SelTy = MRI->getType(MI->getOperand(0).getReg());
1161 LLT CondTy = MRI->getType(MI->getOperand(1).getReg());
1175 LLT DstTy = MRI->getType(MI->getOperand(0).getReg());
1176 LLT SrcTy = MRI->getType(MI->getOperand(1).getReg());
1192 LLT DstTy = MRI->getType(MI->getOperand(0).getReg());
1193 LLT SrcTy = MRI->getType(MI->getOperand(MI->getNumOperands()-1).getReg());
1209 LLT DstTy = MRI->getType(MI->getOperand(0).getReg());
1210 LLT SrcEltTy = MRI->getType(MI->getOperand(1).getReg());
1233 LLT DstTy = MRI->getType(MI->getOperand(0).getReg());
1234 LLT SrcEltTy = MRI->getType(MI->getOperand(1).getReg());
1253 LLT DstTy = MRI->getType(MI->getOperand(0).getReg());
1254 LLT SrcTy = MRI->getType(MI->getOperand(1).getReg());
1270 LLT DstTy = MRI->getType(MI->getOperand(0).getReg());
1271 LLT SrcTy = MRI->getType(MI->getOperand(2).getReg());
1328 LLT DstTy = MRI->getType(MI->getOperand(0).getReg());
1393 LLT DstTy = MRI->getType(MI->getOperand(0).getReg());
1394 LLT SrcTy = MRI->getType(MI->getOperand(1).getReg());
1423 LLT DstTy = MRI->getType(MI->getOperand(0).getReg());
1424 LLT Src0Ty = MRI->getType(MI->getOperand(1).getReg());
1425 LLT Src1Ty = MRI->getType(MI->getOperand(2).getReg());
1544 LLT DstTy = MRI->getType(DstOp.getReg());
1545 LLT SrcTy = MRI->getType(SrcOp.getReg());
1724 LLT Ty = MRI->getType(Reg);
lib/CodeGen/TargetRegisterInfo.cpp 481 LLT Ty = MRI.getType(Reg);
lib/Support/LowLevelType.cpp 48 const constexpr LLT::BitFieldInfo LLT::ScalarSizeFieldInfo;
49 const constexpr LLT::BitFieldInfo LLT::PointerSizeFieldInfo;
50 const constexpr LLT::BitFieldInfo LLT::PointerAddressSpaceFieldInfo;
51 const constexpr LLT::BitFieldInfo LLT::VectorElementsFieldInfo;
52 const constexpr LLT::BitFieldInfo LLT::VectorSizeFieldInfo;
53 const constexpr LLT::BitFieldInfo LLT::PointerVectorElementsFieldInfo;
54 const constexpr LLT::BitFieldInfo LLT::PointerVectorSizeFieldInfo;
55 const constexpr LLT::BitFieldInfo LLT::PointerVectorAddressSpaceFieldInfo;
lib/Target/AArch64/AArch64CallLowering.cpp 65 Register AddrReg = MRI.createGenericVirtualRegister(LLT::pointer(0, 64));
144 LLT p0 = LLT::pointer(0, 64);
144 LLT p0 = LLT::pointer(0, 64);
145 LLT s64 = LLT::scalar(64);
145 LLT s64 = LLT::scalar(64);
180 ValVReg = MIRBuilder.buildAnyExt(LLT::scalar(Size * 8), ValVReg)
296 CurVReg = MIRBuilder.buildZExt(LLT::scalar(8), CurVReg).getReg(0);
309 LLT NewLLT(NewVT);
310 LLT OldLLT(MVT::getVT(CurArgInfo.Ty));
lib/Target/AArch64/AArch64ISelLowering.cpp 1151 LLT Ty, unsigned AddrSpace, unsigned Align, MachineMemOperand::Flags Flags,
1170 Ty == LLT::vector(2, 64);
9060 LLT AArch64TargetLowering::getOptimalMemOpLLT(
9083 return LLT::vector(2, 64);
9085 return LLT::scalar(128);
9087 return LLT::scalar(64);
9089 return LLT::scalar(32);
lib/Target/AArch64/AArch64ISelLowering.h 290 LLT Ty, unsigned AddrSpace, unsigned Align, MachineMemOperand::Flags Flags,
378 LLT getOptimalMemOpLLT(uint64_t Size, unsigned DstAlign, unsigned SrcAlign,
lib/Target/AArch64/AArch64InstructionSelector.cpp 151 const RegisterBank &DstRB, LLT ScalarTy,
304 getRegClassForTypeOnBank(LLT Ty, const RegisterBank &RB,
406 LLT Ty = MRI.getType(I.getOperand(0).getReg());
755 static unsigned selectFPConvOpc(unsigned GenericOpc, LLT DstTy, LLT SrcTy) {
755 static unsigned selectFPConvOpc(unsigned GenericOpc, LLT DstTy, LLT SrcTy) {
836 LLT Ty = MRI.getType(I.getOperand(0).getReg());
837 if (Ty == LLT::scalar(32))
839 else if (Ty == LLT::scalar(64) || Ty == LLT::pointer(0, 64))
839 else if (Ty == LLT::scalar(64) || Ty == LLT::pointer(0, 64))
1013 const LLT Ty = MRI.getType(DstReg);
1021 if (Ty == LLT::vector(2, 64)) {
1023 } else if (Ty == LLT::vector(4, 32)) {
1025 } else if (Ty == LLT::vector(2, 32)) {
1043 const LLT Ty = MRI.getType(DstReg);
1057 if (Ty == LLT::vector(2, 64)) {
1061 } else if (Ty == LLT::vector(4, 32)) {
1065 } else if (Ty == LLT::vector(2, 32)) {
1171 const LLT ShiftTy = MRI.getType(ShiftReg);
1172 const LLT SrcTy = MRI.getType(SrcReg);
1209 const LLT DstTy = MRI.getType(I.getOperand(0).getReg());
1254 LLT DefDstTy = MRI.getType(DefDstReg);
1256 LLT StoreSrcTy = MRI.getType(StoreSrcReg);
1297 LLT Ty = MRI.getType(DefReg);
1298 if (Ty != LLT::scalar(64) && Ty != LLT::scalar(32))
1298 if (Ty != LLT::scalar(64) && Ty != LLT::scalar(32))
1301 if (Ty == LLT::scalar(64)) {
1334 const LLT DefTy = MRI.getType(DefReg);
1388 LLT Ty =
1450 LLT DstTy = MRI.getType(DstReg);
1488 const LLT s8 = LLT::scalar(8);
1488 const LLT s8 = LLT::scalar(8);
1489 const LLT s16 = LLT::scalar(16);
1489 const LLT s16 = LLT::scalar(16);
1490 const LLT s32 = LLT::scalar(32);
1490 const LLT s32 = LLT::scalar(32);
1491 const LLT s64 = LLT::scalar(64);
1491 const LLT s64 = LLT::scalar(64);
1492 const LLT p0 = LLT::pointer(0, 64);
1492 const LLT p0 = LLT::pointer(0, 64);
1495 const LLT DefTy = MRI.getType(DefReg);
1582 LLT SrcTy = MRI.getType(SrcReg);
1583 LLT DstTy = MRI.getType(DstReg);
1611 DstReg, DstRB, LLT::scalar(64), SrcReg, LaneIdx, MIB);
1628 DstReg = MRI.createGenericVirtualRegister(LLT::scalar(64));
1640 LLT SrcTy = MRI.getType(I.getOperand(2).getReg());
1641 LLT DstTy = MRI.getType(I.getOperand(0).getReg());
1660 Register SrcReg = MRI.createGenericVirtualRegister(LLT::scalar(64));
1675 if (Ty != LLT::pointer(0, 64)) {
1722 LLT PtrTy = MRI.getType(I.getOperand(1).getReg());
1724 if (PtrTy != LLT::pointer(0, 64)) {
1835 if (Ty != LLT::scalar(64)) {
1943 const LLT DstTy = MRI.getType(I.getOperand(0).getReg());
1944 const LLT SrcTy = MRI.getType(I.getOperand(1).getReg());
1977 } else if (Opcode == TargetOpcode::G_TRUNC && DstTy == LLT::scalar(32) &&
1978 SrcTy == LLT::scalar(64)) {
1993 if (DstTy == LLT::vector(4, 16) && SrcTy == LLT::vector(4, 32)) {
1993 if (DstTy == LLT::vector(4, 16) && SrcTy == LLT::vector(4, 32)) {
2002 DstReg, DstRB, LLT::scalar(DstTy.getSizeInBits()), SrcReg, 0, MIB);
2063 const LLT DstTy = MRI.getType(DefReg);
2064 const LLT SrcTy = MRI.getType(SrcReg);
2131 const LLT DstTy = MRI.getType(I.getOperand(0).getReg()),
2158 if (MRI.getType(I.getOperand(1).getReg()) != LLT::scalar(1)) {
2194 if (Ty != LLT::scalar(32)) {
2211 if (Ty != LLT::scalar(32)) {
2281 const LLT DstTy = MRI.getType(I.getOperand(0).getReg());
2402 const LLT SrcTy = MRI.getType(I.getOperand(0).getReg());
2457 const LLT SrcTy = MRI.getType(I.getOperand(0).getReg());
2513 LLT DstTy = MRI.getType(DstReg);
2516 LLT SrcTy = MRI.getType(SrcReg);
2712 const LLT DstTy = MRI.getType(I.getOperand(0).getReg());
2713 const LLT SrcTy = MRI.getType(I.getOperand(1).getReg());
2721 if (DstTy == LLT::scalar(128)) {
2805 Optional<Register> DstReg, const RegisterBank &DstRB, LLT ScalarTy,
2824 const LLT &VecTy = MRI.getType(VecReg);
2869 const LLT NarrowTy = MRI.getType(DstReg);
2871 const LLT WideTy = MRI.getType(SrcReg);
2908 const LLT NarrowTy = MRI.getType(I.getOperand(0).getReg());
2909 const LLT SrcTy = MRI.getType(SrcReg);
2953 const LLT NarrowTy = MRI.getType(I.getOperand(0).getReg());
2954 const LLT WideTy = MRI.getType(SrcReg);
3239 LLT CmpTy = MRI.getType(LHS.getReg());
3242 if (CmpTy == LLT::scalar(32)) {
3245 } else if (CmpTy == LLT::scalar(64) || CmpTy.isPointer()) {
3280 const LLT Op1Ty = MRI.getType(Op1);
3281 const LLT Op2Ty = MRI.getType(Op2);
3300 const LLT ScalarTy = LLT::scalar(Op1Ty.getSizeInBits());
3300 const LLT ScalarTy = LLT::scalar(Op1Ty.getSizeInBits());
3611 LLT VecTy = MRI.getType(I.getOperand(0).getReg());
3612 LLT EltTy = VecTy.getElementType();
3651 const LLT DstTy = MRI.getType(I.getOperand(0).getReg());
3653 const LLT Src1Ty = MRI.getType(Src1Reg);
3655 const LLT Src2Ty = MRI.getType(Src2Reg);
3779 const LLT DstTy = MRI.getType(DstReg);
3784 const LLT EltTy = MRI.getType(EltReg);
3854 const LLT DstTy = MRI.getType(I.getOperand(0).getReg());
3855 const LLT EltTy = MRI.getType(I.getOperand(1).getReg());
lib/Target/AArch64/AArch64LegalizerInfo.cpp 35 const LLT p0 = LLT::pointer(0, 64);
35 const LLT p0 = LLT::pointer(0, 64);
36 const LLT s1 = LLT::scalar(1);
36 const LLT s1 = LLT::scalar(1);
37 const LLT s8 = LLT::scalar(8);
37 const LLT s8 = LLT::scalar(8);
38 const LLT s16 = LLT::scalar(16);
38 const LLT s16 = LLT::scalar(16);
39 const LLT s32 = LLT::scalar(32);
39 const LLT s32 = LLT::scalar(32);
40 const LLT s64 = LLT::scalar(64);
40 const LLT s64 = LLT::scalar(64);
41 const LLT s128 = LLT::scalar(128);
41 const LLT s128 = LLT::scalar(128);
42 const LLT s256 = LLT::scalar(256);
42 const LLT s256 = LLT::scalar(256);
43 const LLT s512 = LLT::scalar(512);
43 const LLT s512 = LLT::scalar(512);
44 const LLT v16s8 = LLT::vector(16, 8);
44 const LLT v16s8 = LLT::vector(16, 8);
45 const LLT v8s8 = LLT::vector(8, 8);
45 const LLT v8s8 = LLT::vector(8, 8);
46 const LLT v4s8 = LLT::vector(4, 8);
46 const LLT v4s8 = LLT::vector(4, 8);
47 const LLT v8s16 = LLT::vector(8, 16);
47 const LLT v8s16 = LLT::vector(8, 16);
48 const LLT v4s16 = LLT::vector(4, 16);
48 const LLT v4s16 = LLT::vector(4, 16);
49 const LLT v2s16 = LLT::vector(2, 16);
49 const LLT v2s16 = LLT::vector(2, 16);
50 const LLT v2s32 = LLT::vector(2, 32);
50 const LLT v2s32 = LLT::vector(2, 32);
51 const LLT v4s32 = LLT::vector(4, 32);
51 const LLT v4s32 = LLT::vector(4, 32);
52 const LLT v2s64 = LLT::vector(2, 64);
52 const LLT v2s64 = LLT::vector(2, 64);
53 const LLT v2p0 = LLT::vector(2, p0);
53 const LLT v2p0 = LLT::vector(2, p0);
72 LLT EltTy = Query.Types[0].getElementType();
74 return std::make_pair(0, LLT::vector(2, 64));
122 const auto &SrcTy = Query.Types[0];
123 const auto &AmtTy = Query.Types[1];
160 const auto &Ty = Query.Types[0];
187 const LLT &Ty0 = Query.Types[0];
188 const LLT &Ty1 = Query.Types[1];
205 const LLT &Ty0 = Query.Types[0];
206 const LLT &Ty1 = Query.Types[1];
239 const LLT &ValTy = Query.Types[0];
242 const LLT EltTy = ValTy.getElementType();
324 const LLT &Ty = Query.Types[0];
325 const LLT &SrcTy = Query.Types[1];
356 const LLT &SrcTy = Query.Types[1];
470 const LLT &Ty = Query.Types[TypeIdx];
472 const LLT &EltTy = Ty.getElementType();
502 const LLT &Ty = Query.Types[BigTyIdx];
509 const LLT &Ty = Query.Types[BigTyIdx];
517 return std::make_pair(BigTyIdx, LLT::scalar(NewSizeInBits));
528 const LLT &BigTy = Query.Types[BigTyIdx];
529 const LLT &LitTy = Query.Types[LitTyIdx];
543 const LLT &EltTy = Query.Types[1].getElementType();
548 const LLT &VecTy = Query.Types[1];
555 const LLT &VecTy = Query.Types[0];
583 const LLT &DstTy = Query.Types[0];
584 const LLT &SrcTy = Query.Types[1];
678 auto ExtCst = MIRBuilder.buildZExt(LLT::scalar(64), AmtReg);
698 const LLT ValTy = MRI.getType(ValReg);
708 const LLT NewTy = LLT::vector(ValTy.getNumElements(), PtrSize);
708 const LLT NewTy = LLT::vector(ValTy.getNumElements(), PtrSize);
731 LLT PtrTy = MRI.getType(ListPtr);
732 LLT IntPtrTy = LLT::scalar(PtrTy.getSizeInBits());
732 LLT IntPtrTy = LLT::scalar(PtrTy.getSizeInBits());
lib/Target/AArch64/AArch64RegisterBankInfo.cpp 428 LLT Ty = MRI.getType(MI.getOperand(0).getReg());
444 LLT OpTy = MRI.getType(MI.getOperand(Idx).getReg());
547 LLT DstTy = MRI.getType(MI.getOperand(0).getReg());
548 LLT SrcTy = MRI.getType(MI.getOperand(1).getReg());
558 LLT ShiftAmtTy = MRI.getType(MI.getOperand(2).getReg());
559 LLT SrcTy = MRI.getType(MI.getOperand(1).getReg());
593 LLT DstTy = MRI.getType(MI.getOperand(0).getReg());
594 LLT SrcTy = MRI.getType(MI.getOperand(1).getReg());
622 LLT Ty = MRI.getType(MO.getReg());
639 LLT SrcTy = MRI.getType(MI.getOperand(1).getReg());
712 LLT SrcTy = MRI.getType(MI.getOperand(2).getReg());
768 LLT SrcTy = MRI.getType(MI.getOperand(MI.getNumOperands()-1).getReg());
771 if (SrcTy.isVector() || SrcTy == LLT::scalar(128) ||
804 LLT SrcTy = MRI.getType(MI.getOperand(1).getReg());
825 const LLT SrcTy = MRI.getType(VReg);
lib/Target/AMDGPU/AMDGPUCallLowering.cpp 58 ExtReg = MIRBuilder.buildAnyExt(LLT::scalar(32), ValVReg).getReg(0);
88 LLT::pointer(AMDGPUAS::PRIVATE_ADDRESS, 32));
101 auto Copy = MIRBuilder.buildCopy(LLT::scalar(32), PhysReg);
185 LLT LLTy = getLLTForType(*Ty, DL);
191 LLT PartLLT = getLLTForType(*PartTy, DL);
208 static LLT getMultipleType(LLT OrigTy, int Factor) {
208 static LLT getMultipleType(LLT OrigTy, int Factor) {
210 return LLT::vector(OrigTy.getNumElements() * Factor,
214 return LLT::scalar(OrigTy.getSizeInBits() * Factor);
221 LLT SrcTy,
222 LLT PartTy) {
248 LLT BigTy = getMultipleType(PartTy, NumRoundedParts);
350 LLT PtrType = getLLTForType(*PtrTy, DL);
356 Register OffsetReg = MRI.createGenericVirtualRegister(LLT::scalar(64));
413 const LLT P4 = LLT::pointer(AMDGPUAS::CONSTANT_ADDRESS, 64);
413 const LLT P4 = LLT::pointer(AMDGPUAS::CONSTANT_ADDRESS, 64);
493 LLT LLTy,
494 LLT PartLLT) {
512 LLT RoundedDestTy = LLT::vector(RoundedElts, PartLLT.getElementType());
512 LLT RoundedDestTy = LLT::vector(RoundedElts, PartLLT.getElementType());
522 LLT DstEltTy = LLTy.getElementType();
544 LLT BVType = LLT::vector(LLTy.getNumElements(), PartLLT);
544 LLT BVType = LLT::vector(LLTy.getNumElements(), PartLLT);
lib/Target/AMDGPU/AMDGPUCallLowering.h 33 using SplitArgTy = std::function<void(ArrayRef<Register>, LLT, LLT, int)>;
33 using SplitArgTy = std::function<void(ArrayRef<Register>, LLT, LLT, int)>;
lib/Target/AMDGPU/AMDGPUGenRegisterBankInfo.def 214 getValueMappingLoadSGPROnly(unsigned BankID, LLT SizeTy) {
228 if (SizeTy == LLT::vector(8, 32))
230 else if (SizeTy == LLT::vector(16, 32))
232 else if (SizeTy == LLT::vector(4, 64))
234 else if (SizeTy == LLT::vector(8, 64))
lib/Target/AMDGPU/AMDGPUInstructionSelector.cpp 86 const LLT Ty = MRI.getType(Reg);
103 const LLT Ty = MRI.getType(Reg);
182 const LLT DefTy = MRI->getType(DefReg);
463 LLT DstTy = MRI->getType(DstReg);
464 LLT SrcTy = MRI->getType(MI.getOperand(1).getReg());
507 LLT DstTy = MRI->getType(DstReg0);
508 LLT SrcTy = MRI->getType(SrcReg);
566 LLT Src1Ty = MRI->getType(Src1Reg);
832 static unsigned getBufferStoreOpcode(LLT Ty,
852 static unsigned getBufferStoreFormatOpcode(LLT Ty,
983 LLT Ty = MRI->getType(VData);
1168 const LLT DstTy = MRI->getType(DstReg);
1169 const LLT SrcTy = MRI->getType(SrcReg);
1224 const LLT DstTy = MRI->getType(DstReg);
1225 const LLT SrcTy = MRI->getType(SrcReg);
1226 const LLT S1 = LLT::scalar(1);
1226 const LLT S1 = LLT::scalar(1);
1378 const LLT DstTy = MRI.getType(DstReg);
1541 const LLT PtrTy = MRI->getType(I.getOperand(1).getReg());
1629 LLT Ty = MRI->getType(DstReg);
lib/Target/AMDGPU/AMDGPULegalizerInfo.cpp 45 const LLT Ty = Query.Types[TypeIdx];
46 const LLT EltTy = Ty.getScalarType();
59 const LLT Ty = Query.Types[TypeIdx];
69 const LLT Ty = Query.Types[TypeIdx];
70 const LLT EltTy = Ty.getScalarType();
77 const LLT Ty = Query.Types[TypeIdx];
78 const LLT EltTy = Ty.getElementType();
79 return std::make_pair(TypeIdx, LLT::vector(Ty.getNumElements() + 1, EltTy));
85 const LLT Ty = Query.Types[TypeIdx];
86 const LLT EltTy = Ty.getElementType();
90 return std::make_pair(TypeIdx, LLT::scalarOrVector(NewNumElts, EltTy));
98 const LLT Ty = Query.Types[TypeIdx];
100 const LLT EltTy = Ty.getElementType();
108 return std::make_pair(TypeIdx, LLT::vector(NewNumElts, EltTy));
114 const LLT QueryTy = Query.Types[TypeIdx];
121 const LLT QueryTy = Query.Types[TypeIdx];
128 const LLT QueryTy = Query.Types[TypeIdx];
137 const LLT Ty = Query.Types[TypeIdx];
149 static LegalityPredicate elementTypeIs(unsigned TypeIdx, LLT Type) {
157 const LLT Ty = Query.Types[TypeIdx];
169 return LLT::pointer(AS, TM.getPointerSizeInBits(AS));
172 const LLT S1 = LLT::scalar(1);
172 const LLT S1 = LLT::scalar(1);
173 const LLT S8 = LLT::scalar(8);
173 const LLT S8 = LLT::scalar(8);
174 const LLT S16 = LLT::scalar(16);
174 const LLT S16 = LLT::scalar(16);
175 const LLT S32 = LLT::scalar(32);
175 const LLT S32 = LLT::scalar(32);
176 const LLT S64 = LLT::scalar(64);
176 const LLT S64 = LLT::scalar(64);
177 const LLT S96 = LLT::scalar(96);
177 const LLT S96 = LLT::scalar(96);
178 const LLT S128 = LLT::scalar(128);
178 const LLT S128 = LLT::scalar(128);
179 const LLT S256 = LLT::scalar(256);
179 const LLT S256 = LLT::scalar(256);
180 const LLT S1024 = LLT::scalar(1024);
180 const LLT S1024 = LLT::scalar(1024);
182 const LLT V2S16 = LLT::vector(2, 16);
182 const LLT V2S16 = LLT::vector(2, 16);
183 const LLT V4S16 = LLT::vector(4, 16);
183 const LLT V4S16 = LLT::vector(4, 16);
185 const LLT V2S32 = LLT::vector(2, 32);
185 const LLT V2S32 = LLT::vector(2, 32);
186 const LLT V3S32 = LLT::vector(3, 32);
186 const LLT V3S32 = LLT::vector(3, 32);
187 const LLT V4S32 = LLT::vector(4, 32);
187 const LLT V4S32 = LLT::vector(4, 32);
188 const LLT V5S32 = LLT::vector(5, 32);
188 const LLT V5S32 = LLT::vector(5, 32);
189 const LLT V6S32 = LLT::vector(6, 32);
189 const LLT V6S32 = LLT::vector(6, 32);
190 const LLT V7S32 = LLT::vector(7, 32);
190 const LLT V7S32 = LLT::vector(7, 32);
191 const LLT V8S32 = LLT::vector(8, 32);
191 const LLT V8S32 = LLT::vector(8, 32);
192 const LLT V9S32 = LLT::vector(9, 32);
192 const LLT V9S32 = LLT::vector(9, 32);
193 const LLT V10S32 = LLT::vector(10, 32);
193 const LLT V10S32 = LLT::vector(10, 32);
194 const LLT V11S32 = LLT::vector(11, 32);
194 const LLT V11S32 = LLT::vector(11, 32);
195 const LLT V12S32 = LLT::vector(12, 32);
195 const LLT V12S32 = LLT::vector(12, 32);
196 const LLT V13S32 = LLT::vector(13, 32);
196 const LLT V13S32 = LLT::vector(13, 32);
197 const LLT V14S32 = LLT::vector(14, 32);
197 const LLT V14S32 = LLT::vector(14, 32);
198 const LLT V15S32 = LLT::vector(15, 32);
198 const LLT V15S32 = LLT::vector(15, 32);
199 const LLT V16S32 = LLT::vector(16, 32);
199 const LLT V16S32 = LLT::vector(16, 32);
200 const LLT V32S32 = LLT::vector(32, 32);
200 const LLT V32S32 = LLT::vector(32, 32);
202 const LLT V2S64 = LLT::vector(2, 64);
202 const LLT V2S64 = LLT::vector(2, 64);
203 const LLT V3S64 = LLT::vector(3, 64);
203 const LLT V3S64 = LLT::vector(3, 64);
204 const LLT V4S64 = LLT::vector(4, 64);
204 const LLT V4S64 = LLT::vector(4, 64);
205 const LLT V5S64 = LLT::vector(5, 64);
205 const LLT V5S64 = LLT::vector(5, 64);
206 const LLT V6S64 = LLT::vector(6, 64);
206 const LLT V6S64 = LLT::vector(6, 64);
207 const LLT V7S64 = LLT::vector(7, 64);
207 const LLT V7S64 = LLT::vector(7, 64);
208 const LLT V8S64 = LLT::vector(8, 64);
208 const LLT V8S64 = LLT::vector(8, 64);
209 const LLT V16S64 = LLT::vector(16, 64);
209 const LLT V16S64 = LLT::vector(16, 64);
211 std::initializer_list<LLT> AllS32Vectors =
214 std::initializer_list<LLT> AllS64Vectors =
217 const LLT GlobalPtr = GetAddrSpacePtr(AMDGPUAS::GLOBAL_ADDRESS);
218 const LLT ConstantPtr = GetAddrSpacePtr(AMDGPUAS::CONSTANT_ADDRESS);
219 const LLT Constant32Ptr = GetAddrSpacePtr(AMDGPUAS::CONSTANT_ADDRESS_32BIT);
220 const LLT LocalPtr = GetAddrSpacePtr(AMDGPUAS::LOCAL_ADDRESS);
221 const LLT RegionPtr = GetAddrSpacePtr(AMDGPUAS::REGION_ADDRESS);
222 const LLT FlatPtr = GetAddrSpacePtr(AMDGPUAS::FLAT_ADDRESS);
223 const LLT PrivatePtr = GetAddrSpacePtr(AMDGPUAS::PRIVATE_ADDRESS);
225 const LLT CodePtr = FlatPtr;
227 const std::initializer_list<LLT> AddrSpaces64 = {
231 const std::initializer_list<LLT> AddrSpaces32 = {
235 const std::initializer_list<LLT> FPTypesBase = {
239 const std::initializer_list<LLT> FPTypes16 = {
243 const std::initializer_list<LLT> FPTypesPK16 = {
303 .legalForCartesianProduct({S16, LLT::vector(2, 8), });
440 {S64, LLT::scalar(33)},
441 {S32, S8}, {S128, S32}, {S128, S64}, {S32, LLT::scalar(24)}})
583 return std::make_pair(1, LLT::scalar(Query.Types[0].getSizeInBits()));
587 return std::make_pair(1, LLT::scalar(Query.Types[0].getSizeInBits()));
599 return std::make_pair(0, LLT::scalar(Query.Types[1].getSizeInBits()));
604 return std::make_pair(0, LLT::scalar(Query.Types[1].getSizeInBits()));
638 const LLT DstTy = Query.Types[0];
645 const LLT PtrTy = Query.Types[1];
725 const LLT DstTy = Query.Types[0];
726 const LLT PtrTy = Query.Types[1];
733 return std::make_pair(0, LLT::scalar(MemSize));
738 return std::make_pair(0, LLT::scalar(32 * (DstSize / 32)));
743 return std::make_pair(0, LLT::scalar(MaxSize));
746 return std::make_pair(0, LLT::scalar(Align));
753 const LLT DstTy = Query.Types[0];
754 const LLT PtrTy = Query.Types[1];
756 LLT EltTy = DstTy.getElementType();
771 LLT::vector(NumElts / NumPieces, EltTy));
779 return std::make_pair(0, LLT::vector(EltSize / Align, EltTy));
793 const LLT Ty0 = Query.Types[0];
876 LLT::vector(2, LocalPtr), LLT::vector(2, PrivatePtr)}, {S1})
876 LLT::vector(2, LocalPtr), LLT::vector(2, PrivatePtr)}, {S1})
919 const LLT EltTy = Query.Types[EltTypeIdx];
920 const LLT VecTy = Query.Types[VecTypeIdx];
921 const LLT IdxTy = Query.Types[IdxTypeIdx];
935 const LLT &EltTy = Query.Types[1].getElementType();
948 const LLT BigTy = Query.Types[BigTyIdx];
949 const LLT LitTy = Query.Types[LitTyIdx];
955 const LLT BigTy = Query.Types[BigTyIdx];
961 const LLT LitTy = Query.Types[LitTyIdx];
1006 const LLT &Ty = Query.Types[TypeIdx];
1008 const LLT &EltTy = Ty.getElementType();
1042 const LLT Ty = Query.Types[LitTyIdx];
1050 const LLT Ty = Query.Types[BigTyIdx];
1057 const LLT &Ty = Query.Types[BigTyIdx];
1064 return std::make_pair(BigTyIdx, LLT::scalar(NewSizeInBits));
1067 const LLT &BigTy = Query.Types[BigTyIdx];
1068 const LLT &LitTy = Query.Types[LitTyIdx];
1142 const LLT S32 = LLT::scalar(32);
1142 const LLT S32 = LLT::scalar(32);
1178 LLT::pointer(AMDGPUAS::CONSTANT_ADDRESS, 64));
1205 B.materializeGEP(LoadAddr, QueuePtr, LLT::scalar(64), StructOffset);
1217 const LLT S32 = LLT::scalar(32);
1217 const LLT S32 = LLT::scalar(32);
1221 LLT DstTy = MRI.getType(Dst);
1222 LLT SrcTy = MRI.getType(Src);
1254 LLT::pointer(AMDGPUAS::CONSTANT_ADDRESS_32BIT, 32), AddrHiVal);
1273 Register CmpRes = MRI.createGenericVirtualRegister(LLT::scalar(1));
1296 Register CmpRes = MRI.createGenericVirtualRegister(LLT::scalar(1));
1322 LLT Ty = MRI.getType(Src);
1338 auto Cond = B.buildFCmp(CmpInst::FCMP_OGT, LLT::scalar(1), Fabs, C2);
1348 const LLT S1 = LLT::scalar(1);
1348 const LLT S1 = LLT::scalar(1);
1349 const LLT S64 = LLT::scalar(64);
1349 const LLT S64 = LLT::scalar(64);
1376 LLT S32 = LLT::scalar(32);
1376 LLT S32 = LLT::scalar(32);
1393 const LLT S1 = LLT::scalar(1);
1393 const LLT S1 = LLT::scalar(1);
1394 const LLT S32 = LLT::scalar(32);
1394 const LLT S32 = LLT::scalar(32);
1395 const LLT S64 = LLT::scalar(64);
1395 const LLT S64 = LLT::scalar(64);
1442 const LLT S64 = LLT::scalar(64);
1442 const LLT S64 = LLT::scalar(64);
1443 const LLT S32 = LLT::scalar(32);
1443 const LLT S32 = LLT::scalar(32);
1504 LLT VecTy = MRI.getType(Vec);
1505 LLT EltTy = VecTy.getElementType();
1534 LLT VecTy = MRI.getType(Vec);
1535 LLT EltTy = VecTy.getElementType();
1556 LLT Ty = MRI.getType(DstReg);
1579 Register DstReg, LLT PtrTy,
1613 LLT ConstPtrTy = LLT::pointer(AMDGPUAS::CONSTANT_ADDRESS, 64);
1613 LLT ConstPtrTy = LLT::pointer(AMDGPUAS::CONSTANT_ADDRESS, 64);
1638 LLT Ty = MRI.getType(DstReg);
1682 LLT PtrTy = LLT::pointer(AMDGPUAS::CONSTANT_ADDRESS, 64);
1682 LLT PtrTy = LLT::pointer(AMDGPUAS::CONSTANT_ADDRESS, 64);
1708 LLT ConstPtr = LLT::pointer(AMDGPUAS::CONSTANT_ADDRESS, 64);
1708 LLT ConstPtr = LLT::pointer(AMDGPUAS::CONSTANT_ADDRESS, 64);
1719 LLT Ty = MRI.getType(MI.getOperand(0).getReg());
1723 if (Ty == LLT::scalar(32) && !ST.hasFP32Denormals())
1725 if (Ty == LLT::scalar(16) && !ST.hasFP16Denormals())
1748 LLT ValTy = MRI.getType(CmpVal);
1749 LLT VecTy = LLT::vector(2, ValTy);
1749 LLT VecTy = LLT::vector(2, ValTy);
1777 Register Reg, LLT Ty) const {
1796 LLT Ty = MRI.getType(DstReg);
1801 const LLT S32 = LLT::scalar(32);
1801 const LLT S32 = LLT::scalar(32);
1864 LLT DstTy = MRI.getType(Dst);
1865 LLT S16 = LLT::scalar(16);
1865 LLT S16 = LLT::scalar(16);
1885 LLT ResTy = MRI.getType(Res);
1886 LLT S32 = LLT::scalar(32);
1886 LLT S32 = LLT::scalar(32);
1887 LLT S64 = LLT::scalar(64);
1887 LLT S64 = LLT::scalar(64);
1946 LLT S16 = LLT::scalar(16);
1946 LLT S16 = LLT::scalar(16);
1947 LLT S32 = LLT::scalar(32);
1947 LLT S32 = LLT::scalar(32);
1978 LLT S32 = LLT::scalar(32);
1978 LLT S32 = LLT::scalar(32);
1979 LLT S1 = LLT::scalar(1);
1979 LLT S1 = LLT::scalar(1);
2020 LLT DstTy = MRI.getType(DstReg);
2021 LLT IdxTy = LLT::scalar(DstTy.getSizeInBits());
2021 LLT IdxTy = LLT::scalar(DstTy.getSizeInBits());
2045 auto Hi32 = B.buildExtract(LLT::scalar(32), MI.getOperand(2).getReg(), 32);
2058 const LLT S16 = LLT::scalar(16);
2058 const LLT S16 = LLT::scalar(16);
2059 const LLT S32 = LLT::scalar(32);
2059 const LLT S32 = LLT::scalar(32);
2060 LLT StoreVT = MRI.getType(Reg);
2071 return B.buildBuildVector(LLT::vector(NumElts, S32), WideRegs).getReg(0);
2080 LLT Ty = MRI.getType(VData);
2084 const LLT S32 = LLT::scalar(32);
2084 const LLT S32 = LLT::scalar(32);
2085 const LLT S16 = LLT::scalar(16);
2085 const LLT S16 = LLT::scalar(16);
2088 if (Ty == LLT::scalar(8) || Ty == S16) {
2089 Register AnyExt = B.buildAnyExt(LLT::scalar(32), VData).getReg(0);
lib/Target/AMDGPU/AMDGPULegalizerInfo.h 63 Register DstReg, LLT PtrTy, MachineIRBuilder &B, const GlobalValue *GV,
79 Register Reg, LLT Ty) const;
lib/Target/AMDGPU/AMDGPURegisterBankInfo.cpp 68 if (MRI.getType(Reg) == LLT::scalar(1))
447 LLT PtrTy = MRI.getType(MI.getOperand(1).getReg());
450 LLT LoadTy = MRI.getType(MI.getOperand(0).getReg());
605 LLT HalfTy,
626 LLT NewTy) {
633 static LLT getHalfSizedType(LLT Ty) {
633 static LLT getHalfSizedType(LLT Ty) {
636 return LLT::scalarOrVector(Ty.getNumElements() / 2, Ty.getElementType());
640 return LLT::scalar(Ty.getSizeInBits() / 2);
687 LLT ResTy = MRI.getType(Def.getReg());
770 LLT OpTy = MRI.getType(Op.getReg());
809 LLT S32 = LLT::scalar(32);
809 LLT S32 = LLT::scalar(32);
817 LLT UnmergeTy = OpSize % 64 == 0 ? LLT::scalar(64) : LLT::scalar(32);
817 LLT UnmergeTy = OpSize % 64 == 0 ? LLT::scalar(64) : LLT::scalar(32);
817 LLT UnmergeTy = OpSize % 64 == 0 ? LLT::scalar(64) : LLT::scalar(32);
854 B.buildMerge(LLT::scalar(64),
1041 const LLT LoadTy = MRI.getType(DstReg);
1070 LLT PtrTy = MRI.getType(MI.getOperand(1).getReg());
1077 const LLT LoadSplitTy = LLT::vector(SplitElts, LoadTy.getScalarType());
1077 const LLT LoadSplitTy = LLT::vector(SplitElts, LoadTy.getScalarType());
1100 Register IdxReg = MRI.createGenericVirtualRegister(LLT::scalar(32));
1155 const LLT S16 = LLT::scalar(16);
1155 const LLT S16 = LLT::scalar(16);
1156 LLT StoreVT = MRI.getType(Reg);
1167 const LLT S32 = LLT::scalar(32);
1167 const LLT S32 = LLT::scalar(32);
1170 return B.buildMerge(LLT::vector(NumElts, S32), WideRegs).getReg(0);
1193 const LLT S32 = LLT::scalar(32);
1193 const LLT S32 = LLT::scalar(32);
1257 LLT Ty = MRI.getType(VData);
1334 LLT DstTy = MRI.getType(DstReg);
1338 LLT HalfTy = getHalfSizedType(DstTy);
1384 LLT DstTy = MRI.getType(DstReg);
1388 LLT HalfTy = getHalfSizedType(DstTy);
1438 LLT DstTy = MRI.getType(DstReg);
1439 if (DstTy != LLT::scalar(16))
1453 if (Helper.widenScalar(MI, 0, LLT::scalar(32)) !=
1474 LLT Ty = MRI.getType(DstReg);
1475 LLT S32 = LLT::scalar(32);
1475 LLT S32 = LLT::scalar(32);
1476 LLT S16 = LLT::scalar(16);
1476 LLT S16 = LLT::scalar(16);
1496 LLT SrcTy = MRI.getType(SrcReg);
1503 LLT DstTy = MRI.getType(DstReg);
1512 const LLT S32 = LLT::scalar(32);
1512 const LLT S32 = LLT::scalar(32);
1534 if (SrcTy != LLT::scalar(1))
1549 LLT SelType = UseSel64 ? LLT::scalar(64) : LLT::scalar(32);
1549 LLT SelType = UseSel64 ? LLT::scalar(64) : LLT::scalar(32);
1549 LLT SelType = UseSel64 ? LLT::scalar(64) : LLT::scalar(32);
1576 auto ShiftAmt = B.buildConstant(LLT::scalar(32), DstTy.getSizeInBits() - 1);
1594 LLT DstTy = MRI.getType(DstReg);
1595 if (DstTy != LLT::vector(2, 16))
1610 const LLT S32 = LLT::scalar(32);
1610 const LLT S32 = LLT::scalar(32);
1665 LLT DstTy = MRI.getType(DstReg);
1670 LLT SrcTy = MRI.getType(SrcReg);
1671 const LLT S32 = LLT::scalar(32);
1671 const LLT S32 = LLT::scalar(32);
1672 LLT Vec32 = LLT::vector(2 * SrcTy.getNumElements(), 32);
1672 LLT Vec32 = LLT::vector(2 * SrcTy.getNumElements(), 32);
1732 LLT SrcTy = MRI.getType(SrcReg);
1733 LLT InsTy = MRI.getType(InsReg);
1738 const LLT S32 = LLT::scalar(32);
1738 const LLT S32 = LLT::scalar(32);
1739 LLT Vec32 = LLT::vector(2 * SrcTy.getNumElements(), 32);
1739 LLT Vec32 = LLT::vector(2 * SrcTy.getNumElements(), 32);
2037 LLT LoadTy = MRI.getType(MI.getOperand(0).getReg());
2039 LLT PtrTy = MRI.getType(PtrReg);
2367 LLT DstTy = MRI.getType(MI.getOperand(0).getReg());
2368 if (DstTy == LLT::vector(2, 16)) {
lib/Target/AMDGPU/AMDGPURegisterBankInfo.h 110 LLT HalfTy,
lib/Target/AMDGPU/SIISelLowering.cpp 1617 const LLT S32 = LLT::scalar(32);
1617 const LLT S32 = LLT::scalar(32);
1670 MF.getRegInfo().setType(LiveInVReg, LLT::scalar(32));
1792 MRI.setType(VReg, LLT::pointer(AMDGPUAS::CONSTANT_ADDRESS, 64));
lib/Target/AMDGPU/SIRegisterInfo.h 255 getRegClassForTypeOnBank(LLT Ty,
lib/Target/ARM/ARMCallLowering.cpp 100 LLT p0 = LLT::pointer(0, 32);
100 LLT p0 = LLT::pointer(0, 32);
101 LLT s32 = LLT::scalar(32);
101 LLT s32 = LLT::scalar(32);
158 Register NewRegs[] = {MRI.createGenericVirtualRegister(LLT::scalar(32)),
159 MRI.createGenericVirtualRegister(LLT::scalar(32))};
303 MRI.createGenericVirtualRegister(LLT::pointer(MPO.getAddrSpace(), 32));
321 auto LoadVReg = MRI.createGenericVirtualRegister(LLT::scalar(32));
358 MRI.createGenericVirtualRegister(LLT::scalar(LocSize));
382 Register NewRegs[] = {MRI.createGenericVirtualRegister(LLT::scalar(32)),
383 MRI.createGenericVirtualRegister(LLT::scalar(32))};
lib/Target/ARM/ARMInstructionSelector.cpp 867 LLT SrcTy = MRI.getType(I.getOperand(1).getReg());
1087 LLT ValTy = MRI.getType(Reg);
lib/Target/ARM/ARMLegalizerInfo.cpp 69 const LLT p0 = LLT::pointer(0, 32);
69 const LLT p0 = LLT::pointer(0, 32);
71 const LLT s1 = LLT::scalar(1);
71 const LLT s1 = LLT::scalar(1);
72 const LLT s8 = LLT::scalar(8);
72 const LLT s8 = LLT::scalar(8);
73 const LLT s16 = LLT::scalar(16);
73 const LLT s16 = LLT::scalar(16);
74 const LLT s32 = LLT::scalar(32);
74 const LLT s32 = LLT::scalar(32);
75 const LLT s64 = LLT::scalar(64);
75 const LLT s64 = LLT::scalar(64);
200 for (auto Ty : {s32, s64})
387 Register RetRegs[] = {MRI.createGenericVirtualRegister(LLT::scalar(32)),
423 auto LibcallResult = MRI.createGenericVirtualRegister(LLT::scalar(32));
448 auto Zero = MRI.createGenericVirtualRegister(LLT::scalar(32));
lib/Target/ARM/ARMRegisterBankInfo.cpp 234 LLT Ty = MRI.getType(MI.getOperand(0).getReg());
269 LLT LargeTy = MRI.getType(MI.getOperand(1).getReg());
279 LLT Ty = MRI.getType(MI.getOperand(0).getReg());
292 LLT Ty = MRI.getType(MI.getOperand(0).getReg());
299 LLT Ty = MRI.getType(MI.getOperand(0).getReg());
313 LLT ToTy = MRI.getType(MI.getOperand(0).getReg());
314 LLT FromTy = MRI.getType(MI.getOperand(1).getReg());
322 LLT ToTy = MRI.getType(MI.getOperand(0).getReg());
323 LLT FromTy = MRI.getType(MI.getOperand(1).getReg());
332 LLT ToTy = MRI.getType(MI.getOperand(0).getReg());
333 LLT FromTy = MRI.getType(MI.getOperand(1).getReg());
346 LLT ToTy = MRI.getType(MI.getOperand(0).getReg());
347 LLT FromTy = MRI.getType(MI.getOperand(1).getReg());
359 LLT Ty = MRI.getType(MI.getOperand(0).getReg());
373 LLT Ty = MRI.getType(MI.getOperand(0).getReg());
375 LLT Ty2 = MRI.getType(MI.getOperand(1).getReg());
387 LLT Ty2 = MRI.getType(MI.getOperand(2).getReg());
397 LLT Ty = MRI.getType(MI.getOperand(0).getReg());
399 LLT Ty1 = MRI.getType(MI.getOperand(2).getReg());
400 LLT Ty2 = MRI.getType(MI.getOperand(3).getReg());
419 LLT Ty = MRI.getType(MI.getOperand(0).getReg());
420 LLT Ty1 = MRI.getType(MI.getOperand(1).getReg());
421 LLT Ty2 = MRI.getType(MI.getOperand(2).getReg());
434 LLT Ty = MRI.getType(MI.getOperand(0).getReg());
435 LLT Ty1 = MRI.getType(MI.getOperand(1).getReg());
436 LLT Ty2 = MRI.getType(MI.getOperand(2).getReg());
lib/Target/Mips/MipsCallLowering.cpp 195 Register AddrReg = MRI.createGenericVirtualRegister(LLT::pointer(0, 32));
206 Register LoadReg = MRI.createGenericVirtualRegister(LLT::scalar(32));
292 LLT p0 = LLT::pointer(0, 32);
292 LLT p0 = LLT::pointer(0, 32);
293 LLT s32 = LLT::scalar(32);
293 LLT s32 = LLT::scalar(32);
323 LLT LocTy{VA.getLocVT()};
522 MIRBuilder.buildCopy(LLT::scalar(RegSize * 8), Register(ArgRegs[I]));
526 MIRBuilder.buildFrameIndex(LLT::pointer(MPO.getAddrSpace(), 32), FI);
574 MF.getRegInfo().createGenericVirtualRegister(LLT::pointer(0, 32));
lib/Target/Mips/MipsLegalizerInfo.cpp 20 LLT ValTy;
21 LLT PtrTy;
45 std::initializer_list<LLT> SupportedValues) {
55 const LLT s1 = LLT::scalar(1);
55 const LLT s1 = LLT::scalar(1);
56 const LLT s32 = LLT::scalar(32);
56 const LLT s32 = LLT::scalar(32);
57 const LLT s64 = LLT::scalar(64);
57 const LLT s64 = LLT::scalar(64);
58 const LLT v16s8 = LLT::vector(16, 8);
58 const LLT v16s8 = LLT::vector(16, 8);
59 const LLT v8s16 = LLT::vector(8, 16);
59 const LLT v8s16 = LLT::vector(8, 16);
60 const LLT v4s32 = LLT::vector(4, 32);
60 const LLT v4s32 = LLT::vector(4, 32);
61 const LLT v2s64 = LLT::vector(2, 64);
61 const LLT v2s64 = LLT::vector(2, 64);
62 const LLT p0 = LLT::pointer(0, 32);
62 const LLT p0 = LLT::pointer(0, 32);
251 const LLT s32 = LLT::scalar(32);
251 const LLT s32 = LLT::scalar(32);
252 const LLT s64 = LLT::scalar(64);
252 const LLT s64 = LLT::scalar(64);
258 LLT DstTy = MRI.getType(Dst);
259 LLT SrcTy = MRI.getType(Src);
362 Register Tmp = MRI.createGenericVirtualRegister(LLT::pointer(0, 32));
lib/Target/Mips/MipsRegisterBankInfo.cpp 423 LLT RegTy = MRI.getType(Op.getReg());
434 const LLT Op0Ty = MRI.getType(MI.getOperand(0).getReg());
680 Helper.narrowScalar(MI, 0, LLT::scalar(32));
lib/Target/X86/X86CallLowering.cpp 109 LLT p0 = LLT::pointer(0, DL.getPointerSizeInBits(0));
109 LLT p0 = LLT::pointer(0, DL.getPointerSizeInBits(0));
110 LLT SType = LLT::scalar(DL.getPointerSizeInBits(0));
110 LLT SType = LLT::scalar(DL.getPointerSizeInBits(0));
141 auto MIB = MIRBuilder.buildAnyExt(LLT::scalar(PhysRegSize), ValVReg);
244 LLT::pointer(0, DL.getPointerSizeInBits(0)));
274 auto Copy = MIRBuilder.buildCopy(LLT::scalar(PhysRegSize), PhysReg);
lib/Target/X86/X86InstructionSelector.cpp 72 unsigned getLoadStoreOp(const LLT &Ty, const RegisterBank &RB, unsigned Opc,
126 const TargetRegisterClass *getRegClass(LLT Ty, const RegisterBank &RB) const;
127 const TargetRegisterClass *getRegClass(LLT Ty, unsigned Reg,
168 X86InstructionSelector::getRegClass(LLT Ty, const RegisterBank &RB) const {
196 X86InstructionSelector::getRegClass(LLT Ty, unsigned Reg,
393 unsigned X86InstructionSelector::getLoadStoreOp(const LLT &Ty,
402 if (Ty == LLT::scalar(8)) {
405 } else if (Ty == LLT::scalar(16)) {
408 } else if (Ty == LLT::scalar(32) || Ty == LLT::pointer(0, 32)) {
408 } else if (Ty == LLT::scalar(32) || Ty == LLT::pointer(0, 32)) {
418 } else if (Ty == LLT::scalar(64) || Ty == LLT::pointer(0, 64)) {
418 } else if (Ty == LLT::scalar(64) || Ty == LLT::pointer(0, 64)) {
507 LLT Ty = MRI.getType(DefReg);
549 static unsigned getLeaOP(LLT Ty, const X86Subtarget &STI) {
550 if (Ty == LLT::pointer(0, 64))
552 else if (Ty == LLT::pointer(0, 32))
567 LLT Ty = MRI.getType(DefReg);
620 LLT Ty = MRI.getType(DefReg);
639 LLT Ty = MRI.getType(DefReg);
714 const LLT DstTy = MRI.getType(DstReg);
715 const LLT SrcTy = MRI.getType(SrcReg);
778 const LLT DstTy = MRI.getType(DstReg);
779 const LLT SrcTy = MRI.getType(SrcReg);
787 LLT SrcTy;
788 LLT DstTy;
792 {LLT::scalar(8), LLT::scalar(16), X86::MOVZX16rr8, false}, // i8 => i16
792 {LLT::scalar(8), LLT::scalar(16), X86::MOVZX16rr8, false}, // i8 => i16
793 {LLT::scalar(8), LLT::scalar(64), X86::MOVZX32rr8, true}, // i8 => i64
793 {LLT::scalar(8), LLT::scalar(64), X86::MOVZX32rr8, true}, // i8 => i64
794 {LLT::scalar(16), LLT::scalar(64), X86::MOVZX32rr16, true}, // i16 => i64
794 {LLT::scalar(16), LLT::scalar(64), X86::MOVZX32rr16, true}, // i16 => i64
795 {LLT::scalar(32), LLT::scalar(64), 0, true} // i32 => i64
795 {LLT::scalar(32), LLT::scalar(64), 0, true} // i32 => i64
825 getRegClass(LLT::scalar(32), DstReg, MRI));
845 if (SrcTy != LLT::scalar(1))
849 if (DstTy == LLT::scalar(8))
851 else if (DstTy == LLT::scalar(16))
853 else if (DstTy == LLT::scalar(32))
855 else if (DstTy == LLT::scalar(64))
861 if (DstTy != LLT::scalar(8)) {
889 const LLT DstTy = MRI.getType(DstReg);
890 const LLT SrcTy = MRI.getType(SrcReg);
953 LLT Ty = MRI.getType(LHS);
1015 LLT Ty = MRI.getType(LhsReg);
1030 *getRegClass(LLT::scalar(8), *RBI.getRegBank(ResultReg, MRI, TRI)), MRI);
1089 const LLT DstTy = MRI.getType(DstReg);
1091 if (DstTy != LLT::scalar(32))
1147 const LLT DstTy = MRI.getType(DstReg);
1148 const LLT SrcTy = MRI.getType(SrcReg);
1198 const LLT DstTy = MRI.getType(DstReg);
1199 const LLT SrcTy = MRI.getType(SrcReg);
1236 const LLT DstTy = MRI.getType(DstReg);
1237 const LLT SrcTy = MRI.getType(SrcReg);
1280 const LLT DstTy = MRI.getType(DstReg);
1281 const LLT InsertRegTy = MRI.getType(InsertReg);
1363 const LLT DstTy = MRI.getType(DstReg);
1364 const LLT SrcTy = MRI.getType(SrcReg0);
1435 const LLT DstTy = MRI.getType(DstReg);
1498 const LLT DstTy = MRI.getType(DstReg);
1530 const LLT RegTy = MRI.getType(DstReg);
lib/Target/X86/X86LegalizerInfo.cpp 108 const LLT p0 = LLT::pointer(0, TM.getPointerSizeInBits(0));
108 const LLT p0 = LLT::pointer(0, TM.getPointerSizeInBits(0));
109 const LLT s1 = LLT::scalar(1);
109 const LLT s1 = LLT::scalar(1);
110 const LLT s8 = LLT::scalar(8);
110 const LLT s8 = LLT::scalar(8);
111 const LLT s16 = LLT::scalar(16);
111 const LLT s16 = LLT::scalar(16);
112 const LLT s32 = LLT::scalar(32);
112 const LLT s32 = LLT::scalar(32);
113 const LLT s64 = LLT::scalar(64);
113 const LLT s64 = LLT::scalar(64);
114 const LLT s128 = LLT::scalar(128);
114 const LLT s128 = LLT::scalar(128);
116 for (auto Ty : {p0, s1, s8, s16, s32})
119 for (auto Ty : {s8, s16, s32, p0})
123 for (auto Ty : {s8, s16, s32})
132 for (auto Ty : {s8, s16, s32, p0})
170 for (auto Ty : {s8, s16, s32, p0})
174 for (auto Ty : {s8, s16, s32}) {
185 for (auto Ty : {s8, s16, s32, p0})
189 for (const auto &Ty : {s16, s32, s64}) {
193 for (const auto &Ty : {s8, s16, s32}) {
204 const LLT p0 = LLT::pointer(0, TM.getPointerSizeInBits(0));
204 const LLT p0 = LLT::pointer(0, TM.getPointerSizeInBits(0));
205 const LLT s1 = LLT::scalar(1);
205 const LLT s1 = LLT::scalar(1);
206 const LLT s8 = LLT::scalar(8);
206 const LLT s8 = LLT::scalar(8);
207 const LLT s16 = LLT::scalar(16);
207 const LLT s16 = LLT::scalar(16);
208 const LLT s32 = LLT::scalar(32);
208 const LLT s32 = LLT::scalar(32);
209 const LLT s64 = LLT::scalar(64);
209 const LLT s64 = LLT::scalar(64);
210 const LLT s128 = LLT::scalar(128);
210 const LLT s128 = LLT::scalar(128);
288 const LLT s32 = LLT::scalar(32);
288 const LLT s32 = LLT::scalar(32);
289 const LLT s64 = LLT::scalar(64);
289 const LLT s64 = LLT::scalar(64);
290 const LLT v4s32 = LLT::vector(4, 32);
290 const LLT v4s32 = LLT::vector(4, 32);
291 const LLT v2s64 = LLT::vector(2, 64);
291 const LLT v2s64 = LLT::vector(2, 64);
294 for (auto Ty : {s32, v4s32})
298 for (auto Ty : {v4s32, v2s64})
305 for (const auto &Ty : {v4s32, v2s64}) {
317 const LLT s32 = LLT::scalar(32);
317 const LLT s32 = LLT::scalar(32);
318 const LLT s64 = LLT::scalar(64);
318 const LLT s64 = LLT::scalar(64);
319 const LLT v16s8 = LLT::vector(16, 8);
319 const LLT v16s8 = LLT::vector(16, 8);
320 const LLT v8s16 = LLT::vector(8, 16);
320 const LLT v8s16 = LLT::vector(8, 16);
321 const LLT v4s32 = LLT::vector(4, 32);
321 const LLT v4s32 = LLT::vector(4, 32);
322 const LLT v2s64 = LLT::vector(2, 64);
322 const LLT v2s64 = LLT::vector(2, 64);
324 const LLT v32s8 = LLT::vector(32, 8);
324 const LLT v32s8 = LLT::vector(32, 8);
325 const LLT v16s16 = LLT::vector(16, 16);
325 const LLT v16s16 = LLT::vector(16, 16);
326 const LLT v8s32 = LLT::vector(8, 32);
326 const LLT v8s32 = LLT::vector(8, 32);
327 const LLT v4s64 = LLT::vector(4, 64);
327 const LLT v4s64 = LLT::vector(4, 64);
330 for (auto Ty : {s64, v2s64})
334 for (auto Ty : {v16s8, v8s16, v4s32, v2s64})
349 for (const auto &Ty :
354 for (const auto &Ty : {v16s8, v8s16, v4s32, v2s64}) {
364 const LLT v4s32 = LLT::vector(4, 32);
364 const LLT v4s32 = LLT::vector(4, 32);
373 const LLT v16s8 = LLT::vector(16, 8);
373 const LLT v16s8 = LLT::vector(16, 8);
374 const LLT v8s16 = LLT::vector(8, 16);
374 const LLT v8s16 = LLT::vector(8, 16);
375 const LLT v4s32 = LLT::vector(4, 32);
375 const LLT v4s32 = LLT::vector(4, 32);
376 const LLT v2s64 = LLT::vector(2, 64);
376 const LLT v2s64 = LLT::vector(2, 64);
378 const LLT v32s8 = LLT::vector(32, 8);
378 const LLT v32s8 = LLT::vector(32, 8);
379 const LLT v64s8 = LLT::vector(64, 8);
379 const LLT v64s8 = LLT::vector(64, 8);
380 const LLT v16s16 = LLT::vector(16, 16);
380 const LLT v16s16 = LLT::vector(16, 16);
381 const LLT v32s16 = LLT::vector(32, 16);
381 const LLT v32s16 = LLT::vector(32, 16);
382 const LLT v8s32 = LLT::vector(8, 32);
382 const LLT v8s32 = LLT::vector(8, 32);
383 const LLT v16s32 = LLT::vector(16, 32);
383 const LLT v16s32 = LLT::vector(16, 32);
384 const LLT v4s64 = LLT::vector(4, 64);
384 const LLT v4s64 = LLT::vector(4, 64);
385 const LLT v8s64 = LLT::vector(8, 64);
385 const LLT v8s64 = LLT::vector(8, 64);
388 for (auto Ty : {v8s32, v4s64})
391 for (auto Ty : {v32s8, v16s16, v8s32, v4s64}) {
395 for (auto Ty : {v16s8, v8s16, v4s32, v2s64}) {
400 for (const auto &Ty :
405 for (const auto &Ty :
416 const LLT v32s8 = LLT::vector(32, 8);
416 const LLT v32s8 = LLT::vector(32, 8);
417 const LLT v16s16 = LLT::vector(16, 16);
417 const LLT v16s16 = LLT::vector(16, 16);
418 const LLT v8s32 = LLT::vector(8, 32);
418 const LLT v8s32 = LLT::vector(8, 32);
419 const LLT v4s64 = LLT::vector(4, 64);
419 const LLT v4s64 = LLT::vector(4, 64);
421 const LLT v64s8 = LLT::vector(64, 8);
421 const LLT v64s8 = LLT::vector(64, 8);
422 const LLT v32s16 = LLT::vector(32, 16);
422 const LLT v32s16 = LLT::vector(32, 16);
423 const LLT v16s32 = LLT::vector(16, 32);
423 const LLT v16s32 = LLT::vector(16, 32);
424 const LLT v8s64 = LLT::vector(8, 64);
424 const LLT v8s64 = LLT::vector(8, 64);
427 for (auto Ty : {v32s8, v16s16, v8s32, v4s64})
430 for (auto Ty : {v16s16, v8s32})
434 for (const auto &Ty : {v64s8, v32s16, v16s32, v8s64}) {
438 for (const auto &Ty : {v32s8, v16s16, v8s32, v4s64}) {
448 const LLT v16s8 = LLT::vector(16, 8);
448 const LLT v16s8 = LLT::vector(16, 8);
449 const LLT v8s16 = LLT::vector(8, 16);
449 const LLT v8s16 = LLT::vector(8, 16);
450 const LLT v4s32 = LLT::vector(4, 32);
450 const LLT v4s32 = LLT::vector(4, 32);
451 const LLT v2s64 = LLT::vector(2, 64);
451 const LLT v2s64 = LLT::vector(2, 64);
453 const LLT v32s8 = LLT::vector(32, 8);
453 const LLT v32s8 = LLT::vector(32, 8);
454 const LLT v16s16 = LLT::vector(16, 16);
454 const LLT v16s16 = LLT::vector(16, 16);
455 const LLT v8s32 = LLT::vector(8, 32);
455 const LLT v8s32 = LLT::vector(8, 32);
456 const LLT v4s64 = LLT::vector(4, 64);
456 const LLT v4s64 = LLT::vector(4, 64);
458 const LLT v64s8 = LLT::vector(64, 8);
458 const LLT v64s8 = LLT::vector(64, 8);
459 const LLT v32s16 = LLT::vector(32, 16);
459 const LLT v32s16 = LLT::vector(32, 16);
460 const LLT v16s32 = LLT::vector(16, 32);
460 const LLT v16s32 = LLT::vector(16, 32);
461 const LLT v8s64 = LLT::vector(8, 64);
461 const LLT v8s64 = LLT::vector(8, 64);
464 for (auto Ty : {v16s32, v8s64})
470 for (auto Ty : {v16s32, v8s64})
473 for (auto Ty : {v64s8, v32s16, v16s32, v8s64}) {
477 for (auto Ty : {v32s8, v16s16, v8s32, v4s64, v16s8, v8s16, v4s32, v2s64}) {
486 for (auto Ty : {v4s32, v8s32})
494 const LLT v8s64 = LLT::vector(8, 64);
494 const LLT v8s64 = LLT::vector(8, 64);
502 const LLT v2s64 = LLT::vector(2, 64);
502 const LLT v2s64 = LLT::vector(2, 64);
503 const LLT v4s64 = LLT::vector(4, 64);
503 const LLT v4s64 = LLT::vector(4, 64);
505 for (auto Ty : {v2s64, v4s64})
513 const LLT v64s8 = LLT::vector(64, 8);
513 const LLT v64s8 = LLT::vector(64, 8);
514 const LLT v32s16 = LLT::vector(32, 16);
514 const LLT v32s16 = LLT::vector(32, 16);
517 for (auto Ty : {v64s8, v32s16})
526 const LLT v8s16 = LLT::vector(8, 16);
526 const LLT v8s16 = LLT::vector(8, 16);
527 const LLT v16s16 = LLT::vector(16, 16);
527 const LLT v16s16 = LLT::vector(16, 16);
529 for (auto Ty : {v8s16, v16s16})
lib/Target/X86/X86RegisterBankInfo.cpp 65 X86GenRegisterBankInfo::getPartialMappingIdx(const LLT &Ty, bool isFP) {
150 LLT Ty = MRI.getType(MI.getOperand(0).getReg());
188 LLT Ty = MRI.getType(MI.getOperand(0).getReg());
214 const LLT Ty0 = MRI.getType(Op0.getReg());
215 const LLT Ty1 = MRI.getType(Op1.getReg());
224 LLT Ty1 = MRI.getType(MI.getOperand(2).getReg());
225 LLT Ty2 = MRI.getType(MI.getOperand(3).getReg());
243 const LLT Ty0 = MRI.getType(Op0.getReg());
244 const LLT Ty1 = MRI.getType(Op1.getReg());
lib/Target/X86/X86RegisterBankInfo.h 35 static PartialMappingIdx getPartialMappingIdx(const LLT &Ty, bool isFP);
unittests/CodeGen/GlobalISel/CSETest.cpp 19 LLT s16{LLT::scalar(16)};
19 LLT s16{LLT::scalar(16)};
20 LLT s32{LLT::scalar(32)};
20 LLT s32{LLT::scalar(32)};
61 auto Splat0 = CSEB.buildConstant(LLT::vector(2, s32), 0);
66 auto FSplat = CSEB.buildFConstant(LLT::vector(2, s32), 1.0);
82 LLT s16{LLT::scalar(16)};
82 LLT s16{LLT::scalar(16)};
unittests/CodeGen/GlobalISel/ConstantFoldingTest.cpp 26 LLT s32 = LLT::scalar(32);
26 LLT s32 = LLT::scalar(32);
76 LLT s32{LLT::scalar(32)};
76 LLT s32{LLT::scalar(32)};
unittests/CodeGen/GlobalISel/GISelMITest.cpp 13 operator<<(std::ostream &OS, const LLT Ty) {
unittests/CodeGen/GlobalISel/GISelMITest.h 49 operator<<(std::ostream &OS, const LLT Ty);
unittests/CodeGen/GlobalISel/KnownBitsTest.cpp 127 const LLT S32 = LLT::scalar(32);
127 const LLT S32 = LLT::scalar(32);
unittests/CodeGen/GlobalISel/LegalizerHelperTest.cpp 39 B.buildInstr(TargetOpcode::G_CTTZ, {LLT::scalar(64)}, {Copies[0]});
71 B.buildInstr(TargetOpcode::G_CTTZ, {LLT::scalar(64)}, {Copies[0]});
105 B.buildInstr(TargetOpcode::G_CTTZ, {LLT::scalar(64)}, {Copies[0]});
136 LLT s8{LLT::scalar(8)};
136 LLT s8{LLT::scalar(8)};
137 LLT s16{LLT::scalar(16)};
137 LLT s16{LLT::scalar(16)};
168 LLT s8{LLT::scalar(8)};
168 LLT s8{LLT::scalar(8)};
169 LLT s16{LLT::scalar(16)};
169 LLT s16{LLT::scalar(16)};
170 LLT s32{LLT::scalar(32)};
170 LLT s32{LLT::scalar(32)};
201 {LLT::scalar(64)}, {Copies[0]});
228 B.buildInstr(TargetOpcode::G_CTLZ, {LLT::scalar(64)}, {Copies[0]});
259 B.buildInstr(TargetOpcode::G_CTLZ, {LLT::scalar(64)}, {Copies[0]});
290 LLT s8{LLT::scalar(8)};
290 LLT s8{LLT::scalar(8)};
331 LLT s8{LLT::scalar(8)};
331 LLT s8{LLT::scalar(8)};
332 LLT s16{LLT::scalar(16)};
332 LLT s16{LLT::scalar(16)};
366 LLT s8{LLT::scalar(8)};
366 LLT s8{LLT::scalar(8)};
367 LLT s16{LLT::scalar(16)};
367 LLT s16{LLT::scalar(16)};
402 LLT s8{LLT::scalar(8)};
402 LLT s8{LLT::scalar(8)};
403 LLT s16{LLT::scalar(16)};
403 LLT s16{LLT::scalar(16)};
435 LLT s8{LLT::scalar(8)};
435 LLT s8{LLT::scalar(8)};
436 LLT s16{LLT::scalar(16)};
436 LLT s16{LLT::scalar(16)};
469 LLT s8{LLT::scalar(8)};
469 LLT s8{LLT::scalar(8)};
470 LLT s16{LLT::scalar(16)};
470 LLT s16{LLT::scalar(16)};
503 LLT s8{LLT::scalar(8)};
503 LLT s8{LLT::scalar(8)};
504 LLT s16{LLT::scalar(16)};
504 LLT s16{LLT::scalar(16)};
506 unsigned CarryReg = MRI->createGenericVirtualRegister(LLT::scalar(1));
542 LLT s8{LLT::scalar(8)};
542 LLT s8{LLT::scalar(8)};
543 LLT s16{LLT::scalar(16)};
543 LLT s16{LLT::scalar(16)};
545 unsigned CarryReg = MRI->createGenericVirtualRegister(LLT::scalar(1));
573 const LLT V2S32 = LLT::vector(2, 32);
573 const LLT V2S32 = LLT::vector(2, 32);
574 const LLT V5S32 = LLT::vector(5, 32);
574 const LLT V5S32 = LLT::vector(5, 32);
620 LLT s32 = LLT::scalar(32);
620 LLT s32 = LLT::scalar(32);
621 LLT v2s32 = LLT::vector(2, 32);
621 LLT v2s32 = LLT::vector(2, 32);
622 LLT v6s32 = LLT::vector(6, 32);
622 LLT v6s32 = LLT::vector(6, 32);
661 LLT s1 = LLT::scalar(1);
661 LLT s1 = LLT::scalar(1);
662 LLT s32 = LLT::scalar(32);
662 LLT s32 = LLT::scalar(32);
663 LLT s64 = LLT::scalar(64);
663 LLT s64 = LLT::scalar(64);
664 LLT v2s32 = LLT::vector(2, 32);
664 LLT v2s32 = LLT::vector(2, 32);
665 LLT v5s32 = LLT::vector(5, 32);
665 LLT v5s32 = LLT::vector(5, 32);
673 LLT PhiTy = v5s32;
763 B.buildInstr(TargetOpcode::G_FADD, {LLT::scalar(64)}, {Copies[0], Copies[1]},
768 B.buildInstr(TargetOpcode::G_FNEG, {LLT::scalar(64)}, {FAdd.getReg(0)},
773 B.buildInstr(TargetOpcode::G_FNEG, {LLT::scalar(64)}, {Copies[0]},
801 LLT s64 = LLT::scalar(64);
801 LLT s64 = LLT::scalar(64);
802 LLT v2s32 = LLT::vector(2, 32);
802 LLT v2s32 = LLT::vector(2, 32);
879 LLT S32 = LLT::scalar(32);
879 LLT S32 = LLT::scalar(32);
880 LLT S16 = LLT::scalar(16);
880 LLT S16 = LLT::scalar(16);
881 LLT V2S16 = LLT::vector(2, S16);
881 LLT V2S16 = LLT::vector(2, S16);
882 LLT V2S32 = LLT::vector(2, S32);
882 LLT V2S32 = LLT::vector(2, S32);
925 const LLT S32 = LLT::scalar(32);
925 const LLT S32 = LLT::scalar(32);
926 const LLT S24 = LLT::scalar(24);
926 const LLT S24 = LLT::scalar(24);
927 const LLT S21 = LLT::scalar(21);
927 const LLT S21 = LLT::scalar(21);
928 const LLT S16 = LLT::scalar(16);
928 const LLT S16 = LLT::scalar(16);
929 const LLT S9 = LLT::scalar(9);
929 const LLT S9 = LLT::scalar(9);
930 const LLT S8 = LLT::scalar(8);
930 const LLT S8 = LLT::scalar(8);
931 const LLT S3 = LLT::scalar(3);
931 const LLT S3 = LLT::scalar(3);
1033 const LLT S32 = LLT::scalar(32);
1033 const LLT S32 = LLT::scalar(32);
1034 const LLT S64 = LLT::scalar(64);
1034 const LLT S64 = LLT::scalar(64);
1035 const LLT P0 = LLT::pointer(0, 64);
1035 const LLT P0 = LLT::pointer(0, 64);
1069 TargetOpcode::G_SEXT_INREG, {LLT::scalar(32)},
1070 {B.buildInstr(TargetOpcode::G_TRUNC, {LLT::scalar(32)}, {Copies[0]}),
1100 TargetOpcode::G_SEXT_INREG, {LLT::scalar(16)},
1101 {B.buildInstr(TargetOpcode::G_TRUNC, {LLT::scalar(16)}, {Copies[0]}),
1130 TargetOpcode::G_SEXT_INREG, {LLT::scalar(32)},
1131 {B.buildInstr(TargetOpcode::G_TRUNC, {LLT::scalar(32)}, {Copies[0]}),
1162 TargetOpcode::G_SEXT_INREG, {LLT::scalar(32)},
1163 {B.buildInstr(TargetOpcode::G_TRUNC, {LLT::scalar(32)}, {Copies[0]}),
unittests/CodeGen/GlobalISel/LegalizerInfoTest.cpp 53 L.setAction({Op, 0, LLT::scalar(Size)}, Legal);
92 L.setAction({G_ADD, LLT::vector(8, 8)}, Legal);
93 L.setAction({G_ADD, LLT::vector(16, 8)}, Legal);
94 L.setAction({G_ADD, LLT::vector(4, 16)}, Legal);
95 L.setAction({G_ADD, LLT::vector(8, 16)}, Legal);
96 L.setAction({G_ADD, LLT::vector(2, 32)}, Legal);
97 L.setAction({G_ADD, LLT::vector(4, 32)}, Legal);
102 L.setAction({G_ADD, 0, LLT::scalar(32)}, Legal);
126 LLT p0 = LLT::pointer(0, 64);
126 LLT p0 = LLT::pointer(0, 64);
127 LLT s64 = LLT::scalar(64);
127 LLT s64 = LLT::scalar(64);
154 LLT s32 = LLT::scalar(32);
154 LLT s32 = LLT::scalar(32);
155 LLT s64 = LLT::scalar(64);
155 LLT s64 = LLT::scalar(64);
174 L.setAction({G_UREM, 0, LLT::scalar(Size)}, Legal);
209 const LLT s5 = LLT::scalar(5);
209 const LLT s5 = LLT::scalar(5);
210 const LLT s8 = LLT::scalar(8);
210 const LLT s8 = LLT::scalar(8);
211 const LLT s16 = LLT::scalar(16);
211 const LLT s16 = LLT::scalar(16);
212 const LLT s32 = LLT::scalar(32);
212 const LLT s32 = LLT::scalar(32);
213 const LLT s33 = LLT::scalar(33);
213 const LLT s33 = LLT::scalar(33);
214 const LLT s64 = LLT::scalar(64);
214 const LLT s64 = LLT::scalar(64);
216 const LLT v2s5 = LLT::vector(2, 5);
216 const LLT v2s5 = LLT::vector(2, 5);
217 const LLT v2s8 = LLT::vector(2, 8);
217 const LLT v2s8 = LLT::vector(2, 8);
218 const LLT v2s16 = LLT::vector(2, 16);
218 const LLT v2s16 = LLT::vector(2, 16);
219 const LLT v2s32 = LLT::vector(2, 32);
219 const LLT v2s32 = LLT::vector(2, 32);
220 const LLT v3s32 = LLT::vector(3, 32);
220 const LLT v3s32 = LLT::vector(3, 32);
221 const LLT v4s32 = LLT::vector(4, 32);
221 const LLT v4s32 = LLT::vector(4, 32);
222 const LLT v2s33 = LLT::vector(2, 33);
222 const LLT v2s33 = LLT::vector(2, 33);
223 const LLT v2s64 = LLT::vector(2, 64);
223 const LLT v2s64 = LLT::vector(2, 64);
225 const LLT p0 = LLT::pointer(0, 32);
225 const LLT p0 = LLT::pointer(0, 32);
226 const LLT v3p0 = LLT::vector(3, p0);
226 const LLT v3p0 = LLT::vector(3, p0);
227 const LLT v4p0 = LLT::vector(4, p0);
227 const LLT v4p0 = LLT::vector(4, p0);
363 const LLT s32 = LLT::scalar(32);
363 const LLT s32 = LLT::scalar(32);
364 const LLT p0 = LLT::pointer(0, 64);
364 const LLT p0 = LLT::pointer(0, 64);
unittests/CodeGen/GlobalISel/MachineIRBuilderTest.cpp 17 B.buildConstant(LLT::scalar(32), 42);
18 B.buildFConstant(LLT::scalar(32), 1.0);
20 B.buildConstant(LLT::vector(2, 32), 99);
21 B.buildFConstant(LLT::vector(2, 32), 2.0);
25 B.buildFConstant(LLT::scalar(64), KVal);
84 LLT s64 = LLT::scalar(64);
84 LLT s64 = LLT::scalar(64);
109 B.buildUnmerge(LLT::scalar(32), Copies[0]);
110 B.buildUnmerge(LLT::scalar(16), Copies[1]);
131 LLT S64 = LLT::scalar(64);
131 LLT S64 = LLT::scalar(64);
164 LLT S64 = LLT::scalar(64);
164 LLT S64 = LLT::scalar(64);
193 LLT S64 = LLT::scalar(64);
193 LLT S64 = LLT::scalar(64);
194 LLT S128 = LLT::scalar(128);
194 LLT S128 = LLT::scalar(128);
222 LLT S32 = LLT::scalar(32);
222 LLT S32 = LLT::scalar(32);
250 LLT S32 = LLT::scalar(32);
250 LLT S32 = LLT::scalar(32);
275 LLT S64 = LLT::scalar(64);
275 LLT S64 = LLT::scalar(64);
301 LLT S64 = LLT::scalar(64);
301 LLT S64 = LLT::scalar(64);
302 LLT P0 = LLT::pointer(0, 64);
302 LLT P0 = LLT::pointer(0, 64);
332 LLT S32 = LLT::scalar(32);
332 LLT S32 = LLT::scalar(32);
340 B.buildMerge(LLT::scalar(128), {RegC0, RegC1, RegC2, RegC3});
342 LLT V2x32 = LLT::vector(2, 32);
342 LLT V2x32 = LLT::vector(2, 32);
348 B.buildMerge(LLT::vector(4, 32), {RegC0C1, RegC2C3});
unittests/CodeGen/GlobalISel/PatternMatchTest.cpp 37 auto MIBCst = B.buildConstant(LLT::scalar(64), 42);
48 LLT s64 = LLT::scalar(64);
48 LLT s64 = LLT::scalar(64);
138 LLT s32 = LLT::scalar(32);
138 LLT s32 = LLT::scalar(32);
168 LLT s64 = LLT::scalar(64);
168 LLT s64 = LLT::scalar(64);
180 LLT s16 = LLT::scalar(16);
180 LLT s16 = LLT::scalar(16);
199 LLT s64 = LLT::scalar(64);
199 LLT s64 = LLT::scalar(64);
200 LLT s32 = LLT::scalar(32);
200 LLT s32 = LLT::scalar(32);
247 LLT s64 = LLT::scalar(64);
247 LLT s64 = LLT::scalar(64);
248 LLT s32 = LLT::scalar(32);
248 LLT s32 = LLT::scalar(32);
256 LLT v2s32 = LLT::vector(2, 32);
256 LLT v2s32 = LLT::vector(2, 32);
266 LLT PtrTy = LLT::pointer(0, 64);
266 LLT PtrTy = LLT::pointer(0, 64);
283 LLT s64 = LLT::scalar(64);
283 LLT s64 = LLT::scalar(64);
284 LLT s32 = LLT::scalar(32);
284 LLT s32 = LLT::scalar(32);
308 m_any_of(m_SpecificType(LLT::scalar(16)), m_GSub(m_Reg(), m_Reg())));
317 LLT s64 = LLT::scalar(64);
317 LLT s64 = LLT::scalar(64);
320 B.buildCast(LLT::pointer(0, 32), MIBAdd);
321 B.buildCast(LLT::pointer(1, 32), MIBAdd);
unittests/CodeGen/LowLevelTypeTest.cpp 25 const LLT Ty = LLT::scalar(S);
25 const LLT Ty = LLT::scalar(S);
54 const LLT STy = LLT::scalar(S);
54 const LLT STy = LLT::scalar(S);
55 const LLT VTy = LLT::vector(Elts, S);
55 const LLT VTy = LLT::vector(Elts, S);
59 const LLT VSTy = LLT::vector(Elts, STy);
59 const LLT VSTy = LLT::vector(Elts, STy);
110 const LLT P0 = LLT::pointer(0, 32);
110 const LLT P0 = LLT::pointer(0, 32);
111 const LLT P1 = LLT::pointer(1, 64);
111 const LLT P1 = LLT::pointer(1, 64);
113 const LLT S32 = LLT::scalar(32);
113 const LLT S32 = LLT::scalar(32);
114 const LLT S64 = LLT::scalar(64);
114 const LLT S64 = LLT::scalar(64);
116 const LLT V2S32 = LLT::vector(2, 32);
116 const LLT V2S32 = LLT::vector(2, 32);
117 const LLT V2S64 = LLT::vector(2, 64);
117 const LLT V2S64 = LLT::vector(2, 64);
119 const LLT V2P0 = LLT::vector(2, P0);
119 const LLT V2P0 = LLT::vector(2, P0);
120 const LLT V2P1 = LLT::vector(2, P1);
120 const LLT V2P1 = LLT::vector(2, P1);
146 const LLT P0 = LLT::pointer(0, 32);
146 const LLT P0 = LLT::pointer(0, 32);
147 const LLT V2P0 = LLT::vector(2, P0);
147 const LLT V2P0 = LLT::vector(2, P0);
172 const LLT Ty = LLT::pointer(AS, DL.getPointerSizeInBits(AS));
172 const LLT Ty = LLT::pointer(AS, DL.getPointerSizeInBits(AS));
173 const LLT VTy = LLT::vector(NumElts, Ty);
173 const LLT VTy = LLT::vector(NumElts, Ty);
210 const LLT Ty;
usr/include/c++/7.4.0/bits/alloc_traits.h 387 using allocator_type = allocator<_Tp>;
389 using value_type = _Tp;
392 using pointer = _Tp*;
395 using const_pointer = const _Tp*;
474 construct(allocator_type& __a, _Up* __p, _Args&&... __args)
474 construct(allocator_type& __a, _Up* __p, _Args&&... __args)
486 destroy(allocator_type& __a, _Up* __p)
usr/include/c++/7.4.0/bits/allocator.h 108 class allocator: public __allocator_base<_Tp>
113 typedef _Tp* pointer;
114 typedef const _Tp* const_pointer;
115 typedef _Tp& reference;
116 typedef const _Tp& const_reference;
117 typedef _Tp value_type;
137 allocator(const allocator<_Tp1>&) throw() { }
usr/include/c++/7.4.0/bits/move.h 46 inline _GLIBCXX_CONSTEXPR _Tp*
47 __addressof(_Tp& __r) _GLIBCXX_NOEXCEPT
72 constexpr _Tp&&
73 forward(typename std::remove_reference<_Tp>::type& __t) noexcept
83 constexpr _Tp&&
84 forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
98 move(_Tp&& __t) noexcept
104 : public __and_<__not_<is_nothrow_move_constructible<_Tp>>,
105 is_copy_constructible<_Tp>>::type { };
usr/include/c++/7.4.0/bits/std_function.h 314 _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
317 std::forward<_ArgTypes>(__args)...);
390 : public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>,
595 _Res operator()(_ArgTypes... __args) const;
628 using _Invoker_type = _Res (*)(const _Any_data&, _ArgTypes&&...);
689 typedef _Function_handler<_Res(_ArgTypes...), _Functor> _My_handler;
706 return _M_invoker(_M_functor, std::forward<_ArgTypes>(__args)...);
usr/include/c++/7.4.0/bits/stl_algo.h 3900 const _Tp& __val)
usr/include/c++/7.4.0/bits/stl_construct.h 74 _Construct(_T1* __p, _Args&&... __args)
74 _Construct(_T1* __p, _Args&&... __args)
75 { ::new(static_cast<void*>(__p)) _T1(std::forward<_Args>(__args)...); }
75 { ::new(static_cast<void*>(__p)) _T1(std::forward<_Args>(__args)...); }
204 allocator<_Tp>&)
usr/include/c++/7.4.0/bits/stl_iterator.h 1224 __make_move_if_noexcept_iterator(_Tp* __i)
usr/include/c++/7.4.0/bits/stl_iterator_base_types.h 181 typedef _Tp value_type;
183 typedef _Tp* pointer;
184 typedef _Tp& reference;
192 typedef _Tp value_type;
194 typedef const _Tp* pointer;
195 typedef const _Tp& reference;
usr/include/c++/7.4.0/bits/stl_pair.h 100 return __and_<is_constructible<_T1, const _U1&>,
100 return __and_<is_constructible<_T1, const _U1&>,
101 is_constructible<_T2, const _U2&>>::value;
101 is_constructible<_T2, const _U2&>>::value;
107 return __and_<is_convertible<const _U1&, _T1>,
107 return __and_<is_convertible<const _U1&, _T1>,
108 is_convertible<const _U2&, _T2>>::value;
108 is_convertible<const _U2&, _T2>>::value;
114 return __and_<is_constructible<_T1, _U1&&>,
114 return __and_<is_constructible<_T1, _U1&&>,
115 is_constructible<_T2, _U2&&>>::value;
115 is_constructible<_T2, _U2&&>>::value;
121 return __and_<is_convertible<_U1&&, _T1>,
121 return __and_<is_convertible<_U1&&, _T1>,
122 is_convertible<_U2&&, _T2>>::value;
122 is_convertible<_U2&&, _T2>>::value;
128 using __do_converts = __and_<is_convertible<const _U1&, _T1>,
128 using __do_converts = __and_<is_convertible<const _U1&, _T1>,
129 is_convertible<_U2&&, _T2>>;
129 is_convertible<_U2&&, _T2>>;
133 return __and_<is_constructible<_T1, const _U1&>,
133 return __and_<is_constructible<_T1, const _U1&>,
134 is_constructible<_T2, _U2&&>,
134 is_constructible<_T2, _U2&&>,
142 using __do_converts = __and_<is_convertible<_U1&&, _T1>,
142 using __do_converts = __and_<is_convertible<_U1&&, _T1>,
143 is_convertible<const _U2&, _T2>>;
143 is_convertible<const _U2&, _T2>>;
147 return __and_<is_constructible<_T1, _U1&&>,
147 return __and_<is_constructible<_T1, _U1&&>,
148 is_constructible<_T2, const _U2&&>,
148 is_constructible<_T2, const _U2&&>,
209 : private __pair_base<_T1, _T2>
209 : private __pair_base<_T1, _T2>
211 typedef _T1 first_type; /// @c first_type is the first bound type
212 typedef _T2 second_type; /// @c second_type is the second bound type
214 _T1 first; /// @c first is a copy of the first object
215 _T2 second; /// @c second is a copy of the second object
252 using _PCCP = _PCC<true, _T1, _T2>;
252 using _PCCP = _PCC<true, _T1, _T2>;
260 constexpr pair(const _T1& __a, const _T2& __b)
260 constexpr pair(const _T1& __a, const _T2& __b)
269 explicit constexpr pair(const _T1& __a, const _T2& __b)
269 explicit constexpr pair(const _T1& __a, const _T2& __b)
283 _T1, _T2>;
283 _T1, _T2>;
291 constexpr pair(const pair<_U1, _U2>& __p)
311 constexpr pair(_U1&& __x, const _T2& __y)
311 constexpr pair(_U1&& __x, const _T2& __y)
318 explicit constexpr pair(_U1&& __x, const _T2& __y)
325 constexpr pair(const _T1& __x, _U2&& __y)
325 constexpr pair(const _T1& __x, _U2&& __y)
326 : first(__x), second(std::forward<_U2>(__y)) { }
332 explicit pair(const _T1& __x, _U2&& __y)
341 constexpr pair(_U1&& __x, _U2&& __y)
341 constexpr pair(_U1&& __x, _U2&& __y)
342 : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
360 constexpr pair(pair<_U1, _U2>&& __p)
362 second(std::forward<_U2>(__p.second)) { }
379 __and_<is_copy_assignable<_T1>,
380 is_copy_assignable<_T2>>::value,
390 __and_<is_move_assignable<_T1>,
391 is_move_assignable<_T2>>::value,
402 typename enable_if<__and_<is_assignable<_T1&, const _U1&>,
402 typename enable_if<__and_<is_assignable<_T1&, const _U1&>,
403 is_assignable<_T2&, const _U2&>>::value,
403 is_assignable<_T2&, const _U2&>>::value,
405 operator=(const pair<_U1, _U2>& __p)
405 operator=(const pair<_U1, _U2>& __p)
413 typename enable_if<__and_<is_assignable<_T1&, _U1&&>,
413 typename enable_if<__and_<is_assignable<_T1&, _U1&&>,
414 is_assignable<_T2&, _U2&&>>::value,
414 is_assignable<_T2&, _U2&&>>::value,
416 operator=(pair<_U1, _U2>&& __p)
416 operator=(pair<_U1, _U2>&& __p)
448 operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
448 operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
448 operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
448 operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
523 typename __decay_and_strip<_T2>::__type>
524 make_pair(_T1&& __x, _T2&& __y)
527 typedef typename __decay_and_strip<_T2>::__type __ds_type2;
529 return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y));
usr/include/c++/7.4.0/bits/stl_uninitialized.h 144 const _Tp& __x)
182 const _Tp& __x)
288 _ForwardIterator __result, allocator<_Tp>&)
usr/include/c++/7.4.0/bits/stl_vector.h 77 rebind<_Tp>::other _Tp_alloc_type;
216 class vector : protected _Vector_base<_Tp, _Alloc>
227 typedef _Vector_base<_Tp, _Alloc> _Base;
232 typedef _Tp value_type;
919 _Tp*
923 const _Tp*
1483 _M_realloc_insert(iterator __position, _Args&&... __args);
usr/include/c++/7.4.0/bits/unique_ptr.h 824 make_unique(_Args&&... __args)
825 { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }
usr/include/c++/7.4.0/ext/alloc_traits.h 117 { typedef typename _Base_type::template rebind_alloc<_Tp> other; };
usr/include/c++/7.4.0/ext/new_allocator.h 63 typedef _Tp* pointer;
64 typedef const _Tp* const_pointer;
65 typedef _Tp& reference;
66 typedef const _Tp& const_reference;
67 typedef _Tp value_type;
111 return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
130 { return size_t(-1) / sizeof(_Tp); }
135 construct(_Up* __p, _Args&&... __args)
135 construct(_Up* __p, _Args&&... __args)
136 { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
140 destroy(_Up* __p) { __p->~_Up(); }
usr/include/c++/7.4.0/initializer_list 50 typedef _E value_type;
51 typedef const _E& reference;
52 typedef const _E& const_reference;
54 typedef const _E* iterator;
55 typedef const _E* const_iterator;
usr/include/c++/7.4.0/tuple 125 constexpr _Head_base(const _Head& __h)
132 constexpr _Head_base(_UHead&& __h)
159 static constexpr _Head&
162 static constexpr const _Head&
210 constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail)
216 constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail)
242 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
248 const _Head& __head, const _Tail&... __tail)
350 static constexpr _Head&
353 static constexpr const _Head&
360 constexpr _Tuple_impl(const _Head& __head)
365 constexpr _Tuple_impl(_UHead&& __head)
390 const _Head& __head)
473 return __and_<is_constructible<_Elements, const _UElements&>...>::value;
479 return __and_<is_convertible<const _UElements&, _Elements>...>::value;
485 return __and_<is_constructible<_Elements, _UElements&&>...>::value;
491 return __and_<is_convertible<_UElements&&, _Elements>...>::value;
608 constexpr tuple(const _Elements&... __elements)
619 explicit constexpr tuple(const _Elements&... __elements)
646 constexpr tuple(_UElements&&... __elements)
730 const _Elements&... __elements)
741 const _Elements&... __elements)
1302 constexpr _Head&
1307 constexpr const _Head&
1313 constexpr __tuple_element_t<__i, tuple<_Elements...>>&
1319 constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
1325 constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
usr/include/c++/7.4.0/type_traits 215 : public __is_void_helper<typename remove_cv<_Tp>::type>::type
326 : public __is_integral_helper<typename remove_cv<_Tp>::type>::type
354 : public __is_floating_point_helper<typename remove_cv<_Tp>::type>::type
381 : public __is_pointer_helper<typename remove_cv<_Tp>::type>::type
567 : public __is_null_pointer_helper<typename remove_cv<_Tp>::type>::type
581 : public __or_<is_lvalue_reference<_Tp>,
582 is_rvalue_reference<_Tp>>::type
588 : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
588 : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
601 : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
601 : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
602 is_void<_Tp>>>::type
611 : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
611 : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
611 : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
612 is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
612 is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
631 : public __is_member_pointer_helper<typename remove_cv<_Tp>::type>::type
638 : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
638 : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
762 typename add_rvalue_reference<_Tp>::type declval() noexcept;
777 : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
777 : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
798 typedef decltype(__test<_Tp>(0)) type;
811 remove_all_extents<_Tp>::type>::type
825 : public __is_destructible_safe<_Tp>::type
889 typedef decltype(__test<_Tp>(0)) type;
894 : public __and_<__not_<is_void<_Tp>>,
895 __is_default_constructible_impl<_Tp>>
915 : public __is_default_constructible_atom<_Tp>::type
921 : public __is_default_constructible_safe<_Tp>::type
984 typedef decltype(__test<_Tp, _Arg>(0)) type;
989 : public __and_<is_destructible<_Tp>,
990 __is_direct_constructible_impl<_Tp, _Arg>>
1072 __is_direct_constructible_ref_cast<_Tp, _Arg>,
1073 __is_direct_constructible_new_safe<_Tp, _Arg>
1079 : public __is_direct_constructible_new<_Tp, _Arg>::type
1119 : public __is_direct_constructible<_Tp, _Arg>
1130 : public __is_constructible_impl<_Tp, _Args...>::type
1142 : public is_constructible<_Tp, const _Tp&>
1142 : public is_constructible<_Tp, const _Tp&>
1148 : public __is_copy_constructible_impl<_Tp>
1160 : public is_constructible<_Tp, _Tp&&>
1160 : public is_constructible<_Tp, _Tp&&>
1166 : public __is_move_constructible_impl<_Tp>
1215 : public __and_<is_constructible<_Tp, _Args...>,
1216 __is_nt_constructible_impl<_Tp, _Args...>>
1246 : public is_nothrow_constructible<_Tp, _Tp&&>
1246 : public is_nothrow_constructible<_Tp, _Tp&&>
1252 : public __is_nothrow_move_constructible_impl<_Tp>
1286 : public is_assignable<_Tp&, const _Tp&>
1286 : public is_assignable<_Tp&, const _Tp&>
1292 : public __is_copy_assignable_impl<_Tp>
1304 : public is_assignable<_Tp&, _Tp&&>
1304 : public is_assignable<_Tp&, _Tp&&>
1310 : public __is_move_assignable_impl<_Tp>
1352 : public is_nothrow_assignable<_Tp&, _Tp&&>
1352 : public is_nothrow_assignable<_Tp&, _Tp&&>
1358 : public __is_nt_move_assignable_impl<_Tp>
1377 static void __helper(const _Tp&);
1390 typedef decltype(__test(declval<_Tp>())) type;
1395 : public __is_implicitly_default_constructible_impl<_Tp>::type
1400 : public __and_<is_default_constructible<_Tp>,
1401 __is_implicitly_default_constructible_safe<_Tp>>
1526 static void __test_aux(_To1);
1538 typedef decltype(__test<_From, _To>(0)) type;
1545 : public __is_convertible_helper<_From, _To>::type
1554 { typedef _Tp type; };
1558 { typedef _Tp type; };
1563 { typedef _Tp type; };
1574 remove_const<typename remove_volatile<_Tp>::type>::type type;
1629 { typedef _Tp type; };
1633 { typedef _Tp type; };
1659 { typedef _Tp&& type; };
1664 : public __add_rvalue_reference_helper<_Tp>
1955 { typedef _Tp type; };
2104 { typedef typename remove_cv<_Up>::type __type; };
2118 typedef typename remove_reference<_Tp>::type __remove_type;
2131 typedef _Tp __type;
2144 typename decay<_Tp>::type>::__type __type;
2428 std::declval<_Fn>()(std::declval<_Args>()...)
2439 typedef decltype(_S_test<_Functor, _ArgTypes...>(0)) type;
2452 _Functor, _ArgTypes...
2458 : public __invoke_result<_Functor, _ArgTypes...>
utils/TableGen/GlobalISelEmitter.cpp 101 LLT Ty;
105 LLTCodeGen(const LLT &Ty) : Ty(Ty) {}
151 const LLT &get() const { return Ty; }
192 LLT::vector(VT.getVectorNumElements(), VT.getScalarSizeInBits()));
195 return LLTCodeGen(LLT::scalar(VT.getSizeInBits()));
1506 Optional<Kind *> addPredicate(Args &&... args) {
1510 getInsnVarID(), getOpIdx(), std::forward<Args>(args)...));
1605 addPredicate<LLTOperandMatcher>(LLT::pointer(VTy.getPtrAddrSpace(),
utils/unittest/googletest/include/gtest/gtest-printers.h 223 void DefaultPrintNonContainerTo(const T& value, ::std::ostream* os) {
276 static ::std::string Format(const ToPrint& value) {
351 const T1& value, const T2& /* other_operand */) {
351 const T1& value, const T2& /* other_operand */) {
352 return FormatForComparison<T1, T2>::Format(value);
352 return FormatForComparison<T1, T2>::Format(value);
366 void UniversalPrint(const T& value, ::std::ostream* os);
373 const C& container, ::std::ostream* os) {
439 const T& value, ::std::ostream* os) {
455 void PrintTo(const T& value, ::std::ostream* os) {
478 DefaultPrintTo(IsContainerTest<T>(0), is_pointer<T>(), value, os);
699 static void Print(const T& value, ::std::ostream* os) {
784 static void Print(const T& value, ::std::ostream* os) {
856 typedef T T1;
983 internal::UniversalTersePrinter<T>::Print(value, &ss);
utils/unittest/googletest/include/gtest/gtest.h 1377 const T1& lhs, const T2& rhs) {
1377 const T1& lhs, const T2& rhs) {
1389 const T1& lhs,
1390 const T2& rhs) {
1419 const T1& lhs,
1420 const T2& rhs) {
1487 const T1& val1, const T2& val2,
1487 const T1& val1, const T2& val2,
utils/unittest/googletest/include/gtest/internal/custom/raw-ostream.h 35 auto printable(const T &V) -> decltype(StreamSwitch<T>::printable(V)) {
35 auto printable(const T &V) -> decltype(StreamSwitch<T>::printable(V)) {
37 return StreamSwitch<T>::printable(V);
54 const T& V;
55 friend std::ostream &operator<<(std::ostream &S, const RawStreamProxy<T> &V) {
69 static const RawStreamProxy<T> printable(const T &V) { return {V}; }
69 static const RawStreamProxy<T> printable(const T &V) { return {V}; }
utils/unittest/googletest/include/gtest/internal/gtest-internal.h 94 ::std::string PrintToString(const T& value);