Skip to content

Commit ba3eb68

Browse files
JonPsson1JonPsson1
committed
Pass VL to getScalarizationOverhead
1 parent 4a85911 commit ba3eb68

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
@@ -898,11 +898,11 @@ class TargetTransformInfo {
898898

899899
/// Estimate the overhead of scalarizing an instruction. Insert and Extract
900900
/// are set if the demanded result elements need to be inserted and/or
901-
/// extracted from vectors.
902-
InstructionCost getScalarizationOverhead(VectorType *Ty,
903-
const APInt &DemandedElts,
904-
bool Insert, bool Extract,
905-
TTI::TargetCostKind CostKind) const;
901+
/// extracted from vectors. The involved values may be passed in VL if
902+
/// Insert is true.
903+
InstructionCost getScalarizationOverhead(
904+
VectorType *Ty, const APInt &DemandedElts, bool Insert, bool Extract,
905+
TTI::TargetCostKind CostKind, ArrayRef<Value *> VL = std::nullopt) const;
906906

907907
/// Estimate the overhead of scalarizing an instructions unique
908908
/// non-constant operands. The (potentially vector) types to use for each of
@@ -1973,10 +1973,10 @@ class TargetTransformInfo::Concept {
19731973
virtual bool isTargetIntrinsicTriviallyScalarizable(Intrinsic::ID ID) = 0;
19741974
virtual bool isTargetIntrinsicWithScalarOpAtArg(Intrinsic::ID ID,
19751975
unsigned ScalarOpdIdx) = 0;
1976-
virtual InstructionCost getScalarizationOverhead(VectorType *Ty,
1977-
const APInt &DemandedElts,
1978-
bool Insert, bool Extract,
1979-
TargetCostKind CostKind) = 0;
1976+
virtual InstructionCost
1977+
getScalarizationOverhead(VectorType *Ty, const APInt &DemandedElts,
1978+
bool Insert, bool Extract, TargetCostKind CostKind,
1979+
ArrayRef<Value *> VL = std::nullopt) = 0;
19801980
virtual InstructionCost
19811981
getOperandsScalarizationOverhead(ArrayRef<const Value *> Args,
19821982
ArrayRef<Type *> Tys,
@@ -2536,12 +2536,12 @@ class TargetTransformInfo::Model final : public TargetTransformInfo::Concept {
25362536
return Impl.isTargetIntrinsicWithScalarOpAtArg(ID, ScalarOpdIdx);
25372537
}
25382538

2539-
InstructionCost getScalarizationOverhead(VectorType *Ty,
2540-
const APInt &DemandedElts,
2541-
bool Insert, bool Extract,
2542-
TargetCostKind CostKind) override {
2539+
InstructionCost
2540+
getScalarizationOverhead(VectorType *Ty, const APInt &DemandedElts,
2541+
bool Insert, bool Extract, TargetCostKind CostKind,
2542+
ArrayRef<Value *> VL = std::nullopt) override {
25432543
return Impl.getScalarizationOverhead(Ty, DemandedElts, Insert, Extract,
2544-
CostKind);
2544+
CostKind, VL);
25452545
}
25462546
InstructionCost
25472547
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
@@ -393,10 +393,9 @@ class TargetTransformInfoImplBase {
393393
return false;
394394
}
395395

396-
InstructionCost getScalarizationOverhead(VectorType *Ty,
397-
const APInt &DemandedElts,
398-
bool Insert, bool Extract,
399-
TTI::TargetCostKind CostKind) const {
396+
InstructionCost getScalarizationOverhead(
397+
VectorType *Ty, const APInt &DemandedElts, bool Insert, bool Extract,
398+
TTI::TargetCostKind CostKind, ArrayRef<Value *> VL = std::nullopt) const {
400399
return 0;
401400
}
402401

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

Lines changed: 10 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -760,10 +760,12 @@ class BasicTTIImplBase : public TargetTransformInfoImplCRTPBase<T> {
760760
/// Estimate the overhead of scalarizing an instruction. Insert and Extract
761761
/// are set if the demanded result elements need to be inserted and/or
762762
/// extracted from vectors.
763-
InstructionCost getScalarizationOverhead(VectorType *InTy,
764-
const APInt &DemandedElts,
765-
bool Insert, bool Extract,
766-
TTI::TargetCostKind CostKind) {
763+
InstructionCost getScalarizationOverhead(
764+
VectorType *InTy, const APInt &DemandedElts, bool Insert, bool Extract,
765+
TTI::TargetCostKind CostKind, ArrayRef<Value *> VL = std::nullopt) {
766+
assert((VL.empty() ||
767+
VL.size() == cast<FixedVectorType>(InTy)->getNumElements()) &&
768+
"Type does not match the values.");
767769
/// FIXME: a bitfield is not a reasonable abstraction for talking about
768770
/// which elements are needed from a scalable vector
769771
if (isa<ScalableVectorType>(InTy))
@@ -778,9 +780,11 @@ class BasicTTIImplBase : public TargetTransformInfoImplCRTPBase<T> {
778780
for (int i = 0, e = Ty->getNumElements(); i < e; ++i) {
779781
if (!DemandedElts[i])
780782
continue;
781-
if (Insert)
783+
if (Insert) {
784+
Value *InsertedVal = VL.size() ? VL[i] : nullptr;
782785
Cost += thisT()->getVectorInstrCost(Instruction::InsertElement, Ty,
783-
CostKind, i, nullptr, nullptr);
786+
CostKind, i, nullptr, InsertedVal);
787+
}
784788
if (Extract)
785789
Cost += thisT()->getVectorInstrCost(Instruction::ExtractElement, Ty,
786790
CostKind, i, nullptr, nullptr);

‎llvm/lib/Analysis/TargetTransformInfo.cpp

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -613,9 +613,9 @@ bool TargetTransformInfo::isTargetIntrinsicWithScalarOpAtArg(
613613

614614
InstructionCost TargetTransformInfo::getScalarizationOverhead(
615615
VectorType *Ty, const APInt &DemandedElts, bool Insert, bool Extract,
616-
TTI::TargetCostKind CostKind) const {
616+
TTI::TargetCostKind CostKind, ArrayRef<Value *> VL) const {
617617
return TTIImpl->getScalarizationOverhead(Ty, DemandedElts, Insert, Extract,
618-
CostKind);
618+
CostKind, VL);
619619
}
620620

621621
InstructionCost TargetTransformInfo::getOperandsScalarizationOverhead(

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

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

32493249
InstructionCost AArch64TTIImpl::getScalarizationOverhead(
32503250
VectorType *Ty, const APInt &DemandedElts, bool Insert, bool Extract,
3251-
TTI::TargetCostKind CostKind) {
3251+
TTI::TargetCostKind CostKind, ArrayRef<Value *> VL) {
32523252
if (isa<ScalableVectorType>(Ty))
32533253
return InstructionCost::getInvalid();
32543254
if (Ty->getElementType()->isFloatingPointTy())

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

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -406,7 +406,8 @@ class AArch64TTIImpl : public BasicTTIImplBase<AArch64TTIImpl> {
406406
InstructionCost getScalarizationOverhead(VectorType *Ty,
407407
const APInt &DemandedElts,
408408
bool Insert, bool Extract,
409-
TTI::TargetCostKind CostKind);
409+
TTI::TargetCostKind CostKind,
410+
ArrayRef<Value *> VL = std::nullopt);
410411

411412
/// Return the cost of the scaling factor used in the addressing
412413
/// 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
@@ -152,7 +152,8 @@ class RISCVTTIImpl : public BasicTTIImplBase<RISCVTTIImpl> {
152152
InstructionCost getScalarizationOverhead(VectorType *Ty,
153153
const APInt &DemandedElts,
154154
bool Insert, bool Extract,
155-
TTI::TargetCostKind CostKind);
155+
TTI::TargetCostKind CostKind,
156+
ArrayRef<Value *> VL = std::nullopt);
156157

157158
InstructionCost getIntrinsicInstrCost(const IntrinsicCostAttributes &ICA,
158159
TTI::TargetCostKind CostKind);

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

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

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

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

492503
Cost += BaseT::getScalarizationOverhead(Ty, DemandedElts, Insert, Extract,
493-
CostKind);
504+
CostKind, VL);
494505
return Cost;
495506
}
496507

@@ -1143,7 +1154,7 @@ InstructionCost SystemZTTIImpl::getVectorInstrCost(unsigned Opcode, Type *Val,
11431154
Value *Op1) {
11441155
if (Opcode == Instruction::InsertElement) {
11451156
// Vector Element Load.
1146-
if (Op1 != nullptr && Op1->hasOneUse() && isa<LoadInst>(Op1))
1157+
if (Op1 != nullptr && isFreeEltLoad(Op1))
11471158
return 0;
11481159

11491160
// 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
@@ -4855,10 +4855,9 @@ InstructionCost X86TTIImpl::getVectorInstrCost(unsigned Opcode, Type *Val,
48554855
RegisterFileMoveCost;
48564856
}
48574857

4858-
InstructionCost
4859-
X86TTIImpl::getScalarizationOverhead(VectorType *Ty, const APInt &DemandedElts,
4860-
bool Insert, bool Extract,
4861-
TTI::TargetCostKind CostKind) {
4858+
InstructionCost X86TTIImpl::getScalarizationOverhead(
4859+
VectorType *Ty, const APInt &DemandedElts, bool Insert, bool Extract,
4860+
TTI::TargetCostKind CostKind, ArrayRef<Value *> VL) {
48624861
assert(DemandedElts.getBitWidth() ==
48634862
cast<FixedVectorType>(Ty)->getNumElements() &&
48644863
"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
@@ -13232,17 +13232,10 @@ InstructionCost BoUpSLP::getGatherCost(ArrayRef<Value *> VL, bool ForPoisonSrc,
1323213232
TTI::SK_InsertSubvector, VecTy, std::nullopt, CostKind,
1323313233
I * ScalarTyNumElements, cast<FixedVectorType>(ScalarTy));
1323413234
} else {
13235-
// Add insertion costs for all elements, but not for loads that can be
13236-
// loaded directly into a vector element for free.
13237-
APInt FreeEltLoads = APInt::getZero(VL.size());
13238-
if (TTI->supportsEfficientVectorElementLoadStore())
13239-
for (unsigned I : seq<unsigned>(VL.size()))
13240-
if (VL[I]->hasOneUse() && isa<LoadInst>(VL[I]))
13241-
FreeEltLoads.setBit(I);
13242-
APInt DemandedElts = ~ShuffledElements & ~FreeEltLoads;
13243-
Cost = TTI->getScalarizationOverhead(VecTy, DemandedElts,
13235+
Cost = TTI->getScalarizationOverhead(VecTy,
13236+
/*DemandedElts*/ ~ShuffledElements,
1324413237
/*Insert*/ true,
13245-
/*Extract*/ false, CostKind);
13238+
/*Extract*/ false, CostKind, VL);
1324613239
}
1324713240
}
1324813241
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)