Skip to content

Commit 5f9b9ec

Browse files
JonPsson1JonPsson1
committed
Pass VL to getScalarizationOverhead
1 parent a51f452 commit 5f9b9ec

14 files changed

+120
-59
lines changed

‎llvm/include/llvm/Analysis/TargetTransformInfo.h

Lines changed: 14 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -909,11 +909,11 @@ class TargetTransformInfo {
909909

910910
/// Estimate the overhead of scalarizing an instruction. Insert and Extract
911911
/// are set if the demanded result elements need to be inserted and/or
912-
/// extracted from vectors.
913-
InstructionCost getScalarizationOverhead(VectorType *Ty,
914-
const APInt &DemandedElts,
915-
bool Insert, bool Extract,
916-
TTI::TargetCostKind CostKind) const;
912+
/// extracted from vectors. The involved values may be passed in VL if
913+
/// Insert is true.
914+
InstructionCost getScalarizationOverhead(
915+
VectorType *Ty, const APInt &DemandedElts, bool Insert, bool Extract,
916+
TTI::TargetCostKind CostKind, ArrayRef<Value *> VL = std::nullopt) const;
917917

918918
/// Estimate the overhead of scalarizing an instructions unique
919919
/// non-constant operands. The (potentially vector) types to use for each of
@@ -2001,10 +2001,10 @@ class TargetTransformInfo::Concept {
20012001
unsigned ScalarOpdIdx) = 0;
20022002
virtual bool isVectorIntrinsicWithOverloadTypeAtArg(Intrinsic::ID ID,
20032003
int ScalarOpdIdx) = 0;
2004-
virtual InstructionCost getScalarizationOverhead(VectorType *Ty,
2005-
const APInt &DemandedElts,
2006-
bool Insert, bool Extract,
2007-
TargetCostKind CostKind) = 0;
2004+
virtual InstructionCost
2005+
getScalarizationOverhead(VectorType *Ty, const APInt &DemandedElts,
2006+
bool Insert, bool Extract, TargetCostKind CostKind,
2007+
ArrayRef<Value *> VL = std::nullopt) = 0;
20082008
virtual InstructionCost
20092009
getOperandsScalarizationOverhead(ArrayRef<const Value *> Args,
20102010
ArrayRef<Type *> Tys,
@@ -2582,12 +2582,12 @@ class TargetTransformInfo::Model final : public TargetTransformInfo::Concept {
25822582
return Impl.isVectorIntrinsicWithOverloadTypeAtArg(ID, ScalarOpdIdx);
25832583
}
25842584

2585-
InstructionCost getScalarizationOverhead(VectorType *Ty,
2586-
const APInt &DemandedElts,
2587-
bool Insert, bool Extract,
2588-
TargetCostKind CostKind) override {
2585+
InstructionCost
2586+
getScalarizationOverhead(VectorType *Ty, const APInt &DemandedElts,
2587+
bool Insert, bool Extract, TargetCostKind CostKind,
2588+
ArrayRef<Value *> VL = std::nullopt) override {
25892589
return Impl.getScalarizationOverhead(Ty, DemandedElts, Insert, Extract,
2590-
CostKind);
2590+
CostKind, VL);
25912591
}
25922592
InstructionCost
25932593
getOperandsScalarizationOverhead(ArrayRef<const Value *> Args,

‎llvm/include/llvm/Analysis/TargetTransformInfoImpl.h

Lines changed: 3 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -401,10 +401,9 @@ class TargetTransformInfoImplBase {
401401
return ScalarOpdIdx == -1;
402402
}
403403

404-
InstructionCost getScalarizationOverhead(VectorType *Ty,
405-
const APInt &DemandedElts,
406-
bool Insert, bool Extract,
407-
TTI::TargetCostKind CostKind) const {
404+
InstructionCost getScalarizationOverhead(
405+
VectorType *Ty, const APInt &DemandedElts, bool Insert, bool Extract,
406+
TTI::TargetCostKind CostKind, ArrayRef<Value *> VL = std::nullopt) const {
408407
return 0;
409408
}
410409

‎llvm/include/llvm/CodeGen/BasicTTIImpl.h

Lines changed: 10 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -777,10 +777,12 @@ class BasicTTIImplBase : public TargetTransformInfoImplCRTPBase<T> {
777777
/// Estimate the overhead of scalarizing an instruction. Insert and Extract
778778
/// are set if the demanded result elements need to be inserted and/or
779779
/// extracted from vectors.
780-
InstructionCost getScalarizationOverhead(VectorType *InTy,
781-
const APInt &DemandedElts,
782-
bool Insert, bool Extract,
783-
TTI::TargetCostKind CostKind) {
780+
InstructionCost getScalarizationOverhead(
781+
VectorType *InTy, const APInt &DemandedElts, bool Insert, bool Extract,
782+
TTI::TargetCostKind CostKind, ArrayRef<Value *> VL = std::nullopt) {
783+
assert((VL.empty() ||
784+
VL.size() == cast<FixedVectorType>(InTy)->getNumElements()) &&
785+
"Type does not match the values.");
784786
/// FIXME: a bitfield is not a reasonable abstraction for talking about
785787
/// which elements are needed from a scalable vector
786788
if (isa<ScalableVectorType>(InTy))
@@ -795,9 +797,11 @@ class BasicTTIImplBase : public TargetTransformInfoImplCRTPBase<T> {
795797
for (int i = 0, e = Ty->getNumElements(); i < e; ++i) {
796798
if (!DemandedElts[i])
797799
continue;
798-
if (Insert)
800+
if (Insert) {
801+
Value *InsertedVal = VL.size() ? VL[i] : nullptr;
799802
Cost += thisT()->getVectorInstrCost(Instruction::InsertElement, Ty,
800-
CostKind, i, nullptr, nullptr);
803+
CostKind, i, nullptr, InsertedVal);
804+
}
801805
if (Extract)
802806
Cost += thisT()->getVectorInstrCost(Instruction::ExtractElement, Ty,
803807
CostKind, i, nullptr, nullptr);

‎llvm/lib/Analysis/TargetTransformInfo.cpp

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -622,9 +622,9 @@ bool TargetTransformInfo::isVectorIntrinsicWithOverloadTypeAtArg(
622622

623623
InstructionCost TargetTransformInfo::getScalarizationOverhead(
624624
VectorType *Ty, const APInt &DemandedElts, bool Insert, bool Extract,
625-
TTI::TargetCostKind CostKind) const {
625+
TTI::TargetCostKind CostKind, ArrayRef<Value *> VL) const {
626626
return TTIImpl->getScalarizationOverhead(Ty, DemandedElts, Insert, Extract,
627-
CostKind);
627+
CostKind, VL);
628628
}
629629

630630
InstructionCost TargetTransformInfo::getOperandsScalarizationOverhead(

‎llvm/lib/Target/AArch64/AArch64TargetTransformInfo.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -3363,7 +3363,7 @@ InstructionCost AArch64TTIImpl::getVectorInstrCost(const Instruction &I,
33633363

33643364
InstructionCost AArch64TTIImpl::getScalarizationOverhead(
33653365
VectorType *Ty, const APInt &DemandedElts, bool Insert, bool Extract,
3366-
TTI::TargetCostKind CostKind) {
3366+
TTI::TargetCostKind CostKind, ArrayRef<Value *> VL) {
33673367
if (isa<ScalableVectorType>(Ty))
33683368
return InstructionCost::getInvalid();
33693369
if (Ty->getElementType()->isFloatingPointTy())

‎llvm/lib/Target/AArch64/AArch64TargetTransformInfo.h

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -423,7 +423,8 @@ class AArch64TTIImpl : public BasicTTIImplBase<AArch64TTIImpl> {
423423
InstructionCost getScalarizationOverhead(VectorType *Ty,
424424
const APInt &DemandedElts,
425425
bool Insert, bool Extract,
426-
TTI::TargetCostKind CostKind);
426+
TTI::TargetCostKind CostKind,
427+
ArrayRef<Value *> VL = std::nullopt);
427428

428429
/// Return the cost of the scaling factor used in the addressing
429430
/// mode represented by AM for this target, for a load/store

‎llvm/lib/Target/RISCV/RISCVTargetTransformInfo.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -669,7 +669,7 @@ static unsigned isM1OrSmaller(MVT VT) {
669669

670670
InstructionCost RISCVTTIImpl::getScalarizationOverhead(
671671
VectorType *Ty, const APInt &DemandedElts, bool Insert, bool Extract,
672-
TTI::TargetCostKind CostKind) {
672+
TTI::TargetCostKind CostKind, ArrayRef<Value *> VL) {
673673
if (isa<ScalableVectorType>(Ty))
674674
return InstructionCost::getInvalid();
675675

‎llvm/lib/Target/RISCV/RISCVTargetTransformInfo.h

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -149,7 +149,8 @@ class RISCVTTIImpl : public BasicTTIImplBase<RISCVTTIImpl> {
149149
InstructionCost getScalarizationOverhead(VectorType *Ty,
150150
const APInt &DemandedElts,
151151
bool Insert, bool Extract,
152-
TTI::TargetCostKind CostKind);
152+
TTI::TargetCostKind CostKind,
153+
ArrayRef<Value *> VL = std::nullopt);
153154

154155
InstructionCost getIntrinsicInstrCost(const IntrinsicCostAttributes &ICA,
155156
TTI::TargetCostKind CostKind);

‎llvm/lib/Target/SystemZ/SystemZTargetTransformInfo.cpp

Lines changed: 16 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -468,17 +468,28 @@ bool SystemZTTIImpl::hasDivRemOp(Type *DataType, bool IsSigned) {
468468
return (VT.isScalarInteger() && TLI->isTypeLegal(VT));
469469
}
470470

471+
static bool isFreeEltLoad(Value *Op) {
472+
if (isa<LoadInst>(Op) && Op->hasOneUse()) {
473+
const Instruction *UserI = cast<Instruction>(*Op->user_begin());
474+
return !isa<StoreInst>(UserI); // Prefer MVC
475+
}
476+
return false;
477+
}
478+
471479
InstructionCost SystemZTTIImpl::getScalarizationOverhead(
472480
VectorType *Ty, const APInt &DemandedElts, bool Insert, bool Extract,
473-
TTI::TargetCostKind CostKind) {
481+
TTI::TargetCostKind CostKind, ArrayRef<Value *> VL) {
474482
unsigned NumElts = cast<FixedVectorType>(Ty)->getNumElements();
475483
InstructionCost Cost = 0;
476484

477485
if (Insert && Ty->isIntOrIntVectorTy(64)) {
478-
// VLVGP will insert two GPRs with one instruction.
486+
// VLVGP will insert two GPRs with one instruction, while VLE will load
487+
// an element directly with no extra cost
488+
assert((VL.empty() || VL.size() == NumElts) &&
489+
"Type does not match the number of values.");
479490
InstructionCost CurrVectorCost = 0;
480491
for (unsigned Idx = 0; Idx < NumElts; ++Idx) {
481-
if (DemandedElts[Idx])
492+
if (DemandedElts[Idx] && !(VL.size() && isFreeEltLoad(VL[Idx])))
482493
++CurrVectorCost;
483494
if (Idx % 2 == 1) {
484495
Cost += std::min(InstructionCost(1), CurrVectorCost);
@@ -489,7 +500,7 @@ InstructionCost SystemZTTIImpl::getScalarizationOverhead(
489500
}
490501

491502
Cost += BaseT::getScalarizationOverhead(Ty, DemandedElts, Insert, Extract,
492-
CostKind);
503+
CostKind, VL);
493504
return Cost;
494505
}
495506

@@ -1142,7 +1153,7 @@ InstructionCost SystemZTTIImpl::getVectorInstrCost(unsigned Opcode, Type *Val,
11421153
Value *Op1) {
11431154
if (Opcode == Instruction::InsertElement) {
11441155
// Vector Element Load.
1145-
if (Op1 != nullptr && Op1->hasOneUse() && isa<LoadInst>(Op1))
1156+
if (Op1 != nullptr && isFreeEltLoad(Op1))
11461157
return 0;
11471158

11481159
// vlvgp will insert two grs into a vector register, so count half the

‎llvm/lib/Target/SystemZ/SystemZTargetTransformInfo.h

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -84,7 +84,8 @@ class SystemZTTIImpl : public BasicTTIImplBase<SystemZTTIImpl> {
8484
InstructionCost getScalarizationOverhead(VectorType *Ty,
8585
const APInt &DemandedElts,
8686
bool Insert, bool Extract,
87-
TTI::TargetCostKind CostKind);
87+
TTI::TargetCostKind CostKind,
88+
ArrayRef<Value *> VL = std::nullopt);
8889
bool supportsEfficientVectorElementLoadStore() { return true; }
8990
bool enableInterleavedAccessVectorization() { return true; }
9091

‎llvm/lib/Target/X86/X86TargetTransformInfo.cpp

Lines changed: 3 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -4854,10 +4854,9 @@ InstructionCost X86TTIImpl::getVectorInstrCost(unsigned Opcode, Type *Val,
48544854
RegisterFileMoveCost;
48554855
}
48564856

4857-
InstructionCost
4858-
X86TTIImpl::getScalarizationOverhead(VectorType *Ty, const APInt &DemandedElts,
4859-
bool Insert, bool Extract,
4860-
TTI::TargetCostKind CostKind) {
4857+
InstructionCost X86TTIImpl::getScalarizationOverhead(
4858+
VectorType *Ty, const APInt &DemandedElts, bool Insert, bool Extract,
4859+
TTI::TargetCostKind CostKind, ArrayRef<Value *> VL) {
48614860
assert(DemandedElts.getBitWidth() ==
48624861
cast<FixedVectorType>(Ty)->getNumElements() &&
48634862
"Vector size mismatch");

‎llvm/lib/Target/X86/X86TargetTransformInfo.h

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -169,7 +169,8 @@ class X86TTIImpl : public BasicTTIImplBase<X86TTIImpl> {
169169
InstructionCost getScalarizationOverhead(VectorType *Ty,
170170
const APInt &DemandedElts,
171171
bool Insert, bool Extract,
172-
TTI::TargetCostKind CostKind);
172+
TTI::TargetCostKind CostKind,
173+
ArrayRef<Value *> VL = std::nullopt);
173174
InstructionCost getReplicationShuffleCost(Type *EltTy, int ReplicationFactor,
174175
int VF,
175176
const APInt &DemandedDstElts,

‎llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp

Lines changed: 3 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -13497,17 +13497,10 @@ InstructionCost BoUpSLP::getGatherCost(ArrayRef<Value *> VL, bool ForPoisonSrc,
1349713497
TTI::SK_InsertSubvector, VecTy, std::nullopt, CostKind,
1349813498
I * ScalarTyNumElements, cast<FixedVectorType>(ScalarTy));
1349913499
} else {
13500-
// Add insertion costs for all elements, but not for loads that can be
13501-
// loaded directly into a vector element for free.
13502-
APInt FreeEltLoads = APInt::getZero(VL.size());
13503-
if (TTI->supportsEfficientVectorElementLoadStore())
13504-
for (unsigned I : seq<unsigned>(VL.size()))
13505-
if (VL[I]->hasOneUse() && isa<LoadInst>(VL[I]))
13506-
FreeEltLoads.setBit(I);
13507-
APInt DemandedElts = ~ShuffledElements & ~FreeEltLoads;
13508-
Cost = TTI->getScalarizationOverhead(VecTy, DemandedElts,
13500+
Cost = TTI->getScalarizationOverhead(VecTy,
13501+
/*DemandedElts*/ ~ShuffledElements,
1350913502
/*Insert*/ true,
13510-
/*Extract*/ false, CostKind);
13503+
/*Extract*/ false, CostKind, VL);
1351113504
}
1351213505
}
1351313506
if (DuplicateNonConst)

‎llvm/test/Transforms/SLPVectorizer/SystemZ/vec-elt-insertion.ll

Lines changed: 59 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -6,15 +6,17 @@
66
; Test functions that (at least currently) only gets vectorized if the
77
; insertion cost for an element load is counted as free.
88

9+
declare double @llvm.fmuladd.f64(double, double, double)
10+
911
; This function needs the free element load to be recognized in SLP
1012
; getGatherCost().
11-
define void @fun0(ptr nocapture %0, double %1) {
13+
define void @fun0(ptr %0, double %1) {
1214
; CHECK-LABEL: define void @fun0(
13-
; CHECK-SAME: ptr nocapture [[TMP0:%.*]], double [[TMP1:%.*]]) #[[ATTR0:[0-9]+]] {
15+
; CHECK-SAME: ptr [[TMP0:%.*]], double [[TMP1:%.*]]) #[[ATTR1:[0-9]+]] {
1416
; CHECK-NEXT: [[TMP3:%.*]] = load double, ptr [[TMP0]], align 8
1517
; CHECK-NEXT: [[TMP4:%.*]] = insertelement <2 x double> poison, double [[TMP1]], i32 0
1618
; CHECK-NEXT: [[TMP5:%.*]] = insertelement <2 x double> [[TMP4]], double [[TMP3]], i32 1
17-
; CHECK-NEXT: [[TMP6:%.*]] = fmul <2 x double> [[TMP5]], <double 2.000000e+00, double 2.000000e+00>
19+
; CHECK-NEXT: [[TMP6:%.*]] = fmul <2 x double> [[TMP5]], splat (double 2.000000e+00)
1820
; CHECK-NEXT: [[TMP7:%.*]] = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> [[TMP6]], <2 x double> [[TMP6]], <2 x double> zeroinitializer)
1921
; CHECK-NEXT: [[TMP8:%.*]] = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> [[TMP6]], <2 x double> [[TMP6]], <2 x double> [[TMP7]])
2022
; CHECK-NEXT: [[TMP9:%.*]] = call <2 x double> @llvm.sqrt.v2f64(<2 x double> [[TMP8]])
@@ -43,12 +45,11 @@ define void @fun0(ptr nocapture %0, double %1) {
4345
ret void
4446
}
4547

46-
4748
; This function needs the element-load to be recognized in SystemZ
4849
; getVectorInstrCost().
4950
define void @fun1(double %0) {
5051
; CHECK-LABEL: define void @fun1(
51-
; CHECK-SAME: double [[TMP0:%.*]]) #[[ATTR0]] {
52+
; CHECK-SAME: double [[TMP0:%.*]]) #[[ATTR1]] {
5253
; CHECK-NEXT: [[TMP2:%.*]] = insertelement <2 x double> <double 0.000000e+00, double poison>, double [[TMP0]], i32 1
5354
; CHECK-NEXT: br label %[[BB3:.*]]
5455
; CHECK: [[BB3]]:
@@ -102,13 +103,11 @@ define void @fun1(double %0) {
102103
br label %2
103104
}
104105

105-
declare double @llvm.fmuladd.f64(double, double, double)
106-
107106
; This should *not* be vectorized as the insertion into the vector isn't free,
108107
; which is recognized in SystemZTTImpl::getScalarizationOverhead().
109108
define void @fun2(ptr %0, ptr %Dst) {
110109
; CHECK-LABEL: define void @fun2(
111-
; CHECK-SAME: ptr [[TMP0:%.*]], ptr [[DST:%.*]]) #[[ATTR0]] {
110+
; CHECK-SAME: ptr [[TMP0:%.*]], ptr [[DST:%.*]]) #[[ATTR1]] {
112111
; CHECK-NEXT: [[TMP2:%.*]] = load i64, ptr [[TMP0]], align 8
113112
; CHECK-NEXT: [[TMP3:%.*]] = icmp eq i64 [[TMP2]], 0
114113
; CHECK-NEXT: br i1 [[TMP3]], label %[[BB4:.*]], label %[[BB5:.*]]
@@ -137,3 +136,55 @@ define void @fun2(ptr %0, ptr %Dst) {
137136
store i64 0, ptr %8, align 8
138137
br label %5
139138
}
139+
140+
; This should *not* be vectorized as the load is immediately stored, in which
141+
; case MVC is preferred.
142+
define void @fun3(ptr %0) {
143+
; CHECK-LABEL: define void @fun3(
144+
; CHECK-SAME: ptr [[TMP0:%.*]]) #[[ATTR1]] {
145+
; CHECK-NEXT: [[TMP2:%.*]] = load ptr, ptr inttoptr (i64 568 to ptr), align 8
146+
; CHECK-NEXT: [[TMP3:%.*]] = getelementptr inbounds nuw i8, ptr [[TMP2]], i64 40
147+
; CHECK-NEXT: [[TMP4:%.*]] = getelementptr inbounds nuw i8, ptr [[TMP2]], i64 48
148+
; CHECK-NEXT: br label %[[BB5:.*]]
149+
; CHECK: [[BB5]]:
150+
; CHECK-NEXT: store ptr null, ptr [[TMP3]], align 8, !tbaa [[TBAA0:![0-9]+]]
151+
; CHECK-NEXT: [[TMP6:%.*]] = load ptr, ptr inttoptr (i64 64 to ptr), align 8, !tbaa [[TBAA8:![0-9]+]]
152+
; CHECK-NEXT: store ptr [[TMP6]], ptr [[TMP4]], align 8
153+
; CHECK-NEXT: [[TMP7:%.*]] = tail call i64 [[TMP0]](ptr noundef poison, i64 noundef poison)
154+
; CHECK-NEXT: br label %[[BB5]]
155+
;
156+
%2 = load ptr, ptr inttoptr (i64 568 to ptr), align 8
157+
%3 = getelementptr inbounds nuw i8, ptr %2, i64 40
158+
%4 = getelementptr inbounds nuw i8, ptr %2, i64 48
159+
br label %5
160+
161+
5:
162+
store ptr null, ptr %3, align 8, !tbaa !1
163+
%6 = load ptr, ptr inttoptr (i64 64 to ptr), align 8, !tbaa !9
164+
store ptr %6, ptr %4, align 8
165+
%7 = tail call i64 %0(ptr noundef poison, i64 noundef poison)
166+
br label %5
167+
}
168+
169+
!1 = !{!2, !7, i64 40}
170+
!2 = !{!"arc", !3, i64 0, !6, i64 8, !7, i64 16, !7, i64 24, !8, i64 32, !7, i64 40, !7, i64 48, !6, i64 56, !6, i64 64}
171+
!3 = !{!"int", !4, i64 0}
172+
!4 = !{!"omnipotent char", !5, i64 0}
173+
!5 = !{!"Simple C/C++ TBAA"}
174+
!6 = !{!"long", !4, i64 0}
175+
!7 = !{!"any pointer", !4, i64 0}
176+
!8 = !{!"short", !4, i64 0}
177+
!9 = !{!10, !7, i64 64}
178+
!10 = !{!"node", !6, i64 0, !3, i64 8, !7, i64 16, !7, i64 24, !7, i64 32, !7, i64 40, !7, i64 48, !7, i64 56, !7, i64 64, !7, i64 72, !6, i64 80, !6, i64 88, !3, i64 96, !3, i64 100}
179+
;.
180+
; CHECK: [[TBAA0]] = !{[[META1:![0-9]+]], [[META6:![0-9]+]], i64 40}
181+
; CHECK: [[META1]] = !{!"arc", [[META2:![0-9]+]], i64 0, [[META5:![0-9]+]], i64 8, [[META6]], i64 16, [[META6]], i64 24, [[META7:![0-9]+]], i64 32, [[META6]], i64 40, [[META6]], i64 48, [[META5]], i64 56, [[META5]], i64 64}
182+
; CHECK: [[META2]] = !{!"int", [[META3:![0-9]+]], i64 0}
183+
; CHECK: [[META3]] = !{!"omnipotent char", [[META4:![0-9]+]], i64 0}
184+
; CHECK: [[META4]] = !{!"Simple C/C++ TBAA"}
185+
; CHECK: [[META5]] = !{!"long", [[META3]], i64 0}
186+
; CHECK: [[META6]] = !{!"any pointer", [[META3]], i64 0}
187+
; CHECK: [[META7]] = !{!"short", [[META3]], i64 0}
188+
; CHECK: [[TBAA8]] = !{[[META9:![0-9]+]], [[META6]], i64 64}
189+
; CHECK: [[META9]] = !{!"node", [[META5]], i64 0, [[META2]], i64 8, [[META6]], i64 16, [[META6]], i64 24, [[META6]], i64 32, [[META6]], i64 40, [[META6]], i64 48, [[META6]], i64 56, [[META6]], i64 64, [[META6]], i64 72, [[META5]], i64 80, [[META5]], i64 88, [[META2]], i64 96, [[META2]], i64 100}
190+
;.

0 commit comments

Comments
 (0)