This is an archive of the discontinued LLVM Phabricator instance.

Differential D26869

[LV] Add flag for ignoring target info
AbandonedPublic

Authored by mssimpso on Nov 18 2016, 2:14 PM.

Details

Reviewers
mkuper
gilr
Summary

This patch adds a flag ("loop-vectorize-ignore-target-info") that causes the vectorizer to use the default TTI implementation instead of one based on the target. This is useful for ensuring consistent results across targets when testing. The run lines of all target-independent tests have been updated to use the flag.

Diff Detail

Event Timeline

mssimpso updated this revision to Diff 78579.Nov 18 2016, 2:14 PM
mssimpso retitled this revision from to [LV] Add flag for ignoring target info.
mssimpso updated this object.
mssimpso added reviewers: mkuper, gilr.
mssimpso added subscribers: llvm-commits, mcrosier.
Herald added a subscriber: mzolotukhin. · View Herald TranscriptNov 18 2016, 2:14 PM
mkuper edited edge metadata.Nov 18 2016, 3:23 PM

I like this idea, but that's not very surprising since I suggested it. :-)
So another sanity check would be nice.

lib/Transforms/Vectorize/LoopVectorize.cpp
2092

Maybe it'll look a bit simpler if we make TTI a reference?

E.g. something like (haven't checked if it compiles :-) )

TargetTransformInfo BaseTTI = 
  TargetTransformInfo(F.getParent()->getDataLayout());
TargetTransformInfo &TTI = BaseTTI;
if (!IgnoreTargetInfo)
  TTI = getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F)
7454

Please also update this to honor IgnoreTargetInfo.

mzolotukhin added a comment.Nov 21 2016, 7:14 AM

I like the idea too!

Thanks,
Michael

gilr edited edge metadata.Nov 21 2016, 7:24 AM

Matt, this patch also seems to solve the problem we had with D25333 of how to write non-target-specific cost-model tests. Is that correct?
If so, maybe also move the test added back then out of AArch64? (There are also some other tests I noticed back then currently duplicated for AArch/ARM and X86 that might also be movable to the platform-independent zone).

mcrosier added a comment.Nov 21 2016, 8:11 AM

Thanks for all the feedback, all. Just a heads up that Matt will be out of the office until the 28th due to the holidays.

mssimpso added a comment.Nov 22 2016, 6:54 AM

Thanks for the feedback everyone! I'll incorporate the suggested changes and update the patch after the holidays.

anemet added a subscriber: anemet.Nov 22 2016, 10:11 PM

Hi Matt,

You should probably circulate this more widely on llvm-dev. This is a new policy on how one should write tests going under test/Transform/LoopVectorize.

Thanks,
Adam

mkuper added a comment.Nov 22 2016, 10:46 PM
In D26869#603890, @anemet wrote:

Hi Matt,

You should probably circulate this more widely on llvm-dev. This is a new policy on how one should write tests going under test/Transform/LoopVectorize.

Thanks,
Adam

It's more of a bugfix in the current policy - we used to have "target independent" tests because providing a manual UF and VF would, in effect, mean we'd make no cost model queries that affect the output. That was basically dumb luck - conceptually, tests for passes that rely on TTI need to either specify a target, or somehow be forced to be target-independent.

But I agree, it may be worth circulating more widely, since this problem probably exists outside the LV vectorizer, so we may want a more principled way to do it.

Do you have an opinion on the concept itself, other than "circulate more widely"?

anemet added a comment.Nov 22 2016, 11:12 PM
In D26869#603907, @mkuper wrote:
In D26869#603890, @anemet wrote:

Hi Matt,

You should probably circulate this more widely on llvm-dev. This is a new policy on how one should write tests going under test/Transform/LoopVectorize.

Thanks,
Adam

It's more of a bugfix in the current policy - we used to have "target independent" tests because providing a manual UF and VF would, in effect, mean we'd make no cost model queries that affect the output. That was basically dumb luck - conceptually, tests for passes that rely on TTI need to either specify a target, or somehow be forced to be target-independent.

But I agree, it may be worth circulating more widely, since this problem probably exists outside the LV vectorizer, so we may want a more principled way to do it.

Also there is actual shift of how tests should be written now. I think that we all got used to writing these tests by forcing the vectorization and interleave factors.

Do you have an opinion on the concept itself, other than "circulate more widely"?

I haven't been following the review closely where this came up so I didn't understand the rational and the summary does not really explain how the current practice breaks down. I am assuming we want to write target-indepedent tests but the vectorizer needs a cost model.

Why aren't we adding a forcing flag for this feature as well, just like forcing the vectorization/interleave factors? That may make the test more explicit rather than using the default TTI. To me that would be the generalization of the current concept.

I guess what I am missing to get convinced is a run-down of the alternatives. I know this was discussed in the other review but there is no reference here. It's good to document these things for posterity.

mkuper added a comment.Nov 22 2016, 11:36 PM
In D26869#603921, @anemet wrote:

Also there is actual shift of how tests should be written now. I think that we all got used to writing these tests by forcing the vectorization and interleave factors.

I think most tests will still want to provide explicit vectorization and interleave factors, because we usually want to force vectorization with a specific factor, as opposed to "do the default thing, whatever it happens to be".

Do you have an opinion on the concept itself, other than "circulate more widely"?

I haven't been following the review closely where this came up so I didn't understand the rational and the summary does not really explain how the current practice breaks down. I am assuming we want to write target-indepedent tests but the vectorizer needs a cost model.

The gist is that we now query the cost model to make predication decisions, not just determine the VF and UF.

Why aren't we adding a forcing flag for this feature as well, just like forcing the vectorization/interleave factors? That may make the test more explicit rather than using the default TTI. To me that would be the generalization of the current concept.

This is exactly why I asked for additional opinions. IIRC this is what Matt originally suggested.
What I'm afraid of is flag proliferation - I wouldn't want to have to add another flag to all "target-independent" tests each time we add a cost model query that affects the way the vectorized code looks (as opposed to affecting the VF and UF).

anemet added a comment.Nov 28 2016, 8:56 AM
In D26869#603933, @mkuper wrote:
In D26869#603921, @anemet wrote:

Also there is actual shift of how tests should be written now. I think that we all got used to writing these tests by forcing the vectorization and interleave factors.

I think most tests will still want to provide explicit vectorization and interleave factors, because we usually want to force vectorization with a specific factor, as opposed to "do the default thing, whatever it happens to be".

Sure I mean that there is a new option (-loop-vectorize-ignore-target-info) that probably most new tests need to add.

Do you have an opinion on the concept itself, other than "circulate more widely"?

I haven't been following the review closely where this came up so I didn't understand the rational and the summary does not really explain how the current practice breaks down. I am assuming we want to write target-indepedent tests but the vectorizer needs a cost model.

The gist is that we now query the cost model to make predication decisions, not just determine the VF and UF.

Why aren't we adding a forcing flag for this feature as well, just like forcing the vectorization/interleave factors? That may make the test more explicit rather than using the default TTI. To me that would be the generalization of the current concept.

This is exactly why I asked for additional opinions. IIRC this is what Matt originally suggested.
What I'm afraid of is flag proliferation - I wouldn't want to have to add another flag to all "target-independent" tests each time we add a cost model query that affects the way the vectorized code looks (as opposed to affecting the VF and UF).

OK, so let's continue discussing this on llvm-dev.

mssimpso added a comment.Nov 28 2016, 9:39 AM

Thanks again for the feedback everyone! I'll start the thread on llvm-dev, and we can continue there.

mssimpso abandoned this revision.Nov 30 2016, 8:35 AM

Based on Adam's comment from llvm-dev, it looks like we already are using the default TTI when we don't specify a target. So this patch is not needed after all. Thanks everyone for the feedback.

Revision Contents

PathSize
lib/
Transforms/
Vectorize/
14 lines
test/
Transforms/
LoopVectorize/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
6 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
6 lines
2 lines
2 lines
2 lines
10 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
6 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines

Diff 78579

lib/Transforms/Vectorize/LoopVectorize.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 207 Lines • ▼ Show 20 Linesstatic cl::opt<unsigned> VectorizeSCEVCheckThreshold(
"vectorize-scev-check-threshold", cl::init(16), cl::Hidden, "vectorize-scev-check-threshold", cl::init(16), cl::Hidden,
cl::desc("The maximum number of SCEV checks allowed.")); cl::desc("The maximum number of SCEV checks allowed."));
static cl::opt<unsigned> PragmaVectorizeSCEVCheckThreshold( static cl::opt<unsigned> PragmaVectorizeSCEVCheckThreshold(
"pragma-vectorize-scev-check-threshold", cl::init(128), cl::Hidden, "pragma-vectorize-scev-check-threshold", cl::init(128), cl::Hidden,
cl::desc("The maximum number of SCEV checks allowed with a " cl::desc("The maximum number of SCEV checks allowed with a "
"vectorize(enable) pragma")); "vectorize(enable) pragma"));
static cl::opt<bool> IgnoreTargetInfo(
"loop-vectorize-ignore-target-info", cl::init(false), cl::Hidden,
cl::desc("Ignore target information during loop vectorization"));
/// Create an analysis remark that explains why vectorization failed /// Create an analysis remark that explains why vectorization failed
/// ///
/// \p PassName is the name of the pass (e.g. can be AlwaysPrint). \p /// \p PassName is the name of the pass (e.g. can be AlwaysPrint). \p
/// RemarkName is the identifier for the remark. If \p I is passed it is an /// RemarkName is the identifier for the remark. If \p I is passed it is an
/// instruction that prevents vectorization. Otherwise \p TheLoop is used for /// instruction that prevents vectorization. Otherwise \p TheLoop is used for
/// the location of the remark. \return the remark object that can be /// the location of the remark. \return the remark object that can be
/// streamed to. /// streamed to.
static OptimizationRemarkAnalysis static OptimizationRemarkAnalysis
▲ Show 20 Lines • Show All 1,844 Lines • ▼ Show 20 Linesstruct LoopVectorize : public FunctionPass {
LoopVectorizePass Impl; LoopVectorizePass Impl;
bool runOnFunction(Function &F) override { bool runOnFunction(Function &F) override {
if (skipFunction(F)) if (skipFunction(F))
return false; return false;
auto *SE = &getAnalysis<ScalarEvolutionWrapperPass>().getSE(); auto *SE = &getAnalysis<ScalarEvolutionWrapperPass>().getSE();
auto *LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo(); auto *LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
auto *TTI = &getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F);
auto *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree(); auto *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
auto *BFI = &getAnalysis<BlockFrequencyInfoWrapperPass>().getBFI(); auto *BFI = &getAnalysis<BlockFrequencyInfoWrapperPass>().getBFI();
auto *TLIP = getAnalysisIfAvailable<TargetLibraryInfoWrapperPass>(); auto *TLIP = getAnalysisIfAvailable<TargetLibraryInfoWrapperPass>();
auto *TLI = TLIP ? &TLIP->getTLI() : nullptr; auto *TLI = TLIP ? &TLIP->getTLI() : nullptr;
auto *AA = &getAnalysis<AAResultsWrapperPass>().getAAResults(); auto *AA = &getAnalysis<AAResultsWrapperPass>().getAAResults();
auto *AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F); auto *AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
auto *LAA = &getAnalysis<LoopAccessLegacyAnalysis>(); auto *LAA = &getAnalysis<LoopAccessLegacyAnalysis>();
auto *DB = &getAnalysis<DemandedBitsWrapperPass>().getDemandedBits(); auto *DB = &getAnalysis<DemandedBitsWrapperPass>().getDemandedBits();
auto *ORE = &getAnalysis<OptimizationRemarkEmitterWrapperPass>().getORE(); auto *ORE = &getAnalysis<OptimizationRemarkEmitterWrapperPass>().getORE();
// Use a minimal TTI implementation if we are ignoring target information.
// This is useful for testing to ensure consistent results across targets.
TargetTransformInfo *TTI = nullptr;
mkuperUnsubmitted
Not Done
ReplyInline Actions

Maybe it'll look a bit simpler if we make TTI a reference?

E.g. something like (haven't checked if it compiles :-) )

TargetTransformInfo BaseTTI = 
  TargetTransformInfo(F.getParent()->getDataLayout());
TargetTransformInfo &TTI = BaseTTI;
if (!IgnoreTargetInfo)
  TTI = getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F)
mkuper: Maybe it'll look a bit simpler if we make TTI a reference? E.g. something like (haven't…
TargetTransformInfo TTIImpl(F.getParent()->getDataLayout());
if (!IgnoreTargetInfo)
TTIImpl =
std::move(getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F));
TTI = &TTIImpl;
std::function<const LoopAccessInfo &(Loop &)> GetLAA = std::function<const LoopAccessInfo &(Loop &)> GetLAA =
[&](Loop &L) -> const LoopAccessInfo & { return LAA->getInfo(&L); }; [&](Loop &L) -> const LoopAccessInfo & { return LAA->getInfo(&L); };
return Impl.runImpl(F, *SE, *LI, *TTI, *DT, *BFI, TLI, *DB, *AA, *AC, return Impl.runImpl(F, *SE, *LI, *TTI, *DT, *BFI, TLI, *DB, *AA, *AC,
GetLAA, *ORE); GetLAA, *ORE);
} }
void getAnalysisUsage(AnalysisUsage &AU) const override { void getAnalysisUsage(AnalysisUsage &AU) const override {
▲ Show 20 Lines • Show All 5,339 Lines • ▼ Show 20 Lines
} }
PreservedAnalyses LoopVectorizePass::run(Function &F, PreservedAnalyses LoopVectorizePass::run(Function &F,
FunctionAnalysisManager &AM) { FunctionAnalysisManager &AM) {
auto &SE = AM.getResult<ScalarEvolutionAnalysis>(F); auto &SE = AM.getResult<ScalarEvolutionAnalysis>(F);
auto &LI = AM.getResult<LoopAnalysis>(F); auto &LI = AM.getResult<LoopAnalysis>(F);
auto &TTI = AM.getResult<TargetIRAnalysis>(F); auto &TTI = AM.getResult<TargetIRAnalysis>(F);
mkuperUnsubmitted
Not Done
ReplyInline Actions

Please also update this to honor IgnoreTargetInfo.

mkuper: Please also update this to honor IgnoreTargetInfo.
auto &DT = AM.getResult<DominatorTreeAnalysis>(F); auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
auto &BFI = AM.getResult<BlockFrequencyAnalysis>(F); auto &BFI = AM.getResult<BlockFrequencyAnalysis>(F);
auto *TLI = AM.getCachedResult<TargetLibraryAnalysis>(F); auto *TLI = AM.getCachedResult<TargetLibraryAnalysis>(F);
auto &AA = AM.getResult<AAManager>(F); auto &AA = AM.getResult<AAManager>(F);
auto &AC = AM.getResult<AssumptionAnalysis>(F); auto &AC = AM.getResult<AssumptionAnalysis>(F);
auto &DB = AM.getResult<DemandedBitsAnalysis>(F); auto &DB = AM.getResult<DemandedBitsAnalysis>(F);
auto &ORE = AM.getResult<OptimizationRemarkEmitterAnalysis>(F); auto &ORE = AM.getResult<OptimizationRemarkEmitterAnalysis>(F);
Show All 16 Lines

test/Transforms/LoopVectorize/12-12-11-if-conv.ll

; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -enable-if-conversion -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -enable-if-conversion -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
;CHECK-LABEL: @foo( ;CHECK-LABEL: @foo(
;CHECK: icmp eq <4 x i32> ;CHECK: icmp eq <4 x i32>
;CHECK: select <4 x i1> ;CHECK: select <4 x i1>
;CHECK: ret i32 ;CHECK: ret i32
define i32 @foo(i32 %x, i32 %t, i32* nocapture %A) nounwind uwtable ssp { define i32 @foo(i32 %x, i32 %t, i32* nocapture %A) nounwind uwtable ssp {
Show All 30 Lines

test/Transforms/LoopVectorize/2012-10-20-infloop.ll

; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce
; Check that we don't fall into an infinite loop. ; Check that we don't fall into an infinite loop.
define void @test() nounwind { define void @test() nounwind {
entry: entry:
br label %for.body br label %for.body
for.body: for.body:
%0 = phi i32 [ 1, %entry ], [ 0, %for.body ] %0 = phi i32 [ 1, %entry ], [ 0, %for.body ]
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/2012-10-22-isconsec.ll

; RUN: opt < %s -loop-vectorize -dce -force-vector-interleave=1 -force-vector-width=4 ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -dce -force-vector-interleave=1 -force-vector-width=4
; Check that we don't crash. ; Check that we don't crash.
target datalayout = "e-p:64:64:64-S128-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f16:16:16-f32:32:32-f64:64:64-f128:128:128-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-S128-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f16:16:16-f32:32:32-f64:64:64-f128:128:128-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
module asm "\09.ident\09\22GCC: (GNU) 4.6.3 LLVM: 3.2svn\22" module asm "\09.ident\09\22GCC: (GNU) 4.6.3 LLVM: 3.2svn\22"
@b = common global [32000 x float] zeroinitializer, align 16 @b = common global [32000 x float] zeroinitializer, align 16
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/2016-07-27-loop-vec.ll

; RUN: opt < %s -loop-vectorize -S ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -S
define void @foo() local_unnamed_addr { define void @foo() local_unnamed_addr {
entry: entry:
%exitcond = icmp eq i64 3, 3 %exitcond = icmp eq i64 3, 3
br label %for.body br label %for.body
for.body: ; preds = %entry for.body: ; preds = %entry
%i.05 = phi i64 [ %inc, %for.body ], [ 0, %entry ] %i.05 = phi i64 [ %inc, %for.body ], [ 0, %entry ]
Show All 10 Lines

test/Transforms/LoopVectorize/align.ll

; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -S | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; Make sure we output the abi alignment if no alignment is specified. ; Make sure we output the abi alignment if no alignment is specified.
;CHECK-LABEL: @align ;CHECK-LABEL: @align
;CHECK: load <4 x i32>, <4 x i32>* {{.*}} align 4 ;CHECK: load <4 x i32>, <4 x i32>* {{.*}} align 4
;CHECK: load <4 x i32>, <4 x i32>* {{.*}} align 4 ;CHECK: load <4 x i32>, <4 x i32>* {{.*}} align 4
Show All 23 Lines

test/Transforms/LoopVectorize/bsd_regex.ll

; RUN: opt -S -loop-vectorize -dce -instcombine -force-vector-width=2 -force-vector-interleave=2 < %s | FileCheck %s ; RUN: opt -S -loop-vectorize-ignore-target-info -loop-vectorize -dce -instcombine -force-vector-width=2 -force-vector-interleave=2 < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
;PR 15830. ;PR 15830.
;CHECK-LABEL: @foo( ;CHECK-LABEL: @foo(
; When scalarizing stores we need to preserve the original order. ; When scalarizing stores we need to preserve the original order.
; Make sure that we are extracting in the correct order (0101, and not 0011). ; Make sure that we are extracting in the correct order (0101, and not 0011).
Show All 29 Lines

test/Transforms/LoopVectorize/bzip_reverse_loops.ll

; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S -enable-if-conversion | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S -enable-if-conversion | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
;CHECK: fc ;CHECK: fc
;CHECK: load <4 x i16> ;CHECK: load <4 x i16>
;CHECK-NEXT: shufflevector <4 x i16> ;CHECK-NEXT: shufflevector <4 x i16>
;CHECK: select <4 x i1> ;CHECK: select <4 x i1>
;CHECK: store <4 x i16> ;CHECK: store <4 x i16>
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/calloc.ll

; RUN: opt < %s -basicaa -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -basicaa -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
;CHECK: hexit ;CHECK: hexit
;CHECK: zext <4 x i8> ;CHECK: zext <4 x i8>
;CHECK: ret ;CHECK: ret
define noalias i8* @hexit(i8* nocapture %bytes, i64 %length) nounwind uwtable ssp { define noalias i8* @hexit(i8* nocapture %bytes, i64 %length) nounwind uwtable ssp {
Show All 40 Lines

test/Transforms/LoopVectorize/cast-induction.ll

; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s
; rdar://problem/12848162 ; rdar://problem/12848162
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
@a = common global [2048 x i32] zeroinitializer, align 16 @a = common global [2048 x i32] zeroinitializer, align 16
;CHECK-LABEL: @example12( ;CHECK-LABEL: @example12(
Show All 20 Lines

test/Transforms/LoopVectorize/conditional-assignment.ll

; RUN: opt < %s -loop-vectorize -S -pass-remarks-missed='loop-vectorize' -pass-remarks-analysis='loop-vectorize' 2>&1 | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -S -pass-remarks-missed='loop-vectorize' -pass-remarks-analysis='loop-vectorize' 2>&1 | FileCheck %s
; RUN: opt < %s -passes=loop-vectorize -S -pass-remarks-missed='loop-vectorize' -pass-remarks-analysis='loop-vectorize' 2>&1 | FileCheck %s ; RUN: opt < %s -passes=loop-vectorize -S -pass-remarks-missed='loop-vectorize' -pass-remarks-analysis='loop-vectorize' 2>&1 | FileCheck %s
; CHECK: remark: source.c:2:8: loop not vectorized: store that is conditionally executed prevents vectorization ; CHECK: remark: source.c:2:8: loop not vectorized: store that is conditionally executed prevents vectorization
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
; Function Attrs: nounwind ssp uwtable ; Function Attrs: nounwind ssp uwtable
define void @conditional_store(i32* noalias nocapture %indices) #0 !dbg !4 { define void @conditional_store(i32* noalias nocapture %indices) #0 !dbg !4 {
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/consec_no_gep.ll

;RUN: opt < %s -loop-vectorize -force-vector-width=4 -force-vector-interleave=1 -instcombine -S | FileCheck %s ;RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-width=4 -force-vector-interleave=1 -instcombine -S | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
;; Check consecutive memory access without preceding GEP instruction ;; Check consecutive memory access without preceding GEP instruction
; for (int i=0; i<len; i++) { ; for (int i=0; i<len; i++) {
; *to++ = *from++; ; *to++ = *from++;
; } ; }
Show All 33 Lines

test/Transforms/LoopVectorize/consecutive-ptr-uniforms.ll

; REQUIRES: asserts ; REQUIRES: asserts
; RUN: opt < %s -loop-vectorize -force-vector-width=4 -force-vector-interleave=1 -instcombine -debug-only=loop-vectorize -disable-output -print-after=instcombine 2>&1 | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-width=4 -force-vector-interleave=1 -instcombine -debug-only=loop-vectorize -disable-output -print-after=instcombine 2>&1 | FileCheck %s
; RUN: opt < %s -loop-vectorize -force-vector-width=4 -force-vector-interleave=1 -enable-interleaved-mem-accesses -enable-cond-stores-vec -instcombine -debug-only=loop-vectorize -disable-output -print-after=instcombine 2>&1 | FileCheck %s --check-prefix=INTER ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-width=4 -force-vector-interleave=1 -enable-interleaved-mem-accesses -enable-cond-stores-vec -instcombine -debug-only=loop-vectorize -disable-output -print-after=instcombine 2>&1 | FileCheck %s --check-prefix=INTER
target datalayout = "e-m:e-i64:64-i128:128-n32:64-S128" target datalayout = "e-m:e-i64:64-i128:128-n32:64-S128"
%pair = type { i32, i32 } %pair = type { i32, i32 }
; CHECK-LABEL: consecutive_ptr_forward ; CHECK-LABEL: consecutive_ptr_forward
; ;
; Check that a forward consecutive pointer is recognized as uniform and remains ; Check that a forward consecutive pointer is recognized as uniform and remains
▲ Show 20 Lines • Show All 429 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/control-flow.ll

; RUN: opt < %s -loop-vectorize -force-vector-width=4 -S -pass-remarks-missed='loop-vectorize' 2>&1 | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-width=4 -S -pass-remarks-missed='loop-vectorize' 2>&1 | FileCheck %s
; C/C++ code for control flow test ; C/C++ code for control flow test
; int test(int *A, int Length) { ; int test(int *A, int Length) {
; for (int i = 0; i < Length; i++) { ; for (int i = 0; i < Length; i++) {
; if (A[i] > 10.0) goto end; ; if (A[i] > 10.0) goto end;
; A[i] = 0; ; A[i] = 0;
; } ; }
; end: ; end:
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/cpp-new-array.ll

; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
;CHECK-LABEL: @cpp_new_arrays( ;CHECK-LABEL: @cpp_new_arrays(
;CHECK: sext i32 ;CHECK: sext i32
;CHECK: load <4 x float> ;CHECK: load <4 x float>
;CHECK: fadd <4 x float> ;CHECK: fadd <4 x float>
;CHECK: ret i32 ;CHECK: ret i32
Show All 36 Lines

test/Transforms/LoopVectorize/dbg.value.ll

; RUN: opt < %s -S -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine | FileCheck %s ; RUN: opt < %s -S -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine | FileCheck %s
; Make sure we vectorize with debugging turned on. ; Make sure we vectorize with debugging turned on.
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
@A = global [1024 x i32] zeroinitializer, align 16, !dbg !12 @A = global [1024 x i32] zeroinitializer, align 16, !dbg !12
@B = global [1024 x i32] zeroinitializer, align 16, !dbg !16 @B = global [1024 x i32] zeroinitializer, align 16, !dbg !16
@C = global [1024 x i32] zeroinitializer, align 16, !dbg !17 @C = global [1024 x i32] zeroinitializer, align 16, !dbg !17
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/dead_instructions.ll

; RUN: opt < %s -force-vector-width=2 -force-vector-interleave=2 -loop-vectorize -S | FileCheck %s ; RUN: opt < %s -force-vector-width=2 -force-vector-interleave=2 -loop-vectorize-ignore-target-info -loop-vectorize -S | FileCheck %s
target datalayout = "e-m:e-i64:64-i128:128-n32:64-S128" target datalayout = "e-m:e-i64:64-i128:128-n32:64-S128"
; CHECK-LABEL: @dead_instructions_01 ; CHECK-LABEL: @dead_instructions_01
; ;
; This test ensures that we don't generate trivially dead instructions prior to ; This test ensures that we don't generate trivially dead instructions prior to
; instruction simplification. We don't need to generate instructions ; instruction simplification. We don't need to generate instructions
; corresponding to the original induction variable update or branch condition, ; corresponding to the original induction variable update or branch condition,
Show All 33 Lines

test/Transforms/LoopVectorize/debugloc.ll

; RUN: opt -S < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=2 | FileCheck %s ; RUN: opt -S < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=2 | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; Make sure we are preserving debug info in the vectorized code. ; Make sure we are preserving debug info in the vectorized code.
; CHECK: for.body.lr.ph ; CHECK: for.body.lr.ph
; CHECK: cmp.zero = icmp eq i64 {{.*}}, 0, !dbg !{{[0-9]+}} ; CHECK: cmp.zero = icmp eq i64 {{.*}}, 0, !dbg !{{[0-9]+}}
; CHECK: vector.body ; CHECK: vector.body
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/diag-missing-instr-debug-loc.ll

; RUN: opt -loop-vectorize -pass-remarks-analysis=loop-vectorize < %s 2>&1 | FileCheck %s ; RUN: opt -loop-vectorize-ignore-target-info -loop-vectorize -pass-remarks-analysis=loop-vectorize < %s 2>&1 | FileCheck %s
; 1 extern int map[]; ; 1 extern int map[];
; 2 extern int out[]; ; 2 extern int out[];
; 3 ; 3
; 4 void f(int a, int n) { ; 4 void f(int a, int n) {
; 5 for (int i = 0; i < n; ++i) { ; 5 for (int i = 0; i < n; ++i) {
; 6 out[i] = a; ; 6 out[i] = a;
; 7 a = map[a]; ; 7 a = map[a];
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/diag-with-hotness-info-2.ll

; RUN: opt -S -loop-vectorize -pass-remarks-analysis=loop-vectorize -pass-remarks-with-hotness < %s 2>&1 | FileCheck %s ; RUN: opt -S -loop-vectorize-ignore-target-info -loop-vectorize -pass-remarks-analysis=loop-vectorize -pass-remarks-with-hotness < %s 2>&1 | FileCheck %s
; RUN: opt -S -passes=loop-vectorize -pass-remarks-analysis=loop-vectorize -pass-remarks-with-hotness < %s 2>&1 | FileCheck %s ; RUN: opt -S -passes=loop-vectorize -pass-remarks-analysis=loop-vectorize -pass-remarks-with-hotness < %s 2>&1 | FileCheck %s
; 1 void cold(char *A, char *B, char *C, char *D, char *E, int N) { ; 1 void cold(char *A, char *B, char *C, char *D, char *E, int N) {
; 2 for(int i = 0; i < N; i++) { ; 2 for(int i = 0; i < N; i++) {
; 3 A[i + 1] = A[i] + B[i]; ; 3 A[i + 1] = A[i] + B[i];
; 4 C[i] = D[i] * E[i]; ; 4 C[i] = D[i] * E[i];
; 5 } ; 5 }
; 6 } ; 6 }
▲ Show 20 Lines • Show All 191 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/diag-with-hotness-info.ll

; RUN: opt -S -loop-vectorize -pass-remarks-missed=loop-vectorize \ ; RUN: opt -S -loop-vectorize-ignore-target-info -loop-vectorize -pass-remarks-missed=loop-vectorize \
; RUN: -pass-remarks-with-hotness < %s 2>&1 | \ ; RUN: -pass-remarks-with-hotness < %s 2>&1 | \
; RUN: FileCheck -check-prefix=HOTNESS -check-prefix=BOTH %s ; RUN: FileCheck -check-prefix=HOTNESS -check-prefix=BOTH %s
; RUN: opt -S -loop-vectorize -pass-remarks-missed=loop-vectorize < %s 2>&1 | \ ; RUN: opt -S -loop-vectorize-ignore-target-info -loop-vectorize -pass-remarks-missed=loop-vectorize < %s 2>&1 | \
; RUN: FileCheck -check-prefix=NO_HOTNESS -check-prefix=BOTH %s ; RUN: FileCheck -check-prefix=NO_HOTNESS -check-prefix=BOTH %s
; RUN: opt -S -passes=loop-vectorize -pass-remarks-missed=loop-vectorize \ ; RUN: opt -S -passes=loop-vectorize -pass-remarks-missed=loop-vectorize \
; RUN: -pass-remarks-with-hotness < %s 2>&1 | \ ; RUN: -pass-remarks-with-hotness < %s 2>&1 | \
; RUN: FileCheck -check-prefix=HOTNESS -check-prefix=BOTH %s ; RUN: FileCheck -check-prefix=HOTNESS -check-prefix=BOTH %s
; RUN: opt -S -passes=loop-vectorize -pass-remarks-missed=loop-vectorize < %s 2>&1 | \ ; RUN: opt -S -passes=loop-vectorize -pass-remarks-missed=loop-vectorize < %s 2>&1 | \
▲ Show 20 Lines • Show All 199 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/duplicated-metadata.ll

; RUN: opt < %s -loop-vectorize -S 2>&1 | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -S 2>&1 | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
; This test makes sure we don't duplicate the loop vectorizer's metadata ; This test makes sure we don't duplicate the loop vectorizer's metadata
; while marking them as already vectorized (by setting width = 1), even ; while marking them as already vectorized (by setting width = 1), even
; at lower optimization levels, where no extra cleanup is done ; at lower optimization levels, where no extra cleanup is done
define void @_Z3fooPf(float* %a) { define void @_Z3fooPf(float* %a) {
entry: entry:
Show All 20 Lines

test/Transforms/LoopVectorize/ee-crash.ll

; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -S | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; This test checks that we deal with an in-loop extractelement (for now, this ; This test checks that we deal with an in-loop extractelement (for now, this
; means not crashing by not vectorizing). ; means not crashing by not vectorizing).
; CHECK-LABEL: @_Z4foo1Pii( ; CHECK-LABEL: @_Z4foo1Pii(
; CHECK-NOT: <4 x i32> ; CHECK-NOT: <4 x i32>
; CHECK: ret ; CHECK: ret
Show All 25 Lines

test/Transforms/LoopVectorize/exact.ll

; RUN: opt < %s -loop-vectorize -force-vector-width=4 -S | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-width=4 -S | FileCheck %s
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
; CHECK-LABEL: @lshr_exact( ; CHECK-LABEL: @lshr_exact(
; CHECK: lshr exact <4 x i32> ; CHECK: lshr exact <4 x i32>
define void @lshr_exact(i32* %x) { define void @lshr_exact(i32* %x) {
entry: entry:
br label %for.body br label %for.body
Show All 14 Lines

test/Transforms/LoopVectorize/flags.ll

; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
;CHECK-LABEL: @flags1( ;CHECK-LABEL: @flags1(
;CHECK: load <4 x i32> ;CHECK: load <4 x i32>
;CHECK: mul nsw <4 x i32> ;CHECK: mul nsw <4 x i32>
;CHECK: store <4 x i32> ;CHECK: store <4 x i32>
;CHECK: ret i32 ;CHECK: ret i32
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/float-induction.ll

; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck --check-prefix VEC4_INTERL1 %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck --check-prefix VEC4_INTERL1 %s
; RUN: opt < %s -loop-vectorize -force-vector-interleave=2 -force-vector-width=4 -dce -instcombine -S | FileCheck --check-prefix VEC4_INTERL2 %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=2 -force-vector-width=4 -dce -instcombine -S | FileCheck --check-prefix VEC4_INTERL2 %s
; RUN: opt < %s -loop-vectorize -force-vector-interleave=2 -force-vector-width=1 -dce -instcombine -S | FileCheck --check-prefix VEC1_INTERL2 %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=2 -force-vector-width=1 -dce -instcombine -S | FileCheck --check-prefix VEC1_INTERL2 %s
; VEC4_INTERL1-LABEL: @fp_iv_loop1( ; VEC4_INTERL1-LABEL: @fp_iv_loop1(
; VEC4_INTERL1: %[[FP_INC:.*]] = load float, float* @fp_inc ; VEC4_INTERL1: %[[FP_INC:.*]] = load float, float* @fp_inc
; VEC4_INTERL1: vector.body: ; VEC4_INTERL1: vector.body:
; VEC4_INTERL1: %[[FP_INDEX:.*]] = sitofp i64 {{.*}} to float ; VEC4_INTERL1: %[[FP_INDEX:.*]] = sitofp i64 {{.*}} to float
; VEC4_INTERL1: %[[VEC_INCR:.*]] = fmul fast float {{.*}}, %[[FP_INDEX]] ; VEC4_INTERL1: %[[VEC_INCR:.*]] = fmul fast float {{.*}}, %[[FP_INDEX]]
; VEC4_INTERL1: %[[FP_OFFSET_IDX:.*]] = fsub fast float %init, %[[VEC_INCR]] ; VEC4_INTERL1: %[[FP_OFFSET_IDX:.*]] = fsub fast float %init, %[[VEC_INCR]]
; VEC4_INTERL1: %[[BRCT_INSERT:.*]] = insertelement <4 x float> undef, float %[[FP_OFFSET_IDX]], i32 0 ; VEC4_INTERL1: %[[BRCT_INSERT:.*]] = insertelement <4 x float> undef, float %[[FP_OFFSET_IDX]], i32 0
▲ Show 20 Lines • Show All 207 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/float-reduction.ll

; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
;CHECK-LABEL: @foo( ;CHECK-LABEL: @foo(
;CHECK: fadd fast <4 x float> ;CHECK: fadd fast <4 x float>
;CHECK: ret ;CHECK: ret
define float @foo(float* nocapture %A, i32* nocapture %n) nounwind uwtable readonly ssp { define float @foo(float* nocapture %A, i32* nocapture %n) nounwind uwtable readonly ssp {
entry: entry:
br label %for.body br label %for.body
Show All 37 Lines

test/Transforms/LoopVectorize/funcall.ll

; RUN: opt -S -loop-vectorize -force-vector-width=2 -force-vector-interleave=1 < %s | FileCheck %s ; RUN: opt -S -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-width=2 -force-vector-interleave=1 < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; Make sure we can vectorize loops with functions to math library functions. ; Make sure we can vectorize loops with functions to math library functions.
; They might read the rounding mode but we are only vectorizing loops that ; They might read the rounding mode but we are only vectorizing loops that
; contain a limited set of function calls and none of them sets the rounding ; contain a limited set of function calls and none of them sets the rounding
; mode, so vectorizing them is safe. ; mode, so vectorizing them is safe.
Show All 23 Lines

test/Transforms/LoopVectorize/gcc-examples.ll

; RUN: opt < %s -basicaa -loop-vectorize -force-vector-width=4 -force-vector-interleave=1 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -basicaa -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-width=4 -force-vector-interleave=1 -dce -instcombine -S | FileCheck %s
; RUN: opt < %s -basicaa -loop-vectorize -force-vector-width=4 -force-vector-interleave=4 -dce -instcombine -S | FileCheck %s -check-prefix=UNROLL ; RUN: opt < %s -basicaa -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-width=4 -force-vector-interleave=4 -dce -instcombine -S | FileCheck %s -check-prefix=UNROLL
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
@b = common global [2048 x i32] zeroinitializer, align 16 @b = common global [2048 x i32] zeroinitializer, align 16
@c = common global [2048 x i32] zeroinitializer, align 16 @c = common global [2048 x i32] zeroinitializer, align 16
@a = common global [2048 x i32] zeroinitializer, align 16 @a = common global [2048 x i32] zeroinitializer, align 16
@G = common global [32 x [1024 x i32]] zeroinitializer, align 16 @G = common global [32 x [1024 x i32]] zeroinitializer, align 16
@ub = common global [1024 x i32] zeroinitializer, align 16 @ub = common global [1024 x i32] zeroinitializer, align 16
▲ Show 20 Lines • Show All 675 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/gep_with_bitcast.ll

; RUN: opt -S -loop-vectorize -instcombine -force-vector-width=4 < %s | FileCheck %s ; RUN: opt -S -loop-vectorize-ignore-target-info -loop-vectorize -instcombine -force-vector-width=4 < %s | FileCheck %s
target datalayout = "e-m:e-i64:64-i128:128-n32:64-S128" target datalayout = "e-m:e-i64:64-i128:128-n32:64-S128"
; Vectorization of loop with bitcast between GEP and load ; Vectorization of loop with bitcast between GEP and load
; Simplified source code: ; Simplified source code:
;void foo (double** __restrict__ in, bool * __restrict__ res) { ;void foo (double** __restrict__ in, bool * __restrict__ res) {
; ;
; for (int i = 0; i < 4096; ++i) ; for (int i = 0; i < 4096; ++i)
Show All 32 Lines

test/Transforms/LoopVectorize/global_alias.ll

; RUN: opt < %s -O1 -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -O1 -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:64:128-a0:0:64-n32-S64" target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:64:128-a0:0:64-n32-S64"
%struct.anon = type { [100 x i32], i32, [100 x i32] } %struct.anon = type { [100 x i32], i32, [100 x i32] }
%struct.anon.0 = type { [100 x [100 x i32]], i32, [100 x [100 x i32]] } %struct.anon.0 = type { [100 x [100 x i32]], i32, [100 x [100 x i32]] }
@Foo = common global %struct.anon zeroinitializer, align 4 @Foo = common global %struct.anon zeroinitializer, align 4
@Bar = common global %struct.anon.0 zeroinitializer, align 4 @Bar = common global %struct.anon.0 zeroinitializer, align 4
▲ Show 20 Lines • Show All 1,068 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/hints-trans.ll

; RUN: opt -S -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -instsimplify -simplifycfg < %s | FileCheck %s ; RUN: opt -S -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -instsimplify -simplifycfg < %s | FileCheck %s
; Note: -instsimplify -simplifycfg remove the (now dead) original loop, making ; Note: -instsimplify -simplifycfg remove the (now dead) original loop, making
; it easy to test that the llvm.loop.unroll.disable hint is still present. ; it easy to test that the llvm.loop.unroll.disable hint is still present.
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
; Function Attrs: norecurse nounwind uwtable ; Function Attrs: norecurse nounwind uwtable
define void @foo(i32* nocapture %b) #0 { define void @foo(i32* nocapture %b) #0 {
entry: entry:
br label %for.body br label %for.body
Show All 20 Lines

test/Transforms/LoopVectorize/hoist-loads.ll

; RUN: opt -loop-vectorize -force-vector-width=2 -force-vector-interleave=1 -S < %s | FileCheck %s ; RUN: opt -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-width=2 -force-vector-interleave=1 -S < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
@A = common global [1024 x float] zeroinitializer, align 16 @A = common global [1024 x float] zeroinitializer, align 16
@B = common global [1024 x float] zeroinitializer, align 16 @B = common global [1024 x float] zeroinitializer, align 16
; Make sure we can vectorize in the presence of hoistable conditional loads. ; Make sure we can vectorize in the presence of hoistable conditional loads.
; CHECK-LABEL: @hoist_cond_load( ; CHECK-LABEL: @hoist_cond_load(
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/i8-induction.ll

; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
@a = common global i8 0, align 1 @a = common global i8 0, align 1
@b = common global i8 0, align 1 @b = common global i8 0, align 1
define void @f() nounwind uwtable ssp { define void @f() nounwind uwtable ssp {
scalar.ph: scalar.ph:
Show All 21 Lines

test/Transforms/LoopVectorize/icmp-uniforms.ll

; REQUIRES: asserts ; REQUIRES: asserts
; RUN: opt < %s -loop-vectorize -force-vector-width=4 -force-vector-interleave=1 -instcombine -debug-only=loop-vectorize -disable-output -print-after=instcombine 2>&1 | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-width=4 -force-vector-interleave=1 -instcombine -debug-only=loop-vectorize -disable-output -print-after=instcombine 2>&1 | FileCheck %s
target datalayout = "e-m:e-i64:64-i128:128-n32:64-S128" target datalayout = "e-m:e-i64:64-i128:128-n32:64-S128"
; CHECK-LABEL: more_than_one_use ; CHECK-LABEL: more_than_one_use
; ;
; PR30627. Check that a compare instruction with more than one use is not ; PR30627. Check that a compare instruction with more than one use is not
; recognized as uniform and is vectorized. ; recognized as uniform and is vectorized.
; ;
Show All 25 Lines

test/Transforms/LoopVectorize/if-conv-crash.ll

; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -enable-if-conversion ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -enable-if-conversion
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
define fastcc void @DD_dump() nounwind uwtable ssp { define fastcc void @DD_dump() nounwind uwtable ssp {
entry: entry:
br i1 undef, label %lor.lhs.false, label %if.end25 br i1 undef, label %lor.lhs.false, label %if.end25
lor.lhs.false: ; preds = %entry lor.lhs.false: ; preds = %entry
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/if-conversion-edgemasks.ll

; RUN: opt -S -loop-vectorize < %s | FileCheck %s ; RUN: opt -S -loop-vectorize-ignore-target-info -loop-vectorize < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
@a = global i32* null, align 8 @a = global i32* null, align 8
@b = global i32* null, align 8 @b = global i32* null, align 8
@c = global i32* null, align 8 @c = global i32* null, align 8
; Don't create an exponetial IR for the edge masks needed when if-converting ; Don't create an exponetial IR for the edge masks needed when if-converting
▲ Show 20 Lines • Show All 236 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/if-conversion-nest.ll

; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -enable-if-conversion -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -enable-if-conversion -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
;CHECK-LABEL: @foo( ;CHECK-LABEL: @foo(
;CHECK: icmp sgt ;CHECK: icmp sgt
;CHECK: icmp sgt ;CHECK: icmp sgt
;CHECK: icmp slt ;CHECK: icmp slt
;CHECK: select <4 x i1> ;CHECK: select <4 x i1>
Show All 39 Lines

test/Transforms/LoopVectorize/if-conversion-reduction.ll

; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -enable-if-conversion -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -enable-if-conversion -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
;CHECK-LABEL: @reduction_func( ;CHECK-LABEL: @reduction_func(
;CHECK-NOT: load <4 x i32> ;CHECK-NOT: load <4 x i32>
;CHECK: ret i32 ;CHECK: ret i32
define i32 @reduction_func(i32* nocapture %A, i32 %n) nounwind uwtable readonly ssp { define i32 @reduction_func(i32* nocapture %A, i32 %n) nounwind uwtable readonly ssp {
entry: entry:
Show All 28 Lines

test/Transforms/LoopVectorize/if-conversion.ll

; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -enable-if-conversion -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -enable-if-conversion -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; This is the loop in this example: ; This is the loop in this example:
; ;
;int function0(int *a, int *b, int start, int end) { ;int function0(int *a, int *b, int start, int end) {
; ;
; for (int i=start; i<end; ++i) { ; for (int i=start; i<end; ++i) {
▲ Show 20 Lines • Show All 161 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/if-pred-non-void.ll

; RUN: opt -S -force-vector-width=2 -force-vector-interleave=1 -loop-vectorize -verify-loop-info -simplifycfg < %s | FileCheck %s ; RUN: opt -S -force-vector-width=2 -force-vector-interleave=1 -loop-vectorize-ignore-target-info -loop-vectorize -verify-loop-info -simplifycfg < %s | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
; Test predication of non-void instructions, specifically (i) that these ; Test predication of non-void instructions, specifically (i) that these
; instructions permit vectorization and (ii) the creation of an insertelement ; instructions permit vectorization and (ii) the creation of an insertelement
; and a Phi node. We check the full 2-element sequence for the first ; and a Phi node. We check the full 2-element sequence for the first
; instruction; For the rest we'll just make sure they get predicated based ; instruction; For the rest we'll just make sure they get predicated based
; on the code generated for the first element. ; on the code generated for the first element.
▲ Show 20 Lines • Show All 200 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/if-pred-not-when-safe.ll

; RUN: opt -S -force-vector-width=2 -force-vector-interleave=1 -loop-vectorize -verify-loop-info -simplifycfg < %s | FileCheck %s ; RUN: opt -S -force-vector-width=2 -force-vector-interleave=1 -loop-vectorize-ignore-target-info -loop-vectorize -verify-loop-info -simplifycfg < %s | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
; Test no-predication of instructions that are provably safe, e.g. dividing by ; Test no-predication of instructions that are provably safe, e.g. dividing by
; a non-zero constant. ; a non-zero constant.
define void @test(i32* nocapture %asd, i32* nocapture %aud, define void @test(i32* nocapture %asd, i32* nocapture %aud,
i32* nocapture %asr, i32* nocapture %aur, i32* nocapture %asr, i32* nocapture %aur,
i32* nocapture %asd0, i32* nocapture %aud0, i32* nocapture %asd0, i32* nocapture %aud0,
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/if-pred-stores.ll

; RUN: opt -S -vectorize-num-stores-pred=1 -force-vector-width=1 -force-vector-interleave=2 -loop-vectorize -verify-loop-info -simplifycfg < %s | FileCheck %s --check-prefix=UNROLL ; RUN: opt -S -vectorize-num-stores-pred=1 -force-vector-width=1 -force-vector-interleave=2 -loop-vectorize-ignore-target-info -loop-vectorize -verify-loop-info -simplifycfg < %s | FileCheck %s --check-prefix=UNROLL
; RUN: opt -S -vectorize-num-stores-pred=1 -force-vector-width=1 -force-vector-interleave=2 -loop-vectorize -verify-loop-info < %s | FileCheck %s --check-prefix=UNROLL-NOSIMPLIFY ; RUN: opt -S -vectorize-num-stores-pred=1 -force-vector-width=1 -force-vector-interleave=2 -loop-vectorize-ignore-target-info -loop-vectorize -verify-loop-info < %s | FileCheck %s --check-prefix=UNROLL-NOSIMPLIFY
; RUN: opt -S -vectorize-num-stores-pred=1 -force-vector-width=2 -force-vector-interleave=1 -loop-vectorize -enable-cond-stores-vec -verify-loop-info -simplifycfg < %s | FileCheck %s --check-prefix=VEC ; RUN: opt -S -vectorize-num-stores-pred=1 -force-vector-width=2 -force-vector-interleave=1 -loop-vectorize-ignore-target-info -loop-vectorize -enable-cond-stores-vec -verify-loop-info -simplifycfg < %s | FileCheck %s --check-prefix=VEC
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
; Test predication of stores. ; Test predication of stores.
define i32 @test(i32* nocapture %f) #0 { define i32 @test(i32* nocapture %f) #0 {
entry: entry:
br label %for.body br label %for.body
▲ Show 20 Lines • Show All 121 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/incorrect-dom-info.ll

; This test is based on one of benchmarks from SPEC2006. It exposes a bug with ; This test is based on one of benchmarks from SPEC2006. It exposes a bug with
; incorrect updating of the dom-tree. ; incorrect updating of the dom-tree.
; RUN: opt < %s -loop-vectorize -verify-dom-info ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -verify-dom-info
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
@PL_utf8skip = external constant [0 x i8] @PL_utf8skip = external constant [0 x i8]
; Function Attrs: nounwind ssp uwtable ; Function Attrs: nounwind ssp uwtable
define void @Perl_pp_quotemeta() #0 { define void @Perl_pp_quotemeta() #0 {
%len = alloca i64, align 8 %len = alloca i64, align 8
br i1 undef, label %2, label %1 br i1 undef, label %2, label %1
▲ Show 20 Lines • Show All 131 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/increment.ll

; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
@a = common global [2048 x i32] zeroinitializer, align 16 @a = common global [2048 x i32] zeroinitializer, align 16
; This is the loop. ; This is the loop.
; for (i=0; i<n; i++){ ; for (i=0; i<n; i++){
; a[i] += i; ; a[i] += i;
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/induction-step.ll

; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=8 -S | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=8 -S | FileCheck %s
; int int_inc; ; int int_inc;
; ;
;int induction_with_global(int init, int *restrict A, int N) { ;int induction_with_global(int init, int *restrict A, int N) {
; int x = init; ; int x = init;
; for (int i=0;i<N;i++){ ; for (int i=0;i<N;i++){
; A[i] = x; ; A[i] = x;
; x += int_inc; ; x += int_inc;
▲ Show 20 Lines • Show All 115 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/induction.ll

; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=2 -S | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=2 -S | FileCheck %s
; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=2 -instcombine -S | FileCheck %s --check-prefix=IND ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=2 -instcombine -S | FileCheck %s --check-prefix=IND
; RUN: opt < %s -loop-vectorize -force-vector-interleave=2 -force-vector-width=2 -instcombine -S | FileCheck %s --check-prefix=UNROLL ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=2 -force-vector-width=2 -instcombine -S | FileCheck %s --check-prefix=UNROLL
; RUN: opt < %s -loop-vectorize -force-vector-interleave=2 -force-vector-width=2 -S | FileCheck %s --check-prefix=UNROLL-NO-IC ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=2 -force-vector-width=2 -S | FileCheck %s --check-prefix=UNROLL-NO-IC
; RUN: opt < %s -loop-vectorize -force-vector-interleave=2 -force-vector-width=4 -enable-interleaved-mem-accesses -instcombine -S | FileCheck %s --check-prefix=INTERLEAVE ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=2 -force-vector-width=4 -enable-interleaved-mem-accesses -instcombine -S | FileCheck %s --check-prefix=INTERLEAVE
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; Make sure that we can handle multiple integer induction variables. ; Make sure that we can handle multiple integer induction variables.
; CHECK-LABEL: @multi_int_induction( ; CHECK-LABEL: @multi_int_induction(
; CHECK: vector.body: ; CHECK: vector.body:
; CHECK: %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ] ; CHECK: %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
; CHECK: %[[VAR:.*]] = trunc i64 %index to i32 ; CHECK: %[[VAR:.*]] = trunc i64 %index to i32
▲ Show 20 Lines • Show All 754 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/induction_plus.ll

; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -S | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
@array = common global [1024 x i32] zeroinitializer, align 16 @array = common global [1024 x i32] zeroinitializer, align 16
;CHECK-LABEL: @array_at_plus_one( ;CHECK-LABEL: @array_at_plus_one(
;CHECK: %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ] ;CHECK: %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
;CHECK: %vec.ind = phi <4 x i64> [ <i64 0, i64 1, i64 2, i64 3>, %vector.ph ], [ %vec.ind.next, %vector.body ] ;CHECK: %vec.ind = phi <4 x i64> [ <i64 0, i64 1, i64 2, i64 3>, %vector.ph ], [ %vec.ind.next, %vector.body ]
Show All 25 Lines

test/Transforms/LoopVectorize/infiniteloop.ll

; RUN: opt -S -indvars -loop-vectorize -force-vector-width=2 < %s | FileCheck %s ; RUN: opt -S -indvars -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-width=2 < %s | FileCheck %s
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32-n8:16:32-S128" target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32-n8:16:32-S128"
@a = common global i64 0, align 8 @a = common global i64 0, align 8
@x = common global i32 0, align 4 @x = common global i32 0, align 4
; We used to assert on this loop because we could not find an induction ; We used to assert on this loop because we could not find an induction
; variable but assumed there must be one. Scalar evolution returned a exit ; variable but assumed there must be one. Scalar evolution returned a exit
Show All 25 Lines

test/Transforms/LoopVectorize/interleaved-accesses-1.ll

; RUN: opt -S -loop-vectorize -instcombine -force-vector-width=4 -force-vector-interleave=1 -enable-interleaved-mem-accesses=true < %s | FileCheck %s ; RUN: opt -S -loop-vectorize-ignore-target-info -loop-vectorize -instcombine -force-vector-width=4 -force-vector-interleave=1 -enable-interleaved-mem-accesses=true < %s | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
; Check that the interleaved-mem-access analysis identifies the access ; Check that the interleaved-mem-access analysis identifies the access
; to array 'in' as interleaved, despite the possibly wrapping unsigned ; to array 'in' as interleaved, despite the possibly wrapping unsigned
; 'out_ix' index. ; 'out_ix' index.
; ;
; In this test the interleave-groups are full (have no gaps), so no wrapping ; In this test the interleave-groups are full (have no gaps), so no wrapping
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/interleaved-accesses-2.ll

; RUN: opt -S -loop-vectorize -instcombine -force-vector-width=4 -force-vector-interleave=1 -enable-interleaved-mem-accesses=true < %s | FileCheck %s ; RUN: opt -S -loop-vectorize-ignore-target-info -loop-vectorize -instcombine -force-vector-width=4 -force-vector-interleave=1 -enable-interleaved-mem-accesses=true < %s | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
; Check that the interleaved-mem-access analysis currently does not create an ; Check that the interleaved-mem-access analysis currently does not create an
; interleave group for the access to array 'in' due to the possibly wrapping ; interleave group for the access to array 'in' due to the possibly wrapping
; unsigned 'out_ix' index. ; unsigned 'out_ix' index.
; ;
; In this test the interleave-group of the loads is not full (has gaps), so ; In this test the interleave-group of the loads is not full (has gaps), so
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/interleaved-accesses-3.ll

; RUN: opt -S -loop-vectorize -instcombine -force-vector-width=4 -force-vector-interleave=1 -enable-interleaved-mem-accesses=true < %s | FileCheck %s ; RUN: opt -S -loop-vectorize-ignore-target-info -loop-vectorize -instcombine -force-vector-width=4 -force-vector-interleave=1 -enable-interleaved-mem-accesses=true < %s | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
; Check that the interleaved-mem-access analysis currently does not create an ; Check that the interleaved-mem-access analysis currently does not create an
; interleave group for access 'a' due to the possible pointer wrap-around. ; interleave group for access 'a' due to the possible pointer wrap-around.
; ;
; To begin with, in this test the candidate interleave group can be created ; To begin with, in this test the candidate interleave group can be created
; only when getPtrStride is called with Assume=true. Next, because ; only when getPtrStride is called with Assume=true. Next, because
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/interleaved-accesses-pred-stores.ll

; RUN: opt -S -loop-vectorize -instcombine -force-vector-width=2 -force-vector-interleave=1 -enable-interleaved-mem-accesses -vectorize-num-stores-pred=1 -enable-cond-stores-vec < %s | FileCheck %s ; RUN: opt -S -loop-vectorize-ignore-target-info -loop-vectorize -instcombine -force-vector-width=2 -force-vector-interleave=1 -enable-interleaved-mem-accesses -vectorize-num-stores-pred=1 -enable-cond-stores-vec < %s | FileCheck %s
target datalayout = "e-m:e-i64:64-i128:128-n32:64-S128" target datalayout = "e-m:e-i64:64-i128:128-n32:64-S128"
%pair = type { i64, i64 } %pair = type { i64, i64 }
; Ensure that we vectorize the interleaved load group even though the loop ; Ensure that we vectorize the interleaved load group even though the loop
; contains a conditional store. The store group contains gaps and is not ; contains a conditional store. The store group contains gaps and is not
; vectorized. ; vectorized.
; ;
▲ Show 20 Lines • Show All 155 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/interleaved-accesses.ll

; RUN: opt -S -loop-vectorize -instcombine -force-vector-width=4 -force-vector-interleave=1 -enable-interleaved-mem-accesses=true -runtime-memory-check-threshold=24 < %s | FileCheck %s ; RUN: opt -S -loop-vectorize-ignore-target-info -loop-vectorize -instcombine -force-vector-width=4 -force-vector-interleave=1 -enable-interleaved-mem-accesses=true -runtime-memory-check-threshold=24 < %s | FileCheck %s
target datalayout = "e-m:e-i64:64-i128:128-n32:64-S128" target datalayout = "e-m:e-i64:64-i128:128-n32:64-S128"
; Check vectorization on an interleaved load group of factor 2 and an interleaved ; Check vectorization on an interleaved load group of factor 2 and an interleaved
; store group of factor 2. ; store group of factor 2.
; int AB[1024]; ; int AB[1024];
; int CD[1024]; ; int CD[1024];
▲ Show 20 Lines • Show All 860 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/intrinsic.ll

; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
;CHECK-LABEL: @sqrt_f32( ;CHECK-LABEL: @sqrt_f32(
;CHECK: llvm.sqrt.v4f32 ;CHECK: llvm.sqrt.v4f32
;CHECK: ret void ;CHECK: ret void
define void @sqrt_f32(i32 %n, float* noalias %y, float* noalias %x) nounwind uwtable { define void @sqrt_f32(i32 %n, float* noalias %y, float* noalias %x) nounwind uwtable {
entry: entry:
▲ Show 20 Lines • Show All 1,240 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/iv_outside_user.ll

; RUN: opt -S -loop-vectorize -force-vector-interleave=1 -force-vector-width=2 < %s | FileCheck %s ; RUN: opt -S -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=2 < %s | FileCheck %s
; CHECK-LABEL: @postinc ; CHECK-LABEL: @postinc
; CHECK-LABEL: scalar.ph: ; CHECK-LABEL: scalar.ph:
; CHECK: %bc.resume.val = phi i32 [ %n.vec, %middle.block ], [ 0, %entry ] ; CHECK: %bc.resume.val = phi i32 [ %n.vec, %middle.block ], [ 0, %entry ]
; CHECK-LABEL: for.end: ; CHECK-LABEL: for.end:
; CHECK: %[[RET:.*]] = phi i32 [ {{.*}}, %for.body ], [ %n.vec, %middle.block ] ; CHECK: %[[RET:.*]] = phi i32 [ {{.*}}, %for.body ], [ %n.vec, %middle.block ]
; CHECK: ret i32 %[[RET]] ; CHECK: ret i32 %[[RET]]
define i32 @postinc(i32 %k) { define i32 @postinc(i32 %k) {
▲ Show 20 Lines • Show All 126 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/lcssa-crash.ll

; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=4
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
%type1 = type { %type2 } %type1 = type { %type2 }
%type2 = type { [0 x i8*], i8**, i32, i32, i32 } %type2 = type { [0 x i8*], i8**, i32, i32, i32 }
define void @test() nounwind uwtable align 2 { define void @test() nounwind uwtable align 2 {
br label %for.body.lr.ph.i.i.i br label %for.body.lr.ph.i.i.i
Show All 30 Lines

test/Transforms/LoopVectorize/lifetime.ll

; RUN: opt -S -loop-vectorize -force-vector-width=2 -force-vector-interleave=1 < %s | FileCheck %s ; RUN: opt -S -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-width=2 -force-vector-interleave=1 < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; Make sure we can vectorize loops which contain lifetime markers. ; Make sure we can vectorize loops which contain lifetime markers.
; CHECK-LABEL: @test( ; CHECK-LABEL: @test(
; CHECK: call void @llvm.lifetime.end ; CHECK: call void @llvm.lifetime.end
; CHECK: store <2 x i32> ; CHECK: store <2 x i32>
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/loop-form.ll

; RUN: opt -S -loop-vectorize < %s | FileCheck %s ; RUN: opt -S -loop-vectorize-ignore-target-info -loop-vectorize < %s | FileCheck %s
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
; Check that we vectorize only bottom-tested loops. ; Check that we vectorize only bottom-tested loops.
; This is a reduced testcase from PR21302. ; This is a reduced testcase from PR21302.
; ;
; rdar://problem/18886083 ; rdar://problem/18886083
%struct.X = type { i32, i16 } %struct.X = type { i32, i16 }
Show All 22 Lines

test/Transforms/LoopVectorize/loop-vect-memdep.ll

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
; RUN: opt < %s -S -loop-vectorize -debug-only=loop-vectorize 2>&1 | FileCheck %s ; RUN: opt < %s -S -loop-vectorize-ignore-target-info -loop-vectorize -debug-only=loop-vectorize 2>&1 | FileCheck %s
; REQUIRES: asserts ; REQUIRES: asserts
; CHECK: LV: Can't vectorize due to memory conflicts ; CHECK: LV: Can't vectorize due to memory conflicts
define void @test_loop_novect(double** %arr, i64 %n) { define void @test_loop_novect(double** %arr, i64 %n) {
for.body.lr.ph: for.body.lr.ph:
%t = load double*, double** %arr, align 8 %t = load double*, double** %arr, align 8
br label %for.body br label %for.body
Show All 15 Lines

test/Transforms/LoopVectorize/memdep.ll

; RUN: opt < %s -loop-vectorize -force-vector-width=2 -force-vector-interleave=1 -S | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-width=2 -force-vector-interleave=1 -S | FileCheck %s
; RUN: opt < %s -loop-vectorize -force-vector-width=4 -force-vector-interleave=1 -S | FileCheck %s -check-prefix=WIDTH ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-width=4 -force-vector-interleave=1 -S | FileCheck %s -check-prefix=WIDTH
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; Vectorization with dependence checks. ; Vectorization with dependence checks.
; No plausible dependence - can be vectorized. ; No plausible dependence - can be vectorized.
; for (i = 0; i < 1024; ++i) ; for (i = 0; i < 1024; ++i)
; A[i] = A[i + 1] + 1; ; A[i] = A[i + 1] + 1;
▲ Show 20 Lines • Show All 212 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/metadata-unroll.ll

; RUN: opt < %s -loop-vectorize -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-width=4 -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
@a = common global [2048 x i32] zeroinitializer, align 16 @a = common global [2048 x i32] zeroinitializer, align 16
; This is the loop. ; This is the loop.
; for (i=0; i<n; i++){ ; for (i=0; i<n; i++){
; a[i] += i; ; a[i] += i;
Show All 31 Lines

test/Transforms/LoopVectorize/metadata-width.ll

; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK: store <8 x i32> ; CHECK: store <8 x i32>
; CHECK: ret void ; CHECK: ret void
define void @test1(i32* nocapture %a, i32 %n) #0 { define void @test1(i32* nocapture %a, i32 %n) #0 {
entry: entry:
Show All 21 Lines

test/Transforms/LoopVectorize/metadata.ll

; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -S | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -S | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
define i32 @test1(i32* nocapture %a, float* nocapture readonly %b) #0 { define i32 @test1(i32* nocapture %a, float* nocapture readonly %b) #0 {
entry: entry:
br label %for.body br label %for.body
for.body: ; preds = %for.body, %entry for.body: ; preds = %for.body, %entry
Show All 34 Lines

test/Transforms/LoopVectorize/miniters.ll

; RUN: opt %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -S | FileCheck %s ; RUN: opt %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -S | FileCheck %s
; RUN: opt %s -loop-vectorize -force-vector-interleave=2 -force-vector-width=4 -S | FileCheck %s -check-prefix=UNROLL ; RUN: opt %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=2 -force-vector-width=4 -S | FileCheck %s -check-prefix=UNROLL
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
@b = common global [1000 x i32] zeroinitializer, align 16 @b = common global [1000 x i32] zeroinitializer, align 16
@c = common global [1000 x i32] zeroinitializer, align 16 @c = common global [1000 x i32] zeroinitializer, align 16
@a = common global [1000 x i32] zeroinitializer, align 16 @a = common global [1000 x i32] zeroinitializer, align 16
; Generate min.iters.check to skip the vector loop and jump to scalar.ph directly when loop iteration number is less than VF * UF. ; Generate min.iters.check to skip the vector loop and jump to scalar.ph directly when loop iteration number is less than VF * UF.
Show All 34 Lines

test/Transforms/LoopVectorize/minmax_reduction.ll

; RUN: opt -S -loop-vectorize -dce -instcombine -force-vector-width=2 -force-vector-interleave=1 < %s | FileCheck %s ; RUN: opt -S -loop-vectorize-ignore-target-info -loop-vectorize -dce -instcombine -force-vector-width=2 -force-vector-interleave=1 < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
@A = common global [1024 x i32] zeroinitializer, align 16 @A = common global [1024 x i32] zeroinitializer, align 16
@fA = common global [1024 x float] zeroinitializer, align 16 @fA = common global [1024 x float] zeroinitializer, align 16
@dA = common global [1024 x double] zeroinitializer, align 16 @dA = common global [1024 x double] zeroinitializer, align 16
; Signed tests. ; Signed tests.
▲ Show 20 Lines • Show All 876 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/multi-use-reduction-bug.ll

; RUN: opt -indvars -loop-vectorize -force-vector-width=2 -force-vector-interleave=1 -S < %s | FileCheck %s ; RUN: opt -indvars -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-width=2 -force-vector-interleave=1 -S < %s | FileCheck %s
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
; We must not vectorize this loop. %add55 is not reduction. Its value is used ; We must not vectorize this loop. %add55 is not reduction. Its value is used
; multiple times. ; multiple times.
; PR18526 ; PR18526
Show All 32 Lines

test/Transforms/LoopVectorize/multiple-address-spaces.ll

; RUN: opt < %s -basicaa -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -basicaa -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s
; From a simple program with two address spaces: ; From a simple program with two address spaces:
; char Y[4*10000] __attribute__((address_space(1))); ; char Y[4*10000] __attribute__((address_space(1)));
; char X[4*10000]; ; char X[4*10000];
; int main() { ; int main() {
; for (int i = 0; i < 4*10000; ++i) ; for (int i = 0; i < 4*10000; ++i)
; X[i] = Y[i] + 1; ; X[i] = Y[i] + 1;
; return 0; ; return 0;
Show All 34 Lines

test/Transforms/LoopVectorize/multiple-strides-vectorization.ll

; RUN: opt -loop-vectorize -force-vector-width=4 -S < %s | FileCheck %s ; RUN: opt -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-width=4 -S < %s | FileCheck %s
; This is the test case from PR26314. ; This is the test case from PR26314.
; When we were retrying dependence checking with memchecks only, ; When we were retrying dependence checking with memchecks only,
; the loop-invariant access in the inner loop was incorrectly determined to be wrapping ; the loop-invariant access in the inner loop was incorrectly determined to be wrapping
; because it was not strided in the inner loop. ; because it was not strided in the inner loop.
; Improved wrapping detection allows vectorization in the following case. ; Improved wrapping detection allows vectorization in the following case.
; #define Z 32 ; #define Z 32
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/no_array_bounds.ll

; RUN: opt < %s -loop-vectorize -S 2>&1 | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -S 2>&1 | FileCheck %s
; Verify warning is generated when vectorization/ interleaving is explicitly specified and fails to occur. ; Verify warning is generated when vectorization/ interleaving is explicitly specified and fails to occur.
; CHECK: warning: no_array_bounds.cpp:5:5: loop not vectorized: failed explicitly specified loop vectorization ; CHECK: warning: no_array_bounds.cpp:5:5: loop not vectorized: failed explicitly specified loop vectorization
; CHECK: warning: no_array_bounds.cpp:10:5: loop not interleaved: failed explicitly specified loop interleaving ; CHECK: warning: no_array_bounds.cpp:10:5: loop not interleaved: failed explicitly specified loop interleaving
; #pragma clang loop vectorize(enable) ; #pragma clang loop vectorize(enable)
; for (int i = 0; i < number; i++) { ; for (int i = 0; i < number; i++) {
; A[B[i]]++; ; A[B[i]]++;
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/no_idiv_reduction.ll

; RUN: opt -loop-vectorize -force-vector-width=2 -force-vector-interleave=1 -S < %s | FileCheck %s ; RUN: opt -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-width=2 -force-vector-interleave=1 -S < %s | FileCheck %s
@a = common global [128 x i32] zeroinitializer, align 16 @a = common global [128 x i32] zeroinitializer, align 16
;; Must not vectorize division reduction. Division is lossy. ;; Must not vectorize division reduction. Division is lossy.
define i32 @g() { define i32 @g() {
entry: entry:
br label %for.body br label %for.body
for.body: for.body:
Show All 15 Lines

test/Transforms/LoopVectorize/no_int_induction.ll

; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s
; int __attribute__((noinline)) sum_array(int *A, int n) { ; int __attribute__((noinline)) sum_array(int *A, int n) {
; return std::accumulate(A, A + n, 0); ; return std::accumulate(A, A + n, 0);
; } ; }
target datalayout = "e-p:64:64:64-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-n8:16:32:64-S128"
;CHECK-LABEL: @sum_array( ;CHECK-LABEL: @sum_array(
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/no_outside_user.ll

; RUN: opt -S -loop-vectorize -force-vector-interleave=1 -force-vector-width=2 < %s 2>&1 | FileCheck %s ; RUN: opt -S -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=2 < %s 2>&1 | FileCheck %s
; CHECK: remark: {{.*}}: loop not vectorized: value could not be identified as an induction or reduction variable ; CHECK: remark: {{.*}}: loop not vectorized: value could not be identified as an induction or reduction variable
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32-n8:16:32-S128" target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32-n8:16:32-S128"
@f = common global i32 0, align 4 @f = common global i32 0, align 4
@.str = private unnamed_addr constant [4 x i8] c"%d\0A\00", align 1 @.str = private unnamed_addr constant [4 x i8] c"%d\0A\00", align 1
@c = common global i32 0, align 4 @c = common global i32 0, align 4
Show All 33 Lines

test/Transforms/LoopVectorize/no_switch.ll

; RUN: opt < %s -loop-vectorize -force-vector-width=4 -S 2>&1 | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-width=4 -S 2>&1 | FileCheck %s
; RUN: opt < %s -loop-vectorize -force-vector-width=1 -S 2>&1 | FileCheck %s -check-prefix=NOANALYSIS ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-width=1 -S 2>&1 | FileCheck %s -check-prefix=NOANALYSIS
; RUN: opt < %s -loop-vectorize -force-vector-width=4 -pass-remarks-missed='loop-vectorize' -S 2>&1 | FileCheck %s -check-prefix=MOREINFO ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-width=4 -pass-remarks-missed='loop-vectorize' -S 2>&1 | FileCheck %s -check-prefix=MOREINFO
; CHECK: remark: source.cpp:4:5: loop not vectorized: loop contains a switch statement ; CHECK: remark: source.cpp:4:5: loop not vectorized: loop contains a switch statement
; CHECK: warning: source.cpp:4:5: loop not vectorized: failed explicitly specified loop vectorization ; CHECK: warning: source.cpp:4:5: loop not vectorized: failed explicitly specified loop vectorization
; NOANALYSIS-NOT: remark: {{.*}} ; NOANALYSIS-NOT: remark: {{.*}}
; NOANALYSIS: warning: source.cpp:4:5: loop not interleaved: failed explicitly specified loop interleaving ; NOANALYSIS: warning: source.cpp:4:5: loop not interleaved: failed explicitly specified loop interleaving
; MOREINFO: remark: source.cpp:4:5: loop not vectorized: loop contains a switch statement ; MOREINFO: remark: source.cpp:4:5: loop not vectorized: loop contains a switch statement
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/noalias-md-licm.ll

; RUN: opt -basicaa -scoped-noalias -loop-vectorize -licm -force-vector-width=2 \ ; RUN: opt -basicaa -scoped-noalias -loop-vectorize-ignore-target-info -loop-vectorize -licm -force-vector-width=2 \
; RUN: -force-vector-interleave=1 -S < %s | FileCheck %s ; RUN: -force-vector-interleave=1 -S < %s | FileCheck %s
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
; In order to vectorize the inner loop, it needs to be versioned with ; In order to vectorize the inner loop, it needs to be versioned with
; memchecks between {A} x {B, C} first: ; memchecks between {A} x {B, C} first:
; ;
; for (i = 0; i < n; i++) ; for (i = 0; i < n; i++)
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/noalias-md.ll

; RUN: opt -basicaa -loop-vectorize -force-vector-width=2 \ ; RUN: opt -basicaa -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-width=2 \
; RUN: -force-vector-interleave=1 -S < %s \ ; RUN: -force-vector-interleave=1 -S < %s \
; RUN: | FileCheck %s -check-prefix=BOTH -check-prefix=LV ; RUN: | FileCheck %s -check-prefix=BOTH -check-prefix=LV
; RUN: opt -basicaa -scoped-noalias -loop-vectorize -dse -force-vector-width=2 \ ; RUN: opt -basicaa -scoped-noalias -loop-vectorize-ignore-target-info -loop-vectorize -dse -force-vector-width=2 \
; RUN: -force-vector-interleave=1 -S < %s \ ; RUN: -force-vector-interleave=1 -S < %s \
; RUN: | FileCheck %s -check-prefix=BOTH -check-prefix=DSE ; RUN: | FileCheck %s -check-prefix=BOTH -check-prefix=DSE
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
; This loop needs to be versioned with memchecks between {A, B} x {C} before ; This loop needs to be versioned with memchecks between {A, B} x {C} before
; it can be vectorized. ; it can be vectorized.
; ;
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/nofloat.ll

; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s
; Make sure that we don't vectorize functions with 'noimplicitfloat' attributes. ; Make sure that we don't vectorize functions with 'noimplicitfloat' attributes.
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
@a = common global [2048 x i32] zeroinitializer, align 16 @a = common global [2048 x i32] zeroinitializer, align 16
;CHECK-LABEL: @example12( ;CHECK-LABEL: @example12(
Show All 19 Lines

test/Transforms/LoopVectorize/non-const-n.ll

; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
@b = common global [2048 x i32] zeroinitializer, align 16 @b = common global [2048 x i32] zeroinitializer, align 16
@c = common global [2048 x i32] zeroinitializer, align 16 @c = common global [2048 x i32] zeroinitializer, align 16
@a = common global [2048 x i32] zeroinitializer, align 16 @a = common global [2048 x i32] zeroinitializer, align 16
;CHECK-LABEL: @example1( ;CHECK-LABEL: @example1(
Show All 28 Lines

test/Transforms/LoopVectorize/nontemporal.ll

; RUN: opt < %s -loop-vectorize -force-vector-width=4 -force-vector-interleave=1 -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-width=4 -force-vector-interleave=1 -instcombine -S | FileCheck %s
target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128" target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
; CHECK-LABEL: @foo( ; CHECK-LABEL: @foo(
define void @foo(float* noalias %a, float* noalias %b, float* noalias %c, i32 %N) { define void @foo(float* noalias %a, float* noalias %b, float* noalias %c, i32 %N) {
entry: entry:
%cmp.4 = icmp sgt i32 %N, 0 %cmp.4 = icmp sgt i32 %N, 0
br i1 %cmp.4, label %for.body.preheader, label %for.end br i1 %cmp.4, label %for.body.preheader, label %for.end
Show All 37 Lines

test/Transforms/LoopVectorize/nsw-crash.ll

; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=4
target datalayout = target datalayout =
"e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
define void @test() { define void @test() {
entry: entry:
br i1 undef, label %while.end, label %while.body.lr.ph br i1 undef, label %while.end, label %while.body.lr.ph
Show All 15 Lines

test/Transforms/LoopVectorize/optsize.ll

; This test verifies that the loop vectorizer will NOT produce a tail ; This test verifies that the loop vectorizer will NOT produce a tail
; loop with the optimize for size or the minimize size attributes. ; loop with the optimize for size or the minimize size attributes.
; REQUIRES: asserts ; REQUIRES: asserts
; RUN: opt < %s -loop-vectorize -S | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -S | FileCheck %s
target datalayout = "E-m:e-p:32:32-i64:32-f64:32:64-a:0:32-n32-S128" target datalayout = "E-m:e-p:32:32-i64:32-f64:32:64-a:0:32-n32-S128"
@tab = common global [32 x i8] zeroinitializer, align 1 @tab = common global [32 x i8] zeroinitializer, align 1
define i32 @foo_optsize() #0 { define i32 @foo_optsize() #0 {
; CHECK-LABEL: @foo_optsize( ; CHECK-LABEL: @foo_optsize(
; CHECK-NOT: <2 x i8> ; CHECK-NOT: <2 x i8>
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/phi-hang.ll

; RUN: opt -S -loop-vectorize < %s ; RUN: opt -S -loop-vectorize-ignore-target-info -loop-vectorize < %s
; PR15384 ; PR15384
define void @test1(i32 %arg) { define void @test1(i32 %arg) {
bb: bb:
br label %bb1 br label %bb1
bb1: ; preds = %bb5, %bb bb1: ; preds = %bb5, %bb
%tmp = phi i32 [ 1, %bb ], [ %tmp7, %bb5 ] %tmp = phi i32 [ 1, %bb ], [ %tmp7, %bb5 ]
Show All 38 Lines

test/Transforms/LoopVectorize/pr25281.ll

; RUN: opt < %s -scev-aa -loop-vectorize -print-alias-sets -S -o - 2>&1 | FileCheck %s ; RUN: opt < %s -scev-aa -loop-vectorize-ignore-target-info -loop-vectorize -print-alias-sets -S -o - 2>&1 | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
; PR25281 ; PR25281
; Just check that we don't crash on this test. ; Just check that we don't crash on this test.
; CHECK-LABEL: @foo ; CHECK-LABEL: @foo
define void @foo(float** noalias nocapture readonly %in, i32* noalias nocapture readonly %isCompressed, float* noalias nocapture readonly %out) { define void @foo(float** noalias nocapture readonly %in, i32* noalias nocapture readonly %isCompressed, float* noalias nocapture readonly %out) {
entry_block: entry_block:
%tmp = getelementptr float*, float** %in, i32 0 %tmp = getelementptr float*, float** %in, i32 0
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/pr28541.ll

; RUN: opt -loop-vectorize -pass-remarks=loop-vectorize -S < %s 2>&1 | FileCheck %s ; RUN: opt -loop-vectorize-ignore-target-info -loop-vectorize -pass-remarks=loop-vectorize -S < %s 2>&1 | FileCheck %s
; FIXME: Check for -pass-remarks-missed and -pass-remarks-analysis output when ; FIXME: Check for -pass-remarks-missed and -pass-remarks-analysis output when
; addAcyclicInnerLoop emits analysis. ; addAcyclicInnerLoop emits analysis.
; Check that opt does not crash on such input: ; Check that opt does not crash on such input:
; ;
; a, b, c; ; a, b, c;
; fn1() { ; fn1() {
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/ptr-induction.ll

; RUN: opt < %s -loop-vectorize -force-vector-width=4 -S | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-width=4 -S | FileCheck %s
target datalayout = "e-m:e-i64:64-i128:128-n32:64-S128" target datalayout = "e-m:e-i64:64-i128:128-n32:64-S128"
; This testcase causes SCEV to return a pointer-typed exit value. ; This testcase causes SCEV to return a pointer-typed exit value.
; CHECK: @f ; CHECK: @f
; Expect that the pointer indvar has been converted into an integer indvar. ; Expect that the pointer indvar has been converted into an integer indvar.
; CHECK: %index.next = add i64 %index, 4 ; CHECK: %index.next = add i64 %index, 4
Show All 25 Lines

test/Transforms/LoopVectorize/ptr_loops.ll

; RUN: opt < %s -basicaa -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S -enable-if-conversion | FileCheck %s ; RUN: opt < %s -basicaa -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S -enable-if-conversion | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
@A = global [36 x i32] [i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 16, i32 17, i32 18, i32 19, i32 20, i32 21, i32 22, i32 23, i32 24, i32 25, i32 26, i32 27, i32 28, i32 29, i32 30, i32 31, i32 32, i32 33, i32 34, i32 35], align 16 @A = global [36 x i32] [i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 16, i32 17, i32 18, i32 19, i32 20, i32 21, i32 22, i32 23, i32 24, i32 25, i32 26, i32 27, i32 28, i32 29, i32 30, i32 31, i32 32, i32 33, i32 34, i32 35], align 16
@B = global [36 x i32] [i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 16, i32 17, i32 18, i32 19, i32 20, i32 21, i32 22, i32 23, i32 24, i32 25, i32 26, i32 27, i32 28, i32 29, i32 30, i32 31, i32 32, i32 33, i32 34, i32 35], align 16 @B = global [36 x i32] [i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 16, i32 17, i32 18, i32 19, i32 20, i32 21, i32 22, i32 23, i32 24, i32 25, i32 26, i32 27, i32 28, i32 29, i32 30, i32 31, i32 32, i32 33, i32 34, i32 35], align 16
;CHECK-LABEL:@_Z5test1v( ;CHECK-LABEL:@_Z5test1v(
;CHECK: load <4 x i32> ;CHECK: load <4 x i32>
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/read-only.ll

; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
;CHECK-LABEL: @read_only_func( ;CHECK-LABEL: @read_only_func(
;CHECK: load <4 x i32> ;CHECK: load <4 x i32>
;CHECK: ret i32 ;CHECK: ret i32
define i32 @read_only_func(i32* nocapture %A, i32* nocapture %B, i32 %n) nounwind uwtable readonly ssp { define i32 @read_only_func(i32* nocapture %A, i32* nocapture %B, i32 %n) nounwind uwtable readonly ssp {
%1 = icmp sgt i32 %n, 0 %1 = icmp sgt i32 %n, 0
Show All 22 Lines

test/Transforms/LoopVectorize/reduction.ll

; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
;CHECK-LABEL: @reduction_sum( ;CHECK-LABEL: @reduction_sum(
;CHECK: phi <4 x i32> ;CHECK: phi <4 x i32>
;CHECK: load <4 x i32> ;CHECK: load <4 x i32>
;CHECK: add <4 x i32> ;CHECK: add <4 x i32>
;CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> undef, <4 x i32> <i32 2, i32 3, i32 undef, i32 undef> ;CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> undef, <4 x i32> <i32 2, i32 3, i32 undef, i32 undef>
▲ Show 20 Lines • Show All 486 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/reverse_induction.ll

; RUN: opt < %s -loop-vectorize -force-vector-interleave=2 -force-vector-width=4 -S | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=2 -force-vector-width=4 -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; Make sure consecutive vector generates correct negative indices. ; Make sure consecutive vector generates correct negative indices.
; PR15882 ; PR15882
; CHECK: %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ] ; CHECK: %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
; CHECK: %offset.idx = sub i64 %startval, %index ; CHECK: %offset.idx = sub i64 %startval, %index
▲ Show 20 Lines • Show All 143 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/reverse_iter.ll

; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; Make sure that the reverse iterators are calculated using 64bit arithmetic, not 32. ; Make sure that the reverse iterators are calculated using 64bit arithmetic, not 32.
; ;
; int foo(int n, int *A) { ; int foo(int n, int *A) {
; int sum; ; int sum;
; for (int i=n; i > 0; i--) ; for (int i=n; i > 0; i--)
Show All 35 Lines

test/Transforms/LoopVectorize/runtime-check-address-space.ll

; RUN: opt -S -march=r600 -mcpu=cayman -basicaa -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine < %s | FileCheck %s ; RUN: opt -S -march=r600 -mcpu=cayman -basicaa -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine < %s | FileCheck %s
; Check vectorization that would ordinarily require a runtime bounds ; Check vectorization that would ordinarily require a runtime bounds
; check on the pointers when mixing address spaces. For now we cannot ; check on the pointers when mixing address spaces. For now we cannot
; assume address spaces do not alias, and we can't assume that ; assume address spaces do not alias, and we can't assume that
; different pointers are directly comparable. ; different pointers are directly comparable.
; ;
; These all test this basic loop for different combinations of address ; These all test this basic loop for different combinations of address
; spaces, and swapping in globals or adding noalias. ; spaces, and swapping in globals or adding noalias.
▲ Show 20 Lines • Show All 212 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/runtime-check-readonly-address-space.ll

; RUN: opt -S -march=r600 -mcpu=cayman -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine < %s | FileCheck %s ; RUN: opt -S -march=r600 -mcpu=cayman -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine < %s | FileCheck %s
; Artificial datalayout ; Artificial datalayout
target datalayout = "e-p:32:32:32-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64-v96:128:128-v128:128:128-v192:256:256-v256:256:256-v512:512:512-v1024:1024:1024-v2048:2048:2048-n32:64" target datalayout = "e-p:32:32:32-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64-v96:128:128-v128:128:128-v192:256:256-v256:256:256-v512:512:512-v1024:1024:1024-v2048:2048:2048-n32:64"
define void @add_ints_1_1_1(i32 addrspace(1)* %a, i32 addrspace(1)* %b, i32 addrspace(1)* %c) #0 { define void @add_ints_1_1_1(i32 addrspace(1)* %a, i32 addrspace(1)* %b, i32 addrspace(1)* %c) #0 {
; CHECK-LABEL: @add_ints_1_1_1( ; CHECK-LABEL: @add_ints_1_1_1(
; CHECK: <4 x i32> ; CHECK: <4 x i32>
▲ Show 20 Lines • Show All 123 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/runtime-check-readonly.ll

; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
;CHECK-LABEL: @add_ints( ;CHECK-LABEL: @add_ints(
;CHECK: br ;CHECK: br
;CHECK: br ;CHECK: br
;CHECK: getelementptr ;CHECK: getelementptr
;CHECK-DAG: getelementptr ;CHECK-DAG: getelementptr
Show All 29 Lines

test/Transforms/LoopVectorize/runtime-check.ll

; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; Make sure we vectorize this loop: ; Make sure we vectorize this loop:
; int foo(float *a, float *b, int n) { ; int foo(float *a, float *b, int n) {
; for (int i=0; i<n; ++i) ; for (int i=0; i<n; ++i)
; a[i] = b[i] * 3; ; a[i] = b[i] * 3;
; } ; }
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/runtime-limit.ll

; RUN: opt < %s -loop-vectorize -force-vector-width=4 -force-vector-interleave=1 -dce -instcombine -pass-remarks=loop-vectorize -pass-remarks-missed=loop-vectorize -S 2>&1 | FileCheck %s -check-prefix=OVERRIDE ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-width=4 -force-vector-interleave=1 -dce -instcombine -pass-remarks=loop-vectorize -pass-remarks-missed=loop-vectorize -S 2>&1 | FileCheck %s -check-prefix=OVERRIDE
; RUN: opt < %s -loop-vectorize -force-vector-width=4 -force-vector-interleave=1 -pragma-vectorize-memory-check-threshold=6 -dce -instcombine -pass-remarks=loop-vectorize -pass-remarks-missed=loop-vectorize -S 2>&1 | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-width=4 -force-vector-interleave=1 -pragma-vectorize-memory-check-threshold=6 -dce -instcombine -pass-remarks=loop-vectorize -pass-remarks-missed=loop-vectorize -S 2>&1 | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; First loop produced diagnostic pass remark. ; First loop produced diagnostic pass remark.
;CHECK: remark: {{.*}}:0:0: vectorized loop (vectorization width: 4, interleaved count: 1) ;CHECK: remark: {{.*}}:0:0: vectorized loop (vectorization width: 4, interleaved count: 1)
; Second loop produces diagnostic analysis remark. ; Second loop produces diagnostic analysis remark.
;CHECK: remark: {{.*}}:0:0: loop not vectorized: cannot prove it is safe to reorder memory operations ;CHECK: remark: {{.*}}:0:0: loop not vectorized: cannot prove it is safe to reorder memory operations
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/safegep.ll

; RUN: opt -S -loop-vectorize -force-vector-width=4 -force-vector-interleave=1 < %s | FileCheck %s ; RUN: opt -S -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-width=4 -force-vector-interleave=1 < %s | FileCheck %s
target datalayout = "e-p:32:32:32-S128-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f16:16:16-f32:32:32-f64:32:64-f128:128:128-v64:64:64-v128:128:128-a0:0:64-f80:32:32-n8:16:32" target datalayout = "e-p:32:32:32-S128-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f16:16:16-f32:32:32-f64:32:64-f128:128:128-v64:64:64-v128:128:128-a0:0:64-f80:32:32-n8:16:32"
; We can vectorize this code because if the address computation would wrap then ; We can vectorize this code because if the address computation would wrap then
; a load from 0 would take place which is undefined behaviour in address space 0 ; a load from 0 would take place which is undefined behaviour in address space 0
; according to LLVM IR semantics. ; according to LLVM IR semantics.
; PR16592 ; PR16592
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/same-base-access.ll

; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S -enable-if-conversion | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S -enable-if-conversion | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; This is kernel11 from "LivermoreLoops". We can't vectorize it because we ; This is kernel11 from "LivermoreLoops". We can't vectorize it because we
; access both x[k] and x[k-1]. ; access both x[k] and x[k-1].
; ;
; void kernel11(double *x, double *y, int n) { ; void kernel11(double *x, double *y, int n) {
; for ( int k=1 ; k<n ; k++ ) ; for ( int k=1 ; k<n ; k++ )
▲ Show 20 Lines • Show All 98 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/scalar-select.ll

; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
@a = common global [2048 x i32] zeroinitializer, align 16 @a = common global [2048 x i32] zeroinitializer, align 16
@b = common global [2048 x i32] zeroinitializer, align 16 @b = common global [2048 x i32] zeroinitializer, align 16
@c = common global [2048 x i32] zeroinitializer, align 16 @c = common global [2048 x i32] zeroinitializer, align 16
;CHECK-LABEL: @example1( ;CHECK-LABEL: @example1(
Show All 27 Lines

test/Transforms/LoopVectorize/scalar_after_vectorization.ll

; RUN: opt < %s -force-vector-width=4 -force-vector-interleave=2 -loop-vectorize -instcombine -S | FileCheck %s ; RUN: opt < %s -force-vector-width=4 -force-vector-interleave=2 -loop-vectorize-ignore-target-info -loop-vectorize -instcombine -S | FileCheck %s
; RUN: opt < %s -force-vector-width=4 -force-vector-interleave=2 -loop-vectorize -S | FileCheck %s --check-prefix=NO-IC ; RUN: opt < %s -force-vector-width=4 -force-vector-interleave=2 -loop-vectorize-ignore-target-info -loop-vectorize -S | FileCheck %s --check-prefix=NO-IC
target datalayout = "e-m:e-i64:64-i128:128-n32:64-S128" target datalayout = "e-m:e-i64:64-i128:128-n32:64-S128"
; CHECK-LABEL: @scalar_after_vectorization_0 ; CHECK-LABEL: @scalar_after_vectorization_0
; ;
; CHECK: vector.body: ; CHECK: vector.body:
; CHECK: %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ] ; CHECK: %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
; CHECK: %offset.idx = or i64 %index, 1 ; CHECK: %offset.idx = or i64 %index, 1
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/scev-exitlim-crash.ll

; RUN: opt < %s -loop-vectorize -force-vector-interleave=2 -force-vector-width=8 -S | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=2 -force-vector-width=8 -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
@b = common global i32 0, align 4 @b = common global i32 0, align 4
@f = common global i32 0, align 4 @f = common global i32 0, align 4
@a = common global i32 0, align 4 @a = common global i32 0, align 4
@d = common global i32* null, align 8 @d = common global i32* null, align 8
@e = common global i32* null, align 8 @e = common global i32* null, align 8
▲ Show 20 Lines • Show All 104 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/simple-unroll.ll

; RUN: opt < %s -loop-vectorize -force-vector-width=4 -force-vector-interleave=2 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-width=4 -force-vector-interleave=2 -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
@a = common global [2048 x i32] zeroinitializer, align 16 @a = common global [2048 x i32] zeroinitializer, align 16
; This is the loop. ; This is the loop.
; for (i=0; i<n; i++){ ; for (i=0; i<n; i++){
; a[i] += i; ; a[i] += i;
Show All 29 Lines

test/Transforms/LoopVectorize/small-loop.ll

; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
@a = common global [2048 x i32] zeroinitializer, align 16 @a = common global [2048 x i32] zeroinitializer, align 16
@b = common global [2048 x i32] zeroinitializer, align 16 @b = common global [2048 x i32] zeroinitializer, align 16
@c = common global [2048 x i32] zeroinitializer, align 16 @c = common global [2048 x i32] zeroinitializer, align 16
;CHECK-LABEL: @example1( ;CHECK-LABEL: @example1(
Show All 23 Lines

test/Transforms/LoopVectorize/start-non-zero.ll

; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
;CHECK-LABEL: @start_at_nonzero( ;CHECK-LABEL: @start_at_nonzero(
;CHECK: mul nuw <4 x i32> ;CHECK: mul nuw <4 x i32>
;CHECK: ret i32 ;CHECK: ret i32
define i32 @start_at_nonzero(i32* nocapture %a, i32 %start, i32 %end) nounwind uwtable ssp { define i32 @start_at_nonzero(i32* nocapture %a, i32 %start, i32 %end) nounwind uwtable ssp {
entry: entry:
Show All 21 Lines

test/Transforms/LoopVectorize/store-shuffle-bug.ll

; RUN: opt -S -basicaa -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine < %s | FileCheck %s ; RUN: opt -S -basicaa -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
@uf = common global [100 x i32] zeroinitializer, align 16 @uf = common global [100 x i32] zeroinitializer, align 16
@xi = common global [100 x i32] zeroinitializer, align 16 @xi = common global [100 x i32] zeroinitializer, align 16
@q = common global [100 x i32] zeroinitializer, align 16 @q = common global [100 x i32] zeroinitializer, align 16
; PR16455 ; PR16455
Show All 40 Lines

test/Transforms/LoopVectorize/struct_access.ll

; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
%struct.coordinate = type { i32, i32 } %struct.coordinate = type { i32, i32 }
; Make sure that we don't generate a wide load when accessing the struct. ; Make sure that we don't generate a wide load when accessing the struct.
; struct coordinate { ; struct coordinate {
; int x; ; int x;
▲ Show 20 Lines • Show All 78 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/tbaa-nodep.ll

; RUN: opt < %s -tbaa -basicaa -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -simplifycfg -S | FileCheck %s ; RUN: opt < %s -tbaa -basicaa -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -simplifycfg -S | FileCheck %s
; RUN: opt < %s -basicaa -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -simplifycfg -S | FileCheck %s --check-prefix=CHECK-NOTBAA ; RUN: opt < %s -basicaa -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -simplifycfg -S | FileCheck %s --check-prefix=CHECK-NOTBAA
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
define i32 @test1(i32* nocapture %a, float* nocapture readonly %b) #0 { define i32 @test1(i32* nocapture %a, float* nocapture readonly %b) #0 {
entry: entry:
br label %for.body br label %for.body
for.body: ; preds = %for.body, %entry for.body: ; preds = %for.body, %entry
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/undef-inst-bug.ll

; RUN: opt -S -loop-vectorize -force-vector-width=4 -force-vector-interleave=1 < %s | FileCheck %s ; RUN: opt -S -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-width=4 -force-vector-interleave=1 < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; We use to fail on this loop because we did not properly handle the loop ; We use to fail on this loop because we did not properly handle the loop
; invariant instruction anchored in the loop when used as a getelementptr index. ; invariant instruction anchored in the loop when used as a getelementptr index.
; We would use the index from the original loop resulting in a use not dominated ; We would use the index from the original loop resulting in a use not dominated
; by the definition. ; by the definition.
Show All 27 Lines

test/Transforms/LoopVectorize/unroll.ll

; This test makes sure that loop will not be unrolled in vectorization if VF computed ; This test makes sure that loop will not be unrolled in vectorization if VF computed
; equals to 1. ; equals to 1.
; RUN: opt < %s -loop-vectorize -S | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -S | FileCheck %s
; Make sure there are no geps being merged. ; Make sure there are no geps being merged.
; CHECK-LABEL: @foo( ; CHECK-LABEL: @foo(
; CHECK: getelementptr ; CHECK: getelementptr
; CHECK-NOT: getelementptr ; CHECK-NOT: getelementptr
@N = common global i32 0, align 4 @N = common global i32 0, align 4
@a = common global [1000 x i32] zeroinitializer, align 16 @a = common global [1000 x i32] zeroinitializer, align 16
Show All 26 Lines

test/Transforms/LoopVectorize/unroll_novec.ll

; RUN: opt < %s -loop-vectorize -force-vector-width=1 -force-target-num-scalar-regs=16 -force-target-max-scalar-interleave=8 -force-target-instruction-cost=1 -small-loop-cost=40 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-width=1 -force-target-num-scalar-regs=16 -force-target-max-scalar-interleave=8 -force-target-instruction-cost=1 -small-loop-cost=40 -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
@a = common global [2048 x i32] zeroinitializer, align 16 @a = common global [2048 x i32] zeroinitializer, align 16
; This is the loop. ; This is the loop.
; for (i=0; i<n; i++){ ; for (i=0; i<n; i++){
; a[i] += i; ; a[i] += i;
Show All 39 Lines

test/Transforms/LoopVectorize/unsafe-dep-remark.ll

; RUN: opt -loop-vectorize -force-vector-width=2 -pass-remarks-analysis=loop-vectorize < %s 2>&1 | FileCheck %s ; RUN: opt -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-width=2 -pass-remarks-analysis=loop-vectorize < %s 2>&1 | FileCheck %s
; ModuleID = '/tmp/kk.c' ; ModuleID = '/tmp/kk.c'
source_filename = "/tmp/kk.c" source_filename = "/tmp/kk.c"
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
; 1 void success (char *A, char *B, char *C, char *D, char *E, int N) { ; 1 void success (char *A, char *B, char *C, char *D, char *E, int N) {
; 2 for(int i = 0; i < N; i++) { ; 2 for(int i = 0; i < N; i++) {
; 3 A[i + 1] = A[i] + B[i]; ; 3 A[i + 1] = A[i] + B[i];
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/unsized-pointee-crash.ll

; RUN: opt -S -loop-vectorize < %s | FileCheck %s ; RUN: opt -S -loop-vectorize-ignore-target-info -loop-vectorize < %s | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
; CHECK-LABEL: @fn1 ; CHECK-LABEL: @fn1
define void @fn1() { define void @fn1() {
entry: entry:
br label %for.body br label %for.body
for.body: for.body:
Show All 14 Lines

test/Transforms/LoopVectorize/value-ptr-bug.ll

; RUN: opt -S -loop-vectorize -force-vector-width=4 -force-vector-interleave=1 -dce -instcombine < %s | FileCheck %s ; RUN: opt -S -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-width=4 -force-vector-interleave=1 -dce -instcombine < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; PR16073 ; PR16073
; Because we were caching value pointers across a function call that could RAUW ; Because we were caching value pointers across a function call that could RAUW
; we would generate an undefined value store below: ; we would generate an undefined value store below:
; SCEVExpander::expandCodeFor would change a value (the start value of an ; SCEVExpander::expandCodeFor would change a value (the start value of an
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/vect.stats.ll

; RUN: opt < %s -loop-vectorize -force-vector-interleave=4 -force-vector-width=4 -debug-only=loop-vectorize -stats -S 2>&1 | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=4 -force-vector-width=4 -debug-only=loop-vectorize -stats -S 2>&1 | FileCheck %s
; REQUIRES: asserts ; REQUIRES: asserts
; ;
; We have 2 loops, one of them is vectorizable and the second one is not. ; We have 2 loops, one of them is vectorizable and the second one is not.
; ;
; CHECK: 2 loop-vectorize - Number of loops analyzed for vectorization ; CHECK: 2 loop-vectorize - Number of loops analyzed for vectorization
; CHECK: 1 loop-vectorize - Number of loops vectorized ; CHECK: 1 loop-vectorize - Number of loops vectorized
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/vectorize-once.ll

; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S -simplifycfg | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S -simplifycfg | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; ;
; We want to make sure that we are vectorizeing the scalar loop only once ; We want to make sure that we are vectorizeing the scalar loop only once
; even if the pass manager runs the vectorizer multiple times due to inlining. ; even if the pass manager runs the vectorizer multiple times due to inlining.
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/version-mem-access.ll

; RUN: opt -basicaa -loop-vectorize -enable-mem-access-versioning -force-vector-width=2 -force-vector-interleave=1 < %s -S | FileCheck %s ; RUN: opt -basicaa -loop-vectorize-ignore-target-info -loop-vectorize -enable-mem-access-versioning -force-vector-width=2 -force-vector-interleave=1 < %s -S | FileCheck %s
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
; Check that we version this loop with speculating the value 1 for symbolic ; Check that we version this loop with speculating the value 1 for symbolic
; strides. This also checks that the symbolic stride information is correctly ; strides. This also checks that the symbolic stride information is correctly
; propagated to the memcheck generation. Without this the loop wouldn't ; propagated to the memcheck generation. Without this the loop wouldn't
; vectorize because we couldn't determine the array bounds for the required ; vectorize because we couldn't determine the array bounds for the required
; memchecks. ; memchecks.
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

test/Transforms/LoopVectorize/write-only.ll

; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize-ignore-target-info -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
;CHECK-LABEL: @read_mod_write_single_ptr( ;CHECK-LABEL: @read_mod_write_single_ptr(
;CHECK: load <4 x float> ;CHECK: load <4 x float>
;CHECK: ret i32 ;CHECK: ret i32
define i32 @read_mod_write_single_ptr(float* nocapture %a, i32 %n) nounwind uwtable ssp { define i32 @read_mod_write_single_ptr(float* nocapture %a, i32 %n) nounwind uwtable ssp {
%1 = icmp sgt i32 %n, 0 %1 = icmp sgt i32 %n, 0
Show All 16 Lines

test/Transforms/LoopVectorize/zero-sized-pointee-crash.ll

; RUN: opt -S -loop-vectorize < %s | FileCheck %s ; RUN: opt -S -loop-vectorize-ignore-target-info -loop-vectorize < %s | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
; CHECK-LABEL: @fn1 ; CHECK-LABEL: @fn1
define void @fn1() { define void @fn1() {
entry-block: entry-block:
br label %middle br label %middle
middle: middle:
Show All 17 Lines