Skip to content

Commit 1bd31a6

Browse files
yurai007yurai007
committed
[NFC] Add SmallVector constructor to allow creation of SmallVector<T> from ArrayRef of items convertible to type T
Extracted from https://reviews.llvm.org/D129781 and address comment: https://reviews.llvm.org/D129781#3655571 Differential Revision: https://reviews.llvm.org/D130268
1 parent b2de846 commit 1bd31a6

13 files changed

+90
-32
lines changed

‎llvm/include/llvm/ADT/SmallVector.h

Lines changed: 8 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -32,6 +32,8 @@
3232

3333
namespace llvm {
3434

35+
template <typename T> class ArrayRef;
36+
3537
template <typename IteratorT> class iterator_range;
3638

3739
template <class Iterator>
@@ -1208,6 +1210,12 @@ class LLVM_GSL_OWNER SmallVector : public SmallVectorImpl<T>,
12081210
this->append(IL);
12091211
}
12101212

1213+
template <typename U,
1214+
typename = std::enable_if_t<std::is_convertible<U, T>::value>>
1215+
explicit SmallVector(ArrayRef<U> A) : SmallVectorImpl<T>(N) {
1216+
this->append(A.begin(), A.end());
1217+
}
1218+
12111219
SmallVector(const SmallVector &RHS) : SmallVectorImpl<T>(N) {
12121220
if (!RHS.empty())
12131221
SmallVectorImpl<T>::operator=(RHS);

‎llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -19421,7 +19421,7 @@ SDValue DAGCombiner::combineInsertEltToShuffle(SDNode *N, unsigned InsIndex) {
1942119421
}
1942219422

1942319423
if (ElementOffset != -1) {
19424-
SmallVector<int, 16> NewMask(Mask.begin(), Mask.end());
19424+
SmallVector<int, 16> NewMask(Mask);
1942519425

1942619426
auto *ExtrIndex = cast<ConstantSDNode>(InsertVal.getOperand(1));
1942719427
NewMask[InsIndex] = ElementOffset + ExtrIndex->getZExtValue();
@@ -22401,7 +22401,7 @@ static SDValue replaceShuffleOfInsert(ShuffleVectorSDNode *Shuf,
2240122401
// First, check if we are taking one element of a vector and shuffling that
2240222402
// element into another vector.
2240322403
ArrayRef<int> Mask = Shuf->getMask();
22404-
SmallVector<int, 16> CommutedMask(Mask.begin(), Mask.end());
22404+
SmallVector<int, 16> CommutedMask(Mask);
2240522405
SDValue Op0 = Shuf->getOperand(0);
2240622406
SDValue Op1 = Shuf->getOperand(1);
2240722407
int ShufOp0Index = getShuffleMaskIndexOfOneElementFromOp0IntoOp1(Mask);
@@ -22712,7 +22712,7 @@ SDValue DAGCombiner::visitVECTOR_SHUFFLE(SDNode *N) {
2271222712
if (SDValue InsertN1 = ShuffleToInsert(N0, N1, Mask))
2271322713
return InsertN1;
2271422714
if (N0.getOpcode() == ISD::CONCAT_VECTORS) {
22715-
SmallVector<int> CommuteMask(Mask.begin(), Mask.end());
22715+
SmallVector<int> CommuteMask(Mask);
2271622716
ShuffleVectorSDNode::commuteMask(CommuteMask);
2271722717
if (SDValue InsertN0 = ShuffleToInsert(N1, N0, CommuteMask))
2271822718
return InsertN0;

‎llvm/lib/CodeGen/SelectionDAG/LegalizeVectorTypes.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2286,7 +2286,7 @@ void DAGTypeLegalizer::SplitVecRes_VECTOR_SHUFFLE(ShuffleVectorSDNode *N,
22862286
// If Lo or Hi uses elements from at most two of the four input vectors, then
22872287
// express it as a vector shuffle of those two inputs. Otherwise extract the
22882288
// input elements by hand and construct the Lo/Hi output using a BUILD_VECTOR.
2289-
SmallVector<int> OrigMask(N->getMask().begin(), N->getMask().end());
2289+
SmallVector<int> OrigMask(N->getMask());
22902290
// Try to pack incoming shuffles/inputs.
22912291
auto &&TryPeekThroughShufflesInputs = [&Inputs, &NewVT, this, NewElts,
22922292
&DL](SmallVectorImpl<int> &Mask) {

‎llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1895,7 +1895,7 @@ SDValue SelectionDAG::getVectorShuffle(EVT VT, const SDLoc &dl, SDValue N1,
18951895
"Index out of range");
18961896

18971897
// Copy the mask so we can do any needed cleanup.
1898-
SmallVector<int, 8> MaskVec(Mask.begin(), Mask.end());
1898+
SmallVector<int, 8> MaskVec(Mask);
18991899

19001900
// Canonicalize shuffle v, v -> v, undef
19011901
if (N1 == N2) {
@@ -2051,7 +2051,7 @@ SDValue SelectionDAG::getVectorShuffle(EVT VT, const SDLoc &dl, SDValue N1,
20512051

20522052
SDValue SelectionDAG::getCommutedVectorShuffle(const ShuffleVectorSDNode &SV) {
20532053
EVT VT = SV.getValueType(0);
2054-
SmallVector<int, 8> MaskVec(SV.getMask().begin(), SV.getMask().end());
2054+
SmallVector<int, 8> MaskVec(SV.getMask());
20552055
ShuffleVectorSDNode::commuteMask(MaskVec);
20562056

20572057
SDValue Op0 = SV.getOperand(0);

‎llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -3723,7 +3723,7 @@ void SelectionDAGBuilder::visitShuffleVector(const User &I) {
37233723
}
37243724

37253725
// Calculate new mask.
3726-
SmallVector<int, 8> MappedOps(Mask.begin(), Mask.end());
3726+
SmallVector<int, 8> MappedOps(Mask);
37273727
for (int &Idx : MappedOps) {
37283728
if (Idx >= (int)SrcNumElts)
37293729
Idx -= SrcNumElts + StartIdx[1] - MaskNumElts;

‎llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -3220,7 +3220,7 @@ bool TargetLowering::SimplifyDemandedVectorElts(
32203220
// Simplify mask using undef elements from LHS/RHS.
32213221
bool Updated = false;
32223222
bool IdentityLHS = true, IdentityRHS = true;
3223-
SmallVector<int, 32> NewMask(ShuffleMask.begin(), ShuffleMask.end());
3223+
SmallVector<int, 32> NewMask(ShuffleMask);
32243224
for (unsigned i = 0; i != NumElts; ++i) {
32253225
int &M = NewMask[i];
32263226
if (M < 0)

‎llvm/lib/Target/ARM/ARMISelLowering.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -18334,7 +18334,7 @@ SDValue ARMTargetLowering::PerformMVETruncCombine(
1833418334
if (S0->getOperand(0) == S1->getOperand(0) &&
1833518335
S0->getOperand(1) == S1->getOperand(1)) {
1833618336
// Construct complete shuffle mask
18337-
SmallVector<int, 8> Mask(S0->getMask().begin(), S0->getMask().end());
18337+
SmallVector<int, 8> Mask(S0->getMask());
1833818338
Mask.append(S1->getMask().begin(), S1->getMask().end());
1833918339

1834018340
if (isVMOVNTruncMask(Mask, VT, false))

‎llvm/lib/Target/Hexagon/HexagonISelDAGToDAGHVX.cpp

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1149,7 +1149,7 @@ OpRef HvxSelector::packs(ShuffleMask SM, OpRef Va, OpRef Vb,
11491149

11501150
// Check if we can shuffle vector halves around to get the used elements
11511151
// into a single vector.
1152-
SmallVector<int,128> MaskH(SM.Mask.begin(), SM.Mask.end());
1152+
SmallVector<int, 128> MaskH(SM.Mask);
11531153
SmallVector<unsigned, 4> SegList = getInputSegmentList(SM.Mask, SegLen);
11541154
unsigned SegCount = SegList.size();
11551155
SmallVector<unsigned, 4> SegMap = getOutputSegmentMap(SM.Mask, SegLen);
@@ -1271,11 +1271,11 @@ OpRef HvxSelector::packs(ShuffleMask SM, OpRef Va, OpRef Vb,
12711271

12721272
ShuffleMask SMH(MaskH);
12731273
assert(SMH.Mask.size() == VecLen);
1274-
SmallVector<int,128> MaskA(SMH.Mask.begin(), SMH.Mask.end());
1274+
SmallVector<int, 128> MaskA(SMH.Mask);
12751275

12761276
if (SMH.MaxSrc - SMH.MinSrc >= static_cast<int>(HwLen)) {
12771277
// valign(Lo=Va,Hi=Vb) won't work. Try swapping Va/Vb.
1278-
SmallVector<int,128> Swapped(SMH.Mask.begin(), SMH.Mask.end());
1278+
SmallVector<int, 128> Swapped(SMH.Mask);
12791279
ShuffleVectorSDNode::commuteMask(Swapped);
12801280
ShuffleMask SW(Swapped);
12811281
if (SW.MaxSrc - SW.MinSrc < static_cast<int>(HwLen)) {
@@ -1998,7 +1998,7 @@ OpRef HvxSelector::perfect(ShuffleMask SM, OpRef Va, ResultStack &Results) {
19981998
// a vector pair, but the two vectors in the pair are swapped.
19991999
// The code below that identifies perfect shuffles will reject
20002000
// it, unless the order is reversed.
2001-
SmallVector<int,128> MaskStorage(SM.Mask.begin(), SM.Mask.end());
2001+
SmallVector<int, 128> MaskStorage(SM.Mask);
20022002
bool InvertedPair = false;
20032003
if (HavePairs && SM.Mask[0] >= int(HwLen)) {
20042004
for (int i = 0, e = SM.Mask.size(); i != e; ++i) {

‎llvm/lib/Target/PowerPC/PPCISelLowering.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -14885,7 +14885,7 @@ SDValue PPCTargetLowering::combineVectorShuffle(ShuffleVectorSDNode *SVN,
1488514885
// Adjust the shuffle mask if either input vector comes from a
1488614886
// SCALAR_TO_VECTOR and keep the respective input vector in permuted
1488714887
// form (to prevent the need for a swap).
14888-
SmallVector<int, 16> ShuffV(Mask.begin(), Mask.end());
14888+
SmallVector<int, 16> ShuffV(Mask);
1488914889
SDValue SToVLHS = isScalarToVec(LHS);
1489014890
SDValue SToVRHS = isScalarToVec(RHS);
1489114891
if (SToVLHS || SToVRHS) {

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

Lines changed: 15 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -6158,7 +6158,7 @@ static bool canWidenShuffleElements(ArrayRef<int> Mask,
61586158
SmallVectorImpl<int> &WidenedMask) {
61596159
// Create an alternative mask with info about zeroable elements.
61606160
// Here we do not set undef elements as zeroable.
6161-
SmallVector<int, 64> ZeroableMask(Mask.begin(), Mask.end());
6161+
SmallVector<int, 64> ZeroableMask(Mask);
61626162
if (V2IsZero) {
61636163
assert(!Zeroable.isZero() && "V2's non-undef elements are used?!");
61646164
for (int i = 0, Size = Mask.size(); i != Size; ++i)
@@ -11927,7 +11927,7 @@ static bool is128BitUnpackShuffleMask(ArrayRef<int> Mask,
1192711927
MVT VT = MVT::getVectorVT(EltVT, Mask.size());
1192811928

1192911929
// We can't assume a canonical shuffle mask, so try the commuted version too.
11930-
SmallVector<int, 4> CommutedMask(Mask.begin(), Mask.end());
11930+
SmallVector<int, 4> CommutedMask(Mask);
1193111931
ShuffleVectorSDNode::commuteMask(CommutedMask);
1193211932

1193311933
// Match any of unary/binary or low/high.
@@ -12786,7 +12786,7 @@ static SDValue lowerShuffleAsBlend(const SDLoc &DL, MVT VT, SDValue V1,
1278612786
SelectionDAG &DAG) {
1278712787
uint64_t BlendMask = 0;
1278812788
bool ForceV1Zero = false, ForceV2Zero = false;
12789-
SmallVector<int, 64> Mask(Original.begin(), Original.end());
12789+
SmallVector<int, 64> Mask(Original);
1279012790
if (!matchShuffleAsBlend(V1, V2, Mask, Zeroable, ForceV1Zero, ForceV2Zero,
1279112791
BlendMask))
1279212792
return SDValue();
@@ -14242,7 +14242,7 @@ static SDValue lowerShuffleAsElementInsertion(
1424214242
assert(VT == ExtVT && "Cannot change extended type when non-zeroable!");
1424314243
if (!VT.isFloatingPoint() || V2Index != 0)
1424414244
return SDValue();
14245-
SmallVector<int, 8> V1Mask(Mask.begin(), Mask.end());
14245+
SmallVector<int, 8> V1Mask(Mask);
1424614246
V1Mask[V2Index] = -1;
1424714247
if (!isNoopShuffleMask(V1Mask))
1424814248
return SDValue();
@@ -14391,7 +14391,7 @@ static SDValue lowerShuffleOfExtractsAsVperm(const SDLoc &DL, SDValue N0,
1439114391
// Match extracts of each half of the wide source vector. Commute the shuffle
1439214392
// if the extract of the low half is N1.
1439314393
unsigned NumElts = VT.getVectorNumElements();
14394-
SmallVector<int, 4> NewMask(Mask.begin(), Mask.end());
14394+
SmallVector<int, 4> NewMask(Mask);
1439514395
const APInt &ExtIndex0 = N0.getConstantOperandAPInt(1);
1439614396
const APInt &ExtIndex1 = N1.getConstantOperandAPInt(1);
1439714397
if (ExtIndex1 == 0 && ExtIndex0 == NumElts)
@@ -14695,7 +14695,7 @@ static bool matchShuffleAsInsertPS(SDValue &V1, SDValue &V2,
1469514695
return true;
1469614696

1469714697
// Commute and try again.
14698-
SmallVector<int, 4> CommutedMask(Mask.begin(), Mask.end());
14698+
SmallVector<int, 4> CommutedMask(Mask);
1469914699
ShuffleVectorSDNode::commuteMask(CommutedMask);
1470014700
if (matchAsInsertPS(V2, V1, CommutedMask))
1470114701
return true;
@@ -15030,7 +15030,7 @@ static SDValue lowerShuffleWithSHUFPS(const SDLoc &DL, MVT VT,
1503015030
ArrayRef<int> Mask, SDValue V1,
1503115031
SDValue V2, SelectionDAG &DAG) {
1503215032
SDValue LowV = V1, HighV = V2;
15033-
SmallVector<int, 4> NewMask(Mask.begin(), Mask.end());
15033+
SmallVector<int, 4> NewMask(Mask);
1503415034
int NumV2Elements = count_if(Mask, [](int M) { return M >= 4; });
1503515035

1503615036
if (NumV2Elements == 1) {
@@ -15951,7 +15951,7 @@ static SDValue lowerV8I16Shuffle(const SDLoc &DL, ArrayRef<int> Mask,
1595115951
return Rotate;
1595215952

1595315953
// Make a copy of the mask so it can be modified.
15954-
SmallVector<int, 8> MutableMask(Mask.begin(), Mask.end());
15954+
SmallVector<int, 8> MutableMask(Mask);
1595515955
return lowerV8I16GeneralSingleInputShuffle(DL, MVT::v8i16, V1, MutableMask,
1595615956
Subtarget, DAG);
1595715957
}
@@ -16135,7 +16135,7 @@ static SDValue lowerShuffleWithPERMV(const SDLoc &DL, MVT VT,
1613516135
// Adjust mask to correct indices for the second input.
1613616136
int NumElts = VT.getVectorNumElements();
1613716137
unsigned Scale = 512 / VT.getSizeInBits();
16138-
SmallVector<int, 32> AdjustedMask(Mask.begin(), Mask.end());
16138+
SmallVector<int, 32> AdjustedMask(Mask);
1613916139
for (int &M : AdjustedMask)
1614016140
if (NumElts <= M)
1614116141
M += (Scale - 1) * NumElts;
@@ -16881,7 +16881,7 @@ static SDValue lowerShuffleAsLanePermuteAndShuffle(
1688116881
assert(V2.isUndef() &&
1688216882
"This last part of this routine only works on single input shuffles");
1688316883

16884-
SmallVector<int, 32> InLaneMask(Mask.begin(), Mask.end());
16884+
SmallVector<int, 32> InLaneMask(Mask);
1688516885
for (int i = 0; i < Size; ++i) {
1688616886
int &M = InLaneMask[i];
1688716887
if (M < 0)
@@ -19369,7 +19369,7 @@ static SDValue lowerVECTOR_SHUFFLE(SDValue Op, const X86Subtarget &Subtarget,
1936919369
// the mask.
1937019370
if (V2IsUndef &&
1937119371
any_of(OrigMask, [NumElements](int M) { return M >= NumElements; })) {
19372-
SmallVector<int, 8> NewMask(OrigMask.begin(), OrigMask.end());
19372+
SmallVector<int, 8> NewMask(OrigMask);
1937319373
for (int &M : NewMask)
1937419374
if (M >= NumElements)
1937519375
M = -1;
@@ -19442,7 +19442,7 @@ static SDValue lowerVECTOR_SHUFFLE(SDValue Op, const X86Subtarget &Subtarget,
1944219442
}
1944319443

1944419444
SmallVector<SDValue> Ops = {V1, V2};
19445-
SmallVector<int> Mask(OrigMask.begin(), OrigMask.end());
19445+
SmallVector<int> Mask(OrigMask);
1944619446

1944719447
// Canonicalize the shuffle with any horizontal ops inputs.
1944819448
// NOTE: This may update Ops and Mask.
@@ -37692,7 +37692,7 @@ static bool matchBinaryPermuteShuffle(
3769237692
(MaskVT == MVT::v16i16 && Subtarget.hasAVX2())) {
3769337693
uint64_t BlendMask = 0;
3769437694
bool ForceV1Zero = false, ForceV2Zero = false;
37695-
SmallVector<int, 8> TargetMask(Mask.begin(), Mask.end());
37695+
SmallVector<int, 8> TargetMask(Mask);
3769637696
if (matchShuffleAsBlend(V1, V2, TargetMask, Zeroable, ForceV1Zero,
3769737697
ForceV2Zero, BlendMask)) {
3769837698
if (MaskVT == MVT::v16i16) {
@@ -37895,7 +37895,7 @@ static SDValue combineX86ShuffleChain(ArrayRef<SDValue> Inputs, SDValue Root,
3789537895
return CanonicalizeShuffleInput(RootVT, V1);
3789637896
}
3789737897

37898-
SmallVector<int, 64> Mask(BaseMask.begin(), BaseMask.end());
37898+
SmallVector<int, 64> Mask(BaseMask);
3789937899

3790037900
// See if the shuffle is a hidden identity shuffle - repeated args in HOPs
3790137901
// etc. can be simplified.
@@ -38638,7 +38638,7 @@ static SDValue combineX86ShuffleChainWithExtract(
3863838638
for (unsigned i = 1; i != NumInputs; ++i)
3863938639
Offsets[i] += i * Scale * NumMaskElts;
3864038640

38641-
SmallVector<int, 64> WideMask(BaseMask.begin(), BaseMask.end());
38641+
SmallVector<int, 64> WideMask(BaseMask);
3864238642
for (int &M : WideMask) {
3864338643
if (M < 0)
3864438644
continue;

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

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1865,7 +1865,7 @@ static std::string getShuffleComment(const MachineInstr *MI, unsigned SrcOp1Idx,
18651865
SrcOp2.isReg() ? GetRegisterName(SrcOp2.getReg()) : "mem";
18661866

18671867
// One source operand, fix the mask to print all elements in one span.
1868-
SmallVector<int, 8> ShuffleMask(Mask.begin(), Mask.end());
1868+
SmallVector<int, 8> ShuffleMask(Mask);
18691869
if (Src1Name == Src2Name)
18701870
for (int i = 0, e = ShuffleMask.size(); i != e; ++i)
18711871
if (ShuffleMask[i] >= e)

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

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -7659,7 +7659,7 @@ class ShuffleInstructionBuilder {
76597659

76607660
/// Functions adds masks, merging them into single one.
76617661
void addMask(ArrayRef<unsigned> SubMask) {
7662-
SmallVector<int, 4> NewMask(SubMask.begin(), SubMask.end());
7662+
SmallVector<int, 4> NewMask(SubMask);
76637663
addMask(NewMask);
76647664
}
76657665

@@ -8755,7 +8755,7 @@ BoUpSLP::vectorizeTree(ExtraValueToDebugLocsMap &ExternallyUsedValues) {
87558755
return PoisonValue::get(FixedVectorType::get(
87568756
cast<VectorType>(V1->getType())->getElementType(), Mask.size()));
87578757
Value *Op = V1;
8758-
SmallVector<int> CombinedMask(Mask.begin(), Mask.end());
8758+
SmallVector<int> CombinedMask(Mask);
87598759
PeekThroughShuffles(Op, CombinedMask);
87608760
if (!isa<FixedVectorType>(Op->getType()) ||
87618761
!IsIdentityMask(CombinedMask, cast<FixedVectorType>(Op->getType()))) {

‎llvm/unittests/ADT/SmallVectorTest.cpp

Lines changed: 50 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -246,6 +246,18 @@ TYPED_TEST(SmallVectorTest, ConstructorIterTest) {
246246
assertValuesInOrder(V, 3u, 1, 2, 3);
247247
}
248248

249+
// Constructor test.
250+
TYPED_TEST(SmallVectorTest, ConstructorFromArrayRefSimpleTest) {
251+
SCOPED_TRACE("ConstructorFromArrayRefSimpleTest");
252+
std::array<Constructable, 3> StdArray = {Constructable(1), Constructable(2),
253+
Constructable(3)};
254+
ArrayRef<Constructable> Array = StdArray;
255+
auto &V = this->theVector;
256+
V = SmallVector<Constructable, 4>(Array);
257+
assertValuesInOrder(V, 3u, 1, 2, 3);
258+
ASSERT_EQ(NumBuiltinElts(TypeParam{}), NumBuiltinElts(V));
259+
}
260+
249261
// New vector test.
250262
TYPED_TEST(SmallVectorTest, EmptyVectorTest) {
251263
SCOPED_TRACE("EmptyVectorTest");
@@ -1130,6 +1142,44 @@ TEST(SmallVectorTest, InitializerList) {
11301142
EXPECT_TRUE(makeArrayRef(V2).equals({4, 5, 3, 2}));
11311143
}
11321144

1145+
struct To {
1146+
int Content;
1147+
friend bool operator==(const To &LHS, const To &RHS) {
1148+
return LHS.Content == RHS.Content;
1149+
}
1150+
};
1151+
1152+
class From {
1153+
public:
1154+
From() = default;
1155+
From(To M) { T = M; }
1156+
operator To() const { return T; }
1157+
1158+
private:
1159+
To T;
1160+
};
1161+
1162+
TEST(SmallVectorTest, ConstructFromArrayRefOfConvertibleType) {
1163+
To to1{1}, to2{2}, to3{3};
1164+
std::vector<From> StdVector = {From(to1), From(to2), From(to3)};
1165+
ArrayRef<From> Array = StdVector;
1166+
{
1167+
llvm::SmallVector<To> Vector(Array);
1168+
1169+
ASSERT_EQ(Array.size(), Vector.size());
1170+
for (size_t I = 0; I < Array.size(); ++I)
1171+
EXPECT_EQ(Array[I], Vector[I]);
1172+
}
1173+
{
1174+
llvm::SmallVector<To, 4> Vector(Array);
1175+
1176+
ASSERT_EQ(Array.size(), Vector.size());
1177+
ASSERT_EQ(4u, NumBuiltinElts(Vector));
1178+
for (size_t I = 0; I < Array.size(); ++I)
1179+
EXPECT_EQ(Array[I], Vector[I]);
1180+
}
1181+
}
1182+
11331183
template <class VectorT>
11341184
class SmallVectorReferenceInvalidationTest : public SmallVectorTestBase {
11351185
protected:

0 commit comments

Comments
 (0)