This is an archive of the discontinued LLVM Phabricator instance.

Differential D135484

[opt] Don't translate legacy -analysis flag to require<analysis>
AbandonedPublicDraft

Authored by aeubanks on Oct 7 2022, 1:19 PM.

Details

Reviewers
ctetreau
Summary

Tests relying on this should explicitly use -passes='require<analysis>,foo'.

Diff Detail

Event Timeline

aeubanks created this revision.Oct 7 2022, 1:19 PM
Herald added a reviewer: ctetreau. · View Herald TranscriptOct 7 2022, 1:19 PM
Herald added a project: Restricted Project. · View Herald Transcript
Herald added subscribers: kosarev, mattd, gchakrabarti and 12 others. · View Herald Transcript
Harbormaster completed remote builds in B191005: Diff 466163.Oct 7 2022, 2:08 PM
aeubanks abandoned this revision.Oct 10 2022, 5:40 PM
Herald added a project: Restricted Project. · View Herald TranscriptOct 10 2022, 5:40 PM
Herald added a subscriber: llvm-commits. · View Herald Transcript

Revision Contents

PathSize
llvm/
include/
llvm/
Passes/
6 lines
lib/
Passes/
34 lines
test/
Analysis/
AliasSet/
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
Dominators/
1 line
IVUsers/
2 lines
MemoryDependenceAnalysis/
4 lines
2 lines
2 lines
2 lines
MemorySSA/
2 lines
2 lines
ScalarEvolution/
1 line
2 lines
1 line
1 line
2 lines
2 lines
CodeGen/
AMDGPU/
2 lines
6 lines
Hexagon/
loop-idiom/
2 lines
2 lines
2 lines
DebugInfo/
Generic/
2 lines
4 lines
Feature/
OperandBundles/
2 lines
Other/
2 lines
Transforms/
DeadStoreElimination/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
8 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
8 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
2 lines
2 lines
6 lines
FunctionAttrs/
2 lines
2 lines
2 lines
GVN/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
PRE/
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
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
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
2 lines
2 lines
2 lines
2 lines
IndVarSimplify/
2 lines
Inline/
2 lines
2 lines
2 lines
InstCombine/
2 lines
2 lines
2 lines
2 lines
2 lines
InstMerge/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
LICM/
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
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
1 line
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
LoadStoreVectorizer/
AMDGPU/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
LoopDistribute/
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
LoopIdiom/
X86/
2 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
2 lines
2 lines
LoopInterchange/
2 lines
4 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
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
LoopLoadElim/
2 lines
4 lines
2 lines
2 lines
LoopPredication/
2 lines
LoopSimplify/
2 lines
2 lines
LoopStrengthReduce/
2 lines
LoopUnroll/
1 line
LoopUnrollAndJam/
2 lines
2 lines
2 lines
2 lines
2 lines
LoopVectorize/
AArch64/
2 lines
ARM/
2 lines
PowerPC/
2 lines
2 lines
X86/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
LoopVersioning/
2 lines
2 lines
2 lines
2 lines
2 lines
MemCpyOpt/
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
2 lines
2 lines
NewGVN/
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
ObjCARC/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
Reassociate/
2 lines
SLPVectorizer/
AArch64/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
ARM/
2 lines
2 lines
NVPTX/
4 lines
VE/
4 lines
X86/
2 lines
2 lines
12 lines
12 lines
12 lines
12 lines
12 lines
12 lines
12 lines
12 lines
14 lines
8 lines
14 lines
14 lines
14 lines
14 lines
18 lines
8 lines
18 lines
14 lines
14 lines
14 lines
8 lines
14 lines
14 lines
18 lines
14 lines
14 lines
14 lines
14 lines
14 lines
14 lines
18 lines
14 lines
14 lines
2 lines
2 lines
2 lines
10 lines
8 lines
6 lines
2 lines
4 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
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
10 lines
8 lines
10 lines
2 lines
2 lines
2 lines
8 lines
2 lines
2 lines
2 lines
2 lines
12 lines
12 lines
2 lines
12 lines
12 lines
12 lines
12 lines
12 lines
12 lines
12 lines
12 lines
2 lines
12 lines
12 lines
2 lines
12 lines
12 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
8 lines
6 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
12 lines
12 lines
14 lines
14 lines
14 lines
2 lines
2 lines
12 lines
12 lines
8 lines
2 lines
12 lines
2 lines
12 lines
12 lines
XCore/
2 lines
SimpleLoopUnswitch/
2 lines
Sink/
2 lines
2 lines
2 lines
Util/
2 lines
tools/
opt/
5 lines

Diff 466163

llvm/include/llvm/Passes/PassBuilder.h

Show First 20 Lines • Show All 368 Lines • ▼ Show 20 Linespublic:
/// about the logic used. This routine just provides the textual mapping /// about the logic used. This routine just provides the textual mapping
/// between AA names and the analyses to register with the manager. /// between AA names and the analyses to register with the manager.
/// ///
/// Returns false if the text cannot be parsed cleanly. The specific state of /// Returns false if the text cannot be parsed cleanly. The specific state of
/// the \p AA manager is unspecified if such an error is encountered and this /// the \p AA manager is unspecified if such an error is encountered and this
/// returns false. /// returns false.
Error parseAAPipeline(AAManager &AA, StringRef PipelineText); Error parseAAPipeline(AAManager &AA, StringRef PipelineText);
/// Returns true if the pass name is the name of an alias analysis pass.
bool isAAPassName(StringRef PassName);
/// Returns true if the pass name is the name of a (non-alias) analysis pass.
bool isAnalysisPassName(StringRef PassName);
/// Print pass names. /// Print pass names.
void printPassNames(raw_ostream &OS); void printPassNames(raw_ostream &OS);
/// Register a callback for a default optimizer pipeline extension /// Register a callback for a default optimizer pipeline extension
/// point /// point
/// ///
/// This extension point allows adding passes that perform peephole /// This extension point allows adding passes that perform peephole
/// optimizations similar to the instruction combiner. These passes will be /// optimizations similar to the instruction combiner. These passes will be
▲ Show 20 Lines • Show All 333 Lines • Show Last 20 Lines

llvm/lib/Passes/PassBuilder.cpp

Show First 20 Lines • Show All 1,755 Lines • ▼ Show 20 Lines if (!parseAAPassName(AA, Name))
return make_error<StringError>( return make_error<StringError>(
formatv("unknown alias analysis name '{0}'", Name).str(), formatv("unknown alias analysis name '{0}'", Name).str(),
inconvertibleErrorCode()); inconvertibleErrorCode());
} }
return Error::success(); return Error::success();
} }
bool PassBuilder::isAAPassName(StringRef PassName) {
#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS) \
if (PassName == NAME) \
return true;
#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) \
if (PassName == NAME) \
return true;
#include "PassRegistry.def"
return false;
}
bool PassBuilder::isAnalysisPassName(StringRef PassName) {
#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
if (PassName == NAME) \
return true;
#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
if (PassName == NAME) \
return true;
#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
if (PassName == NAME) \
return true;
#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
if (PassName == NAME) \
return true;
#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS) \
if (PassName == NAME) \
return true;
#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) \
if (PassName == NAME) \
return true;
#include "PassRegistry.def"
return false;
}
static void printPassName(StringRef PassName, raw_ostream &OS) { static void printPassName(StringRef PassName, raw_ostream &OS) {
OS << " " << PassName << "\n"; OS << " " << PassName << "\n";
} }
static void printPassName(StringRef PassName, StringRef Params, static void printPassName(StringRef PassName, StringRef Params,
raw_ostream &OS) { raw_ostream &OS) {
OS << " " << PassName << "<" << Params << ">\n"; OS << " " << PassName << "<" << Params << ">\n";
} }
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

llvm/test/Analysis/AliasSet/argmemonly.ll

; RUN: opt -basic-aa -print-alias-sets -S -o - < %s 2>&1 | FileCheck %s ; RUN: opt -print-alias-sets -S -o - < %s 2>&1 | FileCheck %s
@s = global i8 1, align 1 @s = global i8 1, align 1
@d = global i8 2, align 1 @d = global i8 2, align 1
; CHECK: Alias sets for function 'test_alloca_argmemonly': ; CHECK: Alias sets for function 'test_alloca_argmemonly':
; CHECK-NEXT: Alias Set Tracker: 2 alias sets for 3 pointer values. ; CHECK-NEXT: Alias Set Tracker: 2 alias sets for 3 pointer values.
; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %a, LocationSize::precise(1)) ; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %a, LocationSize::precise(1))
; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref Pointers: (i8* %d, unknown before-or-after), (i8* %s, unknown before-or-after) ; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref Pointers: (i8* %d, unknown before-or-after), (i8* %s, unknown before-or-after)
▲ Show 20 Lines • Show All 126 Lines • Show Last 20 Lines

llvm/test/Analysis/AliasSet/guards.ll

; RUN: opt -basic-aa -print-alias-sets -S -o - < %s 2>&1 | FileCheck %s ; RUN: opt -print-alias-sets -S -o - < %s 2>&1 | FileCheck %s
; RUN: opt -aa-pipeline=basic-aa -passes=print-alias-sets -S -o - < %s 2>&1 | FileCheck %s ; RUN: opt -aa-pipeline=basic-aa -passes=print-alias-sets -S -o - < %s 2>&1 | FileCheck %s
declare void @llvm.experimental.guard(i1, ...) declare void @llvm.experimental.guard(i1, ...)
; CHECK: Alias sets for function 'test0': ; CHECK: Alias sets for function 'test0':
; CHECK: Alias Set Tracker: 3 alias sets for 2 pointer values. ; CHECK: Alias Set Tracker: 3 alias sets for 2 pointer values.
; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (i8* %a, LocationSize::precise(1)) ; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref Pointers: (i8* %a, LocationSize::precise(1))
; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] may alias, Ref ; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] may alias, Ref
; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ] ; CHECK: 1 Unknown instructions: call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
▲ Show 20 Lines • Show All 1,542 Lines • Show Last 20 Lines

llvm/test/Analysis/AliasSet/intrinsics.ll

; RUN: opt -basic-aa -print-alias-sets -S -o - < %s 2>&1 | FileCheck %s ; RUN: opt -print-alias-sets -S -o - < %s 2>&1 | FileCheck %s
; CHECK: Alias sets for function 'test1': ; CHECK: Alias sets for function 'test1':
; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values. ; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %a, LocationSize::precise(1)) ; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %a, LocationSize::precise(1))
; CHECK-NOT: 1 Unknown instruction ; CHECK-NOT: 1 Unknown instruction
; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %b, LocationSize::precise(1)) ; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %b, LocationSize::precise(1))
define void @test1(i32 %c) { define void @test1(i32 %c) {
entry: entry:
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

llvm/test/Analysis/AliasSet/memset.ll

; RUN: opt -basic-aa -print-alias-sets -S -o - < %s 2>&1 | FileCheck %s ; RUN: opt -print-alias-sets -S -o - < %s 2>&1 | FileCheck %s
@s = global i8 1, align 1 @s = global i8 1, align 1
@d = global i8 2, align 1 @d = global i8 2, align 1
; CHECK: Alias sets for function 'test_known_size': ; CHECK: Alias sets for function 'test_known_size':
; CHECK: Alias Set Tracker: 1 alias sets for 1 pointer values. ; CHECK: Alias Set Tracker: 1 alias sets for 1 pointer values.
; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %d, LocationSize::precise(1)) ; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %d, LocationSize::precise(1))
define void @test_known_size(i8* noalias %d) { define void @test_known_size(i8* noalias %d) {
Show All 39 Lines

llvm/test/Analysis/AliasSet/memtransfer.ll

; RUN: opt -basic-aa -print-alias-sets -S -o - < %s 2>&1 | FileCheck %s ; RUN: opt -print-alias-sets -S -o - < %s 2>&1 | FileCheck %s
@s = global i8 1, align 1 @s = global i8 1, align 1
@d = global i8 2, align 1 @d = global i8 2, align 1
; CHECK: Alias sets for function 'test_known_size': ; CHECK: Alias sets for function 'test_known_size':
; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values. ; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %d, LocationSize::precise(1)) ; CHECK: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod Pointers: (i8* %d, LocationSize::precise(1))
▲ Show 20 Lines • Show All 204 Lines • Show Last 20 Lines

llvm/test/Analysis/AliasSet/saturation.ll

; RUN: opt -basic-aa -print-alias-sets -alias-set-saturation-threshold=2 -S -o - < %s 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=NOSAT ; RUN: opt -print-alias-sets -alias-set-saturation-threshold=2 -S -o - < %s 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=NOSAT
; RUN: opt -basic-aa -print-alias-sets -alias-set-saturation-threshold=1 -S -o - < %s 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=SAT ; RUN: opt -print-alias-sets -alias-set-saturation-threshold=1 -S -o - < %s 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=SAT
; CHECK-LABEL: 'allmust' ; CHECK-LABEL: 'allmust'
; CHECK: AliasSet[{{.*}}, 1] must alias, Mod Pointers: (i32* %a, LocationSize::precise(4)) ; CHECK: AliasSet[{{.*}}, 1] must alias, Mod Pointers: (i32* %a, LocationSize::precise(4))
; CHECK: AliasSet[{{.*}}, 1] must alias, Mod Pointers: (i32* %b, LocationSize::precise(4)) ; CHECK: AliasSet[{{.*}}, 1] must alias, Mod Pointers: (i32* %b, LocationSize::precise(4))
; CHECK: AliasSet[{{.*}}, 1] must alias, Mod Pointers: (i32* %c, LocationSize::precise(4)) ; CHECK: AliasSet[{{.*}}, 1] must alias, Mod Pointers: (i32* %c, LocationSize::precise(4))
; CHECK: AliasSet[{{.*}}, 1] must alias, Mod Pointers: (i32* %d, LocationSize::precise(4)) ; CHECK: AliasSet[{{.*}}, 1] must alias, Mod Pointers: (i32* %d, LocationSize::precise(4))
define void @allmust() { define void @allmust() {
%a = alloca i32 %a = alloca i32
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

llvm/test/Analysis/Dominators/2007-01-14-BreakCritEdges.ll

; RUN: opt < %s -domtree -break-crit-edges -disable-output
; RUN: opt < %s -passes='require<domtree>,break-crit-edges' -disable-output ; RUN: opt < %s -passes='require<domtree>,break-crit-edges' -disable-output
; PR1110 ; PR1110
%struct.OggVorbis_File = type { i8*, i32, i64, i64, %struct.ogg_sync_state, i32, i64*, i64*, i32*, i64*, %struct.vorbis_info*, %struct.vorbis_comment*, i64, i32, i32, i32, double, double, %struct.ogg_stream_state, %struct.vorbis_dsp_state, %struct.vorbis_block, %struct.ov_callbacks } %struct.OggVorbis_File = type { i8*, i32, i64, i64, %struct.ogg_sync_state, i32, i64*, i64*, i32*, i64*, %struct.vorbis_info*, %struct.vorbis_comment*, i64, i32, i32, i32, double, double, %struct.ogg_stream_state, %struct.vorbis_dsp_state, %struct.vorbis_block, %struct.ov_callbacks }
%struct.alloc_chain = type { i8*, %struct.alloc_chain* } %struct.alloc_chain = type { i8*, %struct.alloc_chain* }
%struct.ogg_stream_state = type { i8*, i32, i32, i32, i32*, i64*, i32, i32, i32, i32, [282 x i8], i32, i32, i32, i32, i32, i64, i64 } %struct.ogg_stream_state = type { i8*, i32, i32, i32, i32*, i64*, i32, i32, i32, i32, [282 x i8], i32, i32, i32, i32, i32, i64, i64 }
%struct.ogg_sync_state = type { i8*, i32, i32, i32, i32, i32, i32 } %struct.ogg_sync_state = type { i8*, i32, i32, i32, i32, i32, i32 }
%struct.oggpack_buffer = type { i32, i32, i8*, i8*, i32 } %struct.oggpack_buffer = type { i32, i32, i8*, i8*, i32 }
▲ Show 20 Lines • Show All 179 Lines • Show Last 20 Lines

llvm/test/Analysis/IVUsers/deep_recursion_in_scev.ll

; RUN: opt < %s -iv-users ; RUN: opt < %s -passes='print<iv-users>'
; This is a regression test against very slow execution... ; This is a regression test against very slow execution...
; In bad case it should fail by timeout. ; In bad case it should fail by timeout.
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128-ni:1" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128-ni:1"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @quux(i8 addrspace(1)* %arg, i8 addrspace(1)* %arg1) { define void @quux(i8 addrspace(1)* %arg, i8 addrspace(1)* %arg1) {
bb: bb:
%tmp2 = getelementptr inbounds i8, i8 addrspace(1)* %arg, i64 80 %tmp2 = getelementptr inbounds i8, i8 addrspace(1)* %arg, i64 80
▲ Show 20 Lines • Show All 172 Lines • Show Last 20 Lines

llvm/test/Analysis/MemoryDependenceAnalysis/memdep-block-scan-limit.ll

; RUN: opt -S -memdep -gvn -basic-aa < %s | FileCheck %s ; RUN: opt -S -gvn < %s | FileCheck %s
; RUN: opt -S -memdep -memdep-block-scan-limit=1 -gvn -basic-aa < %s | FileCheck %s --check-prefix=WITH-LIMIT ; RUN: opt -S -memdep-block-scan-limit=1 -gvn < %s | FileCheck %s --check-prefix=WITH-LIMIT
; CHECK-LABEL: @test( ; CHECK-LABEL: @test(
; CHECK: load ; CHECK: load
; CHECK-NOT: load ; CHECK-NOT: load
; WITH-LIMIT-LABEL: @test( ; WITH-LIMIT-LABEL: @test(
; WITH-LIMIT-CHECK: load ; WITH-LIMIT-CHECK: load
; WITH-LIMIT-CHECK: load ; WITH-LIMIT-CHECK: load
define i32 @test(i32* %p) { define i32 @test(i32* %p) {
%1 = load i32, i32* %p %1 = load i32, i32* %p
%2 = add i32 %1, 3 %2 = add i32 %1, 3
%3 = load i32, i32* %p %3 = load i32, i32* %p
%4 = add i32 %2, %3 %4 = add i32 %2, %3
ret i32 %4 ret i32 %4
} }

llvm/test/Analysis/MemoryDependenceAnalysis/memdep_requires_dominator_tree.ll

; RUN: opt -memdep -gvn < %s ; RUN: opt -gvn < %s
define void @__memdep_requires_dominator_tree(i32* nocapture %bufUInt, i32* nocapture %pattern) nounwind { define void @__memdep_requires_dominator_tree(i32* nocapture %bufUInt, i32* nocapture %pattern) nounwind {
entry: entry:
br label %for.body br label %for.body
for.exit: ; preds = %for.body for.exit: ; preds = %for.body
ret void ret void
Show All 10 Lines

llvm/test/Analysis/MemoryDependenceAnalysis/reorder-over-store-atomic.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S -gvn -basic-aa < %s | FileCheck %s ; RUN: opt -S -gvn < %s | FileCheck %s
@u = global i32 5, align 4 @u = global i32 5, align 4
@w = global i32 10, align 4 @w = global i32 10, align 4
define i32 @test_load_seq_cst_unordered() { define i32 @test_load_seq_cst_unordered() {
; CHECK-LABEL: @test_load_seq_cst_unordered( ; CHECK-LABEL: @test_load_seq_cst_unordered(
; CHECK-NEXT: [[L1:%.*]] = load atomic i32, i32* @w unordered, align 4 ; CHECK-NEXT: [[L1:%.*]] = load atomic i32, i32* @w unordered, align 4
; CHECK-NEXT: [[LV:%.*]] = load atomic i32, i32* @u seq_cst, align 4 ; CHECK-NEXT: [[LV:%.*]] = load atomic i32, i32* @u seq_cst, align 4
▲ Show 20 Lines • Show All 126 Lines • Show Last 20 Lines

llvm/test/Analysis/MemoryDependenceAnalysis/reorder-volatile.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S -gvn --basic-aa < %s | FileCheck %s ; RUN: opt -S -gvn < %s | FileCheck %s
@u = global i32 5, align 4 @u = global i32 5, align 4
@w = global i32 10, align 4 @w = global i32 10, align 4
define i32 @test_load() { define i32 @test_load() {
; CHECK-LABEL: @test_load( ; CHECK-LABEL: @test_load(
; CHECK-NEXT: [[LV:%.*]] = load volatile i32, i32* @u, align 4 ; CHECK-NEXT: [[LV:%.*]] = load volatile i32, i32* @u, align 4
; CHECK-NEXT: ret i32 [[LV]] ; CHECK-NEXT: ret i32 [[LV]]
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

llvm/test/Analysis/MemorySSA/pr46275.ll

; RUN: opt -S -memoryssa -loop-deletion -loop-simplifycfg -verify-memoryssa < %s | FileCheck %s ; RUN: opt -S -passes='loop-mssa(loop-deletion,loop-simplifycfg)' -verify-memoryssa < %s | FileCheck %s
; REQUIRES: asserts ; REQUIRES: asserts
; CHECK-LABEL: @foo() ; CHECK-LABEL: @foo()
define void @foo() { define void @foo() {
entry: entry:
br i1 false, label %for.body.lr.ph, label %for.end br i1 false, label %for.body.lr.ph, label %for.end
for.body.lr.ph: ; preds = %entry for.body.lr.ph: ; preds = %entry
Show All 14 Lines

llvm/test/Analysis/MemorySSA/reduce_clobber_limit.ll

; RUN: opt -S -memoryssa %s | FileCheck %s ; RUN: opt -S -passes='require<memoryssa>' %s | FileCheck %s
; REQUIRES: asserts ; REQUIRES: asserts
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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; CHECK-LABEL: @func() ; CHECK-LABEL: @func()
; Function Attrs: noinline ; Function Attrs: noinline
define dso_local void @func() unnamed_addr #0 align 2 { define dso_local void @func() unnamed_addr #0 align 2 {
entry: entry:
▲ Show 20 Lines • Show All 122 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/2011-04-26-FoldAddRec.ll

; RUN: opt < %s -disable-output -iv-users
; RUN: opt < %s -passes='print<iv-users>' ; RUN: opt < %s -passes='print<iv-users>'
; PR9633: Tests that SCEV handles the mul.i2 recurrence being folded to ; PR9633: Tests that SCEV handles the mul.i2 recurrence being folded to
; constant zero. ; constant zero.
define signext i8 @func_14(i8 signext %p_18) nounwind readnone ssp { define signext i8 @func_14(i8 signext %p_18) nounwind readnone ssp {
entry: entry:
br label %for.inc br label %for.inc
Show All 25 Lines

llvm/test/Analysis/ScalarEvolution/2012-03-26-LoadConstant.ll

; RUN: opt < %s -basic-aa -globalopt -instcombine -loop-rotate -licm -instcombine -indvars -loop-deletion -constmerge -S | FileCheck %s ; RUN: opt < %s -globalopt -instcombine -loop-rotate -licm -instcombine -indvars -loop-deletion -constmerge -S | FileCheck %s
; PR11882: ComputeLoadConstantCompareExitLimit crash. ; PR11882: ComputeLoadConstantCompareExitLimit crash.
; ;
; for.body is deleted leaving a loop-invariant load. ; for.body is deleted leaving a loop-invariant load.
; CHECK-NOT: for.body ; CHECK-NOT: for.body
target datalayout = "e-p:64:64:64-n32:64" target datalayout = "e-p:64:64:64-n32:64"
@func_21_l_773 = external global i32, align 4 @func_21_l_773 = external global i32, align 4
@g_814 = external global i32, align 4 @g_814 = external global i32, align 4
Show All 34 Lines

llvm/test/Analysis/ScalarEvolution/2012-05-18-LoopPredRecurse.ll

; RUN: opt < %s -iv-users -S -disable-output
; RUN: opt < %s -passes='require<iv-users>' -S -disable-output ; RUN: opt < %s -passes='require<iv-users>' -S -disable-output
; ;
; PR12868: Infinite recursion: ; PR12868: Infinite recursion:
; getUDivExpr()->getZeroExtendExpr()->isLoopBackedgeGuardedBy() ; getUDivExpr()->getZeroExtendExpr()->isLoopBackedgeGuardedBy()
; ;
; We actually want SCEV simplification to fail gracefully in this ; We actually want SCEV simplification to fail gracefully in this
; case, so there's no output to check, just the absence of stack overflow. ; case, so there's no output to check, just the absence of stack overflow.
Show All 22 Lines

llvm/test/Analysis/ScalarEvolution/avoid-infinite-recursion-1.ll

; RUN: opt < %s -iv-users
; RUN: opt < %s -passes='require<iv-users>' ; RUN: opt < %s -passes='require<iv-users>'
; PR4538 ; PR4538
; ModuleID = 'bugpoint-reduced-simplified.bc' ; ModuleID = 'bugpoint-reduced-simplified.bc'
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" 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"
target triple = "x86_64-unknown-freebsd8.0" target triple = "x86_64-unknown-freebsd8.0"
module asm ".ident\09\22$FreeBSD: head/sys/kern/vfs_subr.c 195285 2009-07-02 14:19:33Z jamie $\22" module asm ".ident\09\22$FreeBSD: head/sys/kern/vfs_subr.c 195285 2009-07-02 14:19:33Z jamie $\22"
module asm ".section set_pcpu, \22aw\22, @progbits" module asm ".section set_pcpu, \22aw\22, @progbits"
▲ Show 20 Lines • Show All 346 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/multiple-max-iterations.ll

; Ensure we can pass -scalar-evolution-max-iterations multiple times ; Ensure we can pass -scalar-evolution-max-iterations multiple times
; RUN: opt -S -scalar-evolution -scalar-evolution-max-iterations=42 -scalar-evolution-max-iterations=42 < %s ; RUN: opt -S -passes='require<scalar-evolution>' -scalar-evolution-max-iterations=42 -scalar-evolution-max-iterations=42 < %s

llvm/test/Analysis/ScalarEvolution/scev-aa.ll

; RUN: opt -disable-output < %s -aa-pipeline=scev-aa -passes=aa-eval -print-all-alias-modref-info \ ; RUN: opt -disable-output < %s -aa-pipeline=scev-aa -passes=aa-eval -print-all-alias-modref-info \
; RUN: 2>&1 | FileCheck %s ; RUN: 2>&1 | FileCheck %s
; At the time of this writing, -basic-aa misses the example of the form ; At the time of this writing, misses the example of the form
; A[i+(j+1)] != A[i+j], which can arise from multi-dimensional array references, ; A[i+(j+1)] != A[i+j], which can arise from multi-dimensional array references,
; and the example of the form A[0] != A[i+1], where i+1 is known to be positive. ; and the example of the form A[0] != A[i+1], where i+1 is known to be positive.
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64"
; p[i] and p[i+1] don't alias. ; p[i] and p[i+1] don't alias.
; CHECK-LABEL: Function: loop ; CHECK-LABEL: Function: loop
▲ Show 20 Lines • Show All 336 Lines • Show Last 20 Lines

llvm/test/CodeGen/AMDGPU/amdgpu-unroll-threshold.ll

; RUN: opt < %s -S -mtriple=amdgcn-- -basic-aa -loop-unroll | FileCheck %s ; RUN: opt < %s -S -mtriple=amdgcn-- -loop-unroll | FileCheck %s
; Check that the loop in unroll_default is not fully unrolled using the default ; Check that the loop in unroll_default is not fully unrolled using the default
; unroll threshold ; unroll threshold
; CHECK-LABEL: @unroll_default ; CHECK-LABEL: @unroll_default
; CHECK: entry: ; CHECK: entry:
; CHECK: br i1 %cmp ; CHECK: br i1 %cmp
; CHECK: ret void ; CHECK: ret void
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

llvm/test/CodeGen/AMDGPU/loop-idiom.ll

; RUN: opt -basic-aa -loop-idiom -S < %s -march=r600 -mcpu=redwood | FileCheck --check-prefix=R600 --check-prefix=FUNC %s ; RUN: opt -loop-idiom -S < %s -march=r600 -mcpu=redwood | FileCheck --check-prefix=R600 --check-prefix=FUNC %s
; RUN: opt -basic-aa -loop-idiom -S < %s -march=amdgcn -mcpu=tahiti -verify-machineinstrs| FileCheck --check-prefix=SI --check-prefix=FUNC %s ; RUN: opt -loop-idiom -S < %s -march=amdgcn -mcpu=tahiti -verify-machineinstrs| FileCheck --check-prefix=SI --check-prefix=FUNC %s
; RUN: opt -basic-aa -loop-idiom -S < %s -march=amdgcn -mcpu=tonga -verify-machineinstrs| FileCheck --check-prefix=SI --check-prefix=FUNC %s ; RUN: opt -loop-idiom -S < %s -march=amdgcn -mcpu=tonga -verify-machineinstrs| FileCheck --check-prefix=SI --check-prefix=FUNC %s
target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5" target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5"
; Make sure loop-idiom doesn't create memcpy or memset. There are no library ; Make sure loop-idiom doesn't create memcpy or memset. There are no library
; implementations of these for R600. ; implementations of these for R600.
; FUNC: @no_memcpy ; FUNC: @no_memcpy
; R600-NOT: {{^}}llvm.memcpy ; R600-NOT: {{^}}llvm.memcpy
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

llvm/test/CodeGen/Hexagon/loop-idiom/hexagon-memmove1.ll

; Check for recognizing the "memmove" idiom. ; Check for recognizing the "memmove" idiom.
; RUN: opt -basic-aa -hexagon-loop-idiom -S -mtriple hexagon-unknown-elf < %s \ ; RUN: opt -hexagon-loop-idiom -S -mtriple hexagon-unknown-elf < %s \
; RUN: | FileCheck %s ; RUN: | FileCheck %s
; CHECK: call void @llvm.memmove ; CHECK: call void @llvm.memmove
; Function Attrs: norecurse nounwind ; Function Attrs: norecurse nounwind
define void @foo(i32* nocapture %A, i32* nocapture readonly %B, i32 %n) #0 { define void @foo(i32* nocapture %A, i32* nocapture readonly %B, i32 %n) #0 {
entry: entry:
%cmp1 = icmp sgt i32 %n, 0 %cmp1 = icmp sgt i32 %n, 0
br i1 %cmp1, label %for.body.preheader, label %for.end br i1 %cmp1, label %for.body.preheader, label %for.end
Show All 26 Lines

llvm/test/CodeGen/Hexagon/loop-idiom/hexagon-memmove2.ll

; RUN: opt -basic-aa -hexagon-loop-idiom -S -mtriple hexagon-unknown-elf < %s \ ; RUN: opt -hexagon-loop-idiom -S -mtriple hexagon-unknown-elf < %s \
; RUN: | FileCheck %s ; RUN: | FileCheck %s
define void @PR14241(i32* %s, i64 %size) #0 { define void @PR14241(i32* %s, i64 %size) #0 {
; Ensure that we don't form a memcpy for strided loops. Briefly, when we taught ; Ensure that we don't form a memcpy for strided loops. Briefly, when we taught
; LoopIdiom about memmove and strided loops, this got miscompiled into a memcpy ; LoopIdiom about memmove and strided loops, this got miscompiled into a memcpy
; instead of a memmove. If we get the memmove transform back, this will catch ; instead of a memmove. If we get the memmove transform back, this will catch
; regressions. ; regressions.
; ;
Show All 27 Lines

llvm/test/CodeGen/Hexagon/loop-idiom/nullptr-crash.ll

; RUN: opt -basic-aa -hexagon-loop-idiom -mtriple hexagon-unknown-elf < %s ; RUN: opt -hexagon-loop-idiom -mtriple hexagon-unknown-elf < %s
; REQUIRES: asserts ; REQUIRES: asserts
target triple = "hexagon" target triple = "hexagon"
; Function Attrs: nounwind ; Function Attrs: nounwind
define void @fred(i8 zeroext %L) #0 { define void @fred(i8 zeroext %L) #0 {
entry: entry:
br i1 undef, label %if.end53, label %while.body37 br i1 undef, label %if.end53, label %while.body37
Show All 15 Lines

llvm/test/DebugInfo/Generic/licm-hoist-debug-loc.ll

; RUN: opt -S -licm %s | FileCheck %s ; RUN: opt -S -licm %s | FileCheck %s
; ;
; LICM should null out debug locations when it hoists instructions out of a loop. ; LICM should null out debug locations when it hoists instructions out of a loop.
; ;
; Generated with ; Generated with
; clang -O0 -S -emit-llvm test.cpp -g -gline-tables-only -o t.ll ; clang -O0 -S -emit-llvm test.cpp -g -gline-tables-only -o t.ll
; opt -S -sroa -adce -simplifycfg -reassociate -domtree -loops \ ; opt -S -sroa -adce -simplifycfg -reassociate -domtree -loops \
; -loop-simplify -lcssa -basic-aa -aa -scalar-evolution -loop-rotate t.ll > test.ll ; -loop-simplify -lcssa -aa -scalar-evolution -loop-rotate t.ll > test.ll
; ;
; void bar(int *); ; void bar(int *);
; void foo(int k, int p) ; void foo(int k, int p)
; { ; {
; for (int i = 0; i < k; i++) { ; for (int i = 0; i < k; i++) {
; bar(&p + 4); ; bar(&p + 4);
; } ; }
; } ; }
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

llvm/test/DebugInfo/check-debugify-preserves-analyses.ll

; RUN: opt < %s -globals-aa -function-attrs | \ ; RUN: opt < %s -passes='require<globals-aa>,function-attrs' | \
; RUN: opt -S -strip -strip-dead-prototypes -strip-named-metadata > %t.no_dbg ; RUN: opt -S -strip -strip-dead-prototypes -strip-named-metadata > %t.no_dbg
; RUN: opt < %s -debugify-each -globals-aa -function-attrs | \ ; RUN: opt < %s -debugify-each -passes='require<globals-aa>,function-attrs' | \
; RUN: opt -S -strip -strip-dead-prototypes -strip-named-metadata > %t.with_dbg ; RUN: opt -S -strip -strip-dead-prototypes -strip-named-metadata > %t.with_dbg
; RUN: diff %t.no_dbg %t.with_dbg ; RUN: diff %t.no_dbg %t.with_dbg
define i32 @f_1(i32 %x) { define i32 @f_1(i32 %x) {
%tmp = call i32 @f_1(i32 0) [ "deopt"() ] %tmp = call i32 @f_1(i32 0) [ "deopt"() ]
ret i32 0 ret i32 0
} }

llvm/test/Feature/OperandBundles/pr26510.ll

; RUN: opt -S -globals-aa -function-attrs < %s | FileCheck %s ; RUN: opt -S -passes='require<globals-aa>,function-attrs' < %s | FileCheck %s
; RUN: opt -S -O3 < %s | FileCheck %s ; RUN: opt -S -O3 < %s | FileCheck %s
; Apart from checking for the direct cause of the bug, we also check ; Apart from checking for the direct cause of the bug, we also check
; if any problematic aliasing rules have accidentally snuck into -O3. ; if any problematic aliasing rules have accidentally snuck into -O3.
; ;
; Since the "abc" operand bundle is not a special operand bundle that ; Since the "abc" operand bundle is not a special operand bundle that
; LLVM knows about, all of the stores and loads in @test below have to ; LLVM knows about, all of the stores and loads in @test below have to
; stay. ; stay.
Show All 18 Lines

llvm/test/Other/2006-02-05-PassManager.ll

  • This file was deleted.
; RUN: opt < %s -domtree -gvn -domtree -constmerge -disable-output
define i32 @test1() {
unreachable
}

llvm/test/Other/lint.ll

; RUN: opt -basic-aa -lint -disable-output < %s 2>&1 | FileCheck %s ; RUN: opt -lint -disable-output < %s 2>&1 | FileCheck %s
; RUN: opt -aa-pipeline=basic-aa -passes=lint -disable-output < %s 2>&1 | FileCheck %s ; RUN: opt -aa-pipeline=basic-aa -passes=lint -disable-output < %s 2>&1 | FileCheck %s
target datalayout = "e-p:64:64:64" target datalayout = "e-p:64:64:64"
declare fastcc void @bar() declare fastcc void @bar()
declare void @llvm.stackrestore(i8*) declare void @llvm.stackrestore(i8*)
declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1) nounwind declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1) nounwind
declare void @llvm.memcpy.inline.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1) nounwind declare void @llvm.memcpy.inline.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1) nounwind
declare void @llvm.memset.p0i8.i8.i64(i8* nocapture, i8, i64, i1) nounwind declare void @llvm.memset.p0i8.i8.i64(i8* nocapture, i8, i64, i1) nounwind
▲ Show 20 Lines • Show All 201 Lines • Show Last 20 Lines

llvm/test/Transforms/DeadStoreElimination/2011-03-25-DSEMiscompile.ll

; RUN: opt < %s -basic-aa -dse -S | FileCheck %s ; RUN: opt < %s -dse -S | FileCheck %s
; PR9561 ; PR9561
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:128:128-n8:16:32" 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:128:128-n8:16:32"
target triple = "i386-apple-darwin9.8" target triple = "i386-apple-darwin9.8"
@A = external global [0 x i32] @A = external global [0 x i32]
declare ghccc void @Func2(ptr, ptr, ptr, i32) declare ghccc void @Func2(ptr, ptr, ptr, i32)
Show All 12 Lines

llvm/test/Transforms/DeadStoreElimination/2016-07-17-UseAfterFree.ll

; RUN: opt < %s -basic-aa -dse -S -enable-dse-partial-overwrite-tracking | FileCheck %s ; RUN: opt < %s -dse -S -enable-dse-partial-overwrite-tracking | FileCheck %s
; PR28588 ; PR28588
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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; Function Attrs: nounwind ; Function Attrs: nounwind
define void @_UPT_destroy(ptr nocapture %ptr) local_unnamed_addr #0 { define void @_UPT_destroy(ptr nocapture %ptr) local_unnamed_addr #0 {
entry: entry:
Show All 22 Lines

llvm/test/Transforms/DeadStoreElimination/OverwriteStoreBegin.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -dse -S | FileCheck %s ; RUN: opt < %s -dse -S | FileCheck %s
define void @write4to7(ptr nocapture %p) { define void @write4to7(ptr nocapture %p) {
; CHECK-LABEL: @write4to7( ; CHECK-LABEL: @write4to7(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[ARRAYIDX0:%.*]] = getelementptr inbounds i32, ptr [[P:%.*]], i64 1 ; CHECK-NEXT: [[ARRAYIDX0:%.*]] = getelementptr inbounds i32, ptr [[P:%.*]], i64 1
; CHECK-NEXT: [[TMP0:%.*]] = getelementptr inbounds i8, ptr [[ARRAYIDX0]], i64 4 ; CHECK-NEXT: [[TMP0:%.*]] = getelementptr inbounds i8, ptr [[ARRAYIDX0]], i64 4
; CHECK-NEXT: call void @llvm.memset.p0.i64(ptr align 4 [[TMP0]], i8 0, i64 24, i1 false) ; CHECK-NEXT: call void @llvm.memset.p0.i64(ptr align 4 [[TMP0]], i8 0, i64 24, i1 false)
; CHECK-NEXT: [[ARRAYIDX1:%.*]] = getelementptr inbounds i32, ptr [[P]], i64 1 ; CHECK-NEXT: [[ARRAYIDX1:%.*]] = getelementptr inbounds i32, ptr [[P]], i64 1
▲ Show 20 Lines • Show All 394 Lines • Show Last 20 Lines

llvm/test/Transforms/DeadStoreElimination/OverwriteStoreEnd.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -dse -S | FileCheck %s ; RUN: opt < %s -dse -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.vec2 = type { <4 x i32>, <4 x i32> } %struct.vec2 = type { <4 x i32>, <4 x i32> }
%struct.vec2plusi = type { <4 x i32>, <4 x i32>, i32 } %struct.vec2plusi = type { <4 x i32>, <4 x i32>, i32 }
@glob1 = global %struct.vec2 zeroinitializer, align 16 @glob1 = global %struct.vec2 zeroinitializer, align 16
@glob2 = global %struct.vec2plusi zeroinitializer, align 16 @glob2 = global %struct.vec2plusi zeroinitializer, align 16
▲ Show 20 Lines • Show All 384 Lines • Show Last 20 Lines

llvm/test/Transforms/DeadStoreElimination/PartialStore.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -dse -enable-dse-partial-store-merging=false -S | FileCheck %s ; RUN: opt < %s -dse -enable-dse-partial-store-merging=false -S | FileCheck %s
target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128" target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
; Ensure that the dead store is deleted in this case. It is wholely ; Ensure that the dead store is deleted in this case. It is wholely
; overwritten by the second store. ; overwritten by the second store.
define void @test1(ptr %V) { define void @test1(ptr %V) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: store i32 1234567, ptr [[V:%.*]], align 4 ; CHECK-NEXT: store i32 1234567, ptr [[V:%.*]], align 4
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

llvm/test/Transforms/DeadStoreElimination/atomic-todo.ll

; XFAIL: * ; XFAIL: *
; RUN: opt -basic-aa -dse -S < %s | FileCheck %s ; RUN: opt -dse -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" 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"
target triple = "x86_64-apple-macosx10.7.0" target triple = "x86_64-apple-macosx10.7.0"
; Basic correctness tests for atomic stores. ; Basic correctness tests for atomic stores.
; Note that it turns out essentially every transformation DSE does is legal on ; Note that it turns out essentially every transformation DSE does is legal on
; atomic ops, just some transformations are not allowed across release-acquire pairs. ; atomic ops, just some transformations are not allowed across release-acquire pairs.
Show All 13 Lines

llvm/test/Transforms/DeadStoreElimination/atomic.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -basic-aa -dse -S < %s | FileCheck %s ; RUN: opt -dse -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" 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"
target triple = "x86_64-apple-macosx10.7.0" target triple = "x86_64-apple-macosx10.7.0"
; Basic correctness tests for atomic stores. ; Basic correctness tests for atomic stores.
; Note that it turns out essentially every transformation DSE does is legal on ; Note that it turns out essentially every transformation DSE does is legal on
; atomic ops, just some transformations are not allowed across release-acquire pairs. ; atomic ops, just some transformations are not allowed across release-acquire pairs.
▲ Show 20 Lines • Show All 319 Lines • Show Last 20 Lines

llvm/test/Transforms/DeadStoreElimination/calloc-store.ll

; RUN: opt < %s -basic-aa -dse -S | FileCheck %s ; RUN: opt < %s -dse -S | FileCheck %s
declare noalias ptr @calloc(i64, i64) inaccessiblememonly allockind("alloc,zeroed") declare noalias ptr @calloc(i64, i64) inaccessiblememonly allockind("alloc,zeroed")
define ptr @test1() { define ptr @test1() {
; CHECK-LABEL: test1 ; CHECK-LABEL: test1
%1 = tail call noalias ptr @calloc(i64 1, i64 4) %1 = tail call noalias ptr @calloc(i64 1, i64 4)
; This store is dead and should be removed ; This store is dead and should be removed
store i32 0, ptr %1, align 4 store i32 0, ptr %1, align 4
▲ Show 20 Lines • Show All 144 Lines • Show Last 20 Lines

llvm/test/Transforms/DeadStoreElimination/const-pointers.ll

; RUN: opt -basic-aa -dse -S < %s | FileCheck %s ; RUN: opt -dse -S < %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"
%t = type { i32 } %t = type { i32 }
@g = global i32 42 @g = global i32 42
define void @test1(ptr noalias %pp) { define void @test1(ptr noalias %pp) {
Show All 30 Lines

llvm/test/Transforms/DeadStoreElimination/crash.ll

; RUN: opt < %s -basic-aa -dse -S ; RUN: opt < %s -dse -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:128:128" 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:128:128"
target triple = "i386-apple-darwin10.0" target triple = "i386-apple-darwin10.0"
@g80 = external global i8 ; <ptr> [#uses=3] @g80 = external global i8 ; <ptr> [#uses=3]
declare signext i8 @foo(i8 signext, i8 signext) nounwind readnone ssp declare signext i8 @foo(i8 signext, i8 signext) nounwind readnone ssp
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

llvm/test/Transforms/DeadStoreElimination/cs-cs-aliasing.ll

; RUN: opt -basic-aa -dse -S < %s | FileCheck %s ; RUN: opt -dse -S < %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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
%class.basic_string = type { %"class.__gnu_cxx::__versa_string" } %class.basic_string = type { %"class.__gnu_cxx::__versa_string" }
%"class.__gnu_cxx::__versa_string" = type { %"class.__gnu_cxx::__sso_string_base" } %"class.__gnu_cxx::__versa_string" = type { %"class.__gnu_cxx::__sso_string_base" }
%"class.__gnu_cxx::__sso_string_base" = type { %"struct.__gnu_cxx::__vstring_utility<char, std::char_traits<char>, std::allocator<char> >::_Alloc_hider", i64, %union.anon } %"class.__gnu_cxx::__sso_string_base" = type { %"struct.__gnu_cxx::__vstring_utility<char, std::char_traits<char>, std::allocator<char> >::_Alloc_hider", i64, %union.anon }
%"struct.__gnu_cxx::__vstring_utility<char, std::char_traits<char>, std::allocator<char> >::_Alloc_hider" = type { ptr } %"struct.__gnu_cxx::__vstring_utility<char, std::char_traits<char>, std::allocator<char> >::_Alloc_hider" = type { ptr }
%union.anon = type { i64, [8 x i8] } %union.anon = type { i64, [8 x i8] }
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

llvm/test/Transforms/DeadStoreElimination/debug-counter.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; REQUIRES: asserts ; REQUIRES: asserts
; Eliminates store to %R in the entry block. ; Eliminates store to %R in the entry block.
; RUN: opt < %s -basic-aa -dse -debug-counter=dse-memoryssa-skip=0,dse-memoryssa-count=1 -S | FileCheck --check-prefix=SKIP0-COUNT1 %s ; RUN: opt < %s -dse -debug-counter=dse-memoryssa-skip=0,dse-memoryssa-count=1 -S | FileCheck --check-prefix=SKIP0-COUNT1 %s
; Eliminates store to %P in the entry block. ; Eliminates store to %P in the entry block.
; RUN: opt < %s -basic-aa -dse -debug-counter=dse-memoryssa-skip=1,dse-memoryssa-count=1 -S | FileCheck --check-prefix=SKIP1-COUNT1 %s ; RUN: opt < %s -dse -debug-counter=dse-memoryssa-skip=1,dse-memoryssa-count=1 -S | FileCheck --check-prefix=SKIP1-COUNT1 %s
; Eliminates both stores in the entry block. ; Eliminates both stores in the entry block.
; RUN: opt < %s -basic-aa -dse -debug-counter=dse-memoryssa-skip=0,dse-memoryssa-count=2 -S | FileCheck --check-prefix=SKIP0-COUNT2 %s ; RUN: opt < %s -dse -debug-counter=dse-memoryssa-skip=0,dse-memoryssa-count=2 -S | FileCheck --check-prefix=SKIP0-COUNT2 %s
; Eliminates no stores. ; Eliminates no stores.
; RUN: opt < %s -basic-aa -dse -debug-counter=dse-memoryssa-skip=2,dse-memoryssa-count=1 -S | FileCheck --check-prefix=SKIP2-COUNT1 %s ; RUN: opt < %s -dse -debug-counter=dse-memoryssa-skip=2,dse-memoryssa-count=1 -S | FileCheck --check-prefix=SKIP2-COUNT1 %s
target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64" target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
define void @test(ptr noalias %P, ptr noalias %Q, ptr noalias %R) { define void @test(ptr noalias %P, ptr noalias %Q, ptr noalias %R) {
; SKIP0-COUNT1-LABEL: @test( ; SKIP0-COUNT1-LABEL: @test(
; SKIP0-COUNT1-NEXT: store i32 1, ptr [[P:%.*]] ; SKIP0-COUNT1-NEXT: store i32 1, ptr [[P:%.*]]
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

llvm/test/Transforms/DeadStoreElimination/debuginfo.ll

; RUN: opt < %s -debugify -basic-aa -dse -S | FileCheck %s ; RUN: opt < %s -debugify -dse -S | FileCheck %s
target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128" target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
declare noalias ptr @malloc(i32) declare noalias ptr @malloc(i32)
declare void @test_f() declare void @test_f()
define ptr @test_salvage(i32 %arg) { define ptr @test_salvage(i32 %arg) {
Show All 18 Lines

llvm/test/Transforms/DeadStoreElimination/fence-todo.ll

; XFAIL: * ; XFAIL: *
; RUN: opt -S -basic-aa -dse < %s | FileCheck %s ; RUN: opt -S -dse < %s | FileCheck %s
; We DSE stack alloc'ed and byval locations, in the presence of fences. ; We DSE stack alloc'ed and byval locations, in the presence of fences.
; Fence does not make an otherwise thread local store visible. ; Fence does not make an otherwise thread local store visible.
; Right now the DSE in presence of fence is only done in end blocks (with no successors), ; Right now the DSE in presence of fence is only done in end blocks (with no successors),
; but the same logic applies to other basic blocks as well. ; but the same logic applies to other basic blocks as well.
; The store to %addr.i can be removed since it is a byval attribute ; The store to %addr.i can be removed since it is a byval attribute
define void @test3(ptr byval(i32) %addr.i) { define void @test3(ptr byval(i32) %addr.i) {
; CHECK-LABEL: @test3 ; CHECK-LABEL: @test3
Show All 39 Lines

llvm/test/Transforms/DeadStoreElimination/fence.ll

; RUN: opt -S -basic-aa -dse < %s | FileCheck %s ; RUN: opt -S -dse < %s | FileCheck %s
; We conservative choose to prevent dead store elimination ; We conservative choose to prevent dead store elimination
; across release or stronger fences. It's not required ; across release or stronger fences. It's not required
; (since the must still be a race on %addd.i), but ; (since the must still be a race on %addd.i), but
; it is conservatively correct. A legal optimization ; it is conservatively correct. A legal optimization
; could hoist the second store above the fence, and then ; could hoist the second store above the fence, and then
; DSE one of them. ; DSE one of them.
define void @test1(ptr %addr.i) { define void @test1(ptr %addr.i) {
Show All 39 Lines

llvm/test/Transforms/DeadStoreElimination/free.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -dse -S | FileCheck %s ; RUN: opt < %s -dse -S | FileCheck %s
target datalayout = "e-p:64:64:64" target datalayout = "e-p:64:64:64"
declare void @free(ptr nocapture) allockind("free") declare void @free(ptr nocapture) allockind("free")
declare noalias ptr @malloc(i64) allockind("alloc,uninitialized") declare noalias ptr @malloc(i64) allockind("alloc,uninitialized")
define void @test(ptr %Q, ptr %P) { define void @test(ptr %Q, ptr %P) {
; CHECK-LABEL: @test( ; CHECK-LABEL: @test(
▲ Show 20 Lines • Show All 104 Lines • Show Last 20 Lines

llvm/test/Transforms/DeadStoreElimination/invariant.start.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; Test to make sure llvm.invariant.start calls are not treated as clobbers. ; Test to make sure llvm.invariant.start calls are not treated as clobbers.
; RUN: opt < %s -basic-aa -dse -S | FileCheck %s ; RUN: opt < %s -dse -S | FileCheck %s
declare ptr @llvm.invariant.start.p0(i64, ptr nocapture) nounwind readonly declare ptr @llvm.invariant.start.p0(i64, ptr nocapture) nounwind readonly
; We could remove either store here. The first store is dead in the ; We could remove either store here. The first store is dead in the
; conventional sense, because there is a later killing store. The second store ; conventional sense, because there is a later killing store. The second store
; is undefined behavior by the semantics of invariant.start, and as such ; is undefined behavior by the semantics of invariant.start, and as such
; unreachable. ; unreachable.
define void @test(ptr %p) { define void @test(ptr %p) {
Show All 26 Lines

llvm/test/Transforms/DeadStoreElimination/launder.invariant.group.ll

; RUN: opt < %s -basic-aa -dse -S | FileCheck %s ; RUN: opt < %s -dse -S | FileCheck %s
; CHECK-LABEL: void @skipBarrier(ptr %ptr) ; CHECK-LABEL: void @skipBarrier(ptr %ptr)
define void @skipBarrier(ptr %ptr) { define void @skipBarrier(ptr %ptr) {
; CHECK-NOT: store i8 42 ; CHECK-NOT: store i8 42
store i8 42, ptr %ptr store i8 42, ptr %ptr
; CHECK: %ptr2 = call ptr @llvm.launder.invariant.group.p0(ptr %ptr) ; CHECK: %ptr2 = call ptr @llvm.launder.invariant.group.p0(ptr %ptr)
%ptr2 = call ptr @llvm.launder.invariant.group.p0(ptr %ptr) %ptr2 = call ptr @llvm.launder.invariant.group.p0(ptr %ptr)
; CHECK: store i8 43 ; CHECK: store i8 43
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

llvm/test/Transforms/DeadStoreElimination/libcalls.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -S -inferattrs -basic-aa -dse | FileCheck %s ; RUN: opt < %s -S -inferattrs -dse | FileCheck %s
; RUN: opt < %s -S -aa-pipeline=basic-aa -passes=inferattrs,dse | FileCheck %s ; RUN: opt < %s -S -aa-pipeline=basic-aa -passes=inferattrs,dse | FileCheck %s
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
declare ptr @strcpy(ptr %dest, ptr %src) nounwind declare ptr @strcpy(ptr %dest, ptr %src) nounwind
define void @test1(ptr %src) { define void @test1(ptr %src) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
▲ Show 20 Lines • Show All 571 Lines • Show Last 20 Lines

llvm/test/Transforms/DeadStoreElimination/lifetime.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S -basic-aa -dse < %s | FileCheck %s ; RUN: opt -S -dse < %s | FileCheck %s
target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128" target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
declare void @llvm.lifetime.start.p0(i64, ptr nocapture) nounwind declare void @llvm.lifetime.start.p0(i64, ptr nocapture) nounwind
declare void @llvm.lifetime.end.p0(i64, ptr nocapture) nounwind declare void @llvm.lifetime.end.p0(i64, ptr nocapture) nounwind
declare void @llvm.memset.p0.i8(ptr nocapture, i8, i8, i1) nounwind declare void @llvm.memset.p0.i8(ptr nocapture, i8, i8, i1) nounwind
define void @test1() { define void @test1() {
▲ Show 20 Lines • Show All 136 Lines • Show Last 20 Lines

llvm/test/Transforms/DeadStoreElimination/masked-dead-store-inseltpoison.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -tbaa -dse -S < %s | FileCheck %s ; RUN: opt -dse -S < %s | FileCheck %s
target datalayout = "e-m:e-p:32:32:32-a:0-n16:32-i64:64:64-i32:32:32-i16:16:16-i1:8:8-f32:32:32-f64:64:64-v32:32:32-v64:64:64-v512:512:512-v1024:1024:1024-v2048:2048:2048" target datalayout = "e-m:e-p:32:32:32-a:0-n16:32-i64:64:64-i32:32:32-i16:16:16-i1:8:8-f32:32:32-f64:64:64-v32:32:32-v64:64:64-v512:512:512-v1024:1024:1024-v2048:2048:2048"
define dllexport i32 @f0(ptr %a0, ptr %a1, i32 %a2, i32 %a3, i32 %a4, i32 %a5, i32 %a6, i32 %a7) #0 { define dllexport i32 @f0(ptr %a0, ptr %a1, i32 %a2, i32 %a3, i32 %a4, i32 %a5, i32 %a6, i32 %a7) #0 {
; CHECK-LABEL: @f0( ; CHECK-LABEL: @f0(
; CHECK-NEXT: b0: ; CHECK-NEXT: b0:
; CHECK-NEXT: [[V0:%.*]] = getelementptr inbounds ptr, ptr [[A0:%.*]], i32 [[A2:%.*]] ; CHECK-NEXT: [[V0:%.*]] = getelementptr inbounds ptr, ptr [[A0:%.*]], i32 [[A2:%.*]]
; CHECK-NEXT: [[V1:%.*]] = load ptr, ptr [[V0]], align 4, [[TBAA0:!tbaa !.*]] ; CHECK-NEXT: [[V1:%.*]] = load ptr, ptr [[V0]], align 4, [[TBAA0:!tbaa !.*]]
; CHECK-NEXT: [[V2:%.*]] = getelementptr i8, ptr [[V1]], i32 [[A3:%.*]] ; CHECK-NEXT: [[V2:%.*]] = getelementptr i8, ptr [[V1]], i32 [[A3:%.*]]
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

llvm/test/Transforms/DeadStoreElimination/masked-dead-store.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -tbaa -dse -S < %s | FileCheck %s ; RUN: opt -dse -S < %s | FileCheck %s
target datalayout = "e-m:e-p:32:32:32-a:0-n16:32-i64:64:64-i32:32:32-i16:16:16-i1:8:8-f32:32:32-f64:64:64-v32:32:32-v64:64:64-v512:512:512-v1024:1024:1024-v2048:2048:2048" target datalayout = "e-m:e-p:32:32:32-a:0-n16:32-i64:64:64-i32:32:32-i16:16:16-i1:8:8-f32:32:32-f64:64:64-v32:32:32-v64:64:64-v512:512:512-v1024:1024:1024-v2048:2048:2048"
define dllexport i32 @f0(ptr %a0, ptr %a1, i32 %a2, i32 %a3, i32 %a4, i32 %a5, i32 %a6, i32 %a7) #0 { define dllexport i32 @f0(ptr %a0, ptr %a1, i32 %a2, i32 %a3, i32 %a4, i32 %a5, i32 %a6, i32 %a7) #0 {
; CHECK-LABEL: @f0( ; CHECK-LABEL: @f0(
; CHECK-NEXT: b0: ; CHECK-NEXT: b0:
; CHECK-NEXT: [[V0:%.*]] = getelementptr inbounds ptr, ptr [[A0:%.*]], i32 [[A2:%.*]] ; CHECK-NEXT: [[V0:%.*]] = getelementptr inbounds ptr, ptr [[A0:%.*]], i32 [[A2:%.*]]
; CHECK-NEXT: [[V1:%.*]] = load ptr, ptr [[V0]], align 4, !tbaa [[TBAA0:![0-9]+]] ; CHECK-NEXT: [[V1:%.*]] = load ptr, ptr [[V0]], align 4, !tbaa [[TBAA0:![0-9]+]]
; CHECK-NEXT: [[V2:%.*]] = getelementptr i8, ptr [[V1]], i32 [[A3:%.*]] ; CHECK-NEXT: [[V2:%.*]] = getelementptr i8, ptr [[V1]], i32 [[A3:%.*]]
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

llvm/test/Transforms/DeadStoreElimination/memcpy-complete-overwrite.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; XFAIL: * ; XFAIL: *
; RUN: opt < %s -basic-aa -dse -S | FileCheck %s ; RUN: opt < %s -dse -S | FileCheck %s
; RUN: opt < %s -aa-pipeline=basic-aa -passes=dse -S | FileCheck %s ; RUN: opt < %s -aa-pipeline=basic-aa -passes=dse -S | FileCheck %s
target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128" target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
declare void @llvm.memset.p0.i64(ptr nocapture, i8, i64, i1) nounwind declare void @llvm.memset.p0.i64(ptr nocapture, i8, i64, i1) nounwind
declare void @llvm.memset.element.unordered.atomic.p0.i64(ptr nocapture, i8, i64, i32) nounwind declare void @llvm.memset.element.unordered.atomic.p0.i64(ptr nocapture, i8, i64, i32) nounwind
declare void @llvm.memcpy.p0.p0.i64(ptr nocapture, ptr nocapture, i64, i1) nounwind declare void @llvm.memcpy.p0.p0.i64(ptr nocapture, ptr nocapture, i64, i1) nounwind
declare void @llvm.memcpy.element.unordered.atomic.p0.p0.i64(ptr nocapture, ptr nocapture, i64, i32) nounwind declare void @llvm.memcpy.element.unordered.atomic.p0.p0.i64(ptr nocapture, ptr nocapture, i64, i32) nounwind
▲ Show 20 Lines • Show All 177 Lines • Show Last 20 Lines

llvm/test/Transforms/DeadStoreElimination/memcpy-lifetimes.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -dse -S | FileCheck %s ; RUN: opt < %s -dse -S | FileCheck %s
; RUN: opt < %s -aa-pipeline=basic-aa -passes=dse -S | FileCheck %s ; RUN: opt < %s -aa-pipeline=basic-aa -passes=dse -S | FileCheck %s
target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
%struct.Village = type { [4 x ptr], ptr, %struct.List, %struct.Hosp, i32, i64 } %struct.Village = type { [4 x ptr], ptr, %struct.List, %struct.Hosp, i32, i64 }
%struct.List = type { ptr, ptr, ptr } %struct.List = type { ptr, ptr, ptr }
%struct.Patient = type { i32, i32, i32, ptr } %struct.Patient = type { i32, i32, i32, ptr }
%struct.Hosp = type { i32, i32, i32, %struct.List, %struct.List, %struct.List, %struct.List } %struct.Hosp = type { i32, i32, i32, %struct.List, %struct.List, %struct.List, %struct.List }
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

llvm/test/Transforms/DeadStoreElimination/memoryssa-scan-limit.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -dse -S | FileCheck --check-prefix=NO-LIMIT %s ; RUN: opt < %s -dse -S | FileCheck --check-prefix=NO-LIMIT %s
; RUN: opt < %s -basic-aa -dse -dse-memoryssa-scanlimit=0 -S | FileCheck --check-prefix=LIMIT-0 %s ; RUN: opt < %s -dse -dse-memoryssa-scanlimit=0 -S | FileCheck --check-prefix=LIMIT-0 %s
; RUN: opt < %s -basic-aa -dse -dse-memoryssa-scanlimit=2 -S | FileCheck --check-prefix=LIMIT-2 %s ; RUN: opt < %s -dse -dse-memoryssa-scanlimit=2 -S | FileCheck --check-prefix=LIMIT-2 %s
; RUN: opt < %s -basic-aa -dse -dse-memoryssa-scanlimit=3 -S | FileCheck --check-prefix=LIMIT-3 %s ; RUN: opt < %s -dse -dse-memoryssa-scanlimit=3 -S | FileCheck --check-prefix=LIMIT-3 %s
target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64" target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
define void @test2(ptr noalias %P, ptr noalias %Q, ptr noalias %R) { define void @test2(ptr noalias %P, ptr noalias %Q, ptr noalias %R) {
; NO-LIMIT-LABEL: @test2( ; NO-LIMIT-LABEL: @test2(
; NO-LIMIT-NEXT: br i1 true, label [[BB1:%.*]], label [[BB2:%.*]] ; NO-LIMIT-NEXT: br i1 true, label [[BB1:%.*]], label [[BB2:%.*]]
; NO-LIMIT: bb1: ; NO-LIMIT: bb1:
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

llvm/test/Transforms/DeadStoreElimination/memset-and-memcpy.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -dse -S | FileCheck %s ; RUN: opt < %s -dse -S | FileCheck %s
; RUN: opt < %s -aa-pipeline=basic-aa -passes=dse -S | FileCheck %s ; RUN: opt < %s -aa-pipeline=basic-aa -passes=dse -S | FileCheck %s
target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128" target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
declare void @llvm.memset.p0.i64(ptr nocapture, i8, i64, i1) nounwind declare void @llvm.memset.p0.i64(ptr nocapture, i8, i64, i1) nounwind
declare void @llvm.memset.element.unordered.atomic.p0.i64(ptr nocapture, i8, i64, i32) nounwind declare void @llvm.memset.element.unordered.atomic.p0.i64(ptr nocapture, i8, i64, i32) nounwind
declare void @llvm.memcpy.p0.p0.i64(ptr nocapture, ptr nocapture, i64, i1) nounwind declare void @llvm.memcpy.p0.p0.i64(ptr nocapture, ptr nocapture, i64, i1) nounwind
declare void @llvm.memcpy.element.unordered.atomic.p0.p0.i64(ptr nocapture, ptr nocapture, i64, i32) nounwind declare void @llvm.memcpy.element.unordered.atomic.p0.p0.i64(ptr nocapture, ptr nocapture, i64, i32) nounwind
declare void @llvm.init.trampoline(ptr, ptr, ptr) declare void @llvm.init.trampoline(ptr, ptr, ptr)
▲ Show 20 Lines • Show All 111 Lines • Show Last 20 Lines

llvm/test/Transforms/DeadStoreElimination/multiblock-captures.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -dse -S | FileCheck %s ; RUN: opt < %s -dse -S | FileCheck %s
target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64" target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
declare noalias ptr @malloc(i64) declare noalias ptr @malloc(i64)
declare void @foo() declare void @foo()
declare void @capture(ptr) declare void @capture(ptr)
▲ Show 20 Lines • Show All 307 Lines • Show Last 20 Lines

llvm/test/Transforms/DeadStoreElimination/multiblock-exceptions.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -dse -S | FileCheck %s ; RUN: opt < %s -dse -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" 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"
declare void @f() declare void @f()
declare i32 @__CxxFrameHandler3(...) declare i32 @__CxxFrameHandler3(...)
; Make sure we do not eliminate `store i32 20, ptr %sv`. Even though it is a store ; Make sure we do not eliminate `store i32 20, ptr %sv`. Even though it is a store
; to a stack object, we can read it in the landing/catchpad. ; to a stack object, we can read it in the landing/catchpad.
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

llvm/test/Transforms/DeadStoreElimination/multiblock-loops.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -dse -S | FileCheck %s ; RUN: opt < %s -dse -S | FileCheck %s
target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64" target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
declare void @llvm.memset.p0.i64(ptr nocapture, i8, i64, i32, i1) nounwind declare void @llvm.memset.p0.i64(ptr nocapture, i8, i64, i32, i1) nounwind
define void @test13(ptr noalias %P) { define void @test13(ptr noalias %P) {
; CHECK-LABEL: @test13( ; CHECK-LABEL: @test13(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[FOR:%.*]] ; CHECK-NEXT: br label [[FOR:%.*]]
▲ Show 20 Lines • Show All 967 Lines • Show Last 20 Lines

llvm/test/Transforms/DeadStoreElimination/multiblock-malloc-free.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -dse -S | FileCheck %s ; RUN: opt < %s -dse -S | FileCheck %s
target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64" target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
declare void @unknown_func() declare void @unknown_func()
declare void @llvm.lifetime.start.p0(i64, ptr nocapture) nounwind declare void @llvm.lifetime.start.p0(i64, ptr nocapture) nounwind
declare void @llvm.lifetime.end.p0(i64, ptr nocapture) nounwind declare void @llvm.lifetime.end.p0(i64, ptr nocapture) nounwind
declare void @llvm.memcpy.p0.p0.i64(ptr nocapture, ptr nocapture, i64, i1) nounwind declare void @llvm.memcpy.p0.p0.i64(ptr nocapture, ptr nocapture, i64, i1) nounwind
declare void @llvm.memset.p0.i64(ptr nocapture, i8, i64, i32, i1) nounwind declare void @llvm.memset.p0.i64(ptr nocapture, i8, i64, i32, i1) nounwind
▲ Show 20 Lines • Show All 346 Lines • Show Last 20 Lines

llvm/test/Transforms/DeadStoreElimination/multiblock-memintrinsics.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -dse -S | FileCheck %s ; RUN: opt < %s -dse -S | FileCheck %s
target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64" target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
declare void @unknown_func() declare void @unknown_func()
declare void @llvm.memcpy.p0.p0.i64(ptr nocapture, ptr nocapture, i64, i1) nounwind declare void @llvm.memcpy.p0.p0.i64(ptr nocapture, ptr nocapture, i64, i1) nounwind
declare void @llvm.memset.p0.i64(ptr nocapture, i8, i64, i32, i1) nounwind declare void @llvm.memset.p0.i64(ptr nocapture, i8, i64, i32, i1) nounwind
; Tests where the pointer/object is accessible after the function returns. ; Tests where the pointer/object is accessible after the function returns.
▲ Show 20 Lines • Show All 211 Lines • Show Last 20 Lines

llvm/test/Transforms/DeadStoreElimination/multiblock-memoryphis.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -dse -S | FileCheck %s ; RUN: opt < %s -dse -S | FileCheck %s
target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64" target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
define void @test4(ptr noalias %P) { define void @test4(ptr noalias %P) {
; CHECK-LABEL: @test4( ; CHECK-LABEL: @test4(
; CHECK-NEXT: store i32 0, ptr [[P:%.*]], align 4 ; CHECK-NEXT: store i32 0, ptr [[P:%.*]], align 4
; CHECK-NEXT: br i1 true, label [[BB1:%.*]], label [[BB2:%.*]] ; CHECK-NEXT: br i1 true, label [[BB1:%.*]], label [[BB2:%.*]]
▲ Show 20 Lines • Show All 189 Lines • Show Last 20 Lines

llvm/test/Transforms/DeadStoreElimination/multiblock-multipath-throwing.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -dse -S | FileCheck %s ; RUN: opt < %s -dse -S | FileCheck %s
target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64" target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
declare void @readnone_may_throw() readnone declare void @readnone_may_throw() readnone
declare void @use(ptr) declare void @use(ptr)
; Tests where the pointer/object is accessible after the function returns. ; Tests where the pointer/object is accessible after the function returns.
▲ Show 20 Lines • Show All 161 Lines • Show Last 20 Lines

llvm/test/Transforms/DeadStoreElimination/multiblock-multipath.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -dse -S | FileCheck %s ; RUN: opt < %s -dse -S | FileCheck %s
target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64" target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
declare void @use(ptr) declare void @use(ptr)
; Tests where the pointer/object is accessible after the function returns. ; Tests where the pointer/object is accessible after the function returns.
define void @accessible_after_return_1(ptr noalias %P, i1 %c1) { define void @accessible_after_return_1(ptr noalias %P, i1 %c1) {
▲ Show 20 Lines • Show All 627 Lines • Show Last 20 Lines

llvm/test/Transforms/DeadStoreElimination/multiblock-partial.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -dse -S | FileCheck %s ; RUN: opt < %s -dse -S | FileCheck %s
target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64" target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
define void @second_store_smaller_1(ptr noalias %P, i1 %c) { define void @second_store_smaller_1(ptr noalias %P, i1 %c) {
; CHECK-LABEL: @second_store_smaller_1( ; CHECK-LABEL: @second_store_smaller_1(
; CHECK-NEXT: store i32 0, ptr [[P:%.*]], align 4 ; CHECK-NEXT: store i32 0, ptr [[P:%.*]], align 4
; CHECK-NEXT: br i1 [[C:%.*]], label [[BB1:%.*]], label [[BB2:%.*]] ; CHECK-NEXT: br i1 [[C:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
; CHECK: bb1: ; CHECK: bb1:
▲ Show 20 Lines • Show All 142 Lines • Show Last 20 Lines

llvm/test/Transforms/DeadStoreElimination/multiblock-simple.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -dse -S | FileCheck %s ; RUN: opt < %s -dse -S | FileCheck %s
target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64" target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
define void @test2(ptr noalias %P) { define void @test2(ptr noalias %P) {
; CHECK-LABEL: @test2( ; CHECK-LABEL: @test2(
; CHECK-NEXT: br i1 true, label [[BB1:%.*]], label [[BB2:%.*]] ; CHECK-NEXT: br i1 true, label [[BB1:%.*]], label [[BB2:%.*]]
; CHECK: bb1: ; CHECK: bb1:
▲ Show 20 Lines • Show All 233 Lines • Show Last 20 Lines

llvm/test/Transforms/DeadStoreElimination/multiblock-throwing.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -dse -S | FileCheck %s ; RUN: opt < %s -dse -S | FileCheck %s
target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64" target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
declare void @unknown_func() declare void @unknown_func()
define void @test6_store_same_value(ptr noalias %P) { define void @test6_store_same_value(ptr noalias %P) {
; CHECK-LABEL: @test6_store_same_value( ; CHECK-LABEL: @test6_store_same_value(
; CHECK-NEXT: store i32 0, ptr [[P:%.*]], align 4 ; CHECK-NEXT: store i32 0, ptr [[P:%.*]], align 4
; CHECK-NEXT: br i1 true, label [[BB1:%.*]], label [[BB2:%.*]] ; CHECK-NEXT: br i1 true, label [[BB1:%.*]], label [[BB2:%.*]]
▲ Show 20 Lines • Show All 94 Lines • Show Last 20 Lines

llvm/test/Transforms/DeadStoreElimination/no-targetdata.ll

; RUN: opt -basic-aa -dse -S < %s | FileCheck %s ; RUN: opt -dse -S < %s | FileCheck %s
declare void @llvm.memcpy.p0.p0.i64(ptr nocapture, ptr nocapture, i64, i1) nounwind declare void @llvm.memcpy.p0.p0.i64(ptr nocapture, ptr nocapture, i64, i1) nounwind
define void @fn(ptr nocapture %buf) #0 { define void @fn(ptr nocapture %buf) #0 {
entry: entry:
; We would not eliminate the first memcpy with data layout, and we should not ; We would not eliminate the first memcpy with data layout, and we should not
; eliminate it without data layout. ; eliminate it without data layout.
Show All 12 Lines

llvm/test/Transforms/DeadStoreElimination/noop-stores.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -dse -S | FileCheck %s ; RUN: opt < %s -dse -S | FileCheck %s
; RUN: opt < %s -aa-pipeline=basic-aa -passes='dse,verify<memoryssa>' -S | FileCheck %s ; RUN: opt < %s -aa-pipeline=basic-aa -passes='dse,verify<memoryssa>' -S | FileCheck %s
target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128" target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
declare void @memset_pattern16(ptr, ptr, i64) declare void @memset_pattern16(ptr, ptr, i64)
declare void @llvm.memset.p0.i64(ptr nocapture, i8, i64, i1) nounwind declare void @llvm.memset.p0.i64(ptr nocapture, i8, i64, i1) nounwind
declare void @llvm.memset.element.unordered.atomic.p0.i64(ptr nocapture, i8, i64, i32) nounwind declare void @llvm.memset.element.unordered.atomic.p0.i64(ptr nocapture, i8, i64, i32) nounwind
declare void @llvm.memcpy.p0.p0.i64(ptr nocapture, ptr nocapture, i64, i1) nounwind declare void @llvm.memcpy.p0.p0.i64(ptr nocapture, ptr nocapture, i64, i1) nounwind
▲ Show 20 Lines • Show All 777 Lines • Show Last 20 Lines

llvm/test/Transforms/DeadStoreElimination/operand-bundles.ll

; RUN: opt < %s -basic-aa -dse -S | FileCheck %s ; RUN: opt < %s -dse -S | FileCheck %s
declare noalias ptr @malloc(i64) "malloc-like" declare noalias ptr @malloc(i64) "malloc-like"
declare void @foo() declare void @foo()
declare void @bar(ptr) declare void @bar(ptr)
define void @test() { define void @test() {
%obj = call ptr @malloc(i64 8) %obj = call ptr @malloc(i64 8)
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

llvm/test/Transforms/DeadStoreElimination/overlap.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -dse -S | FileCheck %s ; RUN: opt < %s -dse -S | FileCheck %s
; RUN: opt < %s -aa-pipeline=basic-aa -passes=dse -S | FileCheck %s ; RUN: opt < %s -aa-pipeline=basic-aa -passes=dse -S | FileCheck %s
declare void @use(ptr) declare void @use(ptr)
define void @test1() { define void @test1() {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: [[A:%.*]] = alloca i64, align 8 ; CHECK-NEXT: [[A:%.*]] = alloca i64, align 8
; CHECK-NEXT: call void @use(ptr [[A]]) ; CHECK-NEXT: call void @use(ptr [[A]])
▲ Show 20 Lines • Show All 111 Lines • Show Last 20 Lines

llvm/test/Transforms/DeadStoreElimination/pr11390.ll

; RUN: opt -basic-aa -dse -S < %s | FileCheck %s ; RUN: opt -dse -S < %s | FileCheck %s
; PR11390 ; PR11390
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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define fastcc void @cat_domain(ptr nocapture %name, ptr nocapture %domain, ptr define fastcc void @cat_domain(ptr nocapture %name, ptr nocapture %domain, ptr
nocapture %s) nounwind uwtable { nocapture %s) nounwind uwtable {
entry: entry:
%call = tail call i64 @strlen(ptr %name) nounwind readonly %call = tail call i64 @strlen(ptr %name) nounwind readonly
Show All 29 Lines

llvm/test/Transforms/DeadStoreElimination/scoped-noalias.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S -scoped-noalias-aa -dse < %s | FileCheck %s ; RUN: opt -S -dse < %s | FileCheck %s
; Assume that %p1 != %p2 if and only if %c is true. In that case the noalias ; Assume that %p1 != %p2 if and only if %c is true. In that case the noalias
; metadata is correct, but the first store cannot be eliminated, as it may be ; metadata is correct, but the first store cannot be eliminated, as it may be
; read-clobbered by the load. ; read-clobbered by the load.
define void @test(i1 %c, ptr %p1, ptr %p2) { define void @test(i1 %c, ptr %p1, ptr %p2) {
; CHECK-LABEL: @test( ; CHECK-LABEL: @test(
; CHECK-NEXT: store i8 0, ptr [[P1:%.*]], align 1 ; CHECK-NEXT: store i8 0, ptr [[P1:%.*]], align 1
; CHECK-NEXT: [[TMP1:%.*]] = load i8, ptr [[P2:%.*]], align 1, !alias.scope !0 ; CHECK-NEXT: [[TMP1:%.*]] = load i8, ptr [[P2:%.*]], align 1, !alias.scope !0
Show All 24 Lines

llvm/test/Transforms/DeadStoreElimination/simple.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -dse -S | FileCheck %s ; RUN: opt < %s -dse -S | FileCheck %s
; RUN: opt < %s -aa-pipeline=basic-aa -passes=dse -S | FileCheck %s ; RUN: opt < %s -aa-pipeline=basic-aa -passes=dse -S | FileCheck %s
target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128" target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
declare void @llvm.memset.p0.i64(ptr nocapture, i8, i64, i1) nounwind declare void @llvm.memset.p0.i64(ptr nocapture, i8, i64, i1) nounwind
declare void @llvm.memset.element.unordered.atomic.p0.i64(ptr nocapture, i8, i64, i32) nounwind declare void @llvm.memset.element.unordered.atomic.p0.i64(ptr nocapture, i8, i64, i32) nounwind
declare void @llvm.memcpy.p0.p0.i64(ptr nocapture, ptr nocapture, i64, i1) nounwind declare void @llvm.memcpy.p0.p0.i64(ptr nocapture, ptr nocapture, i64, i1) nounwind
declare void @llvm.memcpy.element.unordered.atomic.p0.p0.i64(ptr nocapture, ptr nocapture, i64, i32) nounwind declare void @llvm.memcpy.element.unordered.atomic.p0.p0.i64(ptr nocapture, ptr nocapture, i64, i32) nounwind
declare void @llvm.init.trampoline(ptr, ptr, ptr) declare void @llvm.init.trampoline(ptr, ptr, ptr)
▲ Show 20 Lines • Show All 783 Lines • Show Last 20 Lines

llvm/test/Transforms/DeadStoreElimination/stats.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -dse -stats -S 2>&1 | FileCheck %s ; RUN: opt < %s -dse -stats -S 2>&1 | FileCheck %s
; REQUIRES: asserts ; REQUIRES: asserts
target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64" target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
define void @test2(ptr noalias %P, ptr noalias %C, i1 %c) { define void @test2(ptr noalias %P, ptr noalias %C, i1 %c) {
; CHECK-LABEL: @test2( ; CHECK-LABEL: @test2(
Show All 26 Lines

llvm/test/Transforms/DeadStoreElimination/stores-of-existing-values.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -basic-aa -dse -dse-optimize-memoryssa=false -S %s | FileCheck --check-prefixes=CHECK,UNOPT %s ; RUN: opt -dse -dse-optimize-memoryssa=false -S %s | FileCheck --check-prefixes=CHECK,UNOPT %s
; RUN: opt -basic-aa -dse -dse-optimize-memoryssa -S %s | FileCheck --check-prefixes=CHECK,OPT %s ; RUN: opt -dse -dse-optimize-memoryssa -S %s | FileCheck --check-prefixes=CHECK,OPT %s
; RUN: opt -basic-aa -dse -S %s | FileCheck --check-prefixes=CHECK,OPT %s ; RUN: opt -dse -S %s | FileCheck --check-prefixes=CHECK,OPT %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 = external global [32 x i8], align 16 @a = external global [32 x i8], align 16
declare void @llvm.memcpy.p0.p0.i64(ptr noalias nocapture writeonly, ptr noalias nocapture readonly, i64, i1 immarg) declare void @llvm.memcpy.p0.p0.i64(ptr noalias nocapture writeonly, ptr noalias nocapture readonly, i64, i1 immarg)
; Test case for PR16520. The store in %if.then is redundant, because the same value ; Test case for PR16520. The store in %if.then is redundant, because the same value
▲ Show 20 Lines • Show All 645 Lines • Show Last 20 Lines

llvm/test/Transforms/FunctionAttrs/2008-09-03-ReadNone.ll

; RUN: opt < %s -basic-aa -function-attrs -S | FileCheck %s ; RUN: opt < %s -function-attrs -S | FileCheck %s
; RUN: opt < %s -aa-pipeline=basic-aa -passes=function-attrs -S | FileCheck %s ; RUN: opt < %s -aa-pipeline=basic-aa -passes=function-attrs -S | FileCheck %s
@x = global i32 0 @x = global i32 0
; CHECK: Function Attrs ; CHECK: Function Attrs
; CHECK-SAME: readnone ; CHECK-SAME: readnone
; CHECK-NEXT: declare i32 @e ; CHECK-NEXT: declare i32 @e
declare i32 @e() readnone declare i32 @e() readnone
Show All 23 Lines

llvm/test/Transforms/FunctionAttrs/2008-12-29-Constant.ll

; RUN: opt < %s -basic-aa -function-attrs -S | FileCheck %s ; RUN: opt < %s -function-attrs -S | FileCheck %s
; RUN: opt < %s -aa-pipeline=basic-aa -passes=function-attrs -S | FileCheck %s ; RUN: opt < %s -aa-pipeline=basic-aa -passes=function-attrs -S | FileCheck %s
@s = external constant i8 ; <i8*> [#uses=1] @s = external constant i8 ; <i8*> [#uses=1]
; CHECK: define i8 @f() #0 ; CHECK: define i8 @f() #0
define i8 @f() { define i8 @f() {
%tmp = load i8, i8* @s ; <i8> [#uses=1] %tmp = load i8, i8* @s ; <i8> [#uses=1]
ret i8 %tmp ret i8 %tmp
} }
; CHECK: attributes #0 = { {{.*}} readnone ; CHECK: attributes #0 = { {{.*}} readnone

llvm/test/Transforms/FunctionAttrs/atomic.ll

; RUN: opt -basic-aa -function-attrs -S < %s | FileCheck %s ; RUN: opt -function-attrs -S < %s | FileCheck %s
; RUN: opt -aa-pipeline=basic-aa -passes=function-attrs -S < %s | FileCheck %s ; RUN: opt -aa-pipeline=basic-aa -passes=function-attrs -S < %s | FileCheck %s
; Atomic load/store to local doesn't affect whether a function is ; Atomic load/store to local doesn't affect whether a function is
; readnone/readonly. ; readnone/readonly.
define i32 @test1(i32 %x) uwtable ssp { define i32 @test1(i32 %x) uwtable ssp {
; CHECK: define i32 @test1(i32 %x) #0 { ; CHECK: define i32 @test1(i32 %x) #0 {
entry: entry:
%x.addr = alloca i32, align 4 %x.addr = alloca i32, align 4
Show All 15 Lines

llvm/test/Transforms/GVN/2007-07-25-InfiniteLoop.ll

; RUN: opt < %s -basic-aa -gvn -S | FileCheck %s ; RUN: opt < %s -gvn -S | FileCheck %s
%struct.INT2 = type { i32, i32 } %struct.INT2 = type { i32, i32 }
@blkshifts = external global %struct.INT2* ; <%struct.INT2**> [#uses=2] @blkshifts = external global %struct.INT2* ; <%struct.INT2**> [#uses=2]
define i32 @xcompact() { define i32 @xcompact() {
entry: entry:
store %struct.INT2* null, %struct.INT2** @blkshifts, align 4 store %struct.INT2* null, %struct.INT2** @blkshifts, align 4
br label %bb br label %bb
bb: ; preds = %bb, %entry bb: ; preds = %bb, %entry
%tmp10 = load %struct.INT2*, %struct.INT2** @blkshifts, align 4 ; <%struct.INT2*> [#uses=0] %tmp10 = load %struct.INT2*, %struct.INT2** @blkshifts, align 4 ; <%struct.INT2*> [#uses=0]
; CHECK-NOT: %tmp10 ; CHECK-NOT: %tmp10
br label %bb br label %bb
} }

llvm/test/Transforms/GVN/2007-07-26-InterlockingLoops.ll

; RUN: opt < %s -basic-aa -gvn -S | FileCheck %s ; RUN: opt < %s -gvn -S | FileCheck %s
@last = external global [65 x i32*] @last = external global [65 x i32*]
define i32 @NextRootMove(i32 %wtm, i32 %x, i32 %y, i32 %z) { define i32 @NextRootMove(i32 %wtm, i32 %x, i32 %y, i32 %z) {
entry: entry:
%A = alloca i32* %A = alloca i32*
%tmp17618 = load i32*, i32** getelementptr ([65 x i32*], [65 x i32*]* @last, i32 0, i32 1), align 4 %tmp17618 = load i32*, i32** getelementptr ([65 x i32*], [65 x i32*]* @last, i32 0, i32 1), align 4
store i32* %tmp17618, i32** %A store i32* %tmp17618, i32** %A
Show All 31 Lines

llvm/test/Transforms/GVN/2007-07-31-NoDomInherit.ll

; RUN: opt < %s -basic-aa -gvn -S | FileCheck %s ; RUN: opt < %s -gvn -S | FileCheck %s
%struct.anon = type { i32 (i32, i32, i32)*, i32, i32, [3 x i32], i8*, i8*, i8* } %struct.anon = type { i32 (i32, i32, i32)*, i32, i32, [3 x i32], i8*, i8*, i8* }
@debug = external constant i32 ; <i32*> [#uses=0] @debug = external constant i32 ; <i32*> [#uses=0]
@counters = external constant i32 ; <i32*> [#uses=1] @counters = external constant i32 ; <i32*> [#uses=1]
@trialx = external global [17 x i32] ; <[17 x i32]*> [#uses=1] @trialx = external global [17 x i32] ; <[17 x i32]*> [#uses=1]
@dummy1 = external global [7 x i32] ; <[7 x i32]*> [#uses=0] @dummy1 = external global [7 x i32] ; <[7 x i32]*> [#uses=0]
@dummy2 = external global [4 x i32] ; <[4 x i32]*> [#uses=0] @dummy2 = external global [4 x i32] ; <[4 x i32]*> [#uses=0]
@unacceptable = external global i32 ; <i32*> [#uses=0] @unacceptable = external global i32 ; <i32*> [#uses=0]
▲ Show 20 Lines • Show All 305 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/2007-07-31-RedundantPhi.ll

; RUN: opt < %s -basic-aa -gvn -S | FileCheck %s ; RUN: opt < %s -gvn -S | FileCheck %s
@img_width = external global i16 ; <i16*> [#uses=2] @img_width = external global i16 ; <i16*> [#uses=2]
define i32 @smpUMHEXBipredIntegerPelBlockMotionSearch(i16* %cur_pic, i16 signext %ref, i32 %list, i32 %pic_pix_x, i32 %pic_pix_y, i32 %blocktype, i16 signext %pred_mv_x1, i16 signext %pred_mv_y1, i16 signext %pred_mv_x2, i16 signext %pred_mv_y2, i16* %mv_x, i16* %mv_y, i16* %s_mv_x, i16* %s_mv_y, i32 %search_range, i32 %min_mcost, i32 %lambda_factor) { define i32 @smpUMHEXBipredIntegerPelBlockMotionSearch(i16* %cur_pic, i16 signext %ref, i32 %list, i32 %pic_pix_x, i32 %pic_pix_y, i32 %blocktype, i16 signext %pred_mv_x1, i16 signext %pred_mv_y1, i16 signext %pred_mv_x2, i16 signext %pred_mv_y2, i16* %mv_x, i16* %mv_y, i16* %s_mv_x, i16* %s_mv_y, i32 %search_range, i32 %min_mcost, i32 %lambda_factor) {
cond_next143: ; preds = %entry cond_next143: ; preds = %entry
store i16 0, i16* @img_width, align 2 store i16 0, i16* @img_width, align 2
br i1 false, label %cond_next449, label %cond_false434 br i1 false, label %cond_next449, label %cond_false434
Show All 14 Lines

llvm/test/Transforms/GVN/2008-07-02-Unreachable.ll

; RUN: opt < %s -basic-aa -gvn -S | FileCheck %s ; RUN: opt < %s -gvn -S | FileCheck %s
; PR2503 ; PR2503
@g_3 = external global i8 ; <i8*> [#uses=2] @g_3 = external global i8 ; <i8*> [#uses=2]
define i8 @func_1(i32 %x, i32 %y) nounwind { define i8 @func_1(i32 %x, i32 %y) nounwind {
entry: entry:
%A = alloca i8 %A = alloca i8
%cmp = icmp eq i32 %x, %y %cmp = icmp eq i32 %x, %y
Show All 27 Lines

llvm/test/Transforms/GVN/2010-03-31-RedundantPHIs.ll

; RUN: opt < %s -basic-aa -gvn -S | FileCheck %s ; RUN: opt < %s -gvn -S | FileCheck %s
; CHECK-NOT: load ; CHECK-NOT: load
; CHECK-NOT: phi ; CHECK-NOT: phi
define i8* @cat(i8* %s1, ...) nounwind { define i8* @cat(i8* %s1, ...) nounwind {
entry: entry:
br i1 undef, label %bb, label %bb3 br i1 undef, label %bb, label %bb3
Show All 33 Lines

llvm/test/Transforms/GVN/2010-11-13-Simplify.ll

; RUN: opt < %s -basic-aa -gvn -S | FileCheck %s ; RUN: opt < %s -gvn -S | FileCheck %s
declare i32 @foo(i32) readnone declare i32 @foo(i32) readnone
define i1 @bar() { define i1 @bar() {
; CHECK-LABEL: @bar( ; CHECK-LABEL: @bar(
%a = call i32 @foo (i32 0) readnone %a = call i32 @foo (i32 0) readnone
%b = call i32 @foo (i32 0) readnone %b = call i32 @foo (i32 0) readnone
%c = and i32 %a, %b %c = and i32 %a, %b
%x = call i32 @foo (i32 %a) readnone %x = call i32 @foo (i32 %a) readnone
%y = call i32 @foo (i32 %c) readnone %y = call i32 @foo (i32 %c) readnone
%z = icmp eq i32 %x, %y %z = icmp eq i32 %x, %y
ret i1 %z ret i1 %z
; CHECK: ret i1 true ; CHECK: ret i1 true
} }

llvm/test/Transforms/GVN/2011-09-07-TypeIdFor.ll

; RUN: opt < %s -basic-aa -gvn -S | FileCheck %s ; RUN: opt < %s -gvn -S | FileCheck %s
%struct.__fundamental_type_info_pseudo = type { %struct.__type_info_pseudo } %struct.__fundamental_type_info_pseudo = type { %struct.__type_info_pseudo }
%struct.__type_info_pseudo = type { i8*, i8* } %struct.__type_info_pseudo = type { i8*, i8* }
@_ZTIi = external constant %struct.__fundamental_type_info_pseudo @_ZTIi = external constant %struct.__fundamental_type_info_pseudo
@_ZTIb = external constant %struct.__fundamental_type_info_pseudo @_ZTIb = external constant %struct.__fundamental_type_info_pseudo
declare void @_Z4barv() declare void @_Z4barv()
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/2016-08-30-MaskedScatterGather-inseltpoison.ll

; RUN: opt < %s -basic-aa -gvn -S | FileCheck %s ; RUN: opt < %s -gvn -S | FileCheck %s
declare void @llvm.masked.scatter.v2i32.v2p0i32(<2 x i32> , <2 x i32*> , i32 , <2 x i1> ) declare void @llvm.masked.scatter.v2i32.v2p0i32(<2 x i32> , <2 x i32*> , i32 , <2 x i1> )
declare <2 x i32> @llvm.masked.gather.v2i32.v2p0i32(<2 x i32*>, i32, <2 x i1>, <2 x i32>) declare <2 x i32> @llvm.masked.gather.v2i32.v2p0i32(<2 x i32*>, i32, <2 x i1>, <2 x i32>)
; This test ensures that masked scatter and gather operations, which take vectors of pointers, ; This test ensures that masked scatter and gather operations, which take vectors of pointers,
; do not have pointer aliasing ignored when being processed. ; do not have pointer aliasing ignored when being processed.
; No scatter/gather calls should end up eliminated ; No scatter/gather calls should end up eliminated
; CHECK: llvm.masked.gather ; CHECK: llvm.masked.gather
Show All 33 Lines

llvm/test/Transforms/GVN/2016-08-30-MaskedScatterGather.ll

; RUN: opt < %s -basic-aa -gvn -S | FileCheck %s ; RUN: opt < %s -gvn -S | FileCheck %s
declare void @llvm.masked.scatter.v2i32.v2p0i32(<2 x i32> , <2 x i32*> , i32 , <2 x i1> ) declare void @llvm.masked.scatter.v2i32.v2p0i32(<2 x i32> , <2 x i32*> , i32 , <2 x i1> )
declare <2 x i32> @llvm.masked.gather.v2i32.v2p0i32(<2 x i32*>, i32, <2 x i1>, <2 x i32>) declare <2 x i32> @llvm.masked.gather.v2i32.v2p0i32(<2 x i32*>, i32, <2 x i1>, <2 x i32>)
; This test ensures that masked scatter and gather operations, which take vectors of pointers, ; This test ensures that masked scatter and gather operations, which take vectors of pointers,
; do not have pointer aliasing ignored when being processed. ; do not have pointer aliasing ignored when being processed.
; No scatter/gather calls should end up eliminated ; No scatter/gather calls should end up eliminated
; CHECK: llvm.masked.gather ; CHECK: llvm.masked.gather
Show All 33 Lines

llvm/test/Transforms/GVN/MemdepMiscompile.ll

; RUN: opt < %s -basic-aa -gvn -S | FileCheck %s ; RUN: opt < %s -gvn -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" 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"
target triple = "x86_64-apple-macosx10.7.0" target triple = "x86_64-apple-macosx10.7.0"
; rdar://12801584 ; rdar://12801584
; Value of %shouldExit can be changed by RunInMode. ; Value of %shouldExit can be changed by RunInMode.
; Make sure we do not replace load %shouldExit in while.cond.backedge ; Make sure we do not replace load %shouldExit in while.cond.backedge
; with a phi node where the value from while.body is 0. ; with a phi node where the value from while.body is 0.
define i32 @test() nounwind ssp { define i32 @test() nounwind ssp {
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/PRE/2011-06-01-NonLocalMemdepMiscompile.ll

; RUN: opt < %s -basic-aa -loops -gvn -S | FileCheck %s ; RUN: opt < %s -passes='require<loops>,gvn' -S | FileCheck %s
; This test is checking that (a) this doesn't crash, and (b) we don't ; This test is checking that (a) this doesn't crash, and (b) we don't
; conclude the value of %tmp17 is available in bb1.bb15_crit_edge. ; conclude the value of %tmp17 is available in bb1.bb15_crit_edge.
; rdar://9429882 ; rdar://9429882
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" 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"
target triple = "x86_64-apple-macosx10.7.0" target triple = "x86_64-apple-macosx10.7.0"
define i1 @rb_intern(i8 *%foo) nounwind ssp { define i1 @rb_intern(i8 *%foo) nounwind ssp {
; CHECK-LABEL: @rb_intern( ; CHECK-LABEL: @rb_intern(
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/PRE/atomic.ll

; RUN: opt -basic-aa -gvn -S < %s | FileCheck %s ; RUN: opt -gvn -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" 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"
target triple = "x86_64-apple-macosx10.7.0" target triple = "x86_64-apple-macosx10.7.0"
@x = common global i32 0, align 4 @x = common global i32 0, align 4
@y = common global i32 0, align 4 @y = common global i32 0, align 4
; GVN across unordered store (allowed) ; GVN across unordered store (allowed)
▲ Show 20 Lines • Show All 494 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/PRE/invariant-load.ll

; Test if the !invariant.load metadata is maintained by GVN. ; Test if the !invariant.load metadata is maintained by GVN.
; RUN: opt -basic-aa -gvn -S < %s | FileCheck %s ; RUN: opt -gvn -S < %s | FileCheck %s
define i32 @test1(i32* nocapture %p, i8* nocapture %q) { define i32 @test1(i32* nocapture %p, i8* nocapture %q) {
; CHECK-LABEL: test1 ; CHECK-LABEL: test1
; CHECK: %x = load i32, i32* %p, align 4, !invariant.load !0 ; CHECK: %x = load i32, i32* %p, align 4, !invariant.load !0
; CHECK-NOT: %y = load ; CHECK-NOT: %y = load
entry: entry:
%x = load i32, i32* %p, align 4, !invariant.load !0 %x = load i32, i32* %p, align 4, !invariant.load !0
%conv = trunc i32 %x to i8 %conv = trunc i32 %x to i8
▲ Show 20 Lines • Show All 126 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/PRE/load-pre-licm.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S -basic-aa -gvn < %s | FileCheck %s ; RUN: opt -S -gvn < %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:128:128-n8:16:32" 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:128:128-n8:16:32"
target triple = "i386-apple-darwin11.0.0" target triple = "i386-apple-darwin11.0.0"
@sortlist = external global [5001 x i32], align 4 @sortlist = external global [5001 x i32], align 4
define void @Bubble() nounwind noinline { define void @Bubble() nounwind noinline {
; CHECK-LABEL: @Bubble( ; CHECK-LABEL: @Bubble(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
▲ Show 20 Lines • Show All 274 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/PRE/load-pre-metadata-accsess-group.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -loops -basic-aa -gvn -enable-split-backedge-in-load-pre -S | FileCheck %s ; RUN: opt < %s -passes='require<loops>,gvn' -enable-split-backedge-in-load-pre -S | FileCheck %s
define dso_local void @test1(i32* nocapture readonly %aa, i32* nocapture %bb) local_unnamed_addr { define dso_local void @test1(i32* nocapture readonly %aa, i32* nocapture %bb) local_unnamed_addr {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[IDX:%.*]] = getelementptr inbounds i32, i32* [[BB:%.*]], i64 1 ; CHECK-NEXT: [[IDX:%.*]] = getelementptr inbounds i32, i32* [[BB:%.*]], i64 1
; CHECK-NEXT: [[IDX2:%.*]] = getelementptr inbounds i32, i32* [[AA:%.*]], i64 1 ; CHECK-NEXT: [[IDX2:%.*]] = getelementptr inbounds i32, i32* [[AA:%.*]], i64 1
; CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* [[IDX2]], align 4 ; CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* [[IDX2]], align 4
; CHECK-NEXT: store i32 [[TMP0]], i32* [[IDX]], align 4 ; CHECK-NEXT: store i32 [[TMP0]], i32* [[IDX]], align 4
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/PRE/load-pre-nonlocal.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S -o - -basic-aa -domtree -gvn %s | FileCheck %s ; RUN: opt -S -o - -gvn %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"
%struct.S1 = type { i32, i32 } %struct.S1 = type { i32, i32 }
@a2 = common global i32* null, align 8 @a2 = common global i32* null, align 8
@a = common global i32* null, align 8 @a = common global i32* null, align 8
@s1 = common global %struct.S1 zeroinitializer, align 8 @s1 = common global %struct.S1 zeroinitializer, align 8
▲ Show 20 Lines • Show All 135 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/PRE/load-pre-split-backedge.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S -basic-aa -gvn -enable-split-backedge-in-load-pre=true < %s | FileCheck %s --check-prefix=ON ; RUN: opt -S -gvn -enable-split-backedge-in-load-pre=true < %s | FileCheck %s --check-prefix=ON
; RUN: opt -S -basic-aa -gvn -enable-split-backedge-in-load-pre=false < %s | FileCheck %s --check-prefix=OFF ; RUN: opt -S -gvn -enable-split-backedge-in-load-pre=false < %s | FileCheck %s --check-prefix=OFF
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:128:128-n8:16:32" 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:128:128-n8:16:32"
define i32 @test(i1 %b, i1 %c, i32* noalias %p, i32* noalias %q) { define i32 @test(i1 %b, i1 %c, i32* noalias %p, i32* noalias %q) {
; ON-LABEL: @test( ; ON-LABEL: @test(
; ON-NEXT: entry: ; ON-NEXT: entry:
; ON-NEXT: [[Y1:%.*]] = load i32, i32* [[P:%.*]], align 4 ; ON-NEXT: [[Y1:%.*]] = load i32, i32* [[P:%.*]], align 4
; ON-NEXT: call void @use(i32 [[Y1]]) ; ON-NEXT: call void @use(i32 [[Y1]])
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/PRE/lpre-call-wrap-2.ll

; RUN: opt -S -basic-aa -gvn -enable-load-pre < %s | FileCheck %s ; RUN: opt -S -gvn -enable-load-pre < %s | FileCheck %s
; ;
; The partially redundant load in bb1 should be hoisted to "bb". This comes ; The partially redundant load in bb1 should be hoisted to "bb". This comes
; from this C code (GCC PR 23455): ; from this C code (GCC PR 23455):
; unsigned outcnt; extern void flush_outbuf(void); ; unsigned outcnt; extern void flush_outbuf(void);
; void bi_windup(unsigned char *outbuf, unsigned char bi_buf) { ; void bi_windup(unsigned char *outbuf, unsigned char bi_buf) {
; outbuf[outcnt] = bi_buf; ; outbuf[outcnt] = bi_buf;
; if (outcnt == 16384) ; if (outcnt == 16384)
; flush_outbuf(); ; flush_outbuf();
Show All 31 Lines

llvm/test/Transforms/GVN/PRE/phi-translate.ll

; RUN: opt -basic-aa -gvn -S < %s | FileCheck %s ; RUN: opt -gvn -S < %s | FileCheck %s
target datalayout = "e-p:64:64:64" target datalayout = "e-p:64:64:64"
; CHECK-LABEL: @foo( ; CHECK-LABEL: @foo(
; CHECK: entry.end_crit_edge: ; CHECK: entry.end_crit_edge:
; CHECK: %[[INDEX:[a-z0-9.]+]] = sext i32 %x to i64{{$}} ; CHECK: %[[INDEX:[a-z0-9.]+]] = sext i32 %x to i64{{$}}
; CHECK: %[[ADDRESS:[a-z0-9.]+]] = getelementptr [100 x i32], [100 x i32]* @G, i64 0, i64 %[[INDEX]]{{$}} ; CHECK: %[[ADDRESS:[a-z0-9.]+]] = getelementptr [100 x i32], [100 x i32]* @G, i64 0, i64 %[[INDEX]]{{$}}
; CHECK: %n.pre = load i32, i32* %[[ADDRESS]], align 4, !dbg [[N_LOC:![0-9]+]] ; CHECK: %n.pre = load i32, i32* %[[ADDRESS]], align 4, !dbg [[N_LOC:![0-9]+]]
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/PRE/pre-after-rle.ll

; RUN: opt -phi-values -gvn -S < %s | FileCheck %s ; RUN: opt -passes='require<phi-values>,gvn' -S < %s | FileCheck %s
declare noalias i8* @malloc(i64) declare noalias i8* @malloc(i64)
; Detecting that %s is fully redundant should let us detect that %w is partially ; Detecting that %s is fully redundant should let us detect that %w is partially
; redundant. ; redundant.
define void @fn1(i32** noalias %start, i32* %width, i32 %h) { define void @fn1(i32** noalias %start, i32* %width, i32 %h) {
; CHECK-LABEL: @fn1 ; CHECK-LABEL: @fn1
entry: entry:
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/PRE/pre-aliasning-path.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -basic-aa -enable-load-pre -enable-pre -gvn -S < %s | FileCheck %s ; RUN: opt -enable-load-pre -enable-pre -gvn -S < %s | FileCheck %s
declare void @side_effect_0() nofree declare void @side_effect_0() nofree
declare void @side_effect_1(i32 %x) nofree declare void @side_effect_1(i32 %x) nofree
declare void @no_side_effect() readonly declare void @no_side_effect() readonly
; TODO: We can PRE the load into the cold path, removing it from the hot path. ; TODO: We can PRE the load into the cold path, removing it from the hot path.
▲ Show 20 Lines • Show All 138 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/PRE/pre-gep-load.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -gvn -enable-load-pre -S | FileCheck %s ; RUN: opt < %s -gvn -enable-load-pre -S | FileCheck %s
; RUN: opt < %s -aa-pipeline=basic-aa -passes=gvn -enable-load-pre -S | FileCheck %s ; RUN: opt < %s -aa-pipeline=basic-aa -passes=gvn -enable-load-pre -S | FileCheck %s
; RUN: opt < %s -aa-pipeline=basic-aa -passes="gvn<load-pre>" -enable-load-pre=false -S | FileCheck %s ; RUN: opt < %s -aa-pipeline=basic-aa -passes="gvn<load-pre>" -enable-load-pre=false -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"
target triple = "aarch64--linux-gnu" target triple = "aarch64--linux-gnu"
define double @foo(i32 %stat, i32 %i, double** %p) { define double @foo(i32 %stat, i32 %i, double** %p) {
; CHECK-LABEL: @foo( ; CHECK-LABEL: @foo(
▲ Show 20 Lines • Show All 118 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/PRE/pre-load-guards.ll

; RUN: opt < %s -basic-aa -gvn -enable-load-pre -S | FileCheck %s ; RUN: opt < %s -gvn -enable-load-pre -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" 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"
declare void @llvm.experimental.guard(i1, ...) declare void @llvm.experimental.guard(i1, ...)
; This is a motivating example on why we prohibit hoisting through guards. ; This is a motivating example on why we prohibit hoisting through guards.
; In the bottom block, we check that the index is within bounds and only access ; In the bottom block, we check that the index is within bounds and only access
; the element in this case and deoptimize otherwise. If we hoist the load to a ; the element in this case and deoptimize otherwise. If we hoist the load to a
; place above the guard, it will may lead to out-of-bound array access. ; place above the guard, it will may lead to out-of-bound array access.
▲ Show 20 Lines • Show All 137 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/PRE/pre-load-in-loop.ll

; RUN: opt < %s -basic-aa -loops -gvn -enable-load-in-loop-pre=false -S | FileCheck %s ; RUN: opt < %s -passes='require<loops>,gvn' -enable-load-in-loop-pre=false -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" 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"
;void test1(int N, double *G) { ;void test1(int N, double *G) {
; int j; ; int j;
; for (j = 0; j < N - 1; j++) ; for (j = 0; j < N - 1; j++)
; G[j] = G[j] + G[j+1]; ; G[j] = G[j] + G[j+1];
;} ;}
Show All 36 Lines

llvm/test/Transforms/GVN/PRE/pre-load.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -gvn -enable-load-pre -S | FileCheck %s ; RUN: opt < %s -gvn -enable-load-pre -S | FileCheck %s
; RUN: opt < %s -aa-pipeline=basic-aa -passes="gvn<load-pre>" -enable-load-pre=false -S | FileCheck %s ; RUN: opt < %s -aa-pipeline=basic-aa -passes="gvn<load-pre>" -enable-load-pre=false -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" 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"
define i32 @test1(i32* %p, i1 %C) { define i32 @test1(i32* %p, i1 %C) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: block1: ; CHECK-NEXT: block1:
; CHECK-NEXT: br i1 [[C:%.*]], label [[BLOCK2:%.*]], label [[BLOCK3:%.*]] ; CHECK-NEXT: br i1 [[C:%.*]], label [[BLOCK2:%.*]], label [[BLOCK3:%.*]]
; CHECK: block2: ; CHECK: block2:
▲ Show 20 Lines • Show All 757 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/PRE/pre-loop-load.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -basic-aa -enable-load-pre -enable-pre -lcssa -gvn -S < %s | FileCheck %s ; RUN: opt -enable-load-pre -enable-pre -lcssa -gvn -S < %s | FileCheck %s
declare void @side_effect() nofree declare void @side_effect() nofree
declare i1 @side_effect_cond() nofree declare i1 @side_effect_cond() nofree
declare void @may_free_memory() declare void @may_free_memory()
declare i32 @personality_function() declare i32 @personality_function()
; We can PRE the load from gc-managed memory away from the hot path. ; We can PRE the load from gc-managed memory away from the hot path.
▲ Show 20 Lines • Show All 931 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/PRE/preserve-tbaa.ll

; RUN: opt -tbaa -basic-aa -gvn -S < %s | FileCheck %s ; RUN: opt -gvn -S < %s | FileCheck %s
target datalayout = "e-p:64:64:64" target datalayout = "e-p:64:64:64"
; GVN should preserve the TBAA tag on loads when doing PRE. ; GVN should preserve the TBAA tag on loads when doing PRE.
; CHECK-LABEL: @test( ; CHECK-LABEL: @test(
; CHECK: %tmp33.pre = load i16, i16* %P, align 2, !tbaa !0 ; CHECK: %tmp33.pre = load i16, i16* %P, align 2, !tbaa !0
; CHECK: br label %for.body ; CHECK: br label %for.body
Show All 22 Lines

llvm/test/Transforms/GVN/PRE/rle-addrspace-cast.ll

; RUN: opt < %s -data-layout="e-p:32:32:32-p1:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-n8:16:32" -basic-aa -gvn -S -dce | FileCheck %s ; RUN: opt < %s -data-layout="e-p:32:32:32-p1:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-n8:16:32" -gvn -S -dce | FileCheck %s
define i8 @coerce_offset0_addrspacecast(i32 %V, i32* %P) { define i8 @coerce_offset0_addrspacecast(i32 %V, i32* %P) {
store i32 %V, i32* %P store i32 %V, i32* %P
%P2 = addrspacecast i32* %P to i8 addrspace(1)* %P2 = addrspacecast i32* %P to i8 addrspace(1)*
%P3 = getelementptr i8, i8 addrspace(1)* %P2, i32 2 %P3 = getelementptr i8, i8 addrspace(1)* %P2, i32 2
%A = load i8, i8 addrspace(1)* %P3 %A = load i8, i8 addrspace(1)* %P3
ret i8 %A ret i8 %A
; CHECK-LABEL: @coerce_offset0_addrspacecast( ; CHECK-LABEL: @coerce_offset0_addrspacecast(
; CHECK-NOT: load ; CHECK-NOT: load
; CHECK: ret i8 ; CHECK: ret i8
} }

llvm/test/Transforms/GVN/PRE/rle-semidominated.ll

; RUN: opt < %s -basic-aa -gvn -S | FileCheck %s ; RUN: opt < %s -gvn -S | FileCheck %s
define i32 @main(i32* %p, i32 %x, i32 %y) { define i32 @main(i32* %p, i32 %x, i32 %y) {
block1: block1:
%z = load i32, i32* %p %z = load i32, i32* %p
%cmp = icmp eq i32 %x, %y %cmp = icmp eq i32 %x, %y
br i1 %cmp, label %block2, label %block3 br i1 %cmp, label %block2, label %block3
block2: block2:
Show All 27 Lines

llvm/test/Transforms/GVN/PRE/rle.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -data-layout="e-p:32:32:32-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-n8:16:32" -basic-aa -gvn -enable-split-backedge-in-load-pre -S -dce | FileCheck %s --check-prefixes=CHECK,LE ; RUN: opt < %s -data-layout="e-p:32:32:32-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-n8:16:32" -gvn -enable-split-backedge-in-load-pre -S -dce | FileCheck %s --check-prefixes=CHECK,LE
; RUN: opt < %s -data-layout="E-p:32:32:32-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-n32" -basic-aa -gvn -enable-split-backedge-in-load-pre -S -dce | FileCheck %s --check-prefixes=CHECK,BE ; RUN: opt < %s -data-layout="E-p:32:32:32-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-n32" -gvn -enable-split-backedge-in-load-pre -S -dce | FileCheck %s --check-prefixes=CHECK,BE
;; Trivial RLE test. ;; Trivial RLE test.
define i32 @test0(i32 %V, i32* %P) { define i32 @test0(i32 %V, i32* %P) {
; CHECK-LABEL: @test0( ; CHECK-LABEL: @test0(
; CHECK-NEXT: store i32 [[V:%.*]], i32* [[P:%.*]], align 4 ; CHECK-NEXT: store i32 [[V:%.*]], i32* [[P:%.*]], align 4
; CHECK-NEXT: ret i32 [[V]] ; CHECK-NEXT: ret i32 [[V]]
; ;
store i32 %V, i32* %P store i32 %V, i32* %P
▲ Show 20 Lines • Show All 1,272 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/PRE/volatile.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; Tests that check our handling of volatile instructions encountered ; Tests that check our handling of volatile instructions encountered
; when scanning for dependencies ; when scanning for dependencies
; RUN: opt -basic-aa -gvn -enable-split-backedge-in-load-pre -S < %s | FileCheck %s ; RUN: opt -gvn -enable-split-backedge-in-load-pre -S < %s | FileCheck %s
; Check that we can bypass a volatile load when searching ; Check that we can bypass a volatile load when searching
; for dependencies of a non-volatile load ; for dependencies of a non-volatile load
define i32 @test1(i32* nocapture %p, i32* nocapture %q) { define i32 @test1(i32* nocapture %p, i32* nocapture %q) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP0:%.*]] = load volatile i32, i32* [[Q:%.*]], align 4 ; CHECK-NEXT: [[TMP0:%.*]] = load volatile i32, i32* [[Q:%.*]], align 4
; CHECK-NEXT: ret i32 0 ; CHECK-NEXT: ret i32 0
▲ Show 20 Lines • Show All 205 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/basic-undef-test.ll

; RUN: opt -basic-aa -gvn -S < %s | FileCheck %s ; RUN: opt -gvn -S < %s | FileCheck %s
; ModuleID = 'test3.ll' ; ModuleID = 'test3.ll'
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"
define i32 @main(i32 *%foo) { define i32 @main(i32 *%foo) {
entry: entry:
; CHECK: load i32, i32* %foo, align 4 ; CHECK: load i32, i32* %foo, align 4
%0 = load i32, i32* %foo, align 4 %0 = load i32, i32* %foo, align 4
store i32 5, i32* undef, align 4 store i32 5, i32* undef, align 4
; CHECK-NOT: load i32, i32* %foo, align 4 ; CHECK-NOT: load i32, i32* %foo, align 4
%1 = load i32, i32* %foo, align 4 %1 = load i32, i32* %foo, align 4
; CHECK: add i32 %0, %0 ; CHECK: add i32 %0, %0
%2 = add i32 %0, %1 %2 = add i32 %0, %1
ret i32 %2 ret i32 %2
} }

llvm/test/Transforms/GVN/calloc-load-removal.ll

; RUN: opt -S -basic-aa -gvn < %s | FileCheck %s ; RUN: opt -S -gvn < %s | FileCheck %s
; Check that loads from calloc are recognized as being zero. ; Check that loads from calloc are recognized as being zero.
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"
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
define i32 @test1() { define i32 @test1() {
%1 = tail call noalias i8* @calloc(i64 1, i64 4) %1 = tail call noalias i8* @calloc(i64 1, i64 4)
%2 = bitcast i8* %1 to i32* %2 = bitcast i8* %1 to i32*
Show All 39 Lines

llvm/test/Transforms/GVN/calls-nonlocal.ll

; Two occurrences of strlen should be zapped. ; Two occurrences of strlen should be zapped.
; RUN: opt < %s -basic-aa -gvn -S | FileCheck %s ; RUN: opt < %s -gvn -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:128:128" 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:128:128"
target triple = "i386-apple-darwin9" target triple = "i386-apple-darwin9"
define i32 @test(i32 %g, i8* %P) nounwind { define i32 @test(i32 %g, i8* %P) nounwind {
entry: entry:
%tmp2 = call i32 @strlen( i8* %P ) nounwind readonly ; <i32> [#uses=1] %tmp2 = call i32 @strlen( i8* %P ) nounwind readonly ; <i32> [#uses=1]
%tmp3 = icmp eq i32 %tmp2, 100 ; <i1> [#uses=1] %tmp3 = icmp eq i32 %tmp2, 100 ; <i1> [#uses=1]
%tmp34 = zext i1 %tmp3 to i8 ; <i8> [#uses=1] %tmp34 = zext i1 %tmp3 to i8 ; <i8> [#uses=1]
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/calls-readonly.ll

; RUN: opt < %s -basic-aa -gvn -S | FileCheck %s ; RUN: opt < %s -gvn -S | FileCheck %s
; Should delete the second call to strlen even though the intervening strchr call exists. ; Should delete the second call to strlen even though the intervening strchr call exists.
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:128:128" 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:128:128"
target triple = "i386-apple-darwin7" target triple = "i386-apple-darwin7"
define i8* @test(i8* %P, i8* %Q, i32 %x, i32 %y) nounwind readonly { define i8* @test(i8* %P, i8* %Q, i32 %x, i32 %y) nounwind readonly {
entry: entry:
%0 = tail call i32 @strlen(i8* %P) ; <i32> [#uses=2] %0 = tail call i32 @strlen(i8* %P) ; <i32> [#uses=2]
Show All 36 Lines

llvm/test/Transforms/GVN/cond_br.ll

; RUN: opt -basic-aa -gvn -S < %s | FileCheck %s ; RUN: opt -gvn -S < %s | FileCheck %s
@y = external global i32 @y = external global i32
@z = external global i32 @z = external global i32
; Function Attrs: nounwind ssp uwtable ; Function Attrs: nounwind ssp uwtable
define void @foo(i32 %x) { define void @foo(i32 %x) {
; CHECK: @foo(i32 %x) ; CHECK: @foo(i32 %x)
; CHECK: %.pre = load i32, i32* @y ; CHECK: %.pre = load i32, i32* @y
; CHECK: call void @bar(i32 %.pre) ; CHECK: call void @bar(i32 %.pre)
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/cond_br2.ll

; RUN: opt -basic-aa -gvn -S < %s | FileCheck %s ; RUN: opt -gvn -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"
%"class.llvm::SmallVector" = type { %"class.llvm::SmallVectorImpl", [1 x %"union.llvm::SmallVectorBase::U"] } %"class.llvm::SmallVector" = type { %"class.llvm::SmallVectorImpl", [1 x %"union.llvm::SmallVectorBase::U"] }
%"class.llvm::SmallVectorImpl" = type { %"class.llvm::SmallVectorTemplateBase" } %"class.llvm::SmallVectorImpl" = type { %"class.llvm::SmallVectorTemplateBase" }
%"class.llvm::SmallVectorTemplateBase" = type { %"class.llvm::SmallVectorTemplateCommon" } %"class.llvm::SmallVectorTemplateBase" = type { %"class.llvm::SmallVectorTemplateCommon" }
%"class.llvm::SmallVectorTemplateCommon" = type { %"class.llvm::SmallVectorBase" } %"class.llvm::SmallVectorTemplateCommon" = type { %"class.llvm::SmallVectorBase" }
%"class.llvm::SmallVectorBase" = type { i8*, i8*, i8*, %"union.llvm::SmallVectorBase::U" } %"class.llvm::SmallVectorBase" = type { i8*, i8*, i8*, %"union.llvm::SmallVectorBase::U" }
%"union.llvm::SmallVectorBase::U" = type { x86_fp80 } %"union.llvm::SmallVectorBase::U" = type { x86_fp80 }
▲ Show 20 Lines • Show All 131 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/condprop.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -gvn -S | FileCheck %s ; RUN: opt < %s -gvn -S | FileCheck %s
@a = external global i32 ; <i32*> [#uses=7] @a = external global i32 ; <i32*> [#uses=7]
define i32 @test1() nounwind { define i32 @test1() nounwind {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* @a, align 4 ; CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* @a, align 4
; CHECK-NEXT: [[TMP1:%.*]] = icmp eq i32 [[TMP0]], 4 ; CHECK-NEXT: [[TMP1:%.*]] = icmp eq i32 [[TMP0]], 4
▲ Show 20 Lines • Show All 605 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/fence.ll

; RUN: opt -S -basic-aa -gvn < %s | FileCheck %s ; RUN: opt -S -gvn < %s | FileCheck %s
@a = external constant i32 @a = external constant i32
; We can value forward across the fence since we can (semantically) ; We can value forward across the fence since we can (semantically)
; reorder the following load before the fence. ; reorder the following load before the fence.
define i32 @test(i32* %addr.i) { define i32 @test(i32* %addr.i) {
; CHECK-LABEL: @test ; CHECK-LABEL: @test
; CHECK: store ; CHECK: store
; CHECK: fence ; CHECK: fence
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/funclet.ll

; RUN: opt -basic-aa -gvn -S < %s | FileCheck %s ; RUN: opt -gvn -S < %s | FileCheck %s
target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32" target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
target triple = "i686-pc-windows-msvc" target triple = "i686-pc-windows-msvc"
%eh.ThrowInfo = type { i32, i8*, i8*, i8* } %eh.ThrowInfo = type { i32, i8*, i8*, i8* }
%struct.A = type { i32* } %struct.A = type { i32* }
@"_TI1?AUA@@" = external constant %eh.ThrowInfo @"_TI1?AUA@@" = external constant %eh.ThrowInfo
Show All 35 Lines

llvm/test/Transforms/GVN/gc_relocate.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -basic-aa -gvn -S < %s | FileCheck %s ; RUN: opt -gvn -S < %s | FileCheck %s
declare void @func() declare void @func()
declare i32 @"personality_function"() declare i32 @"personality_function"()
define i1 @test_trivial(i32 addrspace(1)* %in) gc "statepoint-example" { define i1 @test_trivial(i32 addrspace(1)* %in) gc "statepoint-example" {
; CHECK-LABEL: @test_trivial( ; CHECK-LABEL: @test_trivial(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[SAFEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void ()* elementtype(void ()) @func, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(i32 addrspace(1)* [[IN:%.*]]) ] ; CHECK-NEXT: [[SAFEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void ()* elementtype(void ()) @func, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(i32 addrspace(1)* [[IN:%.*]]) ]
▲ Show 20 Lines • Show All 146 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/gvn-loop-load-pre-order.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -loops -gvn -S | FileCheck -check-prefix=CHECK-PRE %s ; RUN: opt < %s -passes='require<loops>,gvn' -S | FileCheck -check-prefix=CHECK-PRE %s
; RUN: opt < %s -loops -gvn -sccp -S | FileCheck -check-prefix=CHECK-SCCP %s ; RUN: opt < %s -passes='require<loops>,gvn,sccp' -S | FileCheck -check-prefix=CHECK-SCCP %s
@b = external global i32, align 4 @b = external global i32, align 4
define void @main(i1 %cond) { define void @main(i1 %cond) {
; CHECK-PRE-LABEL: @main( ; CHECK-PRE-LABEL: @main(
; CHECK-PRE-NEXT: entry: ; CHECK-PRE-NEXT: entry:
; CHECK-PRE-NEXT: store i32 0, i32* @b, align 4 ; CHECK-PRE-NEXT: store i32 0, i32* @b, align 4
; CHECK-PRE-NEXT: br label [[WHILE_BODY3:%.*]] ; CHECK-PRE-NEXT: br label [[WHILE_BODY3:%.*]]
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/lifetime-simple.ll

; RUN: opt < %s -basic-aa -gvn -S | FileCheck %s ; RUN: opt < %s -gvn -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:128:128" 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:128:128"
target triple = "i386-apple-darwin7" target triple = "i386-apple-darwin7"
define i8 @test(i8* %P) nounwind { define i8 @test(i8* %P) nounwind {
; CHECK: lifetime.start ; CHECK: lifetime.start
; CHECK-NOT: load ; CHECK-NOT: load
; CHECK: lifetime.end ; CHECK: lifetime.end
Show All 11 Lines

llvm/test/Transforms/GVN/load-constant-mem.ll

; RUN: opt < %s -basic-aa -gvn -instcombine -S | FileCheck %s ; RUN: opt < %s -gvn -instcombine -S | FileCheck %s
; PR4189 ; PR4189
@G = external constant [4 x i32] @G = external constant [4 x i32]
define i32 @test(i8* %p, i32 %i) nounwind { define i32 @test(i8* %p, i32 %i) nounwind {
entry: entry:
%P = getelementptr [4 x i32], [4 x i32]* @G, i32 0, i32 %i %P = getelementptr [4 x i32], [4 x i32]* @G, i32 0, i32 %i
%A = load i32, i32* %P %A = load i32, i32* %P
store i8 4, i8* %p store i8 4, i8* %p
Show All 10 Lines

llvm/test/Transforms/GVN/loadpre-context.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -gvn --basic-aa -S | FileCheck %s ; RUN: opt < %s -gvn -S | FileCheck %s
; load may be speculated, address is not null using context search. ; load may be speculated, address is not null using context search.
; There is a critical edge. ; There is a critical edge.
define i32 @loadpre_critical_edge(i32* align 8 dereferenceable_or_null(48) %arg, i32 %N) nofree nosync { define i32 @loadpre_critical_edge(i32* align 8 dereferenceable_or_null(48) %arg, i32 %N) nofree nosync {
; CHECK-LABEL: @loadpre_critical_edge( ; CHECK-LABEL: @loadpre_critical_edge(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32* [[ARG:%.*]], null ; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32* [[ARG:%.*]], null
; CHECK-NEXT: br i1 [[CMP]], label [[NULL_EXIT:%.*]], label [[ENTRY_HEADER_CRIT_EDGE:%.*]] ; CHECK-NEXT: br i1 [[CMP]], label [[NULL_EXIT:%.*]], label [[ENTRY_HEADER_CRIT_EDGE:%.*]]
▲ Show 20 Lines • Show All 141 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/malloc-load-removal.ll

; RUN: opt -S -basic-aa -gvn < %s | FileCheck %s ; RUN: opt -S -gvn < %s | FileCheck %s
; PR13694 ; PR13694
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"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
declare noalias i8* @malloc(i64) nounwind allockind("alloc,uninitialized") allocsize(0) declare noalias i8* @malloc(i64) nounwind allockind("alloc,uninitialized") allocsize(0)
define noalias i8* @test1() nounwind uwtable ssp { define noalias i8* @test1() nounwind uwtable ssp {
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/noalias.ll

; RUN: opt -scoped-noalias-aa -basic-aa -gvn -S < %s | FileCheck %s ; RUN: opt -gvn -S < %s | FileCheck %s
define i32 @test1(i32* %p, i32* %q) { define i32 @test1(i32* %p, i32* %q) {
; CHECK-LABEL: @test1(i32* %p, i32* %q) ; CHECK-LABEL: @test1(i32* %p, i32* %q)
; CHECK: load i32, i32* %p ; CHECK: load i32, i32* %p
; CHECK-NOT: noalias ; CHECK-NOT: noalias
; CHECK: %c = add i32 %a, %a ; CHECK: %c = add i32 %a, %a
%a = load i32, i32* %p, !noalias !3 %a = load i32, i32* %p, !noalias !3
%b = load i32, i32* %p %b = load i32, i32* %p
Show All 35 Lines

llvm/test/Transforms/GVN/non-local-offset.ll

; RUN: opt -basic-aa -gvn -S < %s | FileCheck %s ; RUN: opt -gvn -S < %s | FileCheck %s
target datalayout = "e-p:64:64:64" target datalayout = "e-p:64:64:64"
; GVN should ignore the store to p[1] to see that the load from p[0] is ; GVN should ignore the store to p[1] to see that the load from p[0] is
; fully redundant. ; fully redundant.
; CHECK-LABEL: @yes( ; CHECK-LABEL: @yes(
; CHECK: if.then: ; CHECK: if.then:
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/nonescaping-malloc.ll

; REQUIRES: asserts ; REQUIRES: asserts
; RUN: opt < %s -basic-aa -gvn -stats -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -gvn -stats -disable-output 2>&1 | FileCheck %s
; rdar://7363102 ; rdar://7363102
; CHECK: Number of loads deleted ; CHECK: Number of loads deleted
; GVN should be able to eliminate load %tmp22.i, because it is redundant with ; GVN should be able to eliminate load %tmp22.i, because it is redundant with
; load %tmp8.i. This requires being able to prove that %tmp7.i doesn't ; load %tmp8.i. This requires being able to prove that %tmp7.i doesn't
; alias the malloc'd value %tmp.i20.i.i, which it can do since %tmp7.i ; alias the malloc'd value %tmp.i20.i.i, which it can do since %tmp7.i
; is derived from %tmp5.i which is computed from a load, and %tmp.i20.i.i ; is derived from %tmp5.i which is computed from a load, and %tmp.i20.i.i
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/nonescaping.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -S -basic-aa -gvn 2>&1 | FileCheck %s ; RUN: opt < %s -S -gvn 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" 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"
target triple = "x86_64-apple-darwin10.0" target triple = "x86_64-apple-darwin10.0"
declare noalias i8* @malloc(i64) nounwind allockind("alloc,uninitialized") allocsize(0) inaccessiblememonly declare noalias i8* @malloc(i64) nounwind allockind("alloc,uninitialized") allocsize(0) inaccessiblememonly
declare noalias i8* @calloc(i64, i64) allockind("alloc,zeroed") allocsize(0,1) inaccessiblememonly declare noalias i8* @calloc(i64, i64) allockind("alloc,zeroed") allocsize(0,1) inaccessiblememonly
declare noalias i8* @_Znwm(i64) declare noalias i8* @_Znwm(i64)
declare void @escape(i8*) declare void @escape(i8*)
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/null-aliases-nothing.ll

; RUN: opt < %s -basic-aa -gvn -S | FileCheck %s ; RUN: opt < %s -gvn -S | FileCheck %s
%t = type { i32 } %t = type { i32 }
declare void @test1f(i8*) declare void @test1f(i8*)
define void @test1(%t* noalias %stuff ) { define void @test1(%t* noalias %stuff ) {
%p = getelementptr inbounds %t, %t* %stuff, i32 0, i32 0 %p = getelementptr inbounds %t, %t* %stuff, i32 0, i32 0
%before = load i32, i32* %p %before = load i32, i32* %p
Show All 11 Lines

llvm/test/Transforms/GVN/phi-translate-partial-alias.ll

; RUN: opt -basic-aa -gvn -S < %s | FileCheck %s ; RUN: opt -gvn -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-f128:128:128-n8:16:32:64" 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-f128:128:128-n8:16:32:64"
; GVN shouldn't PRE the load around the loop backedge because it's ; GVN shouldn't PRE the load around the loop backedge because it's
; not actually redundant around the loop backedge, despite appearances ; not actually redundant around the loop backedge, despite appearances
; if phi-translation is ignored. ; if phi-translation is ignored.
; CHECK: define void @test0(i8* %begin) ; CHECK: define void @test0(i8* %begin)
Show All 18 Lines

llvm/test/Transforms/GVN/pr10820.ll

; RUN: opt < %s -basic-aa -gvn -S | FileCheck %s ; RUN: opt < %s -gvn -S | FileCheck %s
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-f128:128:128-n8:16:32:64" "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-f128:128:128-n8:16:32:64"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
@g = external global i31 @g = external global i31
define void @main() nounwind uwtable { define void @main() nounwind uwtable {
Show All 9 Lines

llvm/test/Transforms/GVN/pr17852.ll

; RUN: opt < %s -basic-aa -gvn ; RUN: opt < %s -gvn
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.S0 = type { [2 x i8], [2 x i8], [4 x i8], [2 x i8], i32, i32, i32, i32 } %struct.S0 = type { [2 x i8], [2 x i8], [4 x i8], [2 x i8], i32, i32, i32, i32 }
define void @fn1(%struct.S0* byval(%struct.S0) align 8 %p1) { define void @fn1(%struct.S0* byval(%struct.S0) align 8 %p1) {
br label %for.cond br label %for.cond
for.cond: ; preds = %1, %0 for.cond: ; preds = %1, %0
br label %for.end br label %for.end
%f2 = getelementptr inbounds %struct.S0, %struct.S0* %p1, i64 0, i32 2 %f2 = getelementptr inbounds %struct.S0, %struct.S0* %p1, i64 0, i32 2
%f9 = getelementptr inbounds %struct.S0, %struct.S0* %p1, i64 0, i32 7 %f9 = getelementptr inbounds %struct.S0, %struct.S0* %p1, i64 0, i32 7
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/pr24397.ll

; RUN: opt -basic-aa -gvn -disable-output < %s ; RUN: opt -gvn -disable-output < %s
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define i64 @foo(i64** %arrayidx) { define i64 @foo(i64** %arrayidx) {
entry: entry:
%p = load i64*, i64** %arrayidx, align 8 %p = load i64*, i64** %arrayidx, align 8
%cmpnull = icmp eq i64* %p, null %cmpnull = icmp eq i64* %p, null
br label %BB2 br label %BB2
Show All 9 Lines

llvm/test/Transforms/GVN/pre-new-inst.ll

; RUN: opt -basic-aa -gvn -S %s | FileCheck %s ; RUN: opt -gvn -S %s | FileCheck %s
%MyStruct = type { i32, i32 } %MyStruct = type { i32, i32 }
define i8 @foo(i64 %in, i8* %arr) { define i8 @foo(i64 %in, i8* %arr) {
%addr = alloca %MyStruct %addr = alloca %MyStruct
%dead = trunc i64 %in to i32 %dead = trunc i64 %in to i32
br i1 undef, label %next, label %tmp br i1 undef, label %next, label %tmp
tmp: tmp:
Show All 20 Lines

llvm/test/Transforms/GVN/range.ll

; RUN: opt -basic-aa -gvn -S < %s | FileCheck %s ; RUN: opt -gvn -S < %s | FileCheck %s
define i32 @test1(i32* %p) { define i32 @test1(i32* %p) {
; CHECK-LABEL: @test1(i32* %p) ; CHECK-LABEL: @test1(i32* %p)
; CHECK: %a = load i32, i32* %p, align 4, !range ![[RANGE0:[0-9]+]] ; CHECK: %a = load i32, i32* %p, align 4, !range ![[RANGE0:[0-9]+]]
; CHECK: %c = add i32 %a, %a ; CHECK: %c = add i32 %a, %a
%a = load i32, i32* %p, !range !0 %a = load i32, i32* %p, !range !0
%b = load i32, i32* %p, !range !0 %b = load i32, i32* %p, !range !0
%c = add i32 %a, %b %c = add i32 %a, %b
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/rle-must-alias.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -gvn -S | FileCheck %s ; RUN: opt < %s -gvn -S | FileCheck %s
; GVN should eliminate the fully redundant %9 GEP which ; GVN should eliminate the fully redundant %9 GEP which
; allows DEAD to be removed. This is PR3198. ; allows DEAD to be removed. This is PR3198.
; The %7 and %4 loads combine to make %DEAD unneeded. ; The %7 and %4 loads combine to make %DEAD unneeded.
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:128:128" 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:128:128"
target triple = "i386-apple-darwin7" target triple = "i386-apple-darwin7"
@H = common global [100 x i32] zeroinitializer, align 32 ; <[100 x i32]*> [#uses=3] @H = common global [100 x i32] zeroinitializer, align 32 ; <[100 x i32]*> [#uses=3]
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/rle-nonlocal.ll

; RUN: opt < %s -basic-aa -gvn -S | FileCheck %s ; RUN: opt < %s -gvn -S | FileCheck %s
define i32 @main(i32** %p, i32 %x, i32 %y) { define i32 @main(i32** %p, i32 %x, i32 %y) {
block1: block1:
%cmp = icmp eq i32 %x, %y %cmp = icmp eq i32 %x, %y
br i1 %cmp , label %block2, label %block3 br i1 %cmp , label %block2, label %block3
block2: block2:
%a = load i32*, i32** %p %a = load i32*, i32** %p
Show All 16 Lines

llvm/test/Transforms/GVN/stale-loop-info.ll

; RUN: opt -loops -gvn -S < %s | FileCheck %s ; RUN: opt -passes='require<loops>,gvn' -S < %s | FileCheck %s
; This used to fail with ASAN enabled and if for some reason LoopInfo remained ; This used to fail with ASAN enabled and if for some reason LoopInfo remained
; available during GVN. In this case BasicAA will use LI but ; available during GVN. In this case BasicAA will use LI but
; MergeBlockIntoPredecessor in GVN failed to update LI. ; MergeBlockIntoPredecessor in GVN failed to update LI.
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"
%struct.wibble.1028 = type { i32, i32, %struct.barney.881 } %struct.wibble.1028 = type { i32, i32, %struct.barney.881 }
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/tbaa.ll

; RUN: opt -tbaa -basic-aa -gvn -S < %s | FileCheck %s ; RUN: opt -gvn -S < %s | FileCheck %s
define i32 @test1(i8* %p, i8* %q) { define i32 @test1(i8* %p, i8* %q) {
; CHECK-LABEL: @test1(i8* %p, i8* %q) ; CHECK-LABEL: @test1(i8* %p, i8* %q)
; CHECK: call i32 @foo(i8* %p) ; CHECK: call i32 @foo(i8* %p)
; CHECK-NOT: tbaa ; CHECK-NOT: tbaa
; CHECK: %c = add i32 %a, %a ; CHECK: %c = add i32 %a, %a
%a = call i32 @foo(i8* %p), !tbaa !0 %a = call i32 @foo(i8* %p), !tbaa !0
%b = call i32 @foo(i8* %p) %b = call i32 @foo(i8* %p)
▲ Show 20 Lines • Show All 139 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/unreachable_block_infinite_loop.ll

; RUN: opt -memdep -gvn -disable-output < %s ; RUN: opt -gvn -disable-output < %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" 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"
target triple = "x86_64-apple-darwin10.0" target triple = "x86_64-apple-darwin10.0"
define i32 @test2() nounwind ssp { define i32 @test2() nounwind ssp {
entry: entry:
ret i32 0 ret i32 0
Show All 34 Lines

llvm/test/Transforms/GVN/volatile-nonvolatile.ll

; RUN: opt -tbaa -gvn -S < %s | FileCheck %s ; RUN: opt -gvn -S < %s | FileCheck %s
%struct.t = type { i32* } %struct.t = type { i32* }
; The loaded address and the location of the address itself are not aliased, ; The loaded address and the location of the address itself are not aliased,
; so the second reload is not necessary. Check that it can be eliminated. ; so the second reload is not necessary. Check that it can be eliminated.
; CHECK-LABEL: test1 ; CHECK-LABEL: test1
; CHECK: load ; CHECK: load
; CHECK-NOT: load ; CHECK-NOT: load
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/vscale.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S < %s -basic-aa -gvn -dce | FileCheck %s ; RUN: opt -S < %s -gvn -dce | FileCheck %s
; Analyze Load from clobbering Load. ; Analyze Load from clobbering Load.
define <vscale x 4 x i32> @load_store_clobber_load(<vscale x 4 x i32> *%p) { define <vscale x 4 x i32> @load_store_clobber_load(<vscale x 4 x i32> *%p) {
; CHECK-LABEL: @load_store_clobber_load( ; CHECK-LABEL: @load_store_clobber_load(
; CHECK-NEXT: [[LOAD1:%.*]] = load <vscale x 4 x i32>, <vscale x 4 x i32>* [[P:%.*]], align 16 ; CHECK-NEXT: [[LOAD1:%.*]] = load <vscale x 4 x i32>, <vscale x 4 x i32>* [[P:%.*]], align 16
; CHECK-NEXT: store <vscale x 4 x i32> zeroinitializer, <vscale x 4 x i32>* undef, align 16 ; CHECK-NEXT: store <vscale x 4 x i32> zeroinitializer, <vscale x 4 x i32>* undef, align 16
; CHECK-NEXT: [[ADD:%.*]] = add <vscale x 4 x i32> [[LOAD1]], [[LOAD1]] ; CHECK-NEXT: [[ADD:%.*]] = add <vscale x 4 x i32> [[LOAD1]], [[LOAD1]]
▲ Show 20 Lines • Show All 392 Lines • Show Last 20 Lines

llvm/test/Transforms/IndVarSimplify/loop_evaluate11.ll

; RUN: opt < %s -domfrontier -indvars -loop-deletion ; RUN: opt < %s -indvars -loop-deletion
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:128:128" 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:128:128"
define void @slap_sl_mem_create() nounwind { define void @slap_sl_mem_create() nounwind {
entry: entry:
br label %bb15 br label %bb15
bb15: ; preds = %bb15, %entry bb15: ; preds = %bb15, %entry
Show All 27 Lines

llvm/test/Transforms/Inline/byval-tail-call.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -tailcallelim -inline -instcombine -dse -S | FileCheck %s ; RUN: opt < %s -tailcallelim -inline -instcombine -dse -S | FileCheck %s
; RUN: opt < %s -aa-pipeline=basic-aa -passes='function(tailcallelim),cgscc(inline,function(instcombine,dse))' -S | FileCheck %s ; RUN: opt < %s -aa-pipeline=basic-aa -passes='function(tailcallelim),cgscc(inline,function(instcombine,dse))' -S | FileCheck %s
; PR7272 ; PR7272
; Calls that capture byval parameters cannot be marked as tail calls. Other ; Calls that capture byval parameters cannot be marked as tail calls. Other
; tails that don't capture byval parameters can still be tail calls. ; tails that don't capture byval parameters can still be tail calls.
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" 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"
target triple = "i386-pc-linux-gnu" target triple = "i386-pc-linux-gnu"
▲ Show 20 Lines • Show All 95 Lines • Show Last 20 Lines

llvm/test/Transforms/Inline/noalias-calls.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature
; RUN: opt -basic-aa -inline -enable-noalias-to-md-conversion -S < %s | FileCheck %s ; RUN: opt -inline -enable-noalias-to-md-conversion -S < %s | FileCheck %s
; RUN: opt -aa-pipeline=basic-aa -passes=inline -enable-noalias-to-md-conversion -S < %s | FileCheck %s ; RUN: opt -aa-pipeline=basic-aa -passes=inline -enable-noalias-to-md-conversion -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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture readonly, i64, i1) #0 declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture readonly, i64, i1) #0
declare void @hey() #0 declare void @hey() #0
define void @hello(i8* noalias nocapture %a, i8* noalias nocapture readonly %c, i8* nocapture %b) #1 { define void @hello(i8* noalias nocapture %a, i8* noalias nocapture readonly %c, i8* nocapture %b) #1 {
▲ Show 20 Lines • Show All 103 Lines • Show Last 20 Lines

llvm/test/Transforms/Inline/noalias-calls2.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature
; RUN: opt -basic-aa -inline -enable-noalias-to-md-conversion -S < %s | FileCheck %s ; RUN: opt -inline -enable-noalias-to-md-conversion -S < %s | FileCheck %s
; RUN: opt -aa-pipeline=basic-aa -passes=inline -enable-noalias-to-md-conversion -S < %s | FileCheck %s ; RUN: opt -aa-pipeline=basic-aa -passes=inline -enable-noalias-to-md-conversion -S < %s | FileCheck %s
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
declare void @llvm.experimental.noalias.scope.decl(metadata) #0 declare void @llvm.experimental.noalias.scope.decl(metadata) #0
define void @caller_equals_callee(i32* noalias %p0, i32* noalias %p1, i32 %cnt) { define void @caller_equals_callee(i32* noalias %p0, i32* noalias %p1, i32 %cnt) {
▲ Show 20 Lines • Show All 152 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/assume-loop-align.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -domtree -instcombine -loops -S < %s | FileCheck %s ; RUN: opt -passes='require<domtree>,instcombine,require<domtree>' -S < %s | FileCheck %s
; Note: The -loops above can be anything that requires the domtree, and is ; Note: The -loops above can be anything that requires the domtree, and is
; necessary to work around a pass-manager bug. ; necessary to work around a pass-manager bug.
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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
define void @foo(ptr %a, ptr %b) #0 { define void @foo(ptr %a, ptr %b) #0 {
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/assume-redundant.ll

; RUN: opt -domtree -instcombine -loops -S < %s | FileCheck %s ; RUN: opt -passes='require<domtree>,instcombine,require<domtree>' -S < %s | FileCheck %s
; Note: The -loops above can be anything that requires the domtree, and is ; Note: The -loops above can be anything that requires the domtree, and is
; necessary to work around a pass-manager bug. ; necessary to work around a pass-manager bug.
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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
%struct.s = type { ptr } %struct.s = type { ptr }
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/load-no-aliasing.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -tbaa -instcombine -S < %s | FileCheck %s ; RUN: opt -instcombine -S < %s | FileCheck %s
; Check that load to load forwarding works with non aliasing store inbetween. ; Check that load to load forwarding works with non aliasing store inbetween.
define i32 @test_load_store_load_combine(ptr, ptr) { define i32 @test_load_store_load_combine(ptr, ptr) {
; CHECK-LABEL: @test_load_store_load_combine( ; CHECK-LABEL: @test_load_store_load_combine(
; CHECK-NEXT: [[A:%.*]] = load i32, ptr [[TMP0:%.*]], align 4, !tbaa [[TBAA0:![0-9]+]] ; CHECK-NEXT: [[A:%.*]] = load i32, ptr [[TMP0:%.*]], align 4, !tbaa [[TBAA0:![0-9]+]]
; CHECK-NEXT: [[F:%.*]] = sitofp i32 [[A]] to float ; CHECK-NEXT: [[F:%.*]] = sitofp i32 [[A]] to float
; CHECK-NEXT: store float [[F]], ptr [[TMP1:%.*]], align 4, !tbaa [[TBAA4:![0-9]+]] ; CHECK-NEXT: store float [[F]], ptr [[TMP1:%.*]], align 4, !tbaa [[TBAA4:![0-9]+]]
; CHECK-NEXT: ret i32 [[A]] ; CHECK-NEXT: ret i32 [[A]]
Show All 14 Lines

llvm/test/Transforms/InstCombine/load_combine_aa.ll

; RUN: opt -basic-aa -instcombine -S < %s | FileCheck %s ; RUN: opt -instcombine -S < %s | FileCheck %s
; CHECK-LABEL: @test_load_combine_aa( ; CHECK-LABEL: @test_load_combine_aa(
; CHECK: %[[V:.*]] = load i32, ptr %0 ; CHECK: %[[V:.*]] = load i32, ptr %0
; CHECK: store i32 0, ptr %3 ; CHECK: store i32 0, ptr %3
; CHECK: store i32 %[[V]], ptr %1 ; CHECK: store i32 %[[V]], ptr %1
; CHECK: store i32 %[[V]], ptr %2 ; CHECK: store i32 %[[V]], ptr %2
define void @test_load_combine_aa(ptr, ptr, ptr, ptr noalias) { define void @test_load_combine_aa(ptr, ptr, ptr, ptr noalias) {
%a = load i32, ptr %0 %a = load i32, ptr %0
store i32 0, ptr %3 store i32 0, ptr %3
%b = load i32, ptr %0 %b = load i32, ptr %0
store i32 %a, ptr %1 store i32 %a, ptr %1
store i32 %b, ptr %2 store i32 %b, ptr %2
ret void ret void
} }

llvm/test/Transforms/InstCombine/pr30929.ll

; We need this pipeline because to trigger dominator info verification ; We need this pipeline because to trigger dominator info verification
; we have to compute the dominator before libcalls-shrinkwrap and ; we have to compute the dominator before libcalls-shrinkwrap and
; have a pass which requires the dominator tree after. ; have a pass which requires the dominator tree after.
; RUN: opt -domtree -libcalls-shrinkwrap -instcombine -verify-dom-info %s ; RUN: opt -libcalls-shrinkwrap -instcombine -verify-dom-info %s
define void @main() { define void @main() {
%_tmp31 = call float @acosf(float 2.000000e+00) %_tmp31 = call float @acosf(float 2.000000e+00)
ret void ret void
} }
declare float @acosf(float) declare float @acosf(float)

llvm/test/Transforms/InstMerge/exceptions.ll

; RUN: opt -basic-aa -memdep -mldst-motion -S < %s | FileCheck %s ; RUN: opt -mldst-motion -S < %s | FileCheck %s
; RUN: opt -aa-pipeline=basic-aa -passes='require<memdep>',mldst-motion \ ; RUN: opt -aa-pipeline=basic-aa -passes='require<memdep>',mldst-motion \
; RUN: -S < %s | FileCheck %s ; RUN: -S < %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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
@r = common global i32 0, align 4 @r = common global i32 0, align 4
@s = common global i32 0, align 4 @s = common global i32 0, align 4
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

llvm/test/Transforms/InstMerge/st_sink_barrier_call.ll

; Test to make sure that a function call that needs to be a barrier to sinking stores is indeed a barrier. ; Test to make sure that a function call that needs to be a barrier to sinking stores is indeed a barrier.
; Stores sunks into the footer. ; Stores sunks into the footer.
; RUN: opt -basic-aa -memdep -mldst-motion -S < %s | FileCheck %s ; RUN: opt -mldst-motion -S < %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"
%struct.node = type { i32, %struct.node*, %struct.node*, %struct.node*, i32, i32, i32, i32 } %struct.node = type { i32, %struct.node*, %struct.node*, %struct.node*, i32, i32, i32, i32 }
declare i32 @foo(i32 %x) declare i32 @foo(i32 %x)
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
define void @sink_store(%struct.node* nocapture %r, i32 %index) { define void @sink_store(%struct.node* nocapture %r, i32 %index) {
Show All 32 Lines

llvm/test/Transforms/InstMerge/st_sink_no_barrier_call.ll

; Test to make sure that stores in a diamond get merged with a non barrier function call after the store instruction ; Test to make sure that stores in a diamond get merged with a non barrier function call after the store instruction
; Stores sunks into the footer. ; Stores sunks into the footer.
; RUN: opt -basic-aa -memdep -mldst-motion -S < %s | FileCheck %s ; RUN: opt -mldst-motion -S < %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"
%struct.node = type { i32, %struct.node*, %struct.node*, %struct.node*, i32, i32, i32, i32 } %struct.node = type { i32, %struct.node*, %struct.node*, %struct.node*, i32, i32, i32, i32 }
declare i32 @foo(i32 %x) #0 declare i32 @foo(i32 %x) #0
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
define void @sink_store(%struct.node* nocapture %r, i32 %index) { define void @sink_store(%struct.node* nocapture %r, i32 %index) {
Show All 34 Lines

llvm/test/Transforms/InstMerge/st_sink_no_barrier_load.ll

; Test to make sure that stores in a diamond get merged with a non barrier load after the store instruction ; Test to make sure that stores in a diamond get merged with a non barrier load after the store instruction
; Stores sunks into the footer. ; Stores sunks into the footer.
; RUN: opt -basic-aa -memdep -mldst-motion -S < %s | FileCheck %s ; RUN: opt -mldst-motion -S < %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"
%struct.node = type { i32, %struct.node*, %struct.node*, %struct.node*, i32, i32, i32, i32 } %struct.node = type { i32, %struct.node*, %struct.node*, %struct.node*, i32, i32, i32, i32 }
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
define void @sink_store(%struct.node* nocapture %r, i32 %index) { define void @sink_store(%struct.node* nocapture %r, i32 %index) {
entry: entry:
%node.0.in16 = getelementptr inbounds %struct.node, %struct.node* %r, i64 0, i32 2 %node.0.in16 = getelementptr inbounds %struct.node, %struct.node* %r, i64 0, i32 2
Show All 32 Lines

llvm/test/Transforms/InstMerge/st_sink_no_barrier_store.ll

; Test to make sure that stores in a diamond get merged with a non barrier store after the store instruction to be sunk ; Test to make sure that stores in a diamond get merged with a non barrier store after the store instruction to be sunk
; Stores sunks into the footer. ; Stores sunks into the footer.
; RUN: opt -basic-aa -memdep -mldst-motion -S < %s | FileCheck %s ; RUN: opt -mldst-motion -S < %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"
%struct.node = type { i32, %struct.node*, %struct.node*, %struct.node*, i32, i32, i32, i32 } %struct.node = type { i32, %struct.node*, %struct.node*, %struct.node*, i32, i32, i32, i32 }
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
define void @sink_store(%struct.node* nocapture %r, i32 %index) { define void @sink_store(%struct.node* nocapture %r, i32 %index) {
entry: entry:
%node.0.in16 = getelementptr inbounds %struct.node, %struct.node* %r, i64 0, i32 2 %node.0.in16 = getelementptr inbounds %struct.node, %struct.node* %r, i64 0, i32 2
Show All 31 Lines

llvm/test/Transforms/InstMerge/st_sink_split_bb.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; Test to make sure that a new block is inserted if we ; Test to make sure that a new block is inserted if we
; have more than 2 predecessors for the block we're going to sink to. ; have more than 2 predecessors for the block we're going to sink to.
; RUN: opt -basic-aa -memdep -mldst-motion -S < %s | FileCheck %s --check-prefix=CHECK-NO ; RUN: opt -mldst-motion -S < %s | FileCheck %s --check-prefix=CHECK-NO
; RUN: opt -debug-pass-manager -aa-pipeline=basic-aa -passes='require<memdep>,mldst-motion' -S < %s 2>&1 | FileCheck %s --check-prefixes=CHECK-NO,CHECK-INV-NO ; RUN: opt -debug-pass-manager -aa-pipeline=basic-aa -passes='require<memdep>,mldst-motion' -S < %s 2>&1 | FileCheck %s --check-prefixes=CHECK-NO,CHECK-INV-NO
; RUN: opt -debug-pass-manager -aa-pipeline=basic-aa -passes='require<memdep>,mldst-motion<split-footer-bb>' -S < %s 2>&1 | FileCheck %s --check-prefixes=CHECK-YES,CHECK-INV-YES ; RUN: opt -debug-pass-manager -aa-pipeline=basic-aa -passes='require<memdep>,mldst-motion<split-footer-bb>' -S < %s 2>&1 | FileCheck %s --check-prefixes=CHECK-YES,CHECK-INV-YES
target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128" target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
; When passing split-footer-bb to MLSM, it invalidates CFG analyses ; When passing split-footer-bb to MLSM, it invalidates CFG analyses
; CHECK-INV-NO: Running pass: MergedLoadStoreMotionPass ; CHECK-INV-NO: Running pass: MergedLoadStoreMotionPass
; CHECK-INV-NO-NOT: Invalidating analysis: DominatorTreeAnalysis ; CHECK-INV-NO-NOT: Invalidating analysis: DominatorTreeAnalysis
; CHECK-INV-YES: Running pass: MergedLoadStoreMotionPass ; CHECK-INV-YES: Running pass: MergedLoadStoreMotionPass
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

llvm/test/Transforms/InstMerge/st_sink_two_stores.ll

; Test to make sure that stores in a diamond get merged ; Test to make sure that stores in a diamond get merged
; Stores sunks into the footer. ; Stores sunks into the footer.
; RUN: opt -basic-aa -memdep -mldst-motion -S < %s | FileCheck %s ; RUN: opt -mldst-motion -S < %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"
%struct.node = type { i32, %struct.node*, %struct.node*, %struct.node*, i32, i32, i32, i32 } %struct.node = type { i32, %struct.node*, %struct.node*, %struct.node*, i32, i32, i32, i32 }
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
define void @sink_store(%struct.node* nocapture %r, i32 %index) { define void @sink_store(%struct.node* nocapture %r, i32 %index) {
entry: entry:
%node.0.in16 = getelementptr inbounds %struct.node, %struct.node* %r, i64 0, i32 2 %node.0.in16 = getelementptr inbounds %struct.node, %struct.node* %r, i64 0, i32 2
Show All 36 Lines

llvm/test/Transforms/InstMerge/st_sink_with_barrier.ll

; Test to make sure that load from the same address as a store and appears after the store prevents the store from being sunk ; Test to make sure that load from the same address as a store and appears after the store prevents the store from being sunk
; RUN: opt -basic-aa -memdep -mldst-motion -S < %s | FileCheck %s ; RUN: opt -mldst-motion -S < %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"
%struct.node = type { i32, %struct.node*, %struct.node*, %struct.node*, i32, i32, i32, i32 } %struct.node = type { i32, %struct.node*, %struct.node*, %struct.node*, i32, i32, i32, i32 }
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
define void @sink_store(%struct.node* nocapture %r, i32 %index) { define void @sink_store(%struct.node* nocapture %r, i32 %index) {
entry: entry:
%node.0.in16 = getelementptr inbounds %struct.node, %struct.node* %r, i64 0, i32 2 %node.0.in16 = getelementptr inbounds %struct.node, %struct.node* %r, i64 0, i32 2
Show All 32 Lines

llvm/test/Transforms/LICM/2003-02-26-LoopExitNotDominated.ll

; RUN: opt < %s -basic-aa -licm -disable-output ; RUN: opt < %s -licm -disable-output
;%MoveArray = external global [64 x ulong] ;%MoveArray = external global [64 x ulong]
define void @InitMoveArray() { define void @InitMoveArray() {
bb3: bb3:
%X = alloca [2 x i64] ; <ptr> [#uses=1] %X = alloca [2 x i64] ; <ptr> [#uses=1]
br i1 false, label %bb13, label %bb4 br i1 false, label %bb13, label %bb4
bb4: ; preds = %bb3 bb4: ; preds = %bb3
Show All 9 Lines

llvm/test/Transforms/LICM/2004-09-14-AliasAnalysisInvalidate.ll

; RUN: opt < %s -globals-aa -licm -disable-output ; RUN: opt < %s -passes='require<globals-aa>,function(loop-mssa(licm))' -disable-output
@PL_regcomp_parse = internal global ptr null ; <ptr> [#uses=2] @PL_regcomp_parse = internal global ptr null ; <ptr> [#uses=2]
define void @test() { define void @test() {
br label %Outer br label %Outer
Outer: ; preds = %Next, %0 Outer: ; preds = %Next, %0
br label %Inner br label %Inner
Inner: ; preds = %Inner, %Outer Inner: ; preds = %Inner, %Outer
Show All 10 Lines

llvm/test/Transforms/LICM/2008-07-22-LoadGlobalConstant.ll

; RUN: opt < %s -basic-aa -licm -S | FileCheck %s ; RUN: opt < %s -licm -S | FileCheck %s
@a = external constant ptr @a = external constant ptr
define void @test(i32 %count) { define void @test(i32 %count) {
entry: entry:
br label %forcond br label %forcond
; CHECK: %tmp3 = load ptr, ptr @a ; CHECK: %tmp3 = load ptr, ptr @a
Show All 30 Lines

llvm/test/Transforms/LICM/2011-04-06-HoistMissedASTUpdate.ll

; RUN: opt < %s -basic-aa -licm -S | FileCheck %s ; RUN: opt < %s -licm -S | FileCheck %s
; PR9630 ; PR9630
@g_39 = external global i16, align 2 @g_39 = external global i16, align 2
declare ptr @func_84(ptr nocapture) nounwind readonly declare ptr @func_84(ptr nocapture) nounwind readonly
declare ptr @func_108(ptr nocapture) nounwind readonly declare ptr @func_108(ptr nocapture) nounwind readonly
Show All 23 Lines

llvm/test/Transforms/LICM/2011-04-06-PromoteResultOfPromotion.ll

; RUN: opt < %s -tbaa -licm -S | FileCheck %s ; RUN: opt < %s -licm -S | FileCheck %s
; PR9634 ; PR9634
@g_58 = common global i32 0, align 4 @g_58 = common global i32 0, align 4
@g_116 = common global ptr null, align 8 @g_116 = common global ptr null, align 8
define void @f() nounwind { define void @f() nounwind {
; CHECK: entry: ; CHECK: entry:
Show All 30 Lines

llvm/test/Transforms/LICM/2014-09-10-doFinalizationAssert.ll

; RUN: opt < %s -scalar-evolution -licm -loop-unroll -disable-output ; RUN: opt < %s -licm -loop-unroll -disable-output
; Test triggered an assertion in doFinalization() because loop unroll was deleting ; Test triggered an assertion in doFinalization() because loop unroll was deleting
; the inner loop which caused the loop to not get removed from the ; the inner loop which caused the loop to not get removed from the
; LoopToAliasSetMap. ; LoopToAliasSetMap.
; Test case taken from test/Transforms/LoopUnroll/unloop.ll. ; Test case taken from test/Transforms/LoopUnroll/unloop.ll.
declare i1 @check() nounwind declare i1 @check() nounwind
define void @skiplevelexit() nounwind { define void @skiplevelexit() nounwind {
entry: entry:
Show All 21 Lines

llvm/test/Transforms/LICM/PR21582.ll

; RUN: opt < %s -basic-aa -licm -S | FileCheck %s ; RUN: opt < %s -licm -S | FileCheck %s
@b = external global i32, align 4 @b = external global i32, align 4
@fn3.i = external global i32, align 4 @fn3.i = external global i32, align 4
declare i32 @g() nounwind declare i32 @g() nounwind
define i32 @f() { define i32 @f() {
entry: entry:
br label %for.cond br label %for.cond
Show All 30 Lines

llvm/test/Transforms/LICM/assume.ll

; RUN: opt -licm -basic-aa < %s -S | FileCheck %s ; RUN: opt -licm < %s -S | FileCheck %s
; RUN: opt -aa-pipeline=basic-aa -passes='require<aa>,require<targetir>,require<scalar-evolution>,require<opt-remark-emit>,loop-mssa(licm)' < %s -S | FileCheck %s ; RUN: opt -aa-pipeline=basic-aa -passes='require<aa>,require<targetir>,require<scalar-evolution>,require<opt-remark-emit>,loop-mssa(licm)' < %s -S | FileCheck %s
define void @f_0(i1 %p) nounwind ssp { define void @f_0(i1 %p) nounwind ssp {
; CHECK-LABEL: @f_0( ; CHECK-LABEL: @f_0(
entry: entry:
br label %for.body br label %for.body
for.body: for.body:
▲ Show 20 Lines • Show All 90 Lines • Show Last 20 Lines

llvm/test/Transforms/LICM/call-hoisting.ll

; RUN: opt -S -basic-aa -licm %s | FileCheck %s ; RUN: opt -S -licm %s | FileCheck %s
; RUN: opt -aa-pipeline=basic-aa -passes='require<aa>,require<targetir>,require<scalar-evolution>,require<opt-remark-emit>,loop-mssa(licm)' < %s -S | FileCheck %s ; RUN: opt -aa-pipeline=basic-aa -passes='require<aa>,require<targetir>,require<scalar-evolution>,require<opt-remark-emit>,loop-mssa(licm)' < %s -S | FileCheck %s
declare i32 @load(ptr %p) argmemonly readonly nounwind declare i32 @load(ptr %p) argmemonly readonly nounwind
define void @test_load(ptr noalias %loc, ptr noalias %sink) { define void @test_load(ptr noalias %loc, ptr noalias %sink) {
; CHECK-LABEL: @test_load ; CHECK-LABEL: @test_load
; CHECK-LABEL: entry: ; CHECK-LABEL: entry:
; CHECK: call i32 @load ; CHECK: call i32 @load
▲ Show 20 Lines • Show All 288 Lines • Show Last 20 Lines

llvm/test/Transforms/LICM/constexpr.ll

; RUN: opt < %s -S -basic-aa -licm | FileCheck %s ; RUN: opt < %s -S -licm | FileCheck %s
; RUN: opt -aa-pipeline=basic-aa -passes='require<opt-remark-emit>,loop-mssa(licm)' < %s -S | FileCheck %s ; RUN: opt -aa-pipeline=basic-aa -passes='require<opt-remark-emit>,loop-mssa(licm)' < %s -S | FileCheck %s
; This fixes PR22460 ; This fixes PR22460
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"
target triple = "x86_64-pc-windows-msvc" target triple = "x86_64-pc-windows-msvc"
@in = internal unnamed_addr global ptr null, align 8 @in = internal unnamed_addr global ptr null, align 8
@out = internal unnamed_addr global ptr null, align 8 @out = internal unnamed_addr global ptr null, align 8
Show All 38 Lines

llvm/test/Transforms/LICM/debug-value.ll

; RUN: opt -licm -basic-aa < %s -S | FileCheck %s ; RUN: opt -licm < %s -S | FileCheck %s
; RUN: opt -aa-pipeline=basic-aa -passes='require<aa>,require<targetir>,require<scalar-evolution>,require<opt-remark-emit>,loop-mssa(licm)' < %s -S | FileCheck %s ; RUN: opt -aa-pipeline=basic-aa -passes='require<aa>,require<targetir>,require<scalar-evolution>,require<opt-remark-emit>,loop-mssa(licm)' < %s -S | FileCheck %s
define void @dgefa() nounwind ssp { define void @dgefa() nounwind ssp {
entry: entry:
br label %for.body br label %for.body
for.body: ; preds = %for.cond.backedge, %entry for.body: ; preds = %for.cond.backedge, %entry
br i1 undef, label %if.then, label %for.cond.backedge, !dbg !11 br i1 undef, label %if.then, label %for.cond.backedge, !dbg !11
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

llvm/test/Transforms/LICM/dropped-tbaa.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -scoped-noalias-aa -tbaa -licm -S | FileCheck %s ; RUN: opt < %s -licm -S | FileCheck %s
; This test case case is generated from the following C code with -fstrict-aliasing, ; This test case case is generated from the following C code with -fstrict-aliasing,
; and after passing through -inline -mem2reg -loop-rotate -instcombine ; and after passing through -inline -mem2reg -loop-rotate -instcombine
; void add(ptr restrict data, int *restrict addend) { ; void add(ptr restrict data, int *restrict addend) {
; *data += *addend; ; *data += *addend;
; } ; }
; ;
; void foo(ptr data, int *addend) { ; void foo(ptr data, int *addend) {
▲ Show 20 Lines • Show All 78 Lines • Show Last 20 Lines

llvm/test/Transforms/LICM/explicit_guards.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S -make-guards-explicit -basic-aa -licm < %s | FileCheck %s ; RUN: opt -S -make-guards-explicit -licm < %s | FileCheck %s
; RUN: opt -S -aa-pipeline=basic-aa -passes='require<opt-remark-emit>,make-guards-explicit,loop-mssa(licm)' < %s | FileCheck %s ; RUN: opt -S -aa-pipeline=basic-aa -passes='require<opt-remark-emit>,make-guards-explicit,loop-mssa(licm)' < %s | FileCheck %s
declare void @llvm.experimental.guard(i1,...) declare void @llvm.experimental.guard(i1,...)
declare void @maythrow() declare void @maythrow()
; Make sure that we do not hoist widenable_cond out of loop. ; Make sure that we do not hoist widenable_cond out of loop.
define void @hoist_widenable_cond(i1 %cond, i32 %N, i32 %M) { define void @hoist_widenable_cond(i1 %cond, i32 %N, i32 %M) {
; CHECK-LABEL: @hoist_widenable_cond( ; CHECK-LABEL: @hoist_widenable_cond(
▲ Show 20 Lines • Show All 107 Lines • Show Last 20 Lines

llvm/test/Transforms/LICM/fence.ll

; RUN: opt -licm -basic-aa < %s -S | FileCheck %s ; RUN: opt -licm < %s -S | FileCheck %s
; RUN: opt -aa-pipeline=basic-aa -passes='require<aa>,require<targetir>,require<scalar-evolution>,require<opt-remark-emit>,loop-mssa(licm)' < %s -S | FileCheck %s ; RUN: opt -aa-pipeline=basic-aa -passes='require<aa>,require<targetir>,require<scalar-evolution>,require<opt-remark-emit>,loop-mssa(licm)' < %s -S | FileCheck %s
define void @test1(i64 %n) { define void @test1(i64 %n) {
; CHECK-LABEL: @test1 ; CHECK-LABEL: @test1
; CHECK: fence ; CHECK: fence
; CHECK-LABEL: loop: ; CHECK-LABEL: loop:
entry: entry:
br label %loop br label %loop
▲ Show 20 Lines • Show All 111 Lines • Show Last 20 Lines

llvm/test/Transforms/LICM/gc-relocate.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S -basic-aa -licm < %s | FileCheck %s ; RUN: opt -S -licm < %s | FileCheck %s
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128-ni:1-p2:32:8:8:32-ni:2" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128-ni:1-p2:32:8:8:32-ni:2"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define ptr addrspace(1) @test(ptr addrspace(1) %arg) #0 gc "statepoint-example" personality ptr @wobble { define ptr addrspace(1) @test(ptr addrspace(1) %arg) #0 gc "statepoint-example" personality ptr @wobble {
; CHECK-LABEL: @test( ; CHECK-LABEL: @test(
; CHECK-NEXT: bb: ; CHECK-NEXT: bb:
; CHECK-NEXT: br label [[BB1:%.*]] ; CHECK-NEXT: br label [[BB1:%.*]]
Show All 27 Lines

llvm/test/Transforms/LICM/guards.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; REQUIRES: asserts ; REQUIRES: asserts
; RUN: opt -licm -basic-aa -ipt-expensive-asserts=true < %s -S | FileCheck %s ; RUN: opt -licm -ipt-expensive-asserts=true < %s -S | FileCheck %s
; RUN: opt -aa-pipeline=basic-aa -passes='require<aa>,require<targetir>,require<scalar-evolution>,require<opt-remark-emit>,loop-mssa(licm)' -ipt-expensive-asserts=true < %s -S | FileCheck %s ; RUN: opt -aa-pipeline=basic-aa -passes='require<aa>,require<targetir>,require<scalar-evolution>,require<opt-remark-emit>,loop-mssa(licm)' -ipt-expensive-asserts=true < %s -S | FileCheck %s
; Hoist guard and load. ; Hoist guard and load.
define void @test1(i1 %cond, ptr %ptr) { define void @test1(i1 %cond, ptr %ptr) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: call void (i1, ...) @llvm.experimental.guard(i1 [[COND:%.*]]) [ "deopt"(i32 0) ] ; CHECK-NEXT: call void (i1, ...) @llvm.experimental.guard(i1 [[COND:%.*]]) [ "deopt"(i32 0) ]
; CHECK-NEXT: [[VAL:%.*]] = load i32, ptr [[PTR:%.*]], align 4 ; CHECK-NEXT: [[VAL:%.*]] = load i32, ptr [[PTR:%.*]], align 4
▲ Show 20 Lines • Show All 558 Lines • Show Last 20 Lines

llvm/test/Transforms/LICM/hoist-alloc.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S -basic-aa -licm -use-dereferenceable-at-point-semantics=0 < %s | FileCheck %s ; RUN: opt -S -licm -use-dereferenceable-at-point-semantics=0 < %s | FileCheck %s
; RUN: opt -S -basic-aa -licm -use-dereferenceable-at-point-semantics=1 < %s | FileCheck %s ; RUN: opt -S -licm -use-dereferenceable-at-point-semantics=1 < %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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
declare void @unknown() declare void @unknown()
declare void @init(ptr nocapture) declare void @init(ptr nocapture)
declare void @use(i8) declare void @use(i8)
▲ Show 20 Lines • Show All 390 Lines • Show Last 20 Lines

llvm/test/Transforms/LICM/hoist-bitcast-load.ll

; RUN: opt -aa-pipeline=basic-aa -passes='require<opt-remark-emit>,loop-mssa(loop-simplifycfg,licm)' -S < %s | FileCheck %s ; RUN: opt -aa-pipeline=basic-aa -passes='require<opt-remark-emit>,loop-mssa(loop-simplifycfg,licm)' -S < %s | FileCheck %s
; RUN: opt -S -basic-aa -licm -verify-memoryssa < %s | FileCheck %s ; RUN: opt -S -licm -verify-memoryssa < %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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; Make sure the basic alloca pointer hoisting works: ; Make sure the basic alloca pointer hoisting works:
; CHECK-LABEL: @test1 ; CHECK-LABEL: @test1
; CHECK: load i32, ptr %c, align 4 ; CHECK: load i32, ptr %c, align 4
; CHECK: for.body: ; CHECK: for.body:
▲ Show 20 Lines • Show All 226 Lines • Show Last 20 Lines

llvm/test/Transforms/LICM/hoist-deref-load.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S -basic-aa -licm -verify-memoryssa < %s | FileCheck %s ; RUN: opt -S -licm -verify-memoryssa < %s | FileCheck %s
; RUN: opt -aa-pipeline=basic-aa -passes='require<opt-remark-emit>,loop-mssa(loop-simplifycfg,licm)' -verify-memoryssa -S < %s | FileCheck %s ; RUN: opt -aa-pipeline=basic-aa -passes='require<opt-remark-emit>,loop-mssa(loop-simplifycfg,licm)' -verify-memoryssa -S < %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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; This test represents the following function: ; This test represents the following function:
; void test1(int * __restrict__ a, int * __restrict__ b, int &c, int n) { ; void test1(int * __restrict__ a, int * __restrict__ b, int &c, int n) {
; for (int i = 0; i < n; ++i) ; for (int i = 0; i < n; ++i)
▲ Show 20 Lines • Show All 1,158 Lines • Show Last 20 Lines

llvm/test/Transforms/LICM/hoist-mustexec.ll

; REQUIRES: asserts ; REQUIRES: asserts
; RUN: opt -S -basic-aa -licm -ipt-expensive-asserts=true < %s | FileCheck %s ; RUN: opt -S -licm -ipt-expensive-asserts=true < %s | FileCheck %s
; RUN: opt -aa-pipeline=basic-aa -passes='require<opt-remark-emit>,loop-mssa(licm)' -ipt-expensive-asserts=true -S %s | FileCheck %s ; RUN: opt -aa-pipeline=basic-aa -passes='require<opt-remark-emit>,loop-mssa(licm)' -ipt-expensive-asserts=true -S %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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
declare void @f() nounwind declare void @f() nounwind
declare void @llvm.experimental.guard(i1,...) declare void @llvm.experimental.guard(i1,...)
; constant fold on first ieration ; constant fold on first ieration
▲ Show 20 Lines • Show All 617 Lines • Show Last 20 Lines

llvm/test/Transforms/LICM/hoist-nounwind.ll

; RUN: opt -aa-pipeline=basic-aa -passes='require<opt-remark-emit>,loop-mssa(licm)' -S %s | FileCheck %s ; RUN: opt -aa-pipeline=basic-aa -passes='require<opt-remark-emit>,loop-mssa(licm)' -S %s | FileCheck %s
; RUN: opt -S -basic-aa -licm -verify-memoryssa < %s | FileCheck %s ; RUN: opt -S -licm -verify-memoryssa < %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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
declare void @f() nounwind declare void @f() nounwind
; Don't hoist load past nounwind call. ; Don't hoist load past nounwind call.
define i32 @test1(ptr noalias nocapture readonly %a) nounwind uwtable { define i32 @test1(ptr noalias nocapture readonly %a) nounwind uwtable {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

llvm/test/Transforms/LICM/infinite_loops.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S -basic-aa -licm < %s | FileCheck %s ; RUN: opt -S -licm < %s | FileCheck %s
; RUN: opt -aa-pipeline=basic-aa -passes='require<opt-remark-emit>,loop-mssa(licm)' -S %s | FileCheck %s ; RUN: opt -aa-pipeline=basic-aa -passes='require<opt-remark-emit>,loop-mssa(licm)' -S %s | FileCheck %s
; Make sure we don't hoist the unsafe division to some executable block. ; Make sure we don't hoist the unsafe division to some executable block.
define void @test_impossible_exit_in_untaken_block(i32 %a, i32 %b, ptr %p) { define void @test_impossible_exit_in_untaken_block(i32 %a, i32 %b, ptr %p) {
; CHECK-LABEL: @test_impossible_exit_in_untaken_block( ; CHECK-LABEL: @test_impossible_exit_in_untaken_block(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[LOOP:%.*]] ; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop: ; CHECK: loop:
▲ Show 20 Lines • Show All 122 Lines • Show Last 20 Lines

llvm/test/Transforms/LICM/invariant.start.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -licm -basic-aa < %s -S | FileCheck %s ; RUN: opt -licm < %s -S | FileCheck %s
; RUN: opt -aa-pipeline=basic-aa -passes='require<aa>,require<targetir>,require<scalar-evolution>,require<opt-remark-emit>,loop-mssa(licm)' < %s -S | FileCheck %s ; RUN: opt -aa-pipeline=basic-aa -passes='require<aa>,require<targetir>,require<scalar-evolution>,require<opt-remark-emit>,loop-mssa(licm)' < %s -S | FileCheck %s
define void @test1(i1 %cond, ptr %ptr) { define void @test1(i1 %cond, ptr %ptr) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP0:%.*]] = call ptr @llvm.invariant.start.p0(i64 4, ptr [[PTR:%.*]]) ; CHECK-NEXT: [[TMP0:%.*]] = call ptr @llvm.invariant.start.p0(i64 4, ptr [[PTR:%.*]])
; CHECK-NEXT: [[VAL:%.*]] = load i32, ptr [[PTR]], align 4 ; CHECK-NEXT: [[VAL:%.*]] = load i32, ptr [[PTR]], align 4
; CHECK-NEXT: br label [[LOOP:%.*]] ; CHECK-NEXT: br label [[LOOP:%.*]]
▲ Show 20 Lines • Show All 124 Lines • Show Last 20 Lines

llvm/test/Transforms/LICM/lcssa-ssa-promoter.ll

; RUN: opt -S -basic-aa -licm < %s | FileCheck %s ; RUN: opt -S -licm < %s | FileCheck %s
; RUN: opt -aa-pipeline=basic-aa -passes='require<aa>,require<targetir>,require<scalar-evolution>,require<opt-remark-emit>,loop-mssa(licm)' -S %s| FileCheck %s ; RUN: opt -aa-pipeline=basic-aa -passes='require<aa>,require<targetir>,require<scalar-evolution>,require<opt-remark-emit>,loop-mssa(licm)' -S %s| FileCheck %s
; ;
; Manually validate LCSSA form is preserved even after SSAUpdater is used to ; Manually validate LCSSA form is preserved even after SSAUpdater is used to
; promote things in the loop bodies. ; promote things in the loop bodies.
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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

llvm/test/Transforms/LICM/pr26843.ll

; RUN: opt -S -basic-aa -licm < %s | FileCheck %s ; RUN: opt -S -licm < %s | FileCheck %s
target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32" target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
target triple = "i686-pc-windows-msvc18.0.0" target triple = "i686-pc-windows-msvc18.0.0"
@v = common global i32 zeroinitializer, align 4 @v = common global i32 zeroinitializer, align 4
; Make sure the store to v is not sunk past the memset ; Make sure the store to v is not sunk past the memset
; CHECK-LABEL: @main ; CHECK-LABEL: @main
Show All 23 Lines

llvm/test/Transforms/LICM/pr27262.ll

; RUN: opt -S -basic-aa -licm < %s | FileCheck %s ; RUN: opt -S -licm < %s | FileCheck %s
target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32" target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
target triple = "i686-pc-windows-msvc18.0.0" target triple = "i686-pc-windows-msvc18.0.0"
; Make sure the store to v is not sunk past the memset ; Make sure the store to v is not sunk past the memset
; CHECK-LABEL: @main ; CHECK-LABEL: @main
; CHECK: for.body: ; CHECK: for.body:
; CHECK-NEXT: store i8 1, ptr %p ; CHECK-NEXT: store i8 1, ptr %p
Show All 24 Lines

llvm/test/Transforms/LICM/pr37323.ll

;RUN: opt -verify-dom-info -loop-simplify -postdomtree -licm -adce -verify-loop-info -S -o - %s | FileCheck %s
;RUN: opt -verify-dom-info -passes='loop-simplify,require<postdomtree>,require<opt-remark-emit>,loop-mssa(licm),function(adce)' -S -o - %s | FileCheck %s ;RUN: opt -verify-dom-info -passes='loop-simplify,require<postdomtree>,require<opt-remark-emit>,loop-mssa(licm),function(adce)' -S -o - %s | FileCheck %s
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
@c = external global i16, align 1 @c = external global i16, align 1
;Make sure this test do not crash while accessing PostDomTree which is not ;Make sure this test do not crash while accessing PostDomTree which is not
;preserved in LICM. ;preserved in LICM.
Show All 22 Lines

llvm/test/Transforms/LICM/pr40317.ll

; RUN: opt -S -mcpu=z13 -tbaa -licm -licm-control-flow-hoisting -verify-memoryssa < %s | FileCheck %s ; RUN: opt -S -mcpu=z13 -licm -licm-control-flow-hoisting -verify-memoryssa < %s | FileCheck %s
target datalayout = "E-m:e-i1:8:16-i8:8:16-i64:64-f128:64-v128:64-a:8:16-n32:64" target datalayout = "E-m:e-i1:8:16-i8:8:16-i64:64-f128:64-v128:64-a:8:16-n32:64"
target triple = "s390x-ibm-linux" target triple = "s390x-ibm-linux"
%0 = type { %1, %1, i16, %2 } %0 = type { %1, %1, i16, %2 }
%1 = type <{ i16, i8, i32, i32, i32, i64, i64 }> %1 = type <{ i16, i8, i32, i32, i32, i64, i64 }>
%2 = type { i8, i16, i16, [2 x i8] } %2 = type { i8, i16, i16, [2 x i8] }
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

llvm/test/Transforms/LICM/pr42969.ll

; RUN: opt %s -S -scoped-noalias-aa -licm | FileCheck %s ; RUN: opt %s -S -licm | FileCheck %s
define i16 @main(i1 %a_b_mayalias, ptr %a, ptr %b) { define i16 @main(i1 %a_b_mayalias, ptr %a, ptr %b) {
; CHECK: scalar.body: ; CHECK: scalar.body:
; CHECK-NEXT: [[J:%.*]] = phi i64 ; CHECK-NEXT: [[J:%.*]] = phi i64
; CHECK-NEXT: [[TMP3:%.*]] = load i16 ; CHECK-NEXT: [[TMP3:%.*]] = load i16
; CHECK-NEXT: [[RESULT:%.*]] = add i16 [[TMP3]], 1 ; CHECK-NEXT: [[RESULT:%.*]] = add i16 [[TMP3]], 1
; CHECK-NEXT: store i16 [[RESULT]] ; CHECK-NEXT: store i16 [[RESULT]]
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

llvm/test/Transforms/LICM/pragma-licm-disable.ll

; RUN: opt < %s -S -basic-aa -licm | FileCheck %s ; RUN: opt < %s -S -licm | FileCheck %s
; Check that the LICM pass does not operate on a loop which has the ; Check that the LICM pass does not operate on a loop which has the
; llvm.licm.disable metadata. ; llvm.licm.disable metadata.
; CHECK-LABEL: @licm_disable ; CHECK-LABEL: @licm_disable
; CHECK: entry: ; CHECK: entry:
; CHECK-NOT: load ; CHECK-NOT: load
; CHECK: do.body: ; CHECK: do.body:
; CHECK: load i64, ptr @in ; CHECK: load i64, ptr @in
Show All 24 Lines

llvm/test/Transforms/LICM/scalar-promote-memmodel.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -licm -S | FileCheck %s ; RUN: opt < %s -licm -S | FileCheck %s
; RUN: opt -aa-pipeline=tbaa,basic-aa -passes='require<aa>,require<targetir>,require<scalar-evolution>,require<opt-remark-emit>,loop-mssa(licm)' -S %s | FileCheck %s ; RUN: opt -aa-pipeline=tbaa,basic-aa -passes='require<aa>,require<targetir>,require<scalar-evolution>,require<opt-remark-emit>,loop-mssa(licm)' -S %s | FileCheck %s
; Make sure we don't hoist a conditionally-executed store out of the loop; ; Make sure we don't hoist a conditionally-executed store out of the loop;
; it would violate the concurrency memory model ; it would violate the concurrency memory model
@g = common global i32 0, align 4 @g = common global i32 0, align 4
define void @bar(i32 %n, i32 %b) nounwind uwtable ssp { define void @bar(i32 %n, i32 %b) nounwind uwtable ssp {
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

llvm/test/Transforms/LICM/scalar-promote-unwind.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -licm -S | FileCheck %s ; RUN: opt < %s -licm -S | FileCheck %s
; RUN: opt -aa-pipeline=basic-aa -passes='require<aa>,require<targetir>,require<scalar-evolution>,require<opt-remark-emit>,loop-mssa(licm)' -S %s | FileCheck %s ; RUN: opt -aa-pipeline=basic-aa -passes='require<aa>,require<targetir>,require<scalar-evolution>,require<opt-remark-emit>,loop-mssa(licm)' -S %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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; Make sure we don't hoist the store out of the loop; %a would ; Make sure we don't hoist the store out of the loop; %a would
; have the wrong value if f() unwinds ; have the wrong value if f() unwinds
define void @test1(ptr nocapture noalias %a, i1 zeroext %y) uwtable { define void @test1(ptr nocapture noalias %a, i1 zeroext %y) uwtable {
▲ Show 20 Lines • Show All 559 Lines • Show Last 20 Lines

llvm/test/Transforms/LICM/scalar-promote.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --check-attributes ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --check-attributes
; RUN: opt < %s -basic-aa -tbaa -licm -S | FileCheck %s ; RUN: opt < %s -licm -S | FileCheck %s
; RUN: opt -aa-pipeline=tbaa,basic-aa -passes='require<aa>,require<targetir>,require<scalar-evolution>,require<opt-remark-emit>,loop-mssa(licm)' -S %s | FileCheck %s ; RUN: opt -aa-pipeline=tbaa,basic-aa -passes='require<aa>,require<targetir>,require<scalar-evolution>,require<opt-remark-emit>,loop-mssa(licm)' -S %s | FileCheck %s
target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128" target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
@X = global i32 7 ; <ptr> [#uses=4] @X = global i32 7 ; <ptr> [#uses=4]
define void @test1(i32 %i) { define void @test1(i32 %i) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: Entry: ; CHECK-NEXT: Entry:
▲ Show 20 Lines • Show All 913 Lines • Show Last 20 Lines

llvm/test/Transforms/LICM/sink-promote.ll

; RUN: opt < %s -basic-aa -licm -S | FileCheck %s ; RUN: opt < %s -licm -S | FileCheck %s
; Test moved from sinking.ll, as it tests sinking of a store who alone touches ; Test moved from sinking.ll, as it tests sinking of a store who alone touches
; a memory location in a loop. ; a memory location in a loop.
; Store can be sunk out of exit block containing indirectbr instructions after ; Store can be sunk out of exit block containing indirectbr instructions after
; D50925. Updated to use an argument instead of undef, due to PR38989. ; D50925. Updated to use an argument instead of undef, due to PR38989.
define void @test12(ptr %ptr) { define void @test12(ptr %ptr) {
; CHECK-LABEL: @test12 ; CHECK-LABEL: @test12
; CHECK: store ; CHECK: store
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

llvm/test/Transforms/LICM/sinking-debugify.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -debugify -basic-aa -licm -S | FileCheck %s ; RUN: opt < %s -debugify -licm -S | FileCheck %s
%Ty = type { i32, i32 } %Ty = type { i32, i32 }
@X2 = external global %Ty @X2 = external global %Ty
; The GEP in dead1 is adding a zero offset, so the DIExpression can be kept as ; The GEP in dead1 is adding a zero offset, so the DIExpression can be kept as
; a "register location". ; a "register location".
; The GEP in dead2 is adding a 4 bytes to the pointer, so the DIExpression is ; The GEP in dead2 is adding a 4 bytes to the pointer, so the DIExpression is
; turned into an "implicit location" using DW_OP_stack_value. ; turned into an "implicit location" using DW_OP_stack_value.
Show All 16 Lines

llvm/test/Transforms/LICM/sinking.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -licm -S -verify-memoryssa | FileCheck %s ; RUN: opt < %s -licm -S -verify-memoryssa | FileCheck %s
declare i32 @strlen(ptr) readonly nounwind willreturn declare i32 @strlen(ptr) readonly nounwind willreturn
declare void @foo() declare void @foo()
; Sink readonly function. ; Sink readonly function.
define i32 @test1(ptr %P) { define i32 @test1(ptr %P) {
▲ Show 20 Lines • Show All 996 Lines • Show Last 20 Lines

llvm/test/Transforms/LICM/strlen.ll

; RUN: opt -S -inferattrs -basic-aa -licm < %s | FileCheck %s ; RUN: opt -S -inferattrs -licm < %s | FileCheck %s
define void @test(ptr noalias %loc, ptr noalias %a) { define void @test(ptr noalias %loc, ptr noalias %a) {
; CHECK-LABEL: @test ; CHECK-LABEL: @test
; CHECK: @strlen ; CHECK: @strlen
; CHECK-LABEL: loop: ; CHECK-LABEL: loop:
br label %loop br label %loop
loop: loop:
Show All 10 Lines

llvm/test/Transforms/LICM/unrolled-deeply-nested.ll

; Test that LICM correctly detects conflicting accesses to memory in deeply ; Test that LICM correctly detects conflicting accesses to memory in deeply
; nested subloops. This works in the legacy PM due to a special retained map of ; nested subloops. This works in the legacy PM due to a special retained map of
; alias information for inner loops, and in the new PM it is recomputed for each ; alias information for inner loops, and in the new PM it is recomputed for each
; loop. ; loop.
; ;
; RUN: opt -S -aa-pipeline=basic-aa -passes='require<opt-remark-emit>,loop-mssa(licm)' < %s | FileCheck %s ; RUN: opt -S -aa-pipeline=basic-aa -passes='require<opt-remark-emit>,loop-mssa(licm)' < %s | FileCheck %s
; RUN: opt -S -basic-aa -licm < %s | FileCheck %s ; RUN: opt -S -licm < %s | FileCheck %s
define i32 @test(ptr %a, i64 %n.0, i64 %n.0.0, i64 %n.0.0.0, i64 %n.0.0.0.0) nounwind uwtable readonly { define i32 @test(ptr %a, i64 %n.0, i64 %n.0.0, i64 %n.0.0.0, i64 %n.0.0.0.0) nounwind uwtable readonly {
; CHECK-LABEL: define i32 @test ; CHECK-LABEL: define i32 @test
entry: entry:
%b = alloca i32 %b = alloca i32
%c = alloca i32 %c = alloca i32
br label %l.0.header br label %l.0.header
; CHECK: %b = alloca i32 ; CHECK: %b = alloca i32
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

llvm/test/Transforms/LICM/volatile-alias.ll

; RUN: opt -basic-aa -sroa -loop-rotate %s | opt -aa-pipeline=basic-aa -passes='require<aa>,require<targetir>,require<scalar-evolution>,require<opt-remark-emit>,loop-mssa(licm)' -S | FileCheck %s ; RUN: opt -sroa -loop-rotate %s | opt -aa-pipeline=basic-aa -passes='require<aa>,require<targetir>,require<scalar-evolution>,require<opt-remark-emit>,loop-mssa(licm)' -S | FileCheck %s
; RUN: opt -basic-aa -sroa -loop-rotate -licm -verify-memoryssa -S < %s | FileCheck %s ; RUN: opt -sroa -loop-rotate -licm -verify-memoryssa -S < %s | FileCheck %s
; The objects *p and *q are aliased to each other, but even though *q is ; The objects *p and *q are aliased to each other, but even though *q is
; volatile, *p can be considered invariant in the loop. Check if it is moved ; volatile, *p can be considered invariant in the loop. Check if it is moved
; out of the loop. ; out of the loop.
; CHECK: load i32, ptr %p ; CHECK: load i32, ptr %p
; CHECK: for.body: ; CHECK: for.body:
; CHECK: load volatile i32, ptr %q ; CHECK: load volatile i32, ptr %q
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"
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

llvm/test/Transforms/LoadStoreVectorizer/AMDGPU/complex-index.ll

; RUN: opt -mtriple=amdgcn-amd-amdhsa -basic-aa -load-store-vectorizer -S -o - %s | FileCheck %s ; RUN: opt -mtriple=amdgcn-amd-amdhsa -load-store-vectorizer -S -o - %s | FileCheck %s
; RUN: opt -mtriple=amdgcn-amd-amdhsa -aa-pipeline=basic-aa -passes='function(load-store-vectorizer)' -S -o - %s | FileCheck %s ; RUN: opt -mtriple=amdgcn-amd-amdhsa -aa-pipeline=basic-aa -passes='function(load-store-vectorizer)' -S -o - %s | FileCheck %s
target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5" target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5"
declare i64 @_Z12get_local_idj(i32) declare i64 @_Z12get_local_idj(i32)
declare i64 @_Z12get_group_idj(i32) declare i64 @_Z12get_group_idj(i32)
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

llvm/test/Transforms/LoadStoreVectorizer/AMDGPU/extended-index.ll

; RUN: opt -mtriple=amdgcn-amd-amdhsa -basic-aa -load-store-vectorizer -S -o - %s | FileCheck %s ; RUN: opt -mtriple=amdgcn-amd-amdhsa -load-store-vectorizer -S -o - %s | FileCheck %s
; RUN: opt -mtriple=amdgcn-amd-amdhsa -aa-pipeline=basic-aa -passes='function(load-store-vectorizer)' -S -o - %s | FileCheck %s ; RUN: opt -mtriple=amdgcn-amd-amdhsa -aa-pipeline=basic-aa -passes='function(load-store-vectorizer)' -S -o - %s | FileCheck %s
target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5" target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5"
declare i32 @llvm.amdgcn.workitem.id.x() #1 declare i32 @llvm.amdgcn.workitem.id.x() #1
; CHECK-LABEL: @basic_merge_sext_index( ; CHECK-LABEL: @basic_merge_sext_index(
; CHECK: sext i32 %id.x to i64 ; CHECK: sext i32 %id.x to i64
▲ Show 20 Lines • Show All 142 Lines • Show Last 20 Lines

llvm/test/Transforms/LoadStoreVectorizer/AMDGPU/insertion-point.ll

; RUN: opt -mtriple=amdgcn-amd-amdhsa -basic-aa -load-store-vectorizer -S -o - %s | FileCheck %s ; RUN: opt -mtriple=amdgcn-amd-amdhsa -load-store-vectorizer -S -o - %s | FileCheck %s
; RUN: opt -mtriple=amdgcn-amd-amdhsa -aa-pipeline=basic-aa -passes='function(load-store-vectorizer)' -S -o - %s | FileCheck %s ; RUN: opt -mtriple=amdgcn-amd-amdhsa -aa-pipeline=basic-aa -passes='function(load-store-vectorizer)' -S -o - %s | FileCheck %s
target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5" target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5"
; Check position of the inserted vector load/store. Vectorized loads should be ; Check position of the inserted vector load/store. Vectorized loads should be
; inserted at the position of the first load in the chain, and stores should be ; inserted at the position of the first load in the chain, and stores should be
; inserted at the position of the last store. ; inserted at the position of the last store.
▲ Show 20 Lines • Show All 109 Lines • Show Last 20 Lines

llvm/test/Transforms/LoadStoreVectorizer/AMDGPU/interleaved-mayalias-store.ll

; RUN: opt -mtriple=amdgcn-amd-amdhsa -basic-aa -load-store-vectorizer -S -o - %s | FileCheck %s ; RUN: opt -mtriple=amdgcn-amd-amdhsa -load-store-vectorizer -S -o - %s | FileCheck %s
; RUN: opt -mtriple=amdgcn-amd-amdhsa -aa-pipeline=basic-aa -passes='function(load-store-vectorizer)' -S -o - %s | FileCheck %s ; RUN: opt -mtriple=amdgcn-amd-amdhsa -aa-pipeline=basic-aa -passes='function(load-store-vectorizer)' -S -o - %s | FileCheck %s
target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5" target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5"
; This is NOT OK to vectorize, as either load may alias either store. ; This is NOT OK to vectorize, as either load may alias either store.
; CHECK: load double ; CHECK: load double
; CHECK: store double 0.000000e+00, double addrspace(1)* %a, ; CHECK: store double 0.000000e+00, double addrspace(1)* %a,
Show All 20 Lines

llvm/test/Transforms/LoadStoreVectorizer/AMDGPU/invariant-load.ll

; RUN: opt -mtriple=amdgcn-amd-amdhsa -basic-aa -load-store-vectorizer -S -o - %s | FileCheck %s ; RUN: opt -mtriple=amdgcn-amd-amdhsa -load-store-vectorizer -S -o - %s | FileCheck %s
; RUN: opt -mtriple=amdgcn-amd-amdhsa -aa-pipeline=basic-aa -passes='function(load-store-vectorizer)' -S -o - %s | FileCheck %s ; RUN: opt -mtriple=amdgcn-amd-amdhsa -aa-pipeline=basic-aa -passes='function(load-store-vectorizer)' -S -o - %s | FileCheck %s
target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5" target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5"
; CHECK-LABEL: @interleave ; CHECK-LABEL: @interleave
; CHECK: load <2 x double>, <2 x double> addrspace(1)* %{{.}}, align 8{{$}} ; CHECK: load <2 x double>, <2 x double> addrspace(1)* %{{.}}, align 8{{$}}
; CHECK: store <2 x double> zeroinitializer ; CHECK: store <2 x double> zeroinitializer
; CHECK: store double %add ; CHECK: store double %add
Show All 20 Lines

llvm/test/Transforms/LoadStoreVectorizer/AMDGPU/merge-vectors.ll

; RUN: opt -mtriple=amdgcn-amd-amdhsa -basic-aa -load-store-vectorizer -S -o - %s | FileCheck %s ; RUN: opt -mtriple=amdgcn-amd-amdhsa -load-store-vectorizer -S -o - %s | FileCheck %s
target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5" target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5"
; CHECK-LABEL: @merge_v2i32_v2i32( ; CHECK-LABEL: @merge_v2i32_v2i32(
; CHECK: load <4 x i32> ; CHECK: load <4 x i32>
; CHECK: store <4 x i32> zeroinitializer ; CHECK: store <4 x i32> zeroinitializer
define amdgpu_kernel void @merge_v2i32_v2i32(<2 x i32> addrspace(1)* nocapture %a, <2 x i32> addrspace(1)* nocapture readonly %b) #0 { define amdgpu_kernel void @merge_v2i32_v2i32(<2 x i32> addrspace(1)* nocapture %a, <2 x i32> addrspace(1)* nocapture readonly %b) #0 {
entry: entry:
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

llvm/test/Transforms/LoadStoreVectorizer/AMDGPU/multiple_tails.ll

; RUN: opt -mtriple=amdgcn-amd-amdhsa -mcpu=hawaii -basic-aa -load-store-vectorizer -S -o - %s | FileCheck -check-prefixes=GCN,GFX7 %s ; RUN: opt -mtriple=amdgcn-amd-amdhsa -mcpu=hawaii -load-store-vectorizer -S -o - %s | FileCheck -check-prefixes=GCN,GFX7 %s
; RUN: opt -mtriple=amdgcn-amd-amdhsa -mcpu=gfx900 -basic-aa -load-store-vectorizer -S -o - %s | FileCheck -check-prefixes=GCN,GFX9 %s ; RUN: opt -mtriple=amdgcn-amd-amdhsa -mcpu=gfx900 -load-store-vectorizer -S -o - %s | FileCheck -check-prefixes=GCN,GFX9 %s
target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5" target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5"
; Checks that there is no crash when there are multiple tails ; Checks that there is no crash when there are multiple tails
; for a the same head starting a chain. ; for a the same head starting a chain.
@0 = internal addrspace(3) global [16384 x i32] undef @0 = internal addrspace(3) global [16384 x i32] undef
; GCN-LABEL: @no_crash( ; GCN-LABEL: @no_crash(
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

llvm/test/Transforms/LoadStoreVectorizer/AMDGPU/opaque_ptr.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -mtriple=amdgcn-amd-amdhsa -basic-aa -load-store-vectorizer -S -o - %s | FileCheck %s ; RUN: opt -mtriple=amdgcn-amd-amdhsa -load-store-vectorizer -S -o - %s | FileCheck %s
; Vectorize and emit valid code (Issue #54896). ; Vectorize and emit valid code (Issue #54896).
%S = type { i64, i64 } %S = type { i64, i64 }
@S = external global %S @S = external global %S
define i64 @order() { define i64 @order() {
; CHECK-LABEL: @order( ; CHECK-LABEL: @order(
Show All 14 Lines

llvm/test/Transforms/LoadStoreVectorizer/AMDGPU/pointer-elements.ll

; RUN: opt -mtriple=amdgcn-amd-amdhsa -basic-aa -load-store-vectorizer -S -o - %s | FileCheck %s ; RUN: opt -mtriple=amdgcn-amd-amdhsa -load-store-vectorizer -S -o - %s | FileCheck %s
target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5" target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5"
declare i32 @llvm.amdgcn.workitem.id.x() #1 declare i32 @llvm.amdgcn.workitem.id.x() #1
; CHECK-LABEL: @merge_v2p1i8( ; CHECK-LABEL: @merge_v2p1i8(
; CHECK: load <2 x i64> ; CHECK: load <2 x i64>
; CHECK: inttoptr i64 %{{[^ ]+}} to i8 addrspace(1)* ; CHECK: inttoptr i64 %{{[^ ]+}} to i8 addrspace(1)*
▲ Show 20 Lines • Show All 302 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopDistribute/bounds-expansion-bug.ll

; RUN: opt -basic-aa -loop-distribute -enable-loop-distribute -S < %s | FileCheck %s ; RUN: opt -loop-distribute -enable-loop-distribute -S < %s | FileCheck %s
; When emitting the memchecks for: ; When emitting the memchecks for:
; ;
; for (i = 0; i < n; i++) { ; for (i = 0; i < n; i++) {
; A[i + 1] = A[i] * B[i]; ; A[i + 1] = A[i] * B[i];
; ======================= ; =======================
; C[i] = D[i] * E[i]; ; C[i] = D[i] * E[i];
; } ; }
▲ Show 20 Lines • Show All 99 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopDistribute/convergent-no-cross-partition-checks.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -basic-aa -loop-distribute -enable-loop-distribute \ ; RUN: opt -loop-distribute -enable-loop-distribute \
; RUN: -verify-loop-info -verify-dom-info -S < %s | FileCheck %s ; RUN: -verify-loop-info -verify-dom-info -S < %s | FileCheck %s
; Derived from crash-in-memcheck-generation.ll ; Derived from crash-in-memcheck-generation.ll
; Make sure the loop is distributed even with a convergent ; Make sure the loop is distributed even with a convergent
; op. LoopAccessAnalysis says that runtime checks are necessary, but ; op. LoopAccessAnalysis says that runtime checks are necessary, but
; none are cross partition, so none are truly needed. ; none are cross partition, so none are truly needed.
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopDistribute/crash-in-memcheck-generation.ll

; RUN: opt -basic-aa -loop-distribute -enable-loop-distribute -loop-vectorize -force-vector-width=4 \ ; RUN: opt -loop-distribute -enable-loop-distribute -loop-vectorize -force-vector-width=4 \
; RUN: -verify-loop-info -verify-dom-info -S < %s | FileCheck %s ; RUN: -verify-loop-info -verify-dom-info -S < %s | FileCheck %s
; If only A and B can alias here, we don't need memchecks to distribute since ; If only A and B can alias here, we don't need memchecks to distribute since
; A and B are in the same partition. This used to cause a crash in the ; A and B are in the same partition. This used to cause a crash in the
; memcheck generation. ; memcheck generation.
; ;
; for (i = 0; i < n; i++) { ; for (i = 0; i < n; i++) {
; A[i + 1] = A[i] * B[i]; ; A[i + 1] = A[i] * B[i];
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopDistribute/followup.ll

; RUN: opt -basic-aa -loop-distribute -S < %s | FileCheck %s ; RUN: opt -loop-distribute -S < %s | FileCheck %s
; ;
; Check that followup loop-attributes are applied to the loops after ; Check that followup loop-attributes are applied to the loops after
; loop distribution. ; loop distribution.
; ;
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"
define void @f(i32* %a, i32* %b, i32* %c, i32* %d, i32* %e) { define void @f(i32* %a, i32* %b, i32* %c, i32* %d, i32* %e) {
entry: entry:
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopDistribute/metadata.ll

; RUN: opt -basic-aa -loop-distribute -enable-loop-distribute=0 -S < %s | FileCheck %s --check-prefix=CHECK --check-prefix=EXPLICIT --check-prefix=DEFAULT_OFF ; RUN: opt -loop-distribute -enable-loop-distribute=0 -S < %s | FileCheck %s --check-prefix=CHECK --check-prefix=EXPLICIT --check-prefix=DEFAULT_OFF
; RUN: opt -basic-aa -loop-distribute -enable-loop-distribute=1 -S < %s | FileCheck %s --check-prefix=CHECK --check-prefix=EXPLICIT --check-prefix=DEFAULT_ON ; RUN: opt -loop-distribute -enable-loop-distribute=1 -S < %s | FileCheck %s --check-prefix=CHECK --check-prefix=EXPLICIT --check-prefix=DEFAULT_ON
; Same loop as in basic.ll. Check that distribution is enabled/disabled ; Same loop as in basic.ll. Check that distribution is enabled/disabled
; properly according to -enable-loop-distribute=0/1 and the ; properly according to -enable-loop-distribute=0/1 and the
; llvm.loop.distribute.enable metadata. ; llvm.loop.distribute.enable metadata.
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"
target triple = "x86_64-apple-macosx10.10.0" target triple = "x86_64-apple-macosx10.10.0"
▲ Show 20 Lines • Show All 139 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopDistribute/no-if-convert.ll

; RUN: opt -basic-aa -loop-distribute -enable-loop-distribute -verify-loop-info -verify-dom-info -S < %s \ ; RUN: opt -loop-distribute -enable-loop-distribute -verify-loop-info -verify-dom-info -S < %s \
; RUN: | FileCheck %s ; RUN: | FileCheck %s
; We should distribute this loop along === but not along ---. The last ; We should distribute this loop along === but not along ---. The last
; partition won't be vectorized due to conditional stores so it's better to ; partition won't be vectorized due to conditional stores so it's better to
; keep it with the second partition which has a dependence cycle. ; keep it with the second partition which has a dependence cycle.
; (1st statement): ; (1st statement):
; for (i = 0; i < n; i++) { ; for (i = 0; i < n; i++) {
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopDistribute/pr28443.ll

; RUN: opt -basic-aa -loop-distribute -enable-loop-distribute -verify-loop-info -verify-dom-info -S \ ; RUN: opt -loop-distribute -enable-loop-distribute -verify-loop-info -verify-dom-info -S \
; RUN: < %s | FileCheck %s ; RUN: < %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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @fn1(i64 %a, i64* %b) { define void @fn1(i64 %a, i64* %b) {
entry: entry:
br label %for.body br label %for.body
Show All 27 Lines

llvm/test/Transforms/LoopDistribute/scev-inserted-runtime-check.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -basic-aa -loop-distribute -enable-loop-distribute -S -enable-mem-access-versioning=0 < %s | FileCheck %s ; RUN: opt -loop-distribute -enable-loop-distribute -S -enable-mem-access-versioning=0 < %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"
; PredicatedScalarEvolution decides it needs to insert a bounds check ; PredicatedScalarEvolution decides it needs to insert a bounds check
; not based on memory access. ; not based on memory access.
define void @f(i32* noalias %a, i32* noalias %b, i32* noalias %c, i32* noalias %d, i32* noalias %e, i64 %N) { define void @f(i32* noalias %a, i32* noalias %b, i32* noalias %c, i32* noalias %d, i32* noalias %e, i64 %N) {
; CHECK-LABEL: @f( ; CHECK-LABEL: @f(
▲ Show 20 Lines • Show All 344 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopDistribute/symbolic-stride.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -basic-aa -loop-distribute -enable-loop-distribute -S < %s | \ ; RUN: opt -loop-distribute -enable-loop-distribute -S < %s | \
; RUN: FileCheck %s --check-prefix=DEFAULT ; RUN: FileCheck %s --check-prefix=DEFAULT
; RUN: opt -basic-aa -loop-distribute -enable-loop-distribute -S -enable-mem-access-versioning=0 < %s | \ ; RUN: opt -loop-distribute -enable-loop-distribute -S -enable-mem-access-versioning=0 < %s | \
; RUN: FileCheck %s --check-prefix=NO-VERSION ; RUN: FileCheck %s --check-prefix=NO-VERSION
; If we don't speculate stride for 1 we can't distribute along the line ; If we don't speculate stride for 1 we can't distribute along the line
; because we could have a backward dependence: ; because we could have a backward dependence:
; ;
; for (i = 0; i < n; i++) { ; for (i = 0; i < n; i++) {
; A[i + 1] = A[i] * B[i]; ; A[i + 1] = A[i] * B[i];
; ======================= ; =======================
▲ Show 20 Lines • Show All 141 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopDistribute/uncomputable-backedge-taken-count.ll

; RUN: opt -basic-aa -loop-distribute -enable-loop-distribute -verify-loop-info -verify-dom-info -S \ ; RUN: opt -loop-distribute -enable-loop-distribute -verify-loop-info -verify-dom-info -S \
; RUN: < %s | FileCheck %s ; RUN: < %s | FileCheck %s
target datalayout = "e-m:o-i32:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-i32:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.10.0" target triple = "x86_64-apple-macosx10.10.0"
; NOTE: The tests below use infinite loops to force unknown backedge-taken counts. ; NOTE: The tests below use infinite loops to force unknown backedge-taken counts.
; Making the exit condition depend on a load would break current loop-distribute, ; Making the exit condition depend on a load would break current loop-distribute,
; because it requires all accesses to end up in either of the loops, but not both. ; because it requires all accesses to end up in either of the loops, but not both.
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopDistribute/unknown-bounds-for-memchecks.ll

; RUN: opt -basic-aa -loop-distribute -enable-loop-distribute -S < %s | FileCheck %s ; RUN: opt -loop-distribute -enable-loop-distribute -S < %s | FileCheck %s
; If we can't find the bounds for one of the arrays in order to generate the ; If we can't find the bounds for one of the arrays in order to generate the
; memchecks (e.g., C[i * i] below), loop shold not get distributed. ; memchecks (e.g., C[i * i] below), loop shold not get distributed.
; ;
; for (i = 0; i < n; i++) { ; for (i = 0; i < n; i++) {
; A[i + 1] = A[i] * 3; ; A[i + 1] = A[i] * 3;
; ------------------------------- ; -------------------------------
; C[i * i] = B[i] * 2; ; C[i * i] = B[i] * 2;
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopIdiom/X86/unordered-atomic-memcpy.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -basic-aa -loop-idiom < %s -S | FileCheck %s ; RUN: opt -loop-idiom < %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" 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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
;; memcpy.atomic formation (atomic load & store) ;; memcpy.atomic formation (atomic load & store)
define void @test1(i64 %Size) nounwind ssp { define void @test1(i64 %Size) nounwind ssp {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: bb.nph: ; CHECK-NEXT: bb.nph:
; CHECK-NEXT: [[BASE:%.*]] = alloca i8, i32 10000, align 1 ; CHECK-NEXT: [[BASE:%.*]] = alloca i8, i32 10000, align 1
▲ Show 20 Lines • Show All 757 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopIdiom/basic-address-space.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -basic-aa -loop-idiom < %s -S | FileCheck %s ; RUN: opt -loop-idiom < %s -S | FileCheck %s
target datalayout = "e-p:32:32:32-p1:64:64:64-p2:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:32-n8:16:32:64" target datalayout = "e-p:32:32:32-p1:64:64:64-p2:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:32-n8:16:32:64"
target triple = "x86_64-apple-darwin10.0.0" target triple = "x86_64-apple-darwin10.0.0"
; Two dimensional nested loop should be promoted to one big memset. ; Two dimensional nested loop should be promoted to one big memset.
define void @test10(i8 addrspace(2)* %X) nounwind ssp { define void @test10(i8 addrspace(2)* %X) nounwind ssp {
; CHECK-LABEL: @test10( ; CHECK-LABEL: @test10(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
▲ Show 20 Lines • Show All 127 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopIdiom/basic.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -basic-aa -loop-idiom < %s -S | FileCheck %s ; RUN: opt -loop-idiom < %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" 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"
; For @test11_pattern ; For @test11_pattern
; CHECK: @.memset_pattern = private unnamed_addr constant [4 x i32] [i32 1, i32 1, i32 1, i32 1] ; CHECK: @.memset_pattern = private unnamed_addr constant [4 x i32] [i32 1, i32 1, i32 1, i32 1]
; For @test13_pattern ; For @test13_pattern
; CHECK: @.memset_pattern.1 = private unnamed_addr constant [2 x i32*] [i32* @G, i32* @G] ; CHECK: @.memset_pattern.1 = private unnamed_addr constant [2 x i32*] [i32* @G, i32* @G]
▲ Show 20 Lines • Show All 1,609 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopIdiom/crash.ll

; RUN: opt -basic-aa -loop-idiom -S < %s ; RUN: opt -loop-idiom -S < %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"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
; Don't crash inside DependenceAnalysis ; Don't crash inside DependenceAnalysis
; PR14219 ; PR14219
define void @test1(i64* %iwork, i64 %x) { define void @test1(i64* %iwork, i64 %x) {
bb0: bb0:
%mul116 = mul nsw i64 %x, %x %mul116 = mul nsw i64 %x, %x
Show All 16 Lines

llvm/test/Transforms/LoopIdiom/disable-options.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -basic-aa -loop-idiom < %s -S | FileCheck %s --check-prefix=DIS-NONE ; RUN: opt -loop-idiom < %s -S | FileCheck %s --check-prefix=DIS-NONE
; RUN: opt -basic-aa -loop-idiom -disable-loop-idiom-all < %s -S | FileCheck %s --check-prefix=DIS-ALL ; RUN: opt -loop-idiom -disable-loop-idiom-all < %s -S | FileCheck %s --check-prefix=DIS-ALL
; RUN: opt -basic-aa -loop-idiom -disable-loop-idiom-memcpy < %s -S | FileCheck %s --check-prefix=DIS-MEMCPY ; RUN: opt -loop-idiom -disable-loop-idiom-memcpy < %s -S | FileCheck %s --check-prefix=DIS-MEMCPY
; RUN: opt -basic-aa -loop-idiom -disable-loop-idiom-memset < %s -S | FileCheck %s --check-prefix=DIS-MEMSET ; RUN: opt -loop-idiom -disable-loop-idiom-memset < %s -S | FileCheck %s --check-prefix=DIS-MEMSET
; RUN: opt -basic-aa -loop-idiom -disable-loop-idiom-memset -disable-loop-idiom-memcpy < %s -S | FileCheck %s --check-prefix=DIS-ALL ; RUN: opt -loop-idiom -disable-loop-idiom-memset -disable-loop-idiom-memcpy < %s -S | FileCheck %s --check-prefix=DIS-ALL
; RUN: opt -passes="loop-idiom" -aa-pipeline=basic-aa < %s -S | FileCheck %s --check-prefix=DIS-NONE ; RUN: opt -passes="loop-idiom" -aa-pipeline=basic-aa < %s -S | FileCheck %s --check-prefix=DIS-NONE
; RUN: opt -passes="loop-idiom" -aa-pipeline=basic-aa -disable-loop-idiom-all < %s -S | FileCheck %s --check-prefix=DIS-ALL ; RUN: opt -passes="loop-idiom" -aa-pipeline=basic-aa -disable-loop-idiom-all < %s -S | FileCheck %s --check-prefix=DIS-ALL
; RUN: opt -passes="loop-idiom" -aa-pipeline=basic-aa -disable-loop-idiom-memcpy < %s -S | FileCheck %s --check-prefix=DIS-MEMCPY ; RUN: opt -passes="loop-idiom" -aa-pipeline=basic-aa -disable-loop-idiom-memcpy < %s -S | FileCheck %s --check-prefix=DIS-MEMCPY
; RUN: opt -passes="loop-idiom" -aa-pipeline=basic-aa -disable-loop-idiom-memset < %s -S | FileCheck %s --check-prefix=DIS-MEMSET ; RUN: opt -passes="loop-idiom" -aa-pipeline=basic-aa -disable-loop-idiom-memset < %s -S | FileCheck %s --check-prefix=DIS-MEMSET
; RUN: opt -passes="loop-idiom" -aa-pipeline=basic-aa -disable-loop-idiom-memset -disable-loop-idiom-memcpy < %s -S | FileCheck %s --check-prefix=DIS-ALL ; RUN: opt -passes="loop-idiom" -aa-pipeline=basic-aa -disable-loop-idiom-memset -disable-loop-idiom-memcpy < %s -S | FileCheck %s --check-prefix=DIS-ALL
define void @test-memcpy(i64 %Size) nounwind ssp { define void @test-memcpy(i64 %Size) nounwind ssp {
; DIS-NONE-LABEL: @test-memcpy( ; DIS-NONE-LABEL: @test-memcpy(
▲ Show 20 Lines • Show All 166 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopIdiom/lir-heurs-multi-block-loop.ll

; RUN: opt -basic-aa -loop-idiom -use-lir-code-size-heurs=true < %s -S | FileCheck %s ; RUN: opt -loop-idiom -use-lir-code-size-heurs=true < %s -S | FileCheck %s
; When compiling for codesize we avoid idiom recognition for a ; When compiling for codesize we avoid idiom recognition for a
; multi-block loop unless it is one of ; multi-block loop unless it is one of
; - a loop_memset idiom, or ; - a loop_memset idiom, or
; - a memset/memcpy idiom in a nested loop. ; - a memset/memcpy idiom in a nested loop.
declare void @llvm.memset.p0i8.i64(i8* nocapture, i8, i64, i1) declare void @llvm.memset.p0i8.i64(i8* nocapture, i8, i64, i1)
@APPLES = common global i32 0, align 4 @APPLES = common global i32 0, align 4
▲ Show 20 Lines • Show All 173 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopIdiom/memcpy-debugify-remarks.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -basic-aa -debugify -loop-idiom -pass-remarks=loop-idiom -pass-remarks-analysis=loop-idiom -pass-remarks-output=%t.yaml -verify -verify-each -verify-dom-info -verify-loop-info < %s -S 2>&1 | FileCheck %s ; RUN: opt -debugify -loop-idiom -pass-remarks=loop-idiom -pass-remarks-analysis=loop-idiom -pass-remarks-output=%t.yaml -verify -verify-each -verify-dom-info -verify-loop-info < %s -S 2>&1 | FileCheck %s
; RUN: FileCheck --input-file=%t.yaml %s --check-prefixes=YAML ; RUN: FileCheck --input-file=%t.yaml %s --check-prefixes=YAML
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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; Check that everything still works when debuginfo is present, and that it is reasonably propagated. ; Check that everything still works when debuginfo is present, and that it is reasonably propagated.
; CHECK: remark: <stdin>:6:1: Formed a call to llvm.memcpy.p0i8.p0i8.i64() intrinsic from load and store instruction in test6_dest_align function{{$}} ; CHECK: remark: <stdin>:6:1: Formed a call to llvm.memcpy.p0i8.p0i8.i64() intrinsic from load and store instruction in test6_dest_align function{{$}}
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopIdiom/memcpy.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -basic-aa -loop-idiom < %s -S | FileCheck %s ; RUN: opt -loop-idiom < %s -S | FileCheck %s
define void @copy_both_noalias(float* noalias nocapture %d, float* noalias nocapture readonly %s, i64 %sz) { define void @copy_both_noalias(float* noalias nocapture %d, float* noalias nocapture readonly %s, i64 %sz) {
; CHECK-LABEL: @copy_both_noalias( ; CHECK-LABEL: @copy_both_noalias(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[D1:%.*]] = bitcast float* [[D:%.*]] to i8* ; CHECK-NEXT: [[D1:%.*]] = bitcast float* [[D:%.*]] to i8*
; CHECK-NEXT: [[S2:%.*]] = bitcast float* [[S:%.*]] to i8* ; CHECK-NEXT: [[S2:%.*]] = bitcast float* [[S:%.*]] to i8*
; CHECK-NEXT: [[EXITCOND_NOT1:%.*]] = icmp eq i64 [[SZ:%.*]], 0 ; CHECK-NEXT: [[EXITCOND_NOT1:%.*]] = icmp eq i64 [[SZ:%.*]], 0
; CHECK-NEXT: br i1 [[EXITCOND_NOT1]], label [[FOR_END:%.*]], label [[FOR_BODY_PREHEADER:%.*]] ; CHECK-NEXT: br i1 [[EXITCOND_NOT1]], label [[FOR_END:%.*]], label [[FOR_BODY_PREHEADER:%.*]]
▲ Show 20 Lines • Show All 141 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopIdiom/memset-debugify-remarks.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -basic-aa -debugify -loop-idiom -pass-remarks=loop-idiom -pass-remarks-analysis=loop-idiom -pass-remarks-output=%t.yaml -verify -verify-each -verify-dom-info -verify-loop-info < %s -S 2>&1 | FileCheck %s ; RUN: opt -debugify -loop-idiom -pass-remarks=loop-idiom -pass-remarks-analysis=loop-idiom -pass-remarks-output=%t.yaml -verify -verify-each -verify-dom-info -verify-loop-info < %s -S 2>&1 | FileCheck %s
; RUN: FileCheck --input-file=%t.yaml %s --check-prefixes=YAML ; RUN: FileCheck --input-file=%t.yaml %s --check-prefixes=YAML
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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; Check that everything still works when debuginfo is present, and that it is reasonably propagated. ; Check that everything still works when debuginfo is present, and that it is reasonably propagated.
; void my_basic_memset(char* begin, char* end, char value) { ; void my_basic_memset(char* begin, char* end, char value) {
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopIdiom/memset-pr52104.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -basic-aa -loop-idiom < %s -S | FileCheck %s ; RUN: opt -loop-idiom < %s -S | FileCheck %s
define void @f(i32* nocapture nonnull align 4 dereferenceable(20) %0, i32 %1) local_unnamed_addr #0 align 32 { define void @f(i32* nocapture nonnull align 4 dereferenceable(20) %0, i32 %1) local_unnamed_addr #0 align 32 {
; CHECK-LABEL: @f( ; CHECK-LABEL: @f(
; CHECK-NEXT: [[TMP3:%.*]] = trunc i32 [[TMP1:%.*]] to i2 ; CHECK-NEXT: [[TMP3:%.*]] = trunc i32 [[TMP1:%.*]] to i2
; CHECK-NEXT: [[TMP4:%.*]] = zext i2 [[TMP3]] to i64 ; CHECK-NEXT: [[TMP4:%.*]] = zext i2 [[TMP3]] to i64
; CHECK-NEXT: [[SCEVGEP:%.*]] = getelementptr i32, i32* [[TMP0:%.*]], i64 [[TMP4]] ; CHECK-NEXT: [[SCEVGEP:%.*]] = getelementptr i32, i32* [[TMP0:%.*]], i64 [[TMP4]]
; CHECK-NEXT: [[SCEVGEP1:%.*]] = bitcast i32* [[SCEVGEP]] to i8* ; CHECK-NEXT: [[SCEVGEP1:%.*]] = bitcast i32* [[SCEVGEP]] to i8*
; CHECK-NEXT: [[TMP5:%.*]] = sub i2 -1, [[TMP3]] ; CHECK-NEXT: [[TMP5:%.*]] = sub i2 -1, [[TMP3]]
Show All 33 Lines

llvm/test/Transforms/LoopIdiom/memset-runtime-32bit.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -passes="function(loop(indvars,loop-idiom,loop-deletion),simplifycfg)" -S < %s | FileCheck %s ; RUN: opt -passes="function(loop(indvars,loop-idiom,loop-deletion),simplifycfg)" -S < %s | FileCheck %s
; Compile command: ; Compile command:
; $ clang -m32 -fno-discard-value-names -O0 -S -emit-llvm -Xclang -disable-O0-optnone Code.c ; $ clang -m32 -fno-discard-value-names -O0 -S -emit-llvm -Xclang -disable-O0-optnone Code.c
; $ bin/opt -S -basic-aa -mem2reg -loop-simplify -lcssa -loop-rotate \ ; $ bin/opt -S -mem2reg -loop-simplify -lcssa -loop-rotate \
; -licm -simple-loop-unswitch -enable-nontrivial-unswitch -loop-simplify \ ; -licm -simple-loop-unswitch -enable-nontrivial-unswitch -loop-simplify \
; -loop-deletion -simplifycfg -indvars Code.ll > CodeOpt.ll ; -loop-deletion -simplifycfg -indvars Code.ll > CodeOpt.ll
target datalayout = "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-f64:32:64-f80:32-n8:16:32-S128" target datalayout = "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-f64:32:64-f80:32-n8:16:32-S128"
; void PositiveFor32(int *ar, int n, int m) ; void PositiveFor32(int *ar, int n, int m)
; { ; {
; int i; ; int i;
; for (i=0; i<n; ++i) { ; for (i=0; i<n; ++i) {
; int *arr = ar + i * m; ; int *arr = ar + i * m;
▲ Show 20 Lines • Show All 407 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopIdiom/memset-runtime-64bit.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -passes="function(loop(indvars,loop-idiom,loop-deletion),simplifycfg)" -S < %s | FileCheck %s ; RUN: opt -passes="function(loop(indvars,loop-idiom,loop-deletion),simplifycfg)" -S < %s | FileCheck %s
; Compile command: ; Compile command:
; $ clang -m64 -fno-discard-value-names -O0 -S -emit-llvm -Xclang -disable-O0-optnone Code.c ; $ clang -m64 -fno-discard-value-names -O0 -S -emit-llvm -Xclang -disable-O0-optnone Code.c
; $ bin/opt -S -basic-aa -mem2reg -loop-simplify -lcssa -loop-rotate \ ; $ bin/opt -S -mem2reg -loop-simplify -lcssa -loop-rotate \
; -licm -simple-loop-unswitch -enable-nontrivial-unswitch -loop-simplify \ ; -licm -simple-loop-unswitch -enable-nontrivial-unswitch -loop-simplify \
; -loop-deletion -simplifycfg -indvars Code.ll > CodeOpt.ll ; -loop-deletion -simplifycfg -indvars Code.ll > CodeOpt.ll
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
; void PositiveFor64(int *ar, long long n, long long m) ; void PositiveFor64(int *ar, long long n, long long m)
; { ; {
; long long i; ; long long i;
; for (i=0; i<n; ++i) { ; for (i=0; i<n; ++i) {
; int *arr = ar + i * m; ; int *arr = ar + i * m;
▲ Show 20 Lines • Show All 401 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopIdiom/memset.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -basic-aa -loop-idiom < %s -S | FileCheck %s ; RUN: opt -loop-idiom < %s -S | FileCheck %s
define dso_local void @double_memset(i8* nocapture %p, i8* noalias nocapture %q, i32 %n) { define dso_local void @double_memset(i8* nocapture %p, i8* noalias nocapture %q, i32 %n) {
; CHECK-LABEL: @double_memset( ; CHECK-LABEL: @double_memset(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[CMP4:%.*]] = icmp sgt i32 [[N:%.*]], 0 ; CHECK-NEXT: [[CMP4:%.*]] = icmp sgt i32 [[N:%.*]], 0
; CHECK-NEXT: br i1 [[CMP4]], label [[FOR_BODY_PREHEADER:%.*]], label [[FOR_COND_CLEANUP:%.*]] ; CHECK-NEXT: br i1 [[CMP4]], label [[FOR_BODY_PREHEADER:%.*]], label [[FOR_COND_CLEANUP:%.*]]
; CHECK: for.body.preheader: ; CHECK: for.body.preheader:
Show All 38 Lines

llvm/test/Transforms/LoopIdiom/non-integral-pointers.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S -basic-aa -loop-idiom < %s | FileCheck %s ; RUN: opt -S -loop-idiom < %s | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128-ni:4" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128-ni:4"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; LIR'ing stores of pointers with address space 3 is fine, since ; LIR'ing stores of pointers with address space 3 is fine, since
; they're integral pointers. ; they're integral pointers.
define void @f_0(i8 addrspace(3)** %ptr) { define void @f_0(i8 addrspace(3)** %ptr) {
; CHECK-LABEL: @f_0( ; CHECK-LABEL: @f_0(
▲ Show 20 Lines • Show All 94 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopIdiom/struct-custom-dl.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -basic-aa -loop-idiom < %s -S | FileCheck %s ; RUN: opt -loop-idiom < %s -S | FileCheck %s
target datalayout = "e-p:40:64:64: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:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:40:64:64: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:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
%struct.foo = type { i32, i32 } %struct.foo = type { i32, i32 }
%struct.foo1 = type { i32, i32, i32 } %struct.foo1 = type { i32, i32, i32 }
%struct.foo2 = type { i32, i16, i16 } %struct.foo2 = type { i32, i16, i16 }
;void bar1(foo_t *f, unsigned n) { ;void bar1(foo_t *f, unsigned n) {
; for (unsigned i = 0; i < n; ++i) { ; for (unsigned i = 0; i < n; ++i) {
▲ Show 20 Lines • Show All 314 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopIdiom/struct.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -basic-aa -loop-idiom < %s -S | FileCheck %s ; RUN: opt -loop-idiom < %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" 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"
target triple = "x86_64-apple-darwin10.0.0" target triple = "x86_64-apple-darwin10.0.0"
%struct.foo = type { i32, i32 } %struct.foo = type { i32, i32 }
%struct.foo1 = type { i32, i32, i32 } %struct.foo1 = type { i32, i32, i32 }
%struct.foo2 = type { i32, i16, i16 } %struct.foo2 = type { i32, i16, i16 }
▲ Show 20 Lines • Show All 336 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopIdiom/struct_pattern.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -basic-aa -loop-idiom < %s -S | FileCheck %s ; RUN: opt -loop-idiom < %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" 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"
; CHECK: @.memset_pattern = private unnamed_addr constant [4 x i32] [i32 2, i32 2, i32 2, i32 2], align 16 ; CHECK: @.memset_pattern = private unnamed_addr constant [4 x i32] [i32 2, i32 2, i32 2, i32 2], align 16
; CHECK: @.memset_pattern.1 = private unnamed_addr constant [4 x i32] [i32 2, i32 2, i32 2, i32 2], align 16 ; CHECK: @.memset_pattern.1 = private unnamed_addr constant [4 x i32] [i32 2, i32 2, i32 2, i32 2], align 16
; CHECK: @.memset_pattern.2 = private unnamed_addr constant [4 x i32] [i32 2, i32 2, i32 2, i32 2], align 16 ; CHECK: @.memset_pattern.2 = private unnamed_addr constant [4 x i32] [i32 2, i32 2, i32 2, i32 2], align 16
target triple = "x86_64-apple-darwin10.0.0" target triple = "x86_64-apple-darwin10.0.0"
▲ Show 20 Lines • Show All 280 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopIdiom/unordered-atomic-memcpy-noarch.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -basic-aa -loop-idiom < %s -S | FileCheck %s ; RUN: opt -loop-idiom < %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" 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"
;; memcpy.atomic formation (atomic load & store) -- element size 2 ;; memcpy.atomic formation (atomic load & store) -- element size 2
;; Will not create call due to a max element size of 0 ;; Will not create call due to a max element size of 0
define void @test1(i64 %Size) nounwind ssp { define void @test1(i64 %Size) nounwind ssp {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: bb.nph: ; CHECK-NEXT: bb.nph:
; CHECK-NEXT: [[BASE:%.*]] = alloca i16, i32 10000, align 2 ; CHECK-NEXT: [[BASE:%.*]] = alloca i16, i32 10000, align 2
Show All 32 Lines

llvm/test/Transforms/LoopIdiom/unroll-custom-dl.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -basic-aa -loop-idiom < %s -S | FileCheck %s ; RUN: opt -loop-idiom < %s -S | FileCheck %s
target datalayout = "e-p:64:64:64: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:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64: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:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
; CHECK: @.memset_pattern = private unnamed_addr constant [4 x i32] [i32 2, i32 2, i32 2, i32 2], align 16 ; CHECK: @.memset_pattern = private unnamed_addr constant [4 x i32] [i32 2, i32 2, i32 2, i32 2], align 16
target triple = "x86_64-apple-darwin10.0.0" target triple = "x86_64-apple-darwin10.0.0"
;void test(int *f, unsigned n) { ;void test(int *f, unsigned n) {
; for (unsigned i = 0; i < 2 * n; i += 2) { ; for (unsigned i = 0; i < 2 * n; i += 2) {
▲ Show 20 Lines • Show All 115 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopIdiom/unroll.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -basic-aa -loop-idiom < %s -S | FileCheck %s ; RUN: opt -loop-idiom < %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" 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"
; CHECK: @.memset_pattern = private unnamed_addr constant [4 x i32] [i32 2, i32 2, i32 2, i32 2], align 16 ; CHECK: @.memset_pattern = private unnamed_addr constant [4 x i32] [i32 2, i32 2, i32 2, i32 2], align 16
target triple = "x86_64-apple-darwin10.0.0" target triple = "x86_64-apple-darwin10.0.0"
;void test(int *f, unsigned n) { ;void test(int *f, unsigned n) {
; for (unsigned i = 0; i < 2 * n; i += 2) { ; for (unsigned i = 0; i < 2 * n; i += 2) {
▲ Show 20 Lines • Show All 119 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopInterchange/call-instructions.ll

; REQUIRES: asserts ; REQUIRES: asserts
; RUN: opt < %s -basic-aa -loop-interchange -cache-line-size=64 -pass-remarks-missed='loop-interchange' -pass-remarks-output=%t -S \ ; RUN: opt < %s -loop-interchange -cache-line-size=64 -pass-remarks-missed='loop-interchange' -pass-remarks-output=%t -S \
; RUN: -verify-dom-info -verify-loop-info -stats 2>&1 | FileCheck -check-prefix=STATS %s ; RUN: -verify-dom-info -verify-loop-info -stats 2>&1 | FileCheck -check-prefix=STATS %s
; RUN: FileCheck --input-file=%t %s ; RUN: FileCheck --input-file=%t %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"
@A = common global [100 x [100 x i32]] zeroinitializer @A = common global [100 x [100 x i32]] zeroinitializer
declare void @foo(i64 %a) declare void @foo(i64 %a)
▲ Show 20 Lines • Show All 109 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopInterchange/currentLimitation.ll

; RUN: opt < %s -basic-aa -loop-interchange -cache-line-size=64 -pass-remarks-missed='loop-interchange' \ ; RUN: opt < %s -loop-interchange -cache-line-size=64 -pass-remarks-missed='loop-interchange' \
; RUN: -pass-remarks-output=%t -verify-loop-info -verify-dom-info -S | FileCheck -check-prefix=IR %s ; RUN: -pass-remarks-output=%t -verify-loop-info -verify-dom-info -S | FileCheck -check-prefix=IR %s
; RUN: FileCheck --input-file=%t %s ; RUN: FileCheck --input-file=%t %s
; RUN: opt < %s -basic-aa -loop-interchange -cache-line-size=64 -pass-remarks-missed='loop-interchange' \ ; RUN: opt < %s -loop-interchange -cache-line-size=64 -pass-remarks-missed='loop-interchange' \
; RUN: -da-disable-delinearization-checks -pass-remarks-output=%t \ ; RUN: -da-disable-delinearization-checks -pass-remarks-output=%t \
; RUN: -verify-loop-info -verify-dom-info -S | FileCheck -check-prefix=IR %s ; RUN: -verify-loop-info -verify-dom-info -S | FileCheck -check-prefix=IR %s
; RUN: FileCheck --check-prefix=DELIN --input-file=%t %s ; RUN: FileCheck --check-prefix=DELIN --input-file=%t %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"
@A = common global [100 x [100 x i32]] zeroinitializer @A = common global [100 x [100 x i32]] zeroinitializer
@B = common global [100 x [100 x [100 x i32]]] zeroinitializer @B = common global [100 x [100 x [100 x i32]]] zeroinitializer
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopInterchange/debuginfo.ll

; RUN: opt < %s -basic-aa -loop-interchange -cache-line-size=64 -pass-remarks='loop-interchange' -pass-remarks-output=%t -S \ ; RUN: opt < %s -loop-interchange -cache-line-size=64 -pass-remarks='loop-interchange' -pass-remarks-output=%t -S \
; RUN: -verify-dom-info -verify-loop-info | FileCheck %s ; RUN: -verify-dom-info -verify-loop-info | FileCheck %s
; RUN: FileCheck -check-prefix=REMARK --input-file=%t %s ; RUN: FileCheck -check-prefix=REMARK --input-file=%t %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"
@A = common global [100 x [100 x i64]] zeroinitializer @A = common global [100 x [100 x i64]] zeroinitializer
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopInterchange/inner-indvar-depend-on-outer-indvar.ll

; REQUIRES: asserts ; REQUIRES: asserts
; RUN: opt < %s -basic-aa -loop-interchange -cache-line-size=64 -verify-dom-info -verify-loop-info \ ; RUN: opt < %s -loop-interchange -cache-line-size=64 -verify-dom-info -verify-loop-info \
; RUN: -S -debug 2>&1 | FileCheck %s ; RUN: -S -debug 2>&1 | FileCheck %s
@A = common global [100 x [100 x i64]] zeroinitializer @A = common global [100 x [100 x i64]] zeroinitializer
@N = dso_local local_unnamed_addr global i64 100, align 8 @N = dso_local local_unnamed_addr global i64 100, align 8
;; for(int i=0;i<100;i++) ;; for(int i=0;i<100;i++)
;; for(int j=0;j<i;j++) ;; for(int j=0;j<i;j++)
▲ Show 20 Lines • Show All 143 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopInterchange/inner-only-reductions.ll

; RUN: opt < %s -basic-aa -loop-interchange -cache-line-size=64 -pass-remarks-missed='loop-interchange' -pass-remarks-output=%t -S \ ; RUN: opt < %s -loop-interchange -cache-line-size=64 -pass-remarks-missed='loop-interchange' -pass-remarks-output=%t -S \
; RUN: -verify-dom-info -verify-loop-info -verify-loop-lcssa 2>&1 | FileCheck -check-prefix=IR %s ; RUN: -verify-dom-info -verify-loop-info -verify-loop-lcssa 2>&1 | FileCheck -check-prefix=IR %s
; RUN: FileCheck --input-file=%t %s ; RUN: FileCheck --input-file=%t %s
; Inner loop only reductions are not supported currently. See discussion at ; Inner loop only reductions are not supported currently. See discussion at
; D53027 for more information on the required checks. ; D53027 for more information on the required checks.
@A = common global [500 x [500 x i32]] zeroinitializer @A = common global [500 x [500 x i32]] zeroinitializer
@X = common global i32 0 @X = common global i32 0
▲ Show 20 Lines • Show All 115 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopInterchange/innermost-latch-uses-values-in-middle-header.ll

; REQUIRES: asserts ; REQUIRES: asserts
; RUN: opt < %s -basic-aa -loop-interchange -cache-line-size=64 -verify-dom-info -verify-loop-info \ ; RUN: opt < %s -loop-interchange -cache-line-size=64 -verify-dom-info -verify-loop-info \
; RUN: -S -debug 2>&1 | FileCheck %s ; RUN: -S -debug 2>&1 | FileCheck %s
@a = common global i32 0, align 4 @a = common global i32 0, align 4
@d = common dso_local local_unnamed_addr global [1 x [6 x i32]] zeroinitializer, align 4 @d = common dso_local local_unnamed_addr global [1 x [6 x i32]] zeroinitializer, align 4
;; After interchanging the innermost and the middle loop, we should not continue ;; After interchanging the innermost and the middle loop, we should not continue
;; doing interchange for the (new) middle loop and the outermost loop, because of ;; doing interchange for the (new) middle loop and the outermost loop, because of
;; values defined in the new innermost loop not available in the exiting block of ;; values defined in the new innermost loop not available in the exiting block of
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopInterchange/interchange-flow-dep-outer.ll

; REQUIRES: asserts ; REQUIRES: asserts
; RUN: opt < %s -basic-aa -loop-interchange -cache-line-size=64 -verify-dom-info -verify-loop-info \ ; RUN: opt < %s -loop-interchange -cache-line-size=64 -verify-dom-info -verify-loop-info \
; RUN: -S -debug 2>&1 | FileCheck %s ; RUN: -S -debug 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"
@A = common global [100 x [100 x i32]] zeroinitializer @A = common global [100 x [100 x i32]] zeroinitializer
@B = common global [100 x i32] zeroinitializer @B = common global [100 x i32] zeroinitializer
@C = common global [100 x [100 x i32]] zeroinitializer @C = common global [100 x [100 x i32]] zeroinitializer
@D = common global [100 x [100 x [100 x i32]]] zeroinitializer @D = common global [100 x [100 x [100 x i32]]] zeroinitializer
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopInterchange/interchange-insts-between-indvar.ll

; RUN: opt < %s -basic-aa -loop-interchange -cache-line-size=64 -verify-dom-info -verify-loop-info \ ; RUN: opt < %s -loop-interchange -cache-line-size=64 -verify-dom-info -verify-loop-info \
; RUN: -S -pass-remarks=loop-interchange 2>&1 | FileCheck %s ; RUN: -S -pass-remarks=loop-interchange 2>&1 | FileCheck %s
@A10 = local_unnamed_addr global [3 x [3 x i32]] zeroinitializer, align 16 @A10 = local_unnamed_addr global [3 x [3 x i32]] zeroinitializer, align 16
;; Test to make sure we can handle zext instructions introduced by ;; Test to make sure we can handle zext instructions introduced by
;; IndVarSimplify. ;; IndVarSimplify.
;; ;;
;; for (int i = 0; i < 2; ++i) ;; for (int i = 0; i < 2; ++i)
Show All 39 Lines

llvm/test/Transforms/LoopInterchange/interchangeable-innerloop-multiple-indvars.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -loop-interchange -cache-line-size=64 -verify-dom-info -verify-loop-info -verify-scev -verify-loop-lcssa -S | FileCheck %s ; RUN: opt < %s -loop-interchange -cache-line-size=64 -verify-dom-info -verify-loop-info -verify-scev -verify-loop-lcssa -S | FileCheck %s
@b = common dso_local local_unnamed_addr global [200 x [200 x i32]] zeroinitializer, align 4 @b = common dso_local local_unnamed_addr global [200 x [200 x i32]] zeroinitializer, align 4
@a = common dso_local local_unnamed_addr global i32 0, align 4 @a = common dso_local local_unnamed_addr global i32 0, align 4
;; int a, c, d, e; ;; int a, c, d, e;
;; int b[200][200]; ;; int b[200][200];
;; void fn1() { ;; void fn1() {
;; for (c = 0; c < 100; c++) { ;; for (c = 0; c < 100; c++) {
▲ Show 20 Lines • Show All 287 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopInterchange/interchangeable-outerloop-multiple-indvars.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s --basic-aa -loop-interchange -cache-line-size=64 -verify-dom-info -verify-loop-info -verify-scev -verify-loop-lcssa -S | FileCheck %s ; RUN: opt < %s -loop-interchange -cache-line-size=64 -verify-dom-info -verify-loop-info -verify-scev -verify-loop-lcssa -S | FileCheck %s
@b = constant [200 x [100 x i32]] zeroinitializer, align 4 @b = constant [200 x [100 x i32]] zeroinitializer, align 4
@a = constant i32 0, align 4 @a = constant i32 0, align 4
; // Loop wth two outer indvars. ; // Loop wth two outer indvars.
; int a, c, d, e; ; int a, c, d, e;
; int b[200][100]; ; int b[200][100];
; void test1() { ; void test1() {
▲ Show 20 Lines • Show All 288 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopInterchange/interchangeable.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -loop-interchange -cache-line-size=64 -verify-dom-info -verify-loop-info -verify-scev -verify-loop-lcssa -S | FileCheck %s ; RUN: opt < %s -loop-interchange -cache-line-size=64 -verify-dom-info -verify-loop-info -verify-scev -verify-loop-lcssa -S | FileCheck %s
; RUN: opt < %s -aa-pipeline=basic-aa -passes=loop-interchange -cache-line-size=64 -verify-dom-info -verify-loop-info -verify-scev -verify-loop-lcssa -S | FileCheck %s ; RUN: opt < %s -aa-pipeline=basic-aa -passes=loop-interchange -cache-line-size=64 -verify-dom-info -verify-loop-info -verify-scev -verify-loop-lcssa -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"
@A = common global [100 x [100 x i64]] zeroinitializer @A = common global [100 x [100 x i64]] zeroinitializer
@B = common global [100 x i64] zeroinitializer @B = common global [100 x i64] zeroinitializer
;; for(int i=0;i<100;i++) ;; for(int i=0;i<100;i++)
▲ Show 20 Lines • Show All 193 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopInterchange/interchanged-loop-nest-3.ll

; REQUIRES: asserts ; REQUIRES: asserts
; RUN: opt < %s -basic-aa -loop-interchange -cache-line-size=64 -verify-dom-info -verify-loop-info \ ; RUN: opt < %s -loop-interchange -cache-line-size=64 -verify-dom-info -verify-loop-info \
; RUN: -S -debug 2>&1 | FileCheck %s ; RUN: -S -debug 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"
@D = common global [100 x [100 x [100 x i32]]] zeroinitializer @D = common global [100 x [100 x [100 x i32]]] zeroinitializer
;; Test for interchange in loop nest greater than 2. ;; Test for interchange in loop nest greater than 2.
;; for(int i=0;i<100;i++) ;; for(int i=0;i<100;i++)
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopInterchange/lcssa-preheader.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -loop-interchange -cache-line-size=64 -pass-remarks-missed='loop-interchange' -verify-loop-lcssa -S | FileCheck %s ; RUN: opt < %s -loop-interchange -cache-line-size=64 -pass-remarks-missed='loop-interchange' -verify-loop-lcssa -S | FileCheck %s
; RUN: opt < %s -basic-aa -loop-interchange -cache-line-size=64 -da-disable-delinearization-checks -pass-remarks-missed='loop-interchange' -verify-loop-lcssa -S | FileCheck -check-prefix=CHECK-DELIN %s ; RUN: opt < %s -loop-interchange -cache-line-size=64 -da-disable-delinearization-checks -pass-remarks-missed='loop-interchange' -verify-loop-lcssa -S | FileCheck -check-prefix=CHECK-DELIN %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"
; void foo(int n, int m) { ; void foo(int n, int m) {
; int temp[16][16]; ; int temp[16][16];
; int res[16][16]; ; int res[16][16];
; for(int i = 0; i < n; i++) { ; for(int i = 0; i < n; i++) {
; for(int j = 0; j < m; j++) ; for(int j = 0; j < m; j++)
▲ Show 20 Lines • Show All 158 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopInterchange/lcssa.ll

; RUN: opt < %s -basic-aa -loop-interchange -cache-line-size=64 -pass-remarks-missed='loop-interchange' -verify-loop-lcssa -pass-remarks-output=%t -S ; RUN: opt < %s -loop-interchange -cache-line-size=64 -pass-remarks-missed='loop-interchange' -verify-loop-lcssa -pass-remarks-output=%t -S
; RUN: FileCheck --input-file %t --check-prefix REMARK %s ; RUN: FileCheck --input-file %t --check-prefix REMARK %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"
@A = common global [100 x [100 x i32]] zeroinitializer @A = common global [100 x [100 x i32]] zeroinitializer
@C = common global [100 x [100 x i32]] zeroinitializer @C = common global [100 x [100 x i32]] zeroinitializer
@X = common global i32 0 @X = common global i32 0
@Y = common global i64 0 @Y = common global i64 0
▲ Show 20 Lines • Show All 324 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopInterchange/loop-interchange-optimization-remarks.ll

; Test optimization remarks generated by the LoopInterchange pass. ; Test optimization remarks generated by the LoopInterchange pass.
; ;
; RUN: opt < %s -basic-aa -loop-interchange -cache-line-size=64 -verify-dom-info -verify-loop-info \ ; RUN: opt < %s -loop-interchange -cache-line-size=64 -verify-dom-info -verify-loop-info \
; RUN: -pass-remarks-output=%t -pass-remarks-missed='loop-interchange' \ ; RUN: -pass-remarks-output=%t -pass-remarks-missed='loop-interchange' \
; RUN: -pass-remarks='loop-interchange' -S ; RUN: -pass-remarks='loop-interchange' -S
; RUN: cat %t | FileCheck %s ; RUN: cat %t | FileCheck %s
; RUN: opt < %s -basic-aa -loop-interchange -cache-line-size=64 -verify-dom-info -verify-loop-info \ ; RUN: opt < %s -loop-interchange -cache-line-size=64 -verify-dom-info -verify-loop-info \
; RUN: -pass-remarks-output=%t -pass-remarks-missed='loop-interchange' \ ; RUN: -pass-remarks-output=%t -pass-remarks-missed='loop-interchange' \
; RUN: -pass-remarks='loop-interchange' -S -da-disable-delinearization-checks ; RUN: -pass-remarks='loop-interchange' -S -da-disable-delinearization-checks
; RUN: cat %t | FileCheck --check-prefix=DELIN %s ; RUN: cat %t | FileCheck --check-prefix=DELIN %s
@A = common global [100 x [100 x i32]] zeroinitializer @A = common global [100 x [100 x i32]] zeroinitializer
@B = common global [100 x [100 x i32]] zeroinitializer @B = common global [100 x [100 x i32]] zeroinitializer
@C = common global [100 x i32] zeroinitializer @C = common global [100 x i32] zeroinitializer
▲ Show 20 Lines • Show All 238 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopInterchange/not-interchanged-dependencies-1.ll

; REQUIRES: asserts ; REQUIRES: asserts
; RUN: opt < %s -basic-aa -loop-interchange -cache-line-size=64 -verify-dom-info -verify-loop-info \ ; RUN: opt < %s -loop-interchange -cache-line-size=64 -verify-dom-info -verify-loop-info \
; RUN: -S -debug 2>&1 | FileCheck %s ; RUN: -S -debug 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"
@A = common global [100 x [100 x i32]] zeroinitializer @A = common global [100 x [100 x i32]] zeroinitializer
@B = common global [100 x i32] zeroinitializer @B = common global [100 x i32] zeroinitializer
;; Loops should not be interchanged in this case as it is not legal due to dependency. ;; Loops should not be interchanged in this case as it is not legal due to dependency.
Show All 33 Lines

llvm/test/Transforms/LoopInterchange/not-interchanged-loop-nest-3.ll

; REQUIRES: asserts ; REQUIRES: asserts
; RUN: opt < %s -basic-aa -loop-interchange -cache-line-size=64 -verify-dom-info -verify-loop-info \ ; RUN: opt < %s -loop-interchange -cache-line-size=64 -verify-dom-info -verify-loop-info \
; RUN: -S -debug 2>&1 | FileCheck %s ; RUN: -S -debug 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"
@D = common global [100 x [100 x [100 x i32]]] zeroinitializer @D = common global [100 x [100 x [100 x i32]]] zeroinitializer
;; Test for interchange in loop nest greater than 2. ;; Test for interchange in loop nest greater than 2.
;; for(int i=0;i<100;i++) ;; for(int i=0;i<100;i++)
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopInterchange/not-interchanged-tightly-nested.ll

; REQUIRES: asserts ; REQUIRES: asserts
; RUN: opt < %s -basic-aa -loop-interchange -cache-line-size=64 -verify-dom-info -verify-loop-info \ ; RUN: opt < %s -loop-interchange -cache-line-size=64 -verify-dom-info -verify-loop-info \
; RUN: -S -debug 2>&1 | FileCheck %s ; RUN: -S -debug 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"
@A = common global [100 x [100 x i32]] zeroinitializer @A = common global [100 x [100 x i32]] zeroinitializer
@B = common global [100 x i32] zeroinitializer @B = common global [100 x i32] zeroinitializer
@C = common global [100 x [100 x i32]] zeroinitializer @C = common global [100 x [100 x i32]] zeroinitializer
@D = common global [100 x [100 x [100 x i32]]] zeroinitializer @D = common global [100 x [100 x [100 x i32]]] zeroinitializer
▲ Show 20 Lines • Show All 132 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopInterchange/outer-header-jump-to-inner-latch.ll

; RUN: opt -basic-aa -loop-interchange -cache-line-size=64 -verify-dom-info -verify-loop-info -verify-loop-lcssa -S %s | FileCheck %s ; RUN: opt -loop-interchange -cache-line-size=64 -verify-dom-info -verify-loop-info -verify-loop-lcssa -S %s | FileCheck %s
@b = global [3 x [5 x [8 x i16]]] [[5 x [8 x i16]] zeroinitializer, [5 x [8 x i16]] [[8 x i16] zeroinitializer, [8 x i16] [i16 0, i16 0, i16 0, i16 6, i16 1, i16 6, i16 0, i16 0], [8 x i16] zeroinitializer, [8 x i16] zeroinitializer, [8 x i16] zeroinitializer], [5 x [8 x i16]] zeroinitializer], align 2 @b = global [3 x [5 x [8 x i16]]] [[5 x [8 x i16]] zeroinitializer, [5 x [8 x i16]] [[8 x i16] zeroinitializer, [8 x i16] [i16 0, i16 0, i16 0, i16 6, i16 1, i16 6, i16 0, i16 0], [8 x i16] zeroinitializer, [8 x i16] zeroinitializer, [8 x i16] zeroinitializer], [5 x [8 x i16]] zeroinitializer], align 2
@a = common global i32 0, align 4 @a = common global i32 0, align 4
@d = common dso_local local_unnamed_addr global [1 x [6 x i32]] zeroinitializer, align 4 @d = common dso_local local_unnamed_addr global [1 x [6 x i32]] zeroinitializer, align 4
; Doubly nested loop ; Doubly nested loop
;; C test case: ;; C test case:
▲ Show 20 Lines • Show All 193 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopInterchange/outer-only-reductions.ll

; RUN: opt < %s -basic-aa -loop-interchange -cache-line-size=64 -pass-remarks-missed='loop-interchange' -pass-remarks-output=%t -S \ ; RUN: opt < %s -loop-interchange -cache-line-size=64 -pass-remarks-missed='loop-interchange' -pass-remarks-output=%t -S \
; RUN: -verify-dom-info -verify-loop-info -verify-loop-lcssa 2>&1 | FileCheck -check-prefix=IR %s ; RUN: -verify-dom-info -verify-loop-info -verify-loop-lcssa 2>&1 | FileCheck -check-prefix=IR %s
; RUN: FileCheck --input-file=%t %s ; RUN: FileCheck --input-file=%t %s
; Outer loop only reductions are not supported currently. ; Outer loop only reductions are not supported currently.
@A = common global [500 x [500 x i32]] zeroinitializer @A = common global [500 x [500 x i32]] zeroinitializer
;; global X ;; global X
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopInterchange/pr43326-ideal-access-pattern.ll

; RUN: opt < %s -basic-aa -loop-interchange -cache-line-size=64 -pass-remarks-missed='loop-interchange' -pass-remarks-output=%t -S \ ; RUN: opt < %s -loop-interchange -cache-line-size=64 -pass-remarks-missed='loop-interchange' -pass-remarks-output=%t -S \
; RUN: -verify-dom-info -verify-loop-info -verify-loop-lcssa -stats 2>&1 ; RUN: -verify-dom-info -verify-loop-info -verify-loop-lcssa -stats 2>&1
; RUN: FileCheck --input-file=%t --check-prefix=REMARKS %s ; RUN: FileCheck --input-file=%t --check-prefix=REMARKS %s
; Triply nested loop, should be able to do interchange three times ; Triply nested loop, should be able to do interchange three times
; to get the ideal access pattern. ; to get the ideal access pattern.
; void f(int e[10][10][10], int f[10][10][10]) { ; void f(int e[10][10][10], int f[10][10][10]) {
; for (int a = 0; a < 10; a++) { ; for (int a = 0; a < 10; a++) {
; for (int b = 0; b < 10; b++) { ; for (int b = 0; b < 10; b++) {
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Linesfor.innermost: ; preds = %for.middle.header, %for.innermost
%arrayidx12 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %e, i64 %indvars.innermost, i64 %indvars.middle, i64 %indvars.outermost %arrayidx12 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %e, i64 %indvars.innermost, i64 %indvars.middle, i64 %indvars.outermost
%0 = load i32, i32* %arrayidx12 %0 = load i32, i32* %arrayidx12
%arrayidx18 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %f, i64 %indvars.innermost, i64 %indvars.middle, i64 %indvars.outermost %arrayidx18 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %f, i64 %indvars.innermost, i64 %indvars.middle, i64 %indvars.outermost
store i32 %0, i32* %arrayidx18 store i32 %0, i32* %arrayidx18
%indvars.innermost.next = add nuw nsw i64 %indvars.innermost, 1 %indvars.innermost.next = add nuw nsw i64 %indvars.innermost, 1
%exitcond.innermost = icmp ne i64 %indvars.innermost.next, 10 %exitcond.innermost = icmp ne i64 %indvars.innermost.next, 10
br i1 %exitcond.innermost, label %for.innermost, label %for.middle.latch br i1 %exitcond.innermost, label %for.innermost, label %for.middle.latch
} }
No newline at end of file No newline at end of file

llvm/test/Transforms/LoopInterchange/pr43326.ll

; RUN: opt < %s -basic-aa -loop-interchange -cache-line-size=64 -pass-remarks-missed='loop-interchange' -pass-remarks-output=%t -S \ ; RUN: opt < %s -loop-interchange -cache-line-size=64 -pass-remarks-missed='loop-interchange' -pass-remarks-output=%t -S \
; RUN: -verify-dom-info -verify-loop-info -verify-loop-lcssa -stats 2>&1 ; RUN: -verify-dom-info -verify-loop-info -verify-loop-lcssa -stats 2>&1
; RUN: FileCheck --input-file=%t --check-prefix=REMARKS %s ; RUN: FileCheck --input-file=%t --check-prefix=REMARKS %s
@a = global i32 0 @a = global i32 0
@b = global i8 0 @b = global i8 0
@c = global i32 0 @c = global i32 0
@d = global i32 0 @d = global i32 0
@e = global [1 x [1 x i32]] zeroinitializer @e = global [1 x [1 x i32]] zeroinitializer
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopInterchange/pr48212.ll

; RUN: opt < %s -basic-aa -loop-interchange -cache-line-size=64 -pass-remarks-missed='loop-interchange' -pass-remarks-output=%t -S \ ; RUN: opt < %s -loop-interchange -cache-line-size=64 -pass-remarks-missed='loop-interchange' -pass-remarks-output=%t -S \
; RUN: -verify-dom-info -verify-loop-info -verify-loop-lcssa 2>&1 ; RUN: -verify-dom-info -verify-loop-info -verify-loop-lcssa 2>&1
; RUN: FileCheck --input-file=%t --check-prefix=REMARKS %s ; RUN: FileCheck --input-file=%t --check-prefix=REMARKS %s
; REMARKS: --- !Passed ; REMARKS: --- !Passed
; REMARKS-NEXT: Pass: loop-interchange ; REMARKS-NEXT: Pass: loop-interchange
; REMARKS-NEXT: Name: Interchanged ; REMARKS-NEXT: Name: Interchanged
; REMARKS-NEXT: Function: pr48212 ; REMARKS-NEXT: Function: pr48212
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopInterchange/reductions-across-inner-and-outer-loop.ll

; RUN: opt < %s -basic-aa -loop-interchange -cache-line-size=64 -pass-remarks-missed='loop-interchange' -pass-remarks-output=%t -S \ ; RUN: opt < %s -loop-interchange -cache-line-size=64 -pass-remarks-missed='loop-interchange' -pass-remarks-output=%t -S \
; RUN: -verify-dom-info -verify-loop-info -verify-loop-lcssa -stats 2>&1 | FileCheck %s ; RUN: -verify-dom-info -verify-loop-info -verify-loop-lcssa -stats 2>&1 | FileCheck %s
; RUN: FileCheck --input-file=%t --check-prefix=REMARKS %s ; RUN: FileCheck --input-file=%t --check-prefix=REMARKS %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"
; REMARKS: --- !Passed ; REMARKS: --- !Passed
; REMARKS-NEXT: Pass: loop-interchange ; REMARKS-NEXT: Pass: loop-interchange
▲ Show 20 Lines • Show All 299 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopLoadElim/multiple-stores-same-block.ll

; RUN: opt -basic-aa -loop-load-elim -S < %s | FileCheck %s ; RUN: opt -loop-load-elim -S < %s | FileCheck %s
; In this case the later store forward to the load: ; In this case the later store forward to the load:
; ;
; for (unsigned i = 0; i < 100; i++) { ; for (unsigned i = 0; i < 100; i++) {
; B[i] = A[i] + 1; ; B[i] = A[i] + 1;
; A[i+1] = C[i] + 2; ; A[i+1] = C[i] + 2;
; A[i+1] = D[i] + 3; ; A[i+1] = D[i] + 3;
; } ; }
Show All 39 Lines

llvm/test/Transforms/LoopLoadElim/opt-size.ll

; RUN: opt -basic-aa -loop-load-elim -S < %s | FileCheck %s ; RUN: opt -loop-load-elim -S < %s | FileCheck %s
; RUN: opt -aa-pipeline=basic-aa -passes='require<profile-summary>,function(loop-load-elim)' -S < %s | FileCheck %s -check-prefix=PGSO ; RUN: opt -aa-pipeline=basic-aa -passes='require<profile-summary>,function(loop-load-elim)' -S < %s | FileCheck %s -check-prefix=PGSO
; RUN: opt -basic-aa -loop-load-elim -pgso=false -S < %s | FileCheck %s -check-prefix=NPGSO ; RUN: opt -loop-load-elim -pgso=false -S < %s | FileCheck %s -check-prefix=NPGSO
; When optimizing for size don't eliminate in this loop because the loop would ; When optimizing for size don't eliminate in this loop because the loop would
; have to be versioned first because A and C may alias. ; have to be versioned first because A and C may alias.
; ;
; for (unsigned i = 0; i < 100; i++) { ; for (unsigned i = 0; i < 100; i++) {
; A[i+1] = B[i] + 2; ; A[i+1] = B[i] + 2;
; C[i] = A[i] * 2; ; C[i] = A[i] * 2;
; } ; }
▲ Show 20 Lines • Show All 118 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopLoadElim/pr46854-adress-spaces.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; REQUIRES: amdgpu-registered-target ; REQUIRES: amdgpu-registered-target
; RUN: opt -globals-aa -loop-simplify -loop-load-elim -S %s | FileCheck %s ; RUN: opt -passes='require<globals-aa>,loop-simplify,loop-load-elim' -S %s | FileCheck %s
target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5-ni:7" target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5-ni:7"
target triple = "amdgcn-amd-amdhsa" target triple = "amdgcn-amd-amdhsa"
%struct.foo = type { %struct.pluto, i8, i8*, i32 } %struct.foo = type { %struct.pluto, i8, i8*, i32 }
%struct.pluto = type { i32, i32, i32, %struct.wombat*, i32, i32, i32 } %struct.pluto = type { i32, i32, i32, %struct.wombat*, i32, i32, i32 }
%struct.wombat = type { %struct.barney } %struct.wombat = type { %struct.barney }
%struct.barney = type { <2 x float> } %struct.barney = type { <2 x float> }
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopLoadElim/unknown-dep.ll

; RUN: opt -basic-aa -loop-load-elim -S < %s | FileCheck %s ; RUN: opt -loop-load-elim -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"
; Give up in the presence of unknown deps. Here, the different strides result ; Give up in the presence of unknown deps. Here, the different strides result
; in unknown dependence: ; in unknown dependence:
; ;
; for (unsigned i = 0; i < 100; i++) { ; for (unsigned i = 0; i < 100; i++) {
; A[i+1] = B[i] + 2; ; A[i+1] = B[i] + 2;
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopPredication/invariant_load.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S -basic-aa -loop-predication < %s 2>&1 | FileCheck %s ; RUN: opt -S -loop-predication < %s 2>&1 | FileCheck %s
; RUN: opt -S -aa-pipeline=basic-aa -passes='require<aa>,require<scalar-evolution>,loop-mssa(loop-predication)' -verify-memoryssa < %s 2>&1 | FileCheck %s ; RUN: opt -S -aa-pipeline=basic-aa -passes='require<aa>,require<scalar-evolution>,loop-mssa(loop-predication)' -verify-memoryssa < %s 2>&1 | FileCheck %s
declare void @llvm.experimental.guard(i1, ...) declare void @llvm.experimental.guard(i1, ...)
@UNKNOWN = external global i1 @UNKNOWN = external global i1
define i32 @neg_length_variant(i32* %array, i32* %length, i32 %n) { define i32 @neg_length_variant(i32* %array, i32* %length, i32 %n) {
; CHECK-LABEL: @neg_length_variant( ; CHECK-LABEL: @neg_length_variant(
▲ Show 20 Lines • Show All 435 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopSimplify/2010-07-15-IncorrectDomFrontierUpdate.ll

; RUN: opt < %s -domfrontier -loop-simplify -domfrontier -verify-dom-info ; RUN: opt < %s -passes='require<domfrontier>,loop-simplify,require<domfrontier>' -verify-dom-info
define void @a() nounwind { define void @a() nounwind {
entry: entry:
br i1 undef, label %bb37, label %bb1.i br i1 undef, label %bb37, label %bb1.i
bb1.i: ; preds = %bb1.i, %bb bb1.i: ; preds = %bb1.i, %bb
%indvar = phi i64 [ %indvar.next, %bb1.i ], [ 0, %entry ] ; <i64> [#uses=1] %indvar = phi i64 [ %indvar.next, %bb1.i ], [ 0, %entry ] ; <i64> [#uses=1]
Show All 11 Lines

llvm/test/Transforms/LoopSimplify/ashr-crash.ll

; RUN: opt -basic-aa -loop-rotate -licm -instcombine -indvars -loop-unroll -S %s | FileCheck %s ; RUN: opt -loop-rotate -licm -instcombine -indvars -loop-unroll -S %s | FileCheck %s
; ;
; PR18361: ScalarEvolution::getAddRecExpr(): ; PR18361: ScalarEvolution::getAddRecExpr():
; Assertion `isLoopInvariant(Operands[i],... ; Assertion `isLoopInvariant(Operands[i],...
; ;
; After a series of loop optimizations, SCEV's LoopDispositions grow stale. ; After a series of loop optimizations, SCEV's LoopDispositions grow stale.
; In particular, LoopSimplify hoists %cmp4, resulting in this SCEV for %add: ; In particular, LoopSimplify hoists %cmp4, resulting in this SCEV for %add:
; {(zext i1 %cmp4 to i32),+,1}<nw><%for.cond1.preheader> ; {(zext i1 %cmp4 to i32),+,1}<nw><%for.cond1.preheader>
; ;
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopStrengthReduce/pr3086.ll

; RUN: opt < %s -loop-reduce ; RUN: opt < %s -loop-reduce
; RUN: opt < %s -scalar-evolution ; RUN: opt < %s -passes='require<scalar-evolution>'
; PR 3086 ; PR 3086
%struct.Cls = type { i32, i8, [2 x %struct.Cls*], [2 x %struct.Lit*] } %struct.Cls = type { i32, i8, [2 x %struct.Cls*], [2 x %struct.Lit*] }
%struct.Lit = type { i8 } %struct.Lit = type { i8 }
define fastcc i64 @collect_clauses() nounwind { define fastcc i64 @collect_clauses() nounwind {
entry: entry:
br label %bb11 br label %bb11
Show All 19 Lines

llvm/test/Transforms/LoopUnroll/update-loop-info-in-subloops.ll

; RUN: opt -S < %s -loop-unroll -block-freq | FileCheck %s
; RUN: opt -S < %s -passes='require<opt-remark-emit>,loop-unroll,require<block-freq>' | FileCheck %s ; RUN: opt -S < %s -passes='require<opt-remark-emit>,loop-unroll,require<block-freq>' | FileCheck %s
; Crasher from PR20987. ; Crasher from PR20987.
; CHECK: define void @update_loop_info_in_subloops ; CHECK: define void @update_loop_info_in_subloops
; CHECK: entry: ; CHECK: entry:
; CHECK: L: ; CHECK: L:
; CHECK: L.inner: ; CHECK: L.inner:
; CHECK: L.inner.latch: ; CHECK: L.inner.latch:
Show All 27 Lines

llvm/test/Transforms/LoopUnrollAndJam/dependencies.ll

; RUN: opt -basic-aa -loop-unroll-and-jam -allow-unroll-and-jam -unroll-and-jam-count=4 < %s -S | FileCheck %s ; RUN: opt -loop-unroll-and-jam -allow-unroll-and-jam -unroll-and-jam-count=4 < %s -S | FileCheck %s
; RUN: opt -aa-pipeline=basic-aa -passes='loop-unroll-and-jam' -allow-unroll-and-jam -unroll-and-jam-count=4 < %s -S | FileCheck %s ; RUN: opt -aa-pipeline=basic-aa -passes='loop-unroll-and-jam' -allow-unroll-and-jam -unroll-and-jam-count=4 < %s -S | FileCheck %s
target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64" target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
; CHECK-LABEL: fore_aft_less ; CHECK-LABEL: fore_aft_less
; CHECK: %j = phi ; CHECK: %j = phi
; CHECK: %j.1 = phi ; CHECK: %j.1 = phi
; CHECK: %j.2 = phi ; CHECK: %j.2 = phi
▲ Show 20 Lines • Show All 464 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopUnrollAndJam/dependencies_multidims.ll

; RUN: opt -da-disable-delinearization-checks -basic-aa -loop-unroll-and-jam -allow-unroll-and-jam -unroll-and-jam-count=4 < %s -S | FileCheck %s ; RUN: opt -da-disable-delinearization-checks -loop-unroll-and-jam -allow-unroll-and-jam -unroll-and-jam-count=4 < %s -S | FileCheck %s
; RUN: opt -da-disable-delinearization-checks -aa-pipeline=basic-aa -passes='loop-unroll-and-jam' -allow-unroll-and-jam -unroll-and-jam-count=4 < %s -S | FileCheck %s ; RUN: opt -da-disable-delinearization-checks -aa-pipeline=basic-aa -passes='loop-unroll-and-jam' -allow-unroll-and-jam -unroll-and-jam-count=4 < %s -S | FileCheck %s
target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64" target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
; CHECK-LABEL: sub_sub_less ; CHECK-LABEL: sub_sub_less
; CHECK: %j = phi ; CHECK: %j = phi
; CHECK-NOT: %j.1 = phi ; CHECK-NOT: %j.1 = phi
define void @sub_sub_less([100 x i32]* noalias nocapture %A, i32 %N, i32* noalias nocapture readonly %B) { define void @sub_sub_less([100 x i32]* noalias nocapture %A, i32 %N, i32* noalias nocapture readonly %B) {
▲ Show 20 Lines • Show All 210 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopUnrollAndJam/followup.ll

; RUN: opt -basic-aa -tbaa -loop-unroll-and-jam -allow-unroll-and-jam -unroll-and-jam-count=4 -unroll-remainder < %s -S | FileCheck %s ; RUN: opt -loop-unroll-and-jam -allow-unroll-and-jam -unroll-and-jam-count=4 -unroll-remainder < %s -S | FileCheck %s
; ;
; Check that followup attributes are set in the new loops. ; Check that followup attributes are set in the new loops.
; ;
target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64" target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
define void @followup(i32 %I, i32 %J, i32* noalias nocapture %A, i32* noalias nocapture readonly %B) { define void @followup(i32 %I, i32 %J, i32* noalias nocapture %A, i32* noalias nocapture readonly %B) {
entry: entry:
%cmp = icmp ne i32 %J, 0 %cmp = icmp ne i32 %J, 0
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopUnrollAndJam/unroll-and-jam-many-instr.ll

; RUN: opt -basic-aa -tbaa -loop-unroll-and-jam -allow-unroll-and-jam -unroll-and-jam-count=4 < %s -S | FileCheck %s ; RUN: opt -loop-unroll-and-jam -allow-unroll-and-jam -unroll-and-jam-count=4 < %s -S | FileCheck %s
target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128" target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
@a = common dso_local local_unnamed_addr global i32 0, align 4 @a = common dso_local local_unnamed_addr global i32 0, align 4
@b = common dso_local local_unnamed_addr global i8 0, align 1 @b = common dso_local local_unnamed_addr global i8 0, align 1
@e = common dso_local local_unnamed_addr global i64 0, align 8 @e = common dso_local local_unnamed_addr global i64 0, align 8
@c = common dso_local local_unnamed_addr global i32* null, align 8 @c = common dso_local local_unnamed_addr global i32* null, align 8
@g = common dso_local local_unnamed_addr global i64 0, align 8 @g = common dso_local local_unnamed_addr global i64 0, align 8
@f = common dso_local local_unnamed_addr global i32 0, align 4 @f = common dso_local local_unnamed_addr global i32 0, align 4
▲ Show 20 Lines • Show All 371 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopUnrollAndJam/unroll-and-jam.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -basic-aa -tbaa -loop-unroll-and-jam -allow-unroll-and-jam -unroll-and-jam-count=4 -unroll-remainder < %s -S | FileCheck %s ; RUN: opt -loop-unroll-and-jam -allow-unroll-and-jam -unroll-and-jam-count=4 -unroll-remainder < %s -S | FileCheck %s
; RUN: opt -aa-pipeline=tbaa,basic-aa -passes='loop-unroll-and-jam' -allow-unroll-and-jam -unroll-and-jam-count=4 -unroll-remainder < %s -S | FileCheck %s ; RUN: opt -aa-pipeline=tbaa,basic-aa -passes='loop-unroll-and-jam' -allow-unroll-and-jam -unroll-and-jam-count=4 -unroll-remainder < %s -S | FileCheck %s
target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64" target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
; Tests for(i) { sum = 0; for(j) sum += B[j]; A[i] = sum; } ; Tests for(i) { sum = 0; for(j) sum += B[j]; A[i] = sum; }
define void @test1(i32 %I, i32 %E, i32* noalias nocapture %A, i32* noalias nocapture readonly %B) #0 { define void @test1(i32 %I, i32 %E, i32* noalias nocapture %A, i32* noalias nocapture readonly %B) #0 {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
▲ Show 20 Lines • Show All 1,470 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopVectorize/AArch64/loop-vectorization-factors.ll

; RUN: opt -S < %s -basic-aa -loop-vectorize -force-vector-interleave=1 2>&1 | FileCheck %s ; RUN: opt -S < %s -loop-vectorize -force-vector-interleave=1 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"
target triple = "aarch64" target triple = "aarch64"
; CHECK-LABEL: @add_a( ; CHECK-LABEL: @add_a(
; CHECK: load <16 x i8>, <16 x i8>* ; CHECK: load <16 x i8>, <16 x i8>*
; CHECK: add <16 x i8> ; CHECK: add <16 x i8>
; CHECK: store <16 x i8> ; CHECK: store <16 x i8>
▲ Show 20 Lines • Show All 301 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopVectorize/ARM/vector_cast.ll

; RUN: opt -loop-vectorize -tbaa -S -mattr=+neon < %s | FileCheck %s ; RUN: opt -loop-vectorize -S -mattr=+neon < %s | FileCheck %s
target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64" target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
target triple = "armv7--linux-gnueabi" target triple = "armv7--linux-gnueabi"
; This requires the loop vectorizer to create an interleaved access group ; This requires the loop vectorizer to create an interleaved access group
; for the stores to the struct. Here we need to perform a bitcast from a vector ; for the stores to the struct. Here we need to perform a bitcast from a vector
; of pointers to a vector i32s. ; of pointers to a vector i32s.
Show All 28 Lines

llvm/test/Transforms/LoopVectorize/PowerPC/stride-vectorization.ll

; RUN: opt -S -basic-aa -loop-vectorize < %s | FileCheck %s ; RUN: opt -S -loop-vectorize < %s | FileCheck %s
target datalayout = "E-m:e-i64:64-n32:64" target datalayout = "E-m:e-i64:64-n32:64"
target triple = "powerpc64-unknown-linux-gnu" target triple = "powerpc64-unknown-linux-gnu"
; Function Attrs: nounwind ; Function Attrs: nounwind
define void @foo(double* noalias nocapture %a, double* noalias nocapture readonly %b) #0 { define void @foo(double* noalias nocapture %a, double* noalias nocapture readonly %b) #0 {
entry: entry:
br label %for.body br label %for.body
Show All 27 Lines

llvm/test/Transforms/LoopVectorize/PowerPC/widened-massv-vfabi-attr.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -vectorizer-maximize-bandwidth -mtriple=powerpc64le-- -S \ ; RUN: opt -vectorizer-maximize-bandwidth -mtriple=powerpc64le-- -S \
; RUN: -targetlibinfo -loop-simplify -loop-rotate -loop-vectorize \ ; RUN: -loop-simplify -loop-rotate -loop-vectorize \
; RUN: -instcombine -simplifycfg -simplifycfg-require-and-preserve-domtree=1 -force-vector-interleave=1 < %s | FileCheck %s ; RUN: -instcombine -simplifycfg -simplifycfg-require-and-preserve-domtree=1 -force-vector-interleave=1 < %s | FileCheck %s
define dso_local double @test(float* %Arr) { define dso_local double @test(float* %Arr) {
; CHECK-LABEL: @test( ; CHECK-LABEL: @test(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[VECTOR_BODY:%.*]] ; CHECK-NEXT: br label [[VECTOR_BODY:%.*]]
; CHECK: vector.body: ; CHECK: vector.body:
; CHECK-NEXT: [[INDEX:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[INDEX_NEXT:%.*]], [[VECTOR_BODY]] ] ; CHECK-NEXT: [[INDEX:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[INDEX_NEXT:%.*]], [[VECTOR_BODY]] ]
; CHECK-NEXT: [[VEC_PHI:%.*]] = phi <2 x double> [ zeroinitializer, [[ENTRY]] ], [ [[TMP5:%.*]], [[VECTOR_BODY]] ] ; CHECK-NEXT: [[VEC_PHI:%.*]] = phi <2 x double> [ zeroinitializer, [[ENTRY]] ], [ [[TMP5:%.*]], [[VECTOR_BODY]] ]
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopVectorize/X86/max-mstore.ll

; RUN: opt -basic-aa -loop-vectorize -force-vector-interleave=1 -S -mcpu=core-avx2 ; RUN: opt -loop-vectorize -force-vector-interleave=1 -S -mcpu=core-avx2
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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
@b = common global [256 x i32] zeroinitializer, align 16 @b = common global [256 x i32] zeroinitializer, align 16
@a = common global [256 x i32] zeroinitializer, align 16 @a = common global [256 x i32] zeroinitializer, align 16
; unsigned int a[256], b[256]; ; unsigned int a[256], b[256];
Show All 37 Lines

llvm/test/Transforms/LoopVectorize/X86/small-size.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -loop-vectorize-with-block-frequency -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -loop-vectorize-with-block-frequency -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"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
@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
▲ Show 20 Lines • Show All 571 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopVectorize/X86/uniform_load.ll

; RUN: opt -basic-aa -loop-vectorize -S -mcpu=core-avx2 < %s | FileCheck %s ; RUN: opt -loop-vectorize -S -mcpu=core-avx2 < %s | FileCheck %s
;float inc = 0.5; ;float inc = 0.5;
;void foo(float *A, unsigned N) { ;void foo(float *A, unsigned N) {
; ;
; for (unsigned i=0; i<N; i++){ ; for (unsigned i=0; i<N; i++){
; A[i] += inc; ; A[i] += inc;
; } ; }
;} ;}
Show All 38 Lines

llvm/test/Transforms/LoopVectorize/X86/vector_ptr_load_store.ll

; RUN: opt -basic-aa -loop-vectorize -mcpu=corei7-avx -debug -S < %s 2>&1 | FileCheck %s ; RUN: opt -loop-vectorize -mcpu=corei7-avx -debug -S < %s 2>&1 | FileCheck %s
; REQUIRES: asserts ; REQUIRES: asserts
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"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
%0 = type { %0*, %1 } %0 = type { %0*, %1 }
%1 = type { i8*, i32 } %1 = type { i8*, i32 }
▲ Show 20 Lines • Show All 145 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopVectorize/X86/vectorize-only-for-real.ll

; RUN: opt -S -basic-aa -loop-vectorize < %s | FileCheck %s ; RUN: opt -S -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"
target triple = "x86_64-apple-macosx10.11.0" target triple = "x86_64-apple-macosx10.11.0"
define i32 @accum(i32* nocapture readonly %x, i32 %N) #0 { define i32 @accum(i32* nocapture readonly %x, i32 %N) #0 {
entry: entry:
; CHECK-LABEL: @accum ; CHECK-LABEL: @accum
; CHECK-NOT: x i32> ; CHECK-NOT: x i32>
Show All 30 Lines

llvm/test/Transforms/LoopVectorize/calloc.ll

; RUN: opt < %s -basic-aa -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -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

llvm/test/Transforms/LoopVectorize/gcc-examples.ll

; RUN: opt < %s -basic-aa -loop-vectorize -force-vector-width=4 -force-vector-interleave=1 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize -force-vector-width=4 -force-vector-interleave=1 -dce -instcombine -S | FileCheck %s
; RUN: opt < %s -basic-aa -loop-vectorize -force-vector-width=4 -force-vector-interleave=4 -dce -instcombine -S | FileCheck %s -check-prefix=UNROLL ; RUN: opt < %s -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 676 Lines • Show Last 20 Lines

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

; RUN: opt < %s -basic-aa -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -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

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

; RUN: opt -basic-aa -scoped-noalias-aa -loop-vectorize -licm -force-vector-width=2 \ ; RUN: opt -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

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

; RUN: opt -basic-aa -loop-vectorize -force-vector-width=2 \ ; RUN: opt -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 -basic-aa -scoped-noalias-aa -loop-vectorize -dse -force-vector-width=2 \ ; RUN: opt -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

llvm/test/Transforms/LoopVectorize/pr25281.ll

; RUN: opt < %s -scev-aa -loop-vectorize -print-alias-sets -S -o - 2>&1 | FileCheck %s ; RUN: opt < %s -aa-pipeline=scev-aa -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 41 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopVectorize/ptr_loops.ll

; RUN: opt < %s -basic-aa -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S -enable-if-conversion | FileCheck %s ; RUN: opt < %s -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

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

; RUN: opt -S -march=r600 -mcpu=cayman -basic-aa -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine < %s | FileCheck %s ; RUN: opt -S -march=r600 -mcpu=cayman -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

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

; RUN: opt -S -basic-aa -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine < %s | FileCheck %s ; RUN: opt -S -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

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

; RUN: opt -basic-aa -loop-vectorize -enable-mem-access-versioning -force-vector-width=2 -force-vector-interleave=1 < %s -S | FileCheck %s ; RUN: opt -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 85 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopVersioning/basic.ll

; RUN: opt -basic-aa -loop-versioning -S < %s | FileCheck %s ; RUN: opt -loop-versioning -S < %s | FileCheck %s
; RUN: opt -aa-pipeline=basic-aa -passes=loop-versioning -S < %s | FileCheck %s ; RUN: opt -aa-pipeline=basic-aa -passes=loop-versioning -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"
; Version this loop with overlap checks between a, c and b, c. ; Version this loop with overlap checks between a, c and b, c.
define void @f(i32* %a, i32* %b, i32* %c) { define void @f(i32* %a, i32* %b, i32* %c) {
entry: entry:
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopVersioning/convergent.ll

; RUN: opt -basic-aa -loop-versioning -S < %s | FileCheck %s ; RUN: opt -loop-versioning -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"
; Do not version this loop because of a convergent operation ; Do not version this loop because of a convergent operation
; CHECK-LABEL: @f( ; CHECK-LABEL: @f(
; CHECK: call i32 @llvm.convergent( ; CHECK: call i32 @llvm.convergent(
; CHECK-NOT: call i32 @llvm.convergent( ; CHECK-NOT: call i32 @llvm.convergent(
Show All 31 Lines

llvm/test/Transforms/LoopVersioning/lcssa.ll

; RUN: opt -basic-aa -loop-versioning -S < %s | FileCheck %s ; RUN: opt -loop-versioning -S < %s | FileCheck %s
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @fill(i8** %ls1.20, i8** %ls2.21, i8* %cse3.22) { define void @fill(i8** %ls1.20, i8** %ls2.21, i8* %cse3.22) {
; CHECK-LABEL: @fill( ; CHECK-LABEL: @fill(
; CHECK-NEXT: bb1.lver.check: ; CHECK-NEXT: bb1.lver.check:
; CHECK-NEXT: [[LS1_20_PROMOTED:%.*]] = load i8*, i8** [[LS1_20:%.*]], align 8 ; CHECK-NEXT: [[LS1_20_PROMOTED:%.*]] = load i8*, i8** [[LS1_20:%.*]], align 8
; CHECK-NEXT: [[LS2_21_PROMOTED:%.*]] = load i8*, i8** [[LS2_21:%.*]], align 8 ; CHECK-NEXT: [[LS2_21_PROMOTED:%.*]] = load i8*, i8** [[LS2_21:%.*]], align 8
; CHECK-NEXT: [[SCEVGEP:%.*]] = getelementptr i8, i8* [[LS1_20_PROMOTED]], i64 -1 ; CHECK-NEXT: [[SCEVGEP:%.*]] = getelementptr i8, i8* [[LS1_20_PROMOTED]], i64 -1
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopVersioning/noalias-version-twice.ll

; RUN: opt -basic-aa -loop-distribute -enable-loop-distribute -loop-simplify -scoped-noalias-aa \ ; RUN: opt -loop-distribute -enable-loop-distribute -loop-simplify \
; RUN: -loop-versioning -S < %s | FileCheck %s ; RUN: -loop-versioning -S < %s | FileCheck %s
; Test the metadata generated when versioning an already versioned loop. Here ; Test the metadata generated when versioning an already versioned loop. Here
; we invoke loop distribution to perform the first round of versioning. It ; we invoke loop distribution to perform the first round of versioning. It
; adds memchecks for accesses that can alias across the distribution boundary. ; adds memchecks for accesses that can alias across the distribution boundary.
; Then we further version the distributed loops to fully disambiguate accesses ; Then we further version the distributed loops to fully disambiguate accesses
; within each. ; within each.
; ;
▲ Show 20 Lines • Show All 98 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopVersioning/noalias.ll

; RUN: opt -basic-aa -loop-versioning -S < %s | FileCheck %s ; RUN: opt -loop-versioning -S < %s | FileCheck %s
; A very simple case. After versioning the %loadA and %loadB can't alias with ; A very simple case. After versioning the %loadA and %loadB can't alias with
; the store. ; the store.
; ;
; To see it easier what's going on, I expanded every noalias/scope metadata ; To see it easier what's going on, I expanded every noalias/scope metadata
; reference below in a comment. For a scope I use the format scope(domain), ; reference below in a comment. For a scope I use the format scope(domain),
; e.g. scope 17 in domain 15 is written as 17(15). ; e.g. scope 17 in domain 15 is written as 17(15).
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

llvm/test/Transforms/MemCpyOpt/2008-02-24-MultipleUseofSRet.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -memcpyopt -dse -S -verify-memoryssa | FileCheck %s ; RUN: opt < %s -memcpyopt -dse -S -verify-memoryssa | FileCheck %s
; PR2077 ; PR2077
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" 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"
target triple = "i386-pc-linux-gnu" target triple = "i386-pc-linux-gnu"
%0 = type { x86_fp80, x86_fp80 } %0 = type { x86_fp80, x86_fp80 }
define internal fastcc void @initialize(ptr noalias nocapture sret(%0) %agg.result) nounwind { define internal fastcc void @initialize(ptr noalias nocapture sret(%0) %agg.result) nounwind {
Show All 38 Lines

llvm/test/Transforms/MemCpyOpt/2008-03-13-ReturnSlotBitcast.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -memcpyopt -S -verify-memoryssa | FileCheck %s ; RUN: opt < %s -memcpyopt -S -verify-memoryssa | FileCheck %s
target datalayout = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64" target datalayout = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64"
%a = type { i32 } %a = type { i32 }
%b = type { float } %b = type { float }
declare void @g(ptr nocapture) declare void @g(ptr nocapture)
define float @f() { define float @f() {
Show All 18 Lines

llvm/test/Transforms/MemCpyOpt/2011-06-02-CallSlotOverwritten.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -memcpyopt -S -verify-memoryssa | FileCheck %s ; RUN: opt < %s -memcpyopt -S -verify-memoryssa | FileCheck %s
; PR10067 ; PR10067
; Make sure the call+copy isn't optimized in such a way that ; Make sure the call+copy isn't optimized in such a way that
; %ret ends up with the wrong value. ; %ret ends up with the wrong value.
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:128:128-n8:16:32" 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:128:128-n8:16:32"
target triple = "i386-apple-darwin10" target triple = "i386-apple-darwin10"
%struct1 = type { i32, i32 } %struct1 = type { i32, i32 }
Show All 32 Lines

llvm/test/Transforms/MemCpyOpt/aa-recursion-assertion-failure.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S -scoped-noalias-aa -memcpyopt < %s | FileCheck %s ; RUN: opt -S -memcpyopt < %s | FileCheck %s
; ModuleID = '<stdin>' ; ModuleID = '<stdin>'
source_filename = "test.cpp" source_filename = "test.cpp"
target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128" target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
target triple = "aarch64-unknown-linux-android21" target triple = "aarch64-unknown-linux-android21"
define dso_local void @_Z1ml(i64 %e) { define dso_local void @_Z1ml(i64 %e) {
; CHECK-LABEL: @_Z1ml( ; CHECK-LABEL: @_Z1ml(
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

llvm/test/Transforms/MemCpyOpt/align.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -S -basic-aa -memcpyopt -verify-memoryssa | FileCheck %s ; RUN: opt < %s -S -memcpyopt -verify-memoryssa | FileCheck %s
target datalayout = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64" target datalayout = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64"
declare void @llvm.memcpy.p0.p0.i64(ptr nocapture, ptr nocapture, i64, i1) nounwind declare void @llvm.memcpy.p0.p0.i64(ptr nocapture, ptr nocapture, i64, i1) nounwind
declare void @llvm.memset.p0.i64(ptr nocapture, i8, i64, i1) nounwind declare void @llvm.memset.p0.i64(ptr nocapture, i8, i64, i1) nounwind
; The resulting memset is only 4-byte aligned, despite containing ; The resulting memset is only 4-byte aligned, despite containing
; a 16-byte aligned store in the middle. ; a 16-byte aligned store in the middle.
Show All 33 Lines

llvm/test/Transforms/MemCpyOpt/atomic.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -basic-aa -memcpyopt -S < %s -verify-memoryssa | FileCheck %s ; RUN: opt -memcpyopt -S < %s -verify-memoryssa | 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" 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"
target triple = "x86_64-apple-macosx10.7.0" target triple = "x86_64-apple-macosx10.7.0"
@x = global i32 0 @x = global i32 0
declare void @otherf(ptr) declare void @otherf(ptr)
Show All 40 Lines

llvm/test/Transforms/MemCpyOpt/callslot_aa.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -S -basic-aa -memcpyopt -verify-memoryssa | FileCheck %s ; RUN: opt < %s -S -memcpyopt -verify-memoryssa | 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"
%T = type { i64, i64 } %T = type { i64, i64 }
define void @test(ptr %src) { define void @test(ptr %src) {
; CHECK-LABEL: @test( ; CHECK-LABEL: @test(
; CHECK-NEXT: [[TMP:%.*]] = alloca i8, align 1 ; CHECK-NEXT: [[TMP:%.*]] = alloca i8, align 1
; CHECK-NEXT: [[DST:%.*]] = alloca i8, align 1 ; CHECK-NEXT: [[DST:%.*]] = alloca i8, align 1
Show All 18 Lines

llvm/test/Transforms/MemCpyOpt/callslot_deref.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -S -basic-aa -memcpyopt -verify-memoryssa | FileCheck %s ; RUN: opt < %s -S -memcpyopt -verify-memoryssa | FileCheck %s
target datalayout = "e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-i64:64-f80:128-n8:16:32:64-S128"
declare void @llvm.memcpy.p0.p0.i64(ptr nocapture, ptr nocapture readonly, i64, i1) unnamed_addr nounwind declare void @llvm.memcpy.p0.p0.i64(ptr nocapture, ptr nocapture readonly, i64, i1) unnamed_addr nounwind
declare void @llvm.memset.p0.i64(ptr nocapture, i8, i64, i1) nounwind declare void @llvm.memset.p0.i64(ptr nocapture, i8, i64, i1) nounwind
; all bytes of %dst that are touch by the memset are dereferenceable ; all bytes of %dst that are touch by the memset are dereferenceable
define void @must_remove_memcpy(ptr noalias nocapture dereferenceable(4096) %dst) nofree nosync { define void @must_remove_memcpy(ptr noalias nocapture dereferenceable(4096) %dst) nofree nosync {
; CHECK-LABEL: @must_remove_memcpy( ; CHECK-LABEL: @must_remove_memcpy(
Show All 24 Lines

llvm/test/Transforms/MemCpyOpt/capturing-func.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature
; RUN: opt < %s -basic-aa -globals-aa -memcpyopt -S -verify-memoryssa | FileCheck %s ; RUN: opt < %s -passes='require<globals-aa>,memcpyopt' -S -verify-memoryssa | FileCheck %s
target datalayout = "e" target datalayout = "e"
declare void @foo(ptr) declare void @foo(ptr)
declare void @llvm.memcpy.p0.p0.i32(ptr nocapture, ptr nocapture, i32, i1) nounwind declare void @llvm.memcpy.p0.p0.i32(ptr nocapture, ptr nocapture, i32, i1) nounwind
declare void @llvm.lifetime.start.p0(i64, ptr nocapture) declare void @llvm.lifetime.start.p0(i64, ptr nocapture)
declare void @llvm.lifetime.end.p0(i64, ptr nocapture) declare void @llvm.lifetime.end.p0(i64, ptr nocapture)
▲ Show 20 Lines • Show All 203 Lines • Show Last 20 Lines

llvm/test/Transforms/MemCpyOpt/crash.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -S -basic-aa -memcpyopt -verify-memoryssa | FileCheck %s ; RUN: opt < %s -S -memcpyopt -verify-memoryssa | 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:128:128-a0:0:64" 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:128:128-a0:0:64"
target triple = "armv7-eabi" target triple = "armv7-eabi"
%struct.qw = type { [4 x float] } %struct.qw = type { [4 x float] }
%struct.bar = type { %struct.qw, %struct.qw, %struct.qw, %struct.qw, %struct.qw, float, float} %struct.bar = type { %struct.qw, %struct.qw, %struct.qw, %struct.qw, %struct.qw, float, float}
; PR4882 ; PR4882
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

llvm/test/Transforms/MemCpyOpt/invariant.start.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; MemCpy optimizations should take place even in presence of invariant.start ; MemCpy optimizations should take place even in presence of invariant.start
; RUN: opt < %s -basic-aa -memcpyopt -S -verify-memoryssa | FileCheck %s ; RUN: opt < %s -memcpyopt -S -verify-memoryssa | 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:128:128" 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:128:128"
target triple = "i686-apple-darwin9" target triple = "i686-apple-darwin9"
%0 = type { x86_fp80, x86_fp80 } %0 = type { x86_fp80, x86_fp80 }
declare void @llvm.memcpy.p0.p0.i32(ptr nocapture, ptr nocapture, i32, i1) nounwind declare void @llvm.memcpy.p0.p0.i32(ptr nocapture, ptr nocapture, i32, i1) nounwind
declare void @llvm.memcpy.p0.p0.i64(ptr nocapture, ptr nocapture readonly, i64, i1) declare void @llvm.memcpy.p0.p0.i64(ptr nocapture, ptr nocapture readonly, i64, i1)
Show All 36 Lines

llvm/test/Transforms/MemCpyOpt/load-store-to-memcpy.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -basic-aa -scoped-noalias-aa -memcpyopt -S %s -verify-memoryssa | FileCheck %s ; RUN: opt -memcpyopt -S %s -verify-memoryssa | FileCheck %s
%T = type { i8, i32 } %T = type { i8, i32 }
; A global constant of %T ; A global constant of %T
@C = external constant %T @C = external constant %T
; Ensure load-store forwarding of an aggregate is interpreted as ; Ensure load-store forwarding of an aggregate is interpreted as
; a memmove when the source and dest may alias ; a memmove when the source and dest may alias
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

llvm/test/Transforms/MemCpyOpt/loadstore-sret.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S < %s -basic-aa -memcpyopt -verify-memoryssa | FileCheck %s ; RUN: opt -S < %s -memcpyopt -verify-memoryssa | FileCheck %s
; <rdar://problem/8536696> ; <rdar://problem/8536696>
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" 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"
target triple = "x86_64-apple-darwin10.0.0" target triple = "x86_64-apple-darwin10.0.0"
%"class.std::auto_ptr" = type { ptr } %"class.std::auto_ptr" = type { ptr }
define void @_Z3foov(ptr noalias nocapture sret(%"class.std::auto_ptr") %agg.result) ssp { define void @_Z3foov(ptr noalias nocapture sret(%"class.std::auto_ptr") %agg.result) ssp {
Show All 15 Lines

llvm/test/Transforms/MemCpyOpt/memcpy-to-memset-with-lifetimes.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -basic-aa -memcpyopt -instcombine -S < %s -verify-memoryssa | FileCheck %s ; RUN: opt -memcpyopt -instcombine -S < %s -verify-memoryssa | FileCheck %s
target datalayout = "e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @foo(ptr noalias nocapture sret([8 x i64]) dereferenceable(64) %sret) { define void @foo(ptr noalias nocapture sret([8 x i64]) dereferenceable(64) %sret) {
; CHECK-LABEL: @foo( ; CHECK-LABEL: @foo(
; CHECK-NEXT: entry-block: ; CHECK-NEXT: entry-block:
; CHECK-NEXT: call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(64) [[SRET:%.*]], i8 0, i64 64, i1 false) ; CHECK-NEXT: call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(64) [[SRET:%.*]], i8 0, i64 64, i1 false)
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

llvm/test/Transforms/MemCpyOpt/memcpy-undef.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -memcpyopt -S -verify-memoryssa | FileCheck %s ; RUN: opt < %s -memcpyopt -S -verify-memoryssa | 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"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
%struct.foo = type { i8, [7 x i8], i32 } %struct.foo = type { i8, [7 x i8], i32 }
; Check that the memcpy is removed. ; Check that the memcpy is removed.
define i32 @test1(ptr nocapture %foobie) nounwind noinline ssp uwtable { define i32 @test1(ptr nocapture %foobie) nounwind noinline ssp uwtable {
▲ Show 20 Lines • Show All 117 Lines • Show Last 20 Lines

llvm/test/Transforms/MemCpyOpt/memcpy.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -memcpyopt -dse -S -verify-memoryssa | FileCheck %s ; RUN: opt < %s -memcpyopt -dse -S -verify-memoryssa | 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:128:128" 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:128:128"
target triple = "i686-apple-darwin9" target triple = "i686-apple-darwin9"
%0 = type { x86_fp80, x86_fp80 } %0 = type { x86_fp80, x86_fp80 }
%1 = type { i32, i32 } %1 = type { i32, i32 }
@C = external constant [0 x i8] @C = external constant [0 x i8]
▲ Show 20 Lines • Show All 369 Lines • Show Last 20 Lines

llvm/test/Transforms/MemCpyOpt/memmove.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -memcpyopt -S -verify-memoryssa | FileCheck %s ; RUN: opt < %s -memcpyopt -S -verify-memoryssa | FileCheck %s
; These memmoves should get optimized to memcpys. ; These memmoves should get optimized to memcpys.
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" 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"
target triple = "x86_64-apple-darwin9.0" target triple = "x86_64-apple-darwin9.0"
@C = external constant [0 x i8] @C = external constant [0 x i8]
declare void @llvm.memmove.p0.p0.i64(ptr nocapture, ptr nocapture, i64, i1) nounwind declare void @llvm.memmove.p0.p0.i64(ptr nocapture, ptr nocapture, i64, i1) nounwind
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

llvm/test/Transforms/MemCpyOpt/memset-memcpy-redundant-memset.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -basic-aa -memcpyopt -S %s -verify-memoryssa | FileCheck %s ; RUN: opt -memcpyopt -S %s -verify-memoryssa | 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"
@C = external constant [0 x i8] @C = external constant [0 x i8]
define void @test_constant(i64 %src_size, ptr %dst, i64 %dst_size, i8 %c) { define void @test_constant(i64 %src_size, ptr %dst, i64 %dst_size, i8 %c) {
; CHECK-LABEL: @test_constant( ; CHECK-LABEL: @test_constant(
; CHECK-NEXT: [[TMP1:%.*]] = icmp ule i64 [[DST_SIZE:%.*]], [[SRC_SIZE:%.*]] ; CHECK-NEXT: [[TMP1:%.*]] = icmp ule i64 [[DST_SIZE:%.*]], [[SRC_SIZE:%.*]]
▲ Show 20 Lines • Show All 334 Lines • Show Last 20 Lines

llvm/test/Transforms/MemCpyOpt/opaque-ptr.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -basic-aa -memcpyopt -S %s -verify-memoryssa -opaque-pointers | FileCheck %s ; RUN: opt -memcpyopt -S %s -verify-memoryssa -opaque-pointers | FileCheck %s
define void @test_memset_memcpy(ptr %src, i64 %src_size, ptr noalias %dst, i64 %dst_size, i8 %c) { define void @test_memset_memcpy(ptr %src, i64 %src_size, ptr noalias %dst, i64 %dst_size, i8 %c) {
; CHECK-LABEL: @test_memset_memcpy( ; CHECK-LABEL: @test_memset_memcpy(
; CHECK-NEXT: [[TMP1:%.*]] = icmp ule i64 [[DST_SIZE:%.*]], [[SRC_SIZE:%.*]] ; CHECK-NEXT: [[TMP1:%.*]] = icmp ule i64 [[DST_SIZE:%.*]], [[SRC_SIZE:%.*]]
; CHECK-NEXT: [[TMP2:%.*]] = sub i64 [[DST_SIZE]], [[SRC_SIZE]] ; CHECK-NEXT: [[TMP2:%.*]] = sub i64 [[DST_SIZE]], [[SRC_SIZE]]
; CHECK-NEXT: [[TMP3:%.*]] = select i1 [[TMP1]], i64 0, i64 [[TMP2]] ; CHECK-NEXT: [[TMP3:%.*]] = select i1 [[TMP1]], i64 0, i64 [[TMP2]]
; CHECK-NEXT: [[TMP4:%.*]] = getelementptr i8, ptr [[DST:%.*]], i64 [[SRC_SIZE]] ; CHECK-NEXT: [[TMP4:%.*]] = getelementptr i8, ptr [[DST:%.*]], i64 [[SRC_SIZE]]
; CHECK-NEXT: call void @llvm.memset.p0.i64(ptr align 1 [[TMP4]], i8 [[C:%.*]], i64 [[TMP3]], i1 false) ; CHECK-NEXT: call void @llvm.memset.p0.i64(ptr align 1 [[TMP4]], i8 [[C:%.*]], i64 [[TMP3]], i1 false)
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

llvm/test/Transforms/MemCpyOpt/sret.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -memcpyopt -S -verify-memoryssa | FileCheck %s ; RUN: opt < %s -memcpyopt -S -verify-memoryssa | 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:128:128" 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:128:128"
target triple = "i686-apple-darwin9" target triple = "i686-apple-darwin9"
%0 = type { x86_fp80, x86_fp80 } %0 = type { x86_fp80, x86_fp80 }
define void @ccosl(ptr noalias sret(%0) %agg.result, ptr byval(%0) align 8 %z) nounwind { define void @ccosl(ptr noalias sret(%0) %agg.result, ptr byval(%0) align 8 %z) nounwind {
; CHECK-LABEL: @ccosl( ; CHECK-LABEL: @ccosl(
Show All 31 Lines

llvm/test/Transforms/NewGVN/cond_br2-xfail.ll

; XFAIL: * ; XFAIL: *
; RUN: opt -basic-aa -newgvn -S < %s | FileCheck %s ; RUN: opt -newgvn -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"
%"class.llvm::SmallVector" = type { %"class.llvm::SmallVectorImpl", [1 x %"union.llvm::SmallVectorBase::U"] } %"class.llvm::SmallVector" = type { %"class.llvm::SmallVectorImpl", [1 x %"union.llvm::SmallVectorBase::U"] }
%"class.llvm::SmallVectorImpl" = type { %"class.llvm::SmallVectorTemplateBase" } %"class.llvm::SmallVectorImpl" = type { %"class.llvm::SmallVectorTemplateBase" }
%"class.llvm::SmallVectorTemplateBase" = type { %"class.llvm::SmallVectorTemplateCommon" } %"class.llvm::SmallVectorTemplateBase" = type { %"class.llvm::SmallVectorTemplateCommon" }
%"class.llvm::SmallVectorTemplateCommon" = type { %"class.llvm::SmallVectorBase" } %"class.llvm::SmallVectorTemplateCommon" = type { %"class.llvm::SmallVectorBase" }
%"class.llvm::SmallVectorBase" = type { i8*, i8*, i8*, %"union.llvm::SmallVectorBase::U" } %"class.llvm::SmallVectorBase" = type { i8*, i8*, i8*, %"union.llvm::SmallVectorBase::U" }
%"union.llvm::SmallVectorBase::U" = type { x86_fp80 } %"union.llvm::SmallVectorBase::U" = type { x86_fp80 }
▲ Show 20 Lines • Show All 131 Lines • Show Last 20 Lines

llvm/test/Transforms/NewGVN/noalias.ll

; RUN: opt -scoped-noalias-aa -basic-aa -newgvn -S < %s | FileCheck %s ; RUN: opt -newgvn -S < %s | FileCheck %s
define i32 @test1(i32* %p, i32* %q) { define i32 @test1(i32* %p, i32* %q) {
; CHECK-LABEL: @test1(i32* %p, i32* %q) ; CHECK-LABEL: @test1(i32* %p, i32* %q)
; CHECK: load i32, i32* %p ; CHECK: load i32, i32* %p
; CHECK-NOT: noalias ; CHECK-NOT: noalias
; CHECK: %c = add i32 %a, %a ; CHECK: %c = add i32 %a, %a
%a = load i32, i32* %p, !noalias !3 %a = load i32, i32* %p, !noalias !3
%b = load i32, i32* %p %b = load i32, i32* %p
Show All 35 Lines

llvm/test/Transforms/NewGVN/pr17852.ll

; RUN: opt < %s -basic-aa -newgvn ; RUN: opt < %s -newgvn
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.S0 = type { [2 x i8], [2 x i8], [4 x i8], [2 x i8], i32, i32, i32, i32 } %struct.S0 = type { [2 x i8], [2 x i8], [4 x i8], [2 x i8], i32, i32, i32, i32 }
define void @fn1(%struct.S0* byval(%struct.S0) align 8 %p1) { define void @fn1(%struct.S0* byval(%struct.S0) align 8 %p1) {
br label %for.cond br label %for.cond
for.cond: ; preds = %1, %0 for.cond: ; preds = %1, %0
br label %for.end br label %for.end
%f2 = getelementptr inbounds %struct.S0, %struct.S0* %p1, i64 0, i32 2 %f2 = getelementptr inbounds %struct.S0, %struct.S0* %p1, i64 0, i32 2
%f9 = getelementptr inbounds %struct.S0, %struct.S0* %p1, i64 0, i32 7 %f9 = getelementptr inbounds %struct.S0, %struct.S0* %p1, i64 0, i32 7
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

llvm/test/Transforms/NewGVN/rle.ll

; RUN: opt < %s -data-layout="e-p:32:32:32-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-n8:16:32" -basic-aa -newgvn -S -dce | FileCheck %s ; RUN: opt < %s -data-layout="e-p:32:32:32-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-n8:16:32" -newgvn -S -dce | FileCheck %s
; RUN: opt < %s -data-layout="E-p:32:32:32-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-n32" -basic-aa -newgvn -S -dce | FileCheck %s ; RUN: opt < %s -data-layout="E-p:32:32:32-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-n32" -newgvn -S -dce | FileCheck %s
; memset -> i16 forwarding. ; memset -> i16 forwarding.
define signext i16 @memset_to_i16_local(i16* %A) nounwind ssp { define signext i16 @memset_to_i16_local(i16* %A) nounwind ssp {
entry: entry:
%conv = bitcast i16* %A to i8* %conv = bitcast i16* %A to i8*
tail call void @llvm.memset.p0i8.i64(i8* %conv, i8 1, i64 200, i1 false) tail call void @llvm.memset.p0i8.i64(i8* %conv, i8 1, i64 200, i1 false)
%arrayidx = getelementptr inbounds i16, i16* %A, i64 42 %arrayidx = getelementptr inbounds i16, i16* %A, i64 42
%tmp2 = load i16, i16* %arrayidx %tmp2 = load i16, i16* %arrayidx
ret i16 %tmp2 ret i16 %tmp2
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

llvm/test/Transforms/NewGVN/stale-loop-info.ll

; RUN: opt -loops -newgvn -S < %s | FileCheck %s ; RUN: opt -passes='require<loops>,newgvn' -S < %s | FileCheck %s
; This used to fail with ASAN enabled and if for some reason LoopInfo remained ; This used to fail with ASAN enabled and if for some reason LoopInfo remained
; available during GVN. In this case BasicAA will use LI but ; available during GVN. In this case BasicAA will use LI but
; MergeBlockIntoPredecessor in GVN failed to update LI. ; MergeBlockIntoPredecessor in GVN failed to update LI.
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"
%struct.wibble.1028 = type { i32, i32, %struct.barney.881 } %struct.wibble.1028 = type { i32, i32, %struct.barney.881 }
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

llvm/test/Transforms/NewGVN/tbaa.ll

; RUN: opt -tbaa -basic-aa -newgvn -S < %s | FileCheck %s ; RUN: opt -newgvn -S < %s | FileCheck %s
define i32 @test1(i8* %p, i8* %q) { define i32 @test1(i8* %p, i8* %q) {
; CHECK-LABEL: @test1(i8* %p, i8* %q) ; CHECK-LABEL: @test1(i8* %p, i8* %q)
; CHECK: call i32 @foo(i8* %p) ; CHECK: call i32 @foo(i8* %p)
; CHECK-NOT: tbaa ; CHECK-NOT: tbaa
; CHECK: %c = add i32 %a, %a ; CHECK: %c = add i32 %a, %a
%a = call i32 @foo(i8* %p), !tbaa !0 %a = call i32 @foo(i8* %p), !tbaa !0
%b = call i32 @foo(i8* %p) %b = call i32 @foo(i8* %p)
▲ Show 20 Lines • Show All 139 Lines • Show Last 20 Lines

llvm/test/Transforms/NewGVN/unreachable_block_infinite_loop.ll

; RUN: opt -memdep -newgvn -disable-output < %s ; RUN: opt -newgvn -disable-output < %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" 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"
target triple = "x86_64-apple-darwin10.0" target triple = "x86_64-apple-darwin10.0"
define i32 @test2() nounwind ssp { define i32 @test2() nounwind ssp {
entry: entry:
ret i32 0 ret i32 0
Show All 34 Lines

llvm/test/Transforms/NewGVN/volatile-nonvolatile.ll

; RUN: opt -tbaa -newgvn -S < %s | FileCheck %s ; RUN: opt -newgvn -S < %s | FileCheck %s
%struct.t = type { i32* } %struct.t = type { i32* }
; The loaded address and the location of the address itself are not aliased, ; The loaded address and the location of the address itself are not aliased,
; so the second reload is not necessary. Check that it can be eliminated. ; so the second reload is not necessary. Check that it can be eliminated.
; CHECK-LABEL: test1 ; CHECK-LABEL: test1
; CHECK: load ; CHECK: load
; CHECK-NOT: load ; CHECK-NOT: load
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

llvm/test/Transforms/ObjCARC/basic.ll

; RUN: opt -basic-aa -objc-arc -S < %s | FileCheck %s ; RUN: opt -objc-arc -S < %s | FileCheck %s
; RUN: opt -aa-pipeline=basic-aa -passes=objc-arc -S < %s | FileCheck %s ; RUN: opt -aa-pipeline=basic-aa -passes=objc-arc -S < %s | FileCheck %s
target datalayout = "e-p:64:64:64" target datalayout = "e-p:64:64:64"
declare i8* @llvm.objc.retain(i8*) declare i8* @llvm.objc.retain(i8*)
declare i8* @llvm.objc.retainAutoreleasedReturnValue(i8*) declare i8* @llvm.objc.retainAutoreleasedReturnValue(i8*)
declare i8* @llvm.objc.unsafeClaimAutoreleasedReturnValue(i8*) declare i8* @llvm.objc.unsafeClaimAutoreleasedReturnValue(i8*)
declare void @llvm.objc.release(i8*) declare void @llvm.objc.release(i8*)
▲ Show 20 Lines • Show All 3,069 Lines • Show Last 20 Lines

llvm/test/Transforms/ObjCARC/inlined-autorelease-return-value.ll

; RUN: opt -basic-aa -objc-arc -S < %s | FileCheck %s ; RUN: opt -objc-arc -S < %s | FileCheck %s
target datalayout = "e-p:64:64:64" target datalayout = "e-p:64:64:64"
declare i8* @llvm.objc.retain(i8*) declare i8* @llvm.objc.retain(i8*)
declare i8* @llvm.objc.autoreleaseReturnValue(i8*) declare i8* @llvm.objc.autoreleaseReturnValue(i8*)
declare i8* @llvm.objc.retainAutoreleasedReturnValue(i8*) declare i8* @llvm.objc.retainAutoreleasedReturnValue(i8*)
declare i8* @llvm.objc.unsafeClaimAutoreleasedReturnValue(i8*) declare i8* @llvm.objc.unsafeClaimAutoreleasedReturnValue(i8*)
declare void @opaque() declare void @opaque()
▲ Show 20 Lines • Show All 283 Lines • Show Last 20 Lines

llvm/test/Transforms/ObjCARC/intrinsic-use.ll

; RUN: opt -basic-aa -objc-arc -S < %s | FileCheck %s ; RUN: opt -objc-arc -S < %s | FileCheck %s
target datalayout = "e-p:64:64:64" target datalayout = "e-p:64:64:64"
declare i8* @llvm.objc.retain(i8*) declare i8* @llvm.objc.retain(i8*)
declare i8* @llvm.objc.retainAutorelease(i8*) declare i8* @llvm.objc.retainAutorelease(i8*)
declare void @llvm.objc.release(i8*) declare void @llvm.objc.release(i8*)
declare i8* @llvm.objc.autorelease(i8*) declare i8* @llvm.objc.autorelease(i8*)
▲ Show 20 Lines • Show All 121 Lines • Show Last 20 Lines

llvm/test/Transforms/ObjCARC/retain-block-side-effects.ll

; RUN: opt -S -objc-arc-aa -basic-aa -gvn < %s | FileCheck %s ; RUN: opt -S -aa-pipeline=objc-arc-aa -gvn < %s | FileCheck %s
; rdar://10050579 ; rdar://10050579
; objc_retainBlock stores into %repeater so the load from after the ; objc_retainBlock stores into %repeater so the load from after the
; call isn't forwardable from the store before the call. ; call isn't forwardable from the store before the call.
; CHECK: %tmp16 = call i8* @llvm.objc.retainBlock(i8* %tmp15) [[NUW:#[0-9]+]] ; CHECK: %tmp16 = call i8* @llvm.objc.retainBlock(i8* %tmp15) [[NUW:#[0-9]+]]
; CHECK: %tmp17 = bitcast i8* %tmp16 to void ()* ; CHECK: %tmp17 = bitcast i8* %tmp16 to void ()*
; CHECK: %tmp18 = load %struct.__block_byref_repeater*, %struct.__block_byref_repeater** %byref.forwarding, align 8 ; CHECK: %tmp18 = load %struct.__block_byref_repeater*, %struct.__block_byref_repeater** %byref.forwarding, align 8
Show All 33 Lines

llvm/test/Transforms/ObjCARC/rle-s2l.ll

; RUN: opt -S -basic-aa -objc-arc < %s | FileCheck %s ; RUN: opt -S -objc-arc < %s | FileCheck %s
declare i8* @llvm.objc.loadWeak(i8**) declare i8* @llvm.objc.loadWeak(i8**)
declare i8* @llvm.objc.loadWeakRetained(i8**) declare i8* @llvm.objc.loadWeakRetained(i8**)
declare i8* @llvm.objc.storeWeak(i8**, i8*) declare i8* @llvm.objc.storeWeak(i8**, i8*)
declare i8* @llvm.objc.initWeak(i8**, i8*) declare i8* @llvm.objc.initWeak(i8**, i8*)
declare void @use_pointer(i8*) declare void @use_pointer(i8*)
declare void @callee() declare void @callee()
▲ Show 20 Lines • Show All 129 Lines • Show Last 20 Lines

llvm/test/Transforms/ObjCARC/weak-copies.ll

; RUN: opt -S -basic-aa -objc-arc < %s | FileCheck %s ; RUN: opt -S -objc-arc < %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" 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"
target triple = "x86_64-apple-darwin11.0.0" target triple = "x86_64-apple-darwin11.0.0"
%0 = type { i64, i64, i8*, i8*, i8*, i8* } %0 = type { i64, i64, i8*, i8*, i8*, i8* }
%1 = type <{ i8*, i32, i32, i8*, %struct.__block_descriptor*, i8* }> %1 = type <{ i8*, i32, i32, i8*, %struct.__block_descriptor*, i8* }>
%struct.__block_descriptor = type { i64, i64 } %struct.__block_descriptor = type { i64, i64 }
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

llvm/test/Transforms/ObjCARC/weak-dce.ll

; RUN: opt -S -basic-aa -objc-arc < %s | FileCheck %s ; RUN: opt -S -objc-arc < %s | FileCheck %s
; rdar://11434915 ; rdar://11434915
; Delete the weak calls and replace them with just the net retain. ; Delete the weak calls and replace them with just the net retain.
; CHECK: define void @test0(i8* %p) { ; CHECK: define void @test0(i8* %p) {
; CHECK-NEXT: call i8* @llvm.objc.retain(i8* %p) ; CHECK-NEXT: call i8* @llvm.objc.retain(i8* %p)
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
Show All 37 Lines

llvm/test/Transforms/Reassociate/pr12245.ll

; RUN: opt < %s -basic-aa -inline -instcombine -reassociate -dse -disable-output ; RUN: opt < %s -inline -instcombine -reassociate -dse -disable-output
; PR12245 ; PR12245
@a = common global i32 0, align 4 @a = common global i32 0, align 4
@d = common global i32 0, align 4 @d = common global i32 0, align 4
define i32 @fn2() nounwind uwtable ssp { define i32 @fn2() nounwind uwtable ssp {
entry: entry:
%0 = load i32, i32* @a, align 4 %0 = load i32, i32* @a, align 4
Show All 37 Lines

llvm/test/Transforms/SLPVectorizer/AArch64/load-store-q.ll

; RUN: opt -S -basic-aa -slp-vectorizer < %s | FileCheck %s ; RUN: opt -S -slp-vectorizer < %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"
target triple = "arm64-apple-ios5.0.0" target triple = "arm64-apple-ios5.0.0"
; Holding a value live over a call boundary may require ; Holding a value live over a call boundary may require
; spills and fills. This is the case for <2 x double>, ; spills and fills. This is the case for <2 x double>,
; as it occupies a Q register of which there are no ; as it occupies a Q register of which there are no
; callee-saves. ; callee-saves.
Show All 37 Lines

llvm/test/Transforms/SLPVectorizer/AArch64/matmul.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -S -mtriple=aarch64-unknown-unknown -mcpu=cortex-a53 | FileCheck %s ; RUN: opt < %s -slp-vectorizer -S -mtriple=aarch64-unknown-unknown -mcpu=cortex-a53 | FileCheck %s
target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128" target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
; This test is reduced from the matrix multiplication benchmark in the test-suite: ; This test is reduced from the matrix multiplication benchmark in the test-suite:
; https://github.com/llvm/llvm-test-suite/tree/main/SingleSource/Benchmarks/Misc/matmul_f64_4x4.c ; https://github.com/llvm/llvm-test-suite/tree/main/SingleSource/Benchmarks/Misc/matmul_f64_4x4.c
; The operations here are expected to be vectorized to <2 x double>. ; The operations here are expected to be vectorized to <2 x double>.
; Otherwise, performance will suffer on Cortex-A53. ; Otherwise, performance will suffer on Cortex-A53.
▲ Show 20 Lines • Show All 121 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/AArch64/mul.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -slp-vectorizer -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"
target triple = "aarch64--linux-gnu" target triple = "aarch64--linux-gnu"
; These examples correspond to input code like: ; These examples correspond to input code like:
; ;
; void t(long * __restrict a, long * __restrict b) { ; void t(long * __restrict a, long * __restrict b) {
; a[0] *= b[0]; ; a[0] *= b[0];
▲ Show 20 Lines • Show All 98 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/AArch64/multiple_reduction.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -slp-vectorizer -S | FileCheck %s
target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128" target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
target triple = "aarch64-arm-none-eabi" target triple = "aarch64-arm-none-eabi"
; This test has mutual reductions, referencing the same data: ; This test has mutual reductions, referencing the same data:
; for i = ... ; for i = ...
; sm += x[i]; ; sm += x[i];
; sq += x[i] * x[i]; ; sq += x[i] * x[i];
▲ Show 20 Lines • Show All 1,016 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/AArch64/nontemporal.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S -basic-aa -slp-vectorizer -dce < %s | FileCheck %s ; RUN: opt -S -slp-vectorizer -dce < %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"
target triple = "arm64-apple-ios5.0.0" target triple = "arm64-apple-ios5.0.0"
define void @foo(float* noalias %a, float* noalias %b, float* noalias %c) { define void @foo(float* noalias %a, float* noalias %b, float* noalias %c) {
; CHECK-LABEL: @foo( ; CHECK-LABEL: @foo(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP0:%.*]] = bitcast float* [[B:%.*]] to <4 x float>* ; CHECK-NEXT: [[TMP0:%.*]] = bitcast float* [[B:%.*]] to <4 x float>*
; CHECK-NEXT: [[TMP1:%.*]] = load <4 x float>, <4 x float>* [[TMP0]], align 4, !nontemporal !0 ; CHECK-NEXT: [[TMP1:%.*]] = load <4 x float>, <4 x float>* [[TMP0]], align 4, !nontemporal !0
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/AArch64/reorder-fmuladd-crash.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -S -mtriple=aarch64-w32-windows-gnu | FileCheck %s ; RUN: opt < %s -slp-vectorizer -S -mtriple=aarch64-w32-windows-gnu | FileCheck %s
define i32 @foo() { define i32 @foo() {
; CHECK-LABEL: @foo( ; CHECK-LABEL: @foo(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[FOR_COND15_PREHEADER:%.*]] ; CHECK-NEXT: br label [[FOR_COND15_PREHEADER:%.*]]
; CHECK: for.cond15.preheader: ; CHECK: for.cond15.preheader:
; CHECK-NEXT: br label [[IF_END:%.*]] ; CHECK-NEXT: br label [[IF_END:%.*]]
; CHECK: for.cond15: ; CHECK: for.cond15:
▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/AArch64/sdiv-pow2.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -S -mtriple=aarch64-unknown-linux-gnu -mcpu=cortex-a57 | FileCheck %s ; RUN: opt < %s -slp-vectorizer -S -mtriple=aarch64-unknown-linux-gnu -mcpu=cortex-a57 | 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"
target triple = "aarch64--linux-gnu" target triple = "aarch64--linux-gnu"
define void @test1(i32* noalias nocapture %a, i32* noalias nocapture readonly %b, i32* noalias nocapture readonly %c) { define void @test1(i32* noalias nocapture %a, i32* noalias nocapture readonly %b, i32* noalias nocapture readonly %c) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP0:%.*]] = bitcast i32* [[B:%.*]] to <4 x i32>* ; CHECK-NEXT: [[TMP0:%.*]] = bitcast i32* [[B:%.*]] to <4 x i32>*
; CHECK-NEXT: [[TMP1:%.*]] = load <4 x i32>, <4 x i32>* [[TMP0]], align 4 ; CHECK-NEXT: [[TMP1:%.*]] = load <4 x i32>, <4 x i32>* [[TMP0]], align 4
Show All 40 Lines

llvm/test/Transforms/SLPVectorizer/ARM/memory.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -S -mtriple=thumbv7-apple-ios3.0.0 -mcpu=swift | FileCheck %s ; RUN: opt < %s -slp-vectorizer -S -mtriple=thumbv7-apple-ios3.0.0 -mcpu=swift | FileCheck %s
target datalayout = "e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:32:64-v128:32:128-a0:0:32-n32-S32" target datalayout = "e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:32:64-v128:32:128-a0:0:32-n32-S32"
; On swift unaligned <2 x double> stores need 4uops and it is there for cheaper ; On swift unaligned <2 x double> stores need 4uops and it is there for cheaper
; to do this scalar. ; to do this scalar.
define void @expensive_double_store(double* noalias %dst, double* noalias %src, i64 %count) { define void @expensive_double_store(double* noalias %dst, double* noalias %src, i64 %count) {
; CHECK-LABEL: @expensive_double_store( ; CHECK-LABEL: @expensive_double_store(
Show All 18 Lines

llvm/test/Transforms/SLPVectorizer/ARM/sroa.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S -mcpu=swift -mtriple=thumbv7-apple-ios -basic-aa -slp-vectorizer < %s | FileCheck %s ; RUN: opt -S -mcpu=swift -mtriple=thumbv7-apple-ios -slp-vectorizer < %s | FileCheck %s
target datalayout = "e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:32:64-v128:32:128-a0:0:32-n32-S32" target datalayout = "e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:32:64-v128:32:128-a0:0:32-n32-S32"
%class.Complex = type { double, double } %class.Complex = type { double, double }
; Code like this is the result of SROA. Make sure we don't vectorize this ; Code like this is the result of SROA. Make sure we don't vectorize this
; because the scalar version of the shl/or are handled by the ; because the scalar version of the shl/or are handled by the
; backend and disappear, the vectorized code stays. ; backend and disappear, the vectorized code stays.
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/NVPTX/v2f16.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -S -mtriple=nvptx64-nvidia-cuda -mcpu=sm_70 | FileCheck %s ; RUN: opt < %s -slp-vectorizer -S -mtriple=nvptx64-nvidia-cuda -mcpu=sm_70 | FileCheck %s
; RUN: opt < %s -basic-aa -slp-vectorizer -S -mtriple=nvptx64-nvidia-cuda -mcpu=sm_40 | FileCheck %s -check-prefix=NOVECTOR ; RUN: opt < %s -slp-vectorizer -S -mtriple=nvptx64-nvidia-cuda -mcpu=sm_40 | FileCheck %s -check-prefix=NOVECTOR
define void @fusion(i8* noalias nocapture align 256 dereferenceable(19267584) %arg, i8* noalias nocapture readonly align 256 dereferenceable(19267584) %arg1, i32 %arg2, i32 %arg3) local_unnamed_addr #0 { define void @fusion(i8* noalias nocapture align 256 dereferenceable(19267584) %arg, i8* noalias nocapture readonly align 256 dereferenceable(19267584) %arg1, i32 %arg2, i32 %arg3) local_unnamed_addr #0 {
; CHECK-LABEL: @fusion( ; CHECK-LABEL: @fusion(
; CHECK-NEXT: [[TMP:%.*]] = shl nuw nsw i32 [[ARG2:%.*]], 6 ; CHECK-NEXT: [[TMP:%.*]] = shl nuw nsw i32 [[ARG2:%.*]], 6
; CHECK-NEXT: [[TMP4:%.*]] = or i32 [[TMP]], [[ARG3:%.*]] ; CHECK-NEXT: [[TMP4:%.*]] = or i32 [[TMP]], [[ARG3:%.*]]
; CHECK-NEXT: [[TMP5:%.*]] = shl nuw nsw i32 [[TMP4]], 2 ; CHECK-NEXT: [[TMP5:%.*]] = shl nuw nsw i32 [[TMP4]], 2
; CHECK-NEXT: [[TMP6:%.*]] = zext i32 [[TMP5]] to i64 ; CHECK-NEXT: [[TMP6:%.*]] = zext i32 [[TMP5]] to i64
; CHECK-NEXT: [[TMP10:%.*]] = bitcast i8* [[ARG1:%.*]] to half* ; CHECK-NEXT: [[TMP10:%.*]] = bitcast i8* [[ARG1:%.*]] to half*
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/VE/disable_slp.ll

; RUN: opt < %s -basic-aa -slp-vectorizer -mtriple=ve-linux -S | FileCheck %s -check-prefix=VE ; RUN: opt < %s -slp-vectorizer -mtriple=ve-linux -S | FileCheck %s -check-prefix=VE
; RUN: opt < %s -basic-aa -slp-vectorizer -mtriple=x86_64-pc_linux -mcpu=core-avx2 -S | FileCheck %s -check-prefix=SSE ; RUN: opt < %s -slp-vectorizer -mtriple=x86_64-pc_linux -mcpu=core-avx2 -S | FileCheck %s -check-prefix=SSE
; Make sure SLP does not trigger for VE on an appealing set of combinable loads ; Make sure SLP does not trigger for VE on an appealing set of combinable loads
; and stores that vectorizes for x86 SSE. ; and stores that vectorizes for x86 SSE.
; TODO: Remove this test once VE vector isel is deemed stable. ; TODO: Remove this test once VE vector isel is deemed stable.
; VE-NOT: x double ; VE-NOT: x double
; SSE: x double ; SSE: x double
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/addsub.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -slp-vectorizer -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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
@b = common global [4 x i32] zeroinitializer, align 16 @b = common global [4 x i32] zeroinitializer, align 16
@c = common global [4 x i32] zeroinitializer, align 16 @c = common global [4 x i32] zeroinitializer, align 16
@d = common global [4 x i32] zeroinitializer, align 16 @d = common global [4 x i32] zeroinitializer, align 16
@e = common global [4 x i32] zeroinitializer, align 16 @e = common global [4 x i32] zeroinitializer, align 16
@a = common global [4 x i32] zeroinitializer, align 16 @a = common global [4 x i32] zeroinitializer, align 16
▲ Show 20 Lines • Show All 370 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/align.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | FileCheck %s ; RUN: opt < %s -slp-vectorizer -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | 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"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
; Simple 3-pair chain with loads and stores ; Simple 3-pair chain with loads and stores
define void @test1(double* %a, double* %b, double* %c) { define void @test1(double* %a, double* %b, double* %c) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/alternate-calls-inseltpoison.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefixes=SSE ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -instcombine -S | FileCheck %s --check-prefixes=SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefixes=SLM ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -slp-vectorizer -instcombine -S | FileCheck %s --check-prefixes=SLM
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefixes=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -instcombine -S | FileCheck %s --check-prefixes=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefixes=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -instcombine -S | FileCheck %s --check-prefixes=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefixes=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -slp-vectorizer -instcombine -S | FileCheck %s --check-prefixes=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefixes=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -slp-vectorizer -instcombine -S | FileCheck %s --check-prefixes=AVX
define <8 x float> @ceil_floor(<8 x float> %a) { define <8 x float> @ceil_floor(<8 x float> %a) {
; SSE-LABEL: @ceil_floor( ; SSE-LABEL: @ceil_floor(
; SSE-NEXT: [[A0:%.*]] = extractelement <8 x float> [[A:%.*]], i64 0 ; SSE-NEXT: [[A0:%.*]] = extractelement <8 x float> [[A:%.*]], i64 0
; SSE-NEXT: [[A3:%.*]] = extractelement <8 x float> [[A]], i64 3 ; SSE-NEXT: [[A3:%.*]] = extractelement <8 x float> [[A]], i64 3
; SSE-NEXT: [[AB0:%.*]] = call float @llvm.ceil.f32(float [[A0]]) ; SSE-NEXT: [[AB0:%.*]] = call float @llvm.ceil.f32(float [[A0]])
; SSE-NEXT: [[TMP1:%.*]] = shufflevector <8 x float> [[A]], <8 x float> undef, <2 x i32> <i32 1, i32 2> ; SSE-NEXT: [[TMP1:%.*]] = shufflevector <8 x float> [[A]], <8 x float> undef, <2 x i32> <i32 1, i32 2>
; SSE-NEXT: [[TMP2:%.*]] = call <2 x float> @llvm.floor.v2f32(<2 x float> [[TMP1]]) ; SSE-NEXT: [[TMP2:%.*]] = call <2 x float> @llvm.floor.v2f32(<2 x float> [[TMP1]])
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/alternate-calls.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefixes=SSE ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -instcombine -S | FileCheck %s --check-prefixes=SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefixes=SLM ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -slp-vectorizer -instcombine -S | FileCheck %s --check-prefixes=SLM
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefixes=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -instcombine -S | FileCheck %s --check-prefixes=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefixes=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -instcombine -S | FileCheck %s --check-prefixes=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefixes=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -slp-vectorizer -instcombine -S | FileCheck %s --check-prefixes=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefixes=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -slp-vectorizer -instcombine -S | FileCheck %s --check-prefixes=AVX
define <8 x float> @ceil_floor(<8 x float> %a) { define <8 x float> @ceil_floor(<8 x float> %a) {
; SSE-LABEL: @ceil_floor( ; SSE-LABEL: @ceil_floor(
; SSE-NEXT: [[A0:%.*]] = extractelement <8 x float> [[A:%.*]], i64 0 ; SSE-NEXT: [[A0:%.*]] = extractelement <8 x float> [[A:%.*]], i64 0
; SSE-NEXT: [[A3:%.*]] = extractelement <8 x float> [[A]], i64 3 ; SSE-NEXT: [[A3:%.*]] = extractelement <8 x float> [[A]], i64 3
; SSE-NEXT: [[AB0:%.*]] = call float @llvm.ceil.f32(float [[A0]]) ; SSE-NEXT: [[AB0:%.*]] = call float @llvm.ceil.f32(float [[A0]])
; SSE-NEXT: [[TMP1:%.*]] = shufflevector <8 x float> [[A]], <8 x float> undef, <2 x i32> <i32 1, i32 2> ; SSE-NEXT: [[TMP1:%.*]] = shufflevector <8 x float> [[A]], <8 x float> undef, <2 x i32> <i32 1, i32 2>
; SSE-NEXT: [[TMP2:%.*]] = call <2 x float> @llvm.floor.v2f32(<2 x float> [[TMP1]]) ; SSE-NEXT: [[TMP2:%.*]] = call <2 x float> @llvm.floor.v2f32(<2 x float> [[TMP1]])
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/alternate-cast-inseltpoison.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -instcombine -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -slp-vectorizer -instcombine -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -instcombine -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -instcombine -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -slp-vectorizer -instcombine -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -slp-vectorizer -instcombine -S | FileCheck %s
define <8 x float> @sitofp_uitofp(<8 x i32> %a) { define <8 x float> @sitofp_uitofp(<8 x i32> %a) {
; CHECK-LABEL: @sitofp_uitofp( ; CHECK-LABEL: @sitofp_uitofp(
; CHECK-NEXT: [[TMP1:%.*]] = sitofp <8 x i32> [[A:%.*]] to <8 x float> ; CHECK-NEXT: [[TMP1:%.*]] = sitofp <8 x i32> [[A:%.*]] to <8 x float>
; CHECK-NEXT: [[TMP2:%.*]] = uitofp <8 x i32> [[A]] to <8 x float> ; CHECK-NEXT: [[TMP2:%.*]] = uitofp <8 x i32> [[A]] to <8 x float>
; CHECK-NEXT: [[TMP3:%.*]] = shufflevector <8 x float> [[TMP1]], <8 x float> [[TMP2]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 12, i32 13, i32 14, i32 15> ; CHECK-NEXT: [[TMP3:%.*]] = shufflevector <8 x float> [[TMP1]], <8 x float> [[TMP2]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 12, i32 13, i32 14, i32 15>
; CHECK-NEXT: ret <8 x float> [[TMP3]] ; CHECK-NEXT: ret <8 x float> [[TMP3]]
; ;
▲ Show 20 Lines • Show All 229 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/alternate-cast.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -instcombine -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -slp-vectorizer -instcombine -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -instcombine -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -instcombine -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -slp-vectorizer -instcombine -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -slp-vectorizer -instcombine -S | FileCheck %s
define <8 x float> @sitofp_uitofp(<8 x i32> %a) { define <8 x float> @sitofp_uitofp(<8 x i32> %a) {
; CHECK-LABEL: @sitofp_uitofp( ; CHECK-LABEL: @sitofp_uitofp(
; CHECK-NEXT: [[TMP1:%.*]] = sitofp <8 x i32> [[A:%.*]] to <8 x float> ; CHECK-NEXT: [[TMP1:%.*]] = sitofp <8 x i32> [[A:%.*]] to <8 x float>
; CHECK-NEXT: [[TMP2:%.*]] = uitofp <8 x i32> [[A]] to <8 x float> ; CHECK-NEXT: [[TMP2:%.*]] = uitofp <8 x i32> [[A]] to <8 x float>
; CHECK-NEXT: [[TMP3:%.*]] = shufflevector <8 x float> [[TMP1]], <8 x float> [[TMP2]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 12, i32 13, i32 14, i32 15> ; CHECK-NEXT: [[TMP3:%.*]] = shufflevector <8 x float> [[TMP1]], <8 x float> [[TMP2]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 12, i32 13, i32 14, i32 15>
; CHECK-NEXT: ret <8 x float> [[TMP3]] ; CHECK-NEXT: ret <8 x float> [[TMP3]]
; ;
▲ Show 20 Lines • Show All 229 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/alternate-fp-inseltpoison.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=SSE ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=SLM ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=SLM
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX512
define <8 x float> @fadd_fsub_v8f32(<8 x float> %a, <8 x float> %b) { define <8 x float> @fadd_fsub_v8f32(<8 x float> %a, <8 x float> %b) {
; CHECK-LABEL: @fadd_fsub_v8f32( ; CHECK-LABEL: @fadd_fsub_v8f32(
; CHECK-NEXT: [[TMP1:%.*]] = fadd <8 x float> [[A:%.*]], [[B:%.*]] ; CHECK-NEXT: [[TMP1:%.*]] = fadd <8 x float> [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[TMP2:%.*]] = fsub <8 x float> [[A]], [[B]] ; CHECK-NEXT: [[TMP2:%.*]] = fsub <8 x float> [[A]], [[B]]
; CHECK-NEXT: [[TMP3:%.*]] = shufflevector <8 x float> [[TMP1]], <8 x float> [[TMP2]], <8 x i32> <i32 0, i32 9, i32 10, i32 3, i32 4, i32 13, i32 14, i32 7> ; CHECK-NEXT: [[TMP3:%.*]] = shufflevector <8 x float> [[TMP1]], <8 x float> [[TMP2]], <8 x i32> <i32 0, i32 9, i32 10, i32 3, i32 4, i32 13, i32 14, i32 7>
; CHECK-NEXT: ret <8 x float> [[TMP3]] ; CHECK-NEXT: ret <8 x float> [[TMP3]]
; ;
▲ Show 20 Lines • Show All 115 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/alternate-fp.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=SSE ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=SLM ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=SLM
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX512
define <8 x float> @fadd_fsub_v8f32(<8 x float> %a, <8 x float> %b) { define <8 x float> @fadd_fsub_v8f32(<8 x float> %a, <8 x float> %b) {
; CHECK-LABEL: @fadd_fsub_v8f32( ; CHECK-LABEL: @fadd_fsub_v8f32(
; CHECK-NEXT: [[TMP1:%.*]] = fadd <8 x float> [[A:%.*]], [[B:%.*]] ; CHECK-NEXT: [[TMP1:%.*]] = fadd <8 x float> [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[TMP2:%.*]] = fsub <8 x float> [[A]], [[B]] ; CHECK-NEXT: [[TMP2:%.*]] = fsub <8 x float> [[A]], [[B]]
; CHECK-NEXT: [[TMP3:%.*]] = shufflevector <8 x float> [[TMP1]], <8 x float> [[TMP2]], <8 x i32> <i32 0, i32 9, i32 10, i32 3, i32 4, i32 13, i32 14, i32 7> ; CHECK-NEXT: [[TMP3:%.*]] = shufflevector <8 x float> [[TMP1]], <8 x float> [[TMP2]], <8 x i32> <i32 0, i32 9, i32 10, i32 3, i32 4, i32 13, i32 14, i32 7>
; CHECK-NEXT: ret <8 x float> [[TMP3]] ; CHECK-NEXT: ret <8 x float> [[TMP3]]
; ;
▲ Show 20 Lines • Show All 115 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/alternate-int-inseltpoison.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefixes=CHECK,SSE ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -instcombine -S | FileCheck %s --check-prefixes=CHECK,SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefixes=CHECK,SLM ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -slp-vectorizer -instcombine -S | FileCheck %s --check-prefixes=CHECK,SLM
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefixes=CHECK,AVX1 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -instcombine -S | FileCheck %s --check-prefixes=CHECK,AVX1
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefixes=CHECK,AVX2 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -instcombine -S | FileCheck %s --check-prefixes=CHECK,AVX2
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefixes=CHECK,AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -slp-vectorizer -instcombine -S | FileCheck %s --check-prefixes=CHECK,AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefixes=CHECK,AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -slp-vectorizer -instcombine -S | FileCheck %s --check-prefixes=CHECK,AVX512
define <8 x i32> @add_sub_v8i32(<8 x i32> %a, <8 x i32> %b) { define <8 x i32> @add_sub_v8i32(<8 x i32> %a, <8 x i32> %b) {
; CHECK-LABEL: @add_sub_v8i32( ; CHECK-LABEL: @add_sub_v8i32(
; CHECK-NEXT: [[TMP1:%.*]] = add <8 x i32> [[A:%.*]], [[B:%.*]] ; CHECK-NEXT: [[TMP1:%.*]] = add <8 x i32> [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[TMP2:%.*]] = sub <8 x i32> [[A]], [[B]] ; CHECK-NEXT: [[TMP2:%.*]] = sub <8 x i32> [[A]], [[B]]
; CHECK-NEXT: [[TMP3:%.*]] = shufflevector <8 x i32> [[TMP1]], <8 x i32> [[TMP2]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 12, i32 13, i32 14, i32 15> ; CHECK-NEXT: [[TMP3:%.*]] = shufflevector <8 x i32> [[TMP1]], <8 x i32> [[TMP2]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 12, i32 13, i32 14, i32 15>
; CHECK-NEXT: ret <8 x i32> [[TMP3]] ; CHECK-NEXT: ret <8 x i32> [[TMP3]]
; ;
▲ Show 20 Lines • Show All 522 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/alternate-int.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefixes=CHECK,SSE ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -instcombine -S | FileCheck %s --check-prefixes=CHECK,SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefixes=CHECK,SLM ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -slp-vectorizer -instcombine -S | FileCheck %s --check-prefixes=CHECK,SLM
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefixes=CHECK,AVX1 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -instcombine -S | FileCheck %s --check-prefixes=CHECK,AVX1
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefixes=CHECK,AVX2 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -instcombine -S | FileCheck %s --check-prefixes=CHECK,AVX2
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefixes=CHECK,AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -slp-vectorizer -instcombine -S | FileCheck %s --check-prefixes=CHECK,AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefixes=CHECK,AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -slp-vectorizer -instcombine -S | FileCheck %s --check-prefixes=CHECK,AVX512
define <8 x i32> @add_sub_v8i32(<8 x i32> %a, <8 x i32> %b) { define <8 x i32> @add_sub_v8i32(<8 x i32> %a, <8 x i32> %b) {
; CHECK-LABEL: @add_sub_v8i32( ; CHECK-LABEL: @add_sub_v8i32(
; CHECK-NEXT: [[TMP1:%.*]] = add <8 x i32> [[A:%.*]], [[B:%.*]] ; CHECK-NEXT: [[TMP1:%.*]] = add <8 x i32> [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[TMP2:%.*]] = sub <8 x i32> [[A]], [[B]] ; CHECK-NEXT: [[TMP2:%.*]] = sub <8 x i32> [[A]], [[B]]
; CHECK-NEXT: [[TMP3:%.*]] = shufflevector <8 x i32> [[TMP1]], <8 x i32> [[TMP2]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 12, i32 13, i32 14, i32 15> ; CHECK-NEXT: [[TMP3:%.*]] = shufflevector <8 x i32> [[TMP1]], <8 x i32> [[TMP2]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 12, i32 13, i32 14, i32 15>
; CHECK-NEXT: ret <8 x i32> [[TMP3]] ; CHECK-NEXT: ret <8 x i32> [[TMP3]]
; ;
▲ Show 20 Lines • Show All 522 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/arith-abs.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=SSE ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -S | FileCheck %s --check-prefix=SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=SLM ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -slp-vectorizer -S | FileCheck %s --check-prefix=SLM
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -S | FileCheck %s --check-prefix=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -S | FileCheck %s --check-prefix=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -slp-vectorizer -S | FileCheck %s --check-prefix=AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=-prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=-prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefix=AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefix=AVX
@a64 = common global [8 x i64] zeroinitializer, align 64 @a64 = common global [8 x i64] zeroinitializer, align 64
@b64 = common global [8 x i64] zeroinitializer, align 64 @b64 = common global [8 x i64] zeroinitializer, align 64
@c64 = common global [8 x i64] zeroinitializer, align 64 @c64 = common global [8 x i64] zeroinitializer, align 64
@a32 = common global [16 x i32] zeroinitializer, align 64 @a32 = common global [16 x i32] zeroinitializer, align 64
@b32 = common global [16 x i32] zeroinitializer, align 64 @b32 = common global [16 x i32] zeroinitializer, align 64
@c32 = common global [16 x i32] zeroinitializer, align 64 @c32 = common global [16 x i32] zeroinitializer, align 64
@a16 = common global [32 x i16] zeroinitializer, align 64 @a16 = common global [32 x i16] zeroinitializer, align 64
▲ Show 20 Lines • Show All 566 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/arith-add-load.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -S -mtriple=x86_64-unknown -mcpu=x86-64 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SSE ; RUN: opt < %s -slp-vectorizer -S -mtriple=x86_64-unknown -mcpu=x86-64 -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SSE
; RUN: opt < %s -basic-aa -slp-vectorizer -S -mtriple=x86_64-unknown -mcpu=x86-64-v2 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SSE ; RUN: opt < %s -slp-vectorizer -S -mtriple=x86_64-unknown -mcpu=x86-64-v2 -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SSE
; RUN: opt < %s -basic-aa -slp-vectorizer -S -mtriple=x86_64-unknown -mcpu=x86-64-v3 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX ; RUN: opt < %s -slp-vectorizer -S -mtriple=x86_64-unknown -mcpu=x86-64-v3 -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX
; RUN: opt < %s -basic-aa -slp-vectorizer -S -mtriple=x86_64-unknown -mcpu=x86-64-v4 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX ; RUN: opt < %s -slp-vectorizer -S -mtriple=x86_64-unknown -mcpu=x86-64-v4 -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX
; // PR47491 ; // PR47491
; void pr(char* r, char* a){ ; void pr(char* r, char* a){
; for (int i = 0; i < 8; i++){ ; for (int i = 0; i < 8; i++){
; r[i] += a[i]; ; r[i] += a[i];
; } ; }
; } ; }
▲ Show 20 Lines • Show All 417 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/arith-add-saddo.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -slp-vectorizer -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -slp-vectorizer -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=-prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=-prefer-256-bit -slp-vectorizer -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+prefer-256-bit -slp-vectorizer -S | FileCheck %s
@a64 = common global [8 x i64] zeroinitializer, align 64 @a64 = common global [8 x i64] zeroinitializer, align 64
@b64 = common global [8 x i64] zeroinitializer, align 64 @b64 = common global [8 x i64] zeroinitializer, align 64
@c64 = common global [8 x i64] zeroinitializer, align 64 @c64 = common global [8 x i64] zeroinitializer, align 64
@a32 = common global [16 x i32] zeroinitializer, align 64 @a32 = common global [16 x i32] zeroinitializer, align 64
@b32 = common global [16 x i32] zeroinitializer, align 64 @b32 = common global [16 x i32] zeroinitializer, align 64
@c32 = common global [16 x i32] zeroinitializer, align 64 @c32 = common global [16 x i32] zeroinitializer, align 64
@a16 = common global [32 x i16] zeroinitializer, align 64 @a16 = common global [32 x i16] zeroinitializer, align 64
▲ Show 20 Lines • Show All 1,238 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/arith-add-ssat.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=SSE ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -S | FileCheck %s --check-prefixes=SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=SLM ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -slp-vectorizer -S | FileCheck %s --check-prefixes=SLM
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX,AVX1 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX,AVX1
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX,AVX2 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX,AVX2
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=-prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=-prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX
@a64 = common global [8 x i64] zeroinitializer, align 64 @a64 = common global [8 x i64] zeroinitializer, align 64
@b64 = common global [8 x i64] zeroinitializer, align 64 @b64 = common global [8 x i64] zeroinitializer, align 64
@c64 = common global [8 x i64] zeroinitializer, align 64 @c64 = common global [8 x i64] zeroinitializer, align 64
@a32 = common global [16 x i32] zeroinitializer, align 64 @a32 = common global [16 x i32] zeroinitializer, align 64
@b32 = common global [16 x i32] zeroinitializer, align 64 @b32 = common global [16 x i32] zeroinitializer, align 64
@c32 = common global [16 x i32] zeroinitializer, align 64 @c32 = common global [16 x i32] zeroinitializer, align 64
@a16 = common global [32 x i16] zeroinitializer, align 64 @a16 = common global [32 x i16] zeroinitializer, align 64
▲ Show 20 Lines • Show All 791 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/arith-add-uaddo.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -slp-vectorizer -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -slp-vectorizer -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=-prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=-prefer-256-bit -slp-vectorizer -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+prefer-256-bit -slp-vectorizer -S | FileCheck %s
@a64 = common global [8 x i64] zeroinitializer, align 64 @a64 = common global [8 x i64] zeroinitializer, align 64
@b64 = common global [8 x i64] zeroinitializer, align 64 @b64 = common global [8 x i64] zeroinitializer, align 64
@c64 = common global [8 x i64] zeroinitializer, align 64 @c64 = common global [8 x i64] zeroinitializer, align 64
@a32 = common global [16 x i32] zeroinitializer, align 64 @a32 = common global [16 x i32] zeroinitializer, align 64
@b32 = common global [16 x i32] zeroinitializer, align 64 @b32 = common global [16 x i32] zeroinitializer, align 64
@c32 = common global [16 x i32] zeroinitializer, align 64 @c32 = common global [16 x i32] zeroinitializer, align 64
@a16 = common global [32 x i16] zeroinitializer, align 64 @a16 = common global [32 x i16] zeroinitializer, align 64
▲ Show 20 Lines • Show All 1,238 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/arith-add-usat.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=SSE ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -S | FileCheck %s --check-prefixes=SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=SSE ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -slp-vectorizer -S | FileCheck %s --check-prefixes=SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=-prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=-prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX
@a64 = common global [8 x i64] zeroinitializer, align 64 @a64 = common global [8 x i64] zeroinitializer, align 64
@b64 = common global [8 x i64] zeroinitializer, align 64 @b64 = common global [8 x i64] zeroinitializer, align 64
@c64 = common global [8 x i64] zeroinitializer, align 64 @c64 = common global [8 x i64] zeroinitializer, align 64
@a32 = common global [16 x i32] zeroinitializer, align 64 @a32 = common global [16 x i32] zeroinitializer, align 64
@b32 = common global [16 x i32] zeroinitializer, align 64 @b32 = common global [16 x i32] zeroinitializer, align 64
@c32 = common global [16 x i32] zeroinitializer, align 64 @c32 = common global [16 x i32] zeroinitializer, align 64
@a16 = common global [32 x i16] zeroinitializer, align 64 @a16 = common global [32 x i16] zeroinitializer, align 64
▲ Show 20 Lines • Show All 670 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/arith-add.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=SSE ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -S | FileCheck %s --check-prefix=SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=SLM ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -slp-vectorizer -S | FileCheck %s --check-prefix=SLM
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -mattr=-prefer-128-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -mattr=-prefer-128-bit -slp-vectorizer -S | FileCheck %s --check-prefix=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -mattr=+prefer-128-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=SSE ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -mattr=+prefer-128-bit -slp-vectorizer -S | FileCheck %s --check-prefix=SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -mattr=-prefer-128-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -mattr=-prefer-128-bit -slp-vectorizer -S | FileCheck %s --check-prefix=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -mattr=+prefer-128-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=SSE ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -mattr=+prefer-128-bit -slp-vectorizer -S | FileCheck %s --check-prefix=SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -slp-vectorizer -S | FileCheck %s --check-prefix=AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=-prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=-prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefix=AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefix=AVX
@a64 = common global [8 x i64] zeroinitializer, align 64 @a64 = common global [8 x i64] zeroinitializer, align 64
@b64 = common global [8 x i64] zeroinitializer, align 64 @b64 = common global [8 x i64] zeroinitializer, align 64
@c64 = common global [8 x i64] zeroinitializer, align 64 @c64 = common global [8 x i64] zeroinitializer, align 64
@a32 = common global [16 x i32] zeroinitializer, align 64 @a32 = common global [16 x i32] zeroinitializer, align 64
@b32 = common global [16 x i32] zeroinitializer, align 64 @b32 = common global [16 x i32] zeroinitializer, align 64
@c32 = common global [16 x i32] zeroinitializer, align 64 @c32 = common global [16 x i32] zeroinitializer, align 64
@a16 = common global [32 x i16] zeroinitializer, align 64 @a16 = common global [32 x i16] zeroinitializer, align 64
▲ Show 20 Lines • Show All 725 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/arith-and-const-load.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -S -mtriple=x86_64-unknown -mcpu=x86-64 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SSE ; RUN: opt < %s -slp-vectorizer -S -mtriple=x86_64-unknown -mcpu=x86-64 -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SSE
; RUN: opt < %s -basic-aa -slp-vectorizer -S -mtriple=x86_64-unknown -mcpu=x86-64-v2 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SSE ; RUN: opt < %s -slp-vectorizer -S -mtriple=x86_64-unknown -mcpu=x86-64-v2 -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SSE
; RUN: opt < %s -basic-aa -slp-vectorizer -S -mtriple=x86_64-unknown -mcpu=x86-64-v3 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX ; RUN: opt < %s -slp-vectorizer -S -mtriple=x86_64-unknown -mcpu=x86-64-v3 -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX
; RUN: opt < %s -basic-aa -slp-vectorizer -S -mtriple=x86_64-unknown -mcpu=x86-64-v4 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX ; RUN: opt < %s -slp-vectorizer -S -mtriple=x86_64-unknown -mcpu=x86-64-v4 -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX
; // PR49934 ; // PR49934
; void baz(unsigned char *dst, unsigned char *src) { ; void baz(unsigned char *dst, unsigned char *src) {
; for( int x = 0; x < 8; x++ ) { ; for( int x = 0; x < 8; x++ ) {
; dst[x] = src[x]&(~63); ; dst[x] = src[x]&(~63);
; } ; }
; } ; }
▲ Show 20 Lines • Show All 351 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/arith-div.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=SSE ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -S | FileCheck %s --check-prefix=SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=SLM ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -slp-vectorizer -S | FileCheck %s --check-prefix=SLM
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -mattr=-prefer-128-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -mattr=-prefer-128-bit -slp-vectorizer -S | FileCheck %s --check-prefix=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -mattr=+prefer-128-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=SSE ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -mattr=+prefer-128-bit -slp-vectorizer -S | FileCheck %s --check-prefix=SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -mattr=-prefer-128-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -mattr=-prefer-128-bit -slp-vectorizer -S | FileCheck %s --check-prefix=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -mattr=+prefer-128-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=SSE ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -mattr=+prefer-128-bit -slp-vectorizer -S | FileCheck %s --check-prefix=SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -slp-vectorizer -S | FileCheck %s --check-prefix=AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=-prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=-prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefix=AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefix=AVX
@a64 = common global [8 x i64] zeroinitializer, align 64 @a64 = common global [8 x i64] zeroinitializer, align 64
@b64 = common global [8 x i64] zeroinitializer, align 64 @b64 = common global [8 x i64] zeroinitializer, align 64
@c64 = common global [8 x i64] zeroinitializer, align 64 @c64 = common global [8 x i64] zeroinitializer, align 64
@a32 = common global [16 x i32] zeroinitializer, align 64 @a32 = common global [16 x i32] zeroinitializer, align 64
@b32 = common global [16 x i32] zeroinitializer, align 64 @b32 = common global [16 x i32] zeroinitializer, align 64
@c32 = common global [16 x i32] zeroinitializer, align 64 @c32 = common global [16 x i32] zeroinitializer, align 64
@a16 = common global [32 x i16] zeroinitializer, align 64 @a16 = common global [32 x i16] zeroinitializer, align 64
▲ Show 20 Lines • Show All 393 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/arith-fix.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=SSE ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -S | FileCheck %s --check-prefixes=SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=SLM ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -slp-vectorizer -S | FileCheck %s --check-prefixes=SLM
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX,AVX1 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX,AVX1
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX,AVX2 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX,AVX2
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=-prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=-prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX,AVX256BW ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX,AVX256BW
@a64 = common global [8 x i64] zeroinitializer, align 64 @a64 = common global [8 x i64] zeroinitializer, align 64
@b64 = common global [8 x i64] zeroinitializer, align 64 @b64 = common global [8 x i64] zeroinitializer, align 64
@c64 = common global [8 x i64] zeroinitializer, align 64 @c64 = common global [8 x i64] zeroinitializer, align 64
@a32 = common global [16 x i32] zeroinitializer, align 64 @a32 = common global [16 x i32] zeroinitializer, align 64
@b32 = common global [16 x i32] zeroinitializer, align 64 @b32 = common global [16 x i32] zeroinitializer, align 64
@c32 = common global [16 x i32] zeroinitializer, align 64 @c32 = common global [16 x i32] zeroinitializer, align 64
@a16 = common global [32 x i16] zeroinitializer, align 64 @a16 = common global [32 x i16] zeroinitializer, align 64
▲ Show 20 Lines • Show All 1,611 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/arith-fp-inseltpoison.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SSE ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SLM ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SLM
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -mattr=-prefer-128-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -mattr=-prefer-128-bit -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -mattr=+prefer-128-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SSE ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -mattr=+prefer-128-bit -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -mattr=-prefer-128-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -mattr=-prefer-128-bit -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -mattr=+prefer-128-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SSE ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -mattr=+prefer-128-bit -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX512
; ;
; 128-bit Vectors ; 128-bit Vectors
; ;
define <2 x double> @buildvector_add_2f64(<2 x double> %a, <2 x double> %b) { define <2 x double> @buildvector_add_2f64(<2 x double> %a, <2 x double> %b) {
; CHECK-LABEL: @buildvector_add_2f64( ; CHECK-LABEL: @buildvector_add_2f64(
; CHECK-NEXT: [[TMP1:%.*]] = fadd <2 x double> [[A:%.*]], [[B:%.*]] ; CHECK-NEXT: [[TMP1:%.*]] = fadd <2 x double> [[A:%.*]], [[B:%.*]]
▲ Show 20 Lines • Show All 968 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/arith-fp.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SSE ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SLM ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SLM
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -mattr=-prefer-128-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -mattr=-prefer-128-bit -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -mattr=+prefer-128-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SSE ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -mattr=+prefer-128-bit -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -mattr=-prefer-128-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -mattr=-prefer-128-bit -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -mattr=+prefer-128-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SSE ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -mattr=+prefer-128-bit -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX512
; ;
; 128-bit Vectors ; 128-bit Vectors
; ;
define <2 x double> @buildvector_add_2f64(<2 x double> %a, <2 x double> %b) { define <2 x double> @buildvector_add_2f64(<2 x double> %a, <2 x double> %b) {
; CHECK-LABEL: @buildvector_add_2f64( ; CHECK-LABEL: @buildvector_add_2f64(
; CHECK-NEXT: [[TMP1:%.*]] = fadd <2 x double> [[A:%.*]], [[B:%.*]] ; CHECK-NEXT: [[TMP1:%.*]] = fadd <2 x double> [[A:%.*]], [[B:%.*]]
▲ Show 20 Lines • Show All 968 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/arith-mul-load.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -S -mtriple=x86_64-unknown -mcpu=x86-64 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SSE ; RUN: opt < %s -slp-vectorizer -S -mtriple=x86_64-unknown -mcpu=x86-64 -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SSE
; RUN: opt < %s -basic-aa -slp-vectorizer -S -mtriple=x86_64-unknown -mcpu=x86-64-v2 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SSE ; RUN: opt < %s -slp-vectorizer -S -mtriple=x86_64-unknown -mcpu=x86-64-v2 -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SSE
; RUN: opt < %s -basic-aa -slp-vectorizer -S -mtriple=x86_64-unknown -mcpu=x86-64-v3 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX ; RUN: opt < %s -slp-vectorizer -S -mtriple=x86_64-unknown -mcpu=x86-64-v3 -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX
; RUN: opt < %s -basic-aa -slp-vectorizer -S -mtriple=x86_64-unknown -mcpu=x86-64-v4 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX ; RUN: opt < %s -slp-vectorizer -S -mtriple=x86_64-unknown -mcpu=x86-64-v4 -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX
; // PR47491 ; // PR47491
; void pr(char* r, char* a){ ; void pr(char* r, char* a){
; for (int i = 0; i < 8; i++){ ; for (int i = 0; i < 8; i++){
; r[i] *= a[i]; ; r[i] *= a[i];
; } ; }
; } ; }
▲ Show 20 Lines • Show All 417 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/arith-mul-smulo.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -slp-vectorizer -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -slp-vectorizer -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=-prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=-prefer-256-bit -slp-vectorizer -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+prefer-256-bit -slp-vectorizer -S | FileCheck %s
@a64 = common global [8 x i64] zeroinitializer, align 64 @a64 = common global [8 x i64] zeroinitializer, align 64
@b64 = common global [8 x i64] zeroinitializer, align 64 @b64 = common global [8 x i64] zeroinitializer, align 64
@c64 = common global [8 x i64] zeroinitializer, align 64 @c64 = common global [8 x i64] zeroinitializer, align 64
@a32 = common global [16 x i32] zeroinitializer, align 64 @a32 = common global [16 x i32] zeroinitializer, align 64
@b32 = common global [16 x i32] zeroinitializer, align 64 @b32 = common global [16 x i32] zeroinitializer, align 64
@c32 = common global [16 x i32] zeroinitializer, align 64 @c32 = common global [16 x i32] zeroinitializer, align 64
@a16 = common global [32 x i16] zeroinitializer, align 64 @a16 = common global [32 x i16] zeroinitializer, align 64
▲ Show 20 Lines • Show All 1,238 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/arith-mul-umulo.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -slp-vectorizer -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -slp-vectorizer -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=-prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=-prefer-256-bit -slp-vectorizer -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+prefer-256-bit -slp-vectorizer -S | FileCheck %s
@a64 = common global [8 x i64] zeroinitializer, align 64 @a64 = common global [8 x i64] zeroinitializer, align 64
@b64 = common global [8 x i64] zeroinitializer, align 64 @b64 = common global [8 x i64] zeroinitializer, align 64
@c64 = common global [8 x i64] zeroinitializer, align 64 @c64 = common global [8 x i64] zeroinitializer, align 64
@a32 = common global [16 x i32] zeroinitializer, align 64 @a32 = common global [16 x i32] zeroinitializer, align 64
@b32 = common global [16 x i32] zeroinitializer, align 64 @b32 = common global [16 x i32] zeroinitializer, align 64
@c32 = common global [16 x i32] zeroinitializer, align 64 @c32 = common global [16 x i32] zeroinitializer, align 64
@a16 = common global [32 x i16] zeroinitializer, align 64 @a16 = common global [32 x i16] zeroinitializer, align 64
▲ Show 20 Lines • Show All 1,238 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/arith-mul.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=SSE ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -S | FileCheck %s --check-prefix=SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=SLM ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -slp-vectorizer -S | FileCheck %s --check-prefix=SLM
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -mattr=+prefer-128-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX128 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -mattr=+prefer-128-bit -slp-vectorizer -S | FileCheck %s --check-prefix=AVX128
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -mattr=-prefer-128-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX256 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -mattr=-prefer-128-bit -slp-vectorizer -S | FileCheck %s --check-prefix=AVX256
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -mattr=+prefer-128-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX128 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -mattr=+prefer-128-bit -slp-vectorizer -S | FileCheck %s --check-prefix=AVX128
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -mattr=-prefer-128-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX256 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -mattr=-prefer-128-bit -slp-vectorizer -S | FileCheck %s --check-prefix=AVX256
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -slp-vectorizer -S | FileCheck %s --check-prefix=AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=-prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=-prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefix=AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX256 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefix=AVX256
@a64 = common global [8 x i64] zeroinitializer, align 64 @a64 = common global [8 x i64] zeroinitializer, align 64
@b64 = common global [8 x i64] zeroinitializer, align 64 @b64 = common global [8 x i64] zeroinitializer, align 64
@c64 = common global [8 x i64] zeroinitializer, align 64 @c64 = common global [8 x i64] zeroinitializer, align 64
@a32 = common global [16 x i32] zeroinitializer, align 64 @a32 = common global [16 x i32] zeroinitializer, align 64
@b32 = common global [16 x i32] zeroinitializer, align 64 @b32 = common global [16 x i32] zeroinitializer, align 64
@c32 = common global [16 x i32] zeroinitializer, align 64 @c32 = common global [16 x i32] zeroinitializer, align 64
@a16 = common global [32 x i16] zeroinitializer, align 64 @a16 = common global [32 x i16] zeroinitializer, align 64
▲ Show 20 Lines • Show All 833 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/arith-smax.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=SSE ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -S | FileCheck %s --check-prefix=SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=SSE ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -slp-vectorizer -S | FileCheck %s --check-prefix=SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -S | FileCheck %s --check-prefix=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -S | FileCheck %s --check-prefix=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -slp-vectorizer -S | FileCheck %s --check-prefix=AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=-prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=-prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefix=AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefix=AVX
@a64 = common global [8 x i64] zeroinitializer, align 64 @a64 = common global [8 x i64] zeroinitializer, align 64
@b64 = common global [8 x i64] zeroinitializer, align 64 @b64 = common global [8 x i64] zeroinitializer, align 64
@c64 = common global [8 x i64] zeroinitializer, align 64 @c64 = common global [8 x i64] zeroinitializer, align 64
@a32 = common global [16 x i32] zeroinitializer, align 64 @a32 = common global [16 x i32] zeroinitializer, align 64
@b32 = common global [16 x i32] zeroinitializer, align 64 @b32 = common global [16 x i32] zeroinitializer, align 64
@c32 = common global [16 x i32] zeroinitializer, align 64 @c32 = common global [16 x i32] zeroinitializer, align 64
@a16 = common global [32 x i16] zeroinitializer, align 64 @a16 = common global [32 x i16] zeroinitializer, align 64
▲ Show 20 Lines • Show All 654 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/arith-smin.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=SSE ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -S | FileCheck %s --check-prefix=SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=SSE ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -slp-vectorizer -S | FileCheck %s --check-prefix=SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -S | FileCheck %s --check-prefix=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -S | FileCheck %s --check-prefix=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -slp-vectorizer -S | FileCheck %s --check-prefix=AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=-prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=-prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefix=AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefix=AVX
@a64 = common global [8 x i64] zeroinitializer, align 64 @a64 = common global [8 x i64] zeroinitializer, align 64
@b64 = common global [8 x i64] zeroinitializer, align 64 @b64 = common global [8 x i64] zeroinitializer, align 64
@c64 = common global [8 x i64] zeroinitializer, align 64 @c64 = common global [8 x i64] zeroinitializer, align 64
@a32 = common global [16 x i32] zeroinitializer, align 64 @a32 = common global [16 x i32] zeroinitializer, align 64
@b32 = common global [16 x i32] zeroinitializer, align 64 @b32 = common global [16 x i32] zeroinitializer, align 64
@c32 = common global [16 x i32] zeroinitializer, align 64 @c32 = common global [16 x i32] zeroinitializer, align 64
@a16 = common global [32 x i16] zeroinitializer, align 64 @a16 = common global [32 x i16] zeroinitializer, align 64
▲ Show 20 Lines • Show All 654 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/arith-sub-ssat.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=SSE ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -S | FileCheck %s --check-prefixes=SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=SLM ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -slp-vectorizer -S | FileCheck %s --check-prefixes=SLM
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX,AVX1 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX,AVX1
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX,AVX2 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX,AVX2
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=-prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=-prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX
@a64 = common global [8 x i64] zeroinitializer, align 64 @a64 = common global [8 x i64] zeroinitializer, align 64
@b64 = common global [8 x i64] zeroinitializer, align 64 @b64 = common global [8 x i64] zeroinitializer, align 64
@c64 = common global [8 x i64] zeroinitializer, align 64 @c64 = common global [8 x i64] zeroinitializer, align 64
@a32 = common global [16 x i32] zeroinitializer, align 64 @a32 = common global [16 x i32] zeroinitializer, align 64
@b32 = common global [16 x i32] zeroinitializer, align 64 @b32 = common global [16 x i32] zeroinitializer, align 64
@c32 = common global [16 x i32] zeroinitializer, align 64 @c32 = common global [16 x i32] zeroinitializer, align 64
@a16 = common global [32 x i16] zeroinitializer, align 64 @a16 = common global [32 x i16] zeroinitializer, align 64
▲ Show 20 Lines • Show All 791 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/arith-sub-ssubo.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -slp-vectorizer -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -slp-vectorizer -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=-prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=-prefer-256-bit -slp-vectorizer -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+prefer-256-bit -slp-vectorizer -S | FileCheck %s
@a64 = common global [8 x i64] zeroinitializer, align 64 @a64 = common global [8 x i64] zeroinitializer, align 64
@b64 = common global [8 x i64] zeroinitializer, align 64 @b64 = common global [8 x i64] zeroinitializer, align 64
@c64 = common global [8 x i64] zeroinitializer, align 64 @c64 = common global [8 x i64] zeroinitializer, align 64
@a32 = common global [16 x i32] zeroinitializer, align 64 @a32 = common global [16 x i32] zeroinitializer, align 64
@b32 = common global [16 x i32] zeroinitializer, align 64 @b32 = common global [16 x i32] zeroinitializer, align 64
@c32 = common global [16 x i32] zeroinitializer, align 64 @c32 = common global [16 x i32] zeroinitializer, align 64
@a16 = common global [32 x i16] zeroinitializer, align 64 @a16 = common global [32 x i16] zeroinitializer, align 64
▲ Show 20 Lines • Show All 1,238 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/arith-sub-usat.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=SSE ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -S | FileCheck %s --check-prefixes=SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=SSE ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -slp-vectorizer -S | FileCheck %s --check-prefixes=SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=-prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=-prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX
@a64 = common global [8 x i64] zeroinitializer, align 64 @a64 = common global [8 x i64] zeroinitializer, align 64
@b64 = common global [8 x i64] zeroinitializer, align 64 @b64 = common global [8 x i64] zeroinitializer, align 64
@c64 = common global [8 x i64] zeroinitializer, align 64 @c64 = common global [8 x i64] zeroinitializer, align 64
@a32 = common global [16 x i32] zeroinitializer, align 64 @a32 = common global [16 x i32] zeroinitializer, align 64
@b32 = common global [16 x i32] zeroinitializer, align 64 @b32 = common global [16 x i32] zeroinitializer, align 64
@c32 = common global [16 x i32] zeroinitializer, align 64 @c32 = common global [16 x i32] zeroinitializer, align 64
@a16 = common global [32 x i16] zeroinitializer, align 64 @a16 = common global [32 x i16] zeroinitializer, align 64
▲ Show 20 Lines • Show All 670 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/arith-sub-usubo.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -slp-vectorizer -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -slp-vectorizer -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=-prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=-prefer-256-bit -slp-vectorizer -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+prefer-256-bit -slp-vectorizer -S | FileCheck %s
@a64 = common global [8 x i64] zeroinitializer, align 64 @a64 = common global [8 x i64] zeroinitializer, align 64
@b64 = common global [8 x i64] zeroinitializer, align 64 @b64 = common global [8 x i64] zeroinitializer, align 64
@c64 = common global [8 x i64] zeroinitializer, align 64 @c64 = common global [8 x i64] zeroinitializer, align 64
@a32 = common global [16 x i32] zeroinitializer, align 64 @a32 = common global [16 x i32] zeroinitializer, align 64
@b32 = common global [16 x i32] zeroinitializer, align 64 @b32 = common global [16 x i32] zeroinitializer, align 64
@c32 = common global [16 x i32] zeroinitializer, align 64 @c32 = common global [16 x i32] zeroinitializer, align 64
@a16 = common global [32 x i16] zeroinitializer, align 64 @a16 = common global [32 x i16] zeroinitializer, align 64
▲ Show 20 Lines • Show All 1,238 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/arith-sub.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=SSE ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -S | FileCheck %s --check-prefix=SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=SLM ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -slp-vectorizer -S | FileCheck %s --check-prefix=SLM
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -mattr=-prefer-128-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -mattr=-prefer-128-bit -slp-vectorizer -S | FileCheck %s --check-prefix=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -mattr=+prefer-128-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=SSE ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -mattr=+prefer-128-bit -slp-vectorizer -S | FileCheck %s --check-prefix=SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -mattr=-prefer-128-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -mattr=-prefer-128-bit -slp-vectorizer -S | FileCheck %s --check-prefix=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -mattr=+prefer-128-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=SSE ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -mattr=+prefer-128-bit -slp-vectorizer -S | FileCheck %s --check-prefix=SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -slp-vectorizer -S | FileCheck %s --check-prefix=AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=-prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=-prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefix=AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefix=AVX
@a64 = common global [8 x i64] zeroinitializer, align 64 @a64 = common global [8 x i64] zeroinitializer, align 64
@b64 = common global [8 x i64] zeroinitializer, align 64 @b64 = common global [8 x i64] zeroinitializer, align 64
@c64 = common global [8 x i64] zeroinitializer, align 64 @c64 = common global [8 x i64] zeroinitializer, align 64
@a32 = common global [16 x i32] zeroinitializer, align 64 @a32 = common global [16 x i32] zeroinitializer, align 64
@b32 = common global [16 x i32] zeroinitializer, align 64 @b32 = common global [16 x i32] zeroinitializer, align 64
@c32 = common global [16 x i32] zeroinitializer, align 64 @c32 = common global [16 x i32] zeroinitializer, align 64
@a16 = common global [32 x i16] zeroinitializer, align 64 @a16 = common global [32 x i16] zeroinitializer, align 64
▲ Show 20 Lines • Show All 725 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/arith-umax.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=SSE ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -S | FileCheck %s --check-prefix=SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=SSE ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -slp-vectorizer -S | FileCheck %s --check-prefix=SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -S | FileCheck %s --check-prefix=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -S | FileCheck %s --check-prefix=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -slp-vectorizer -S | FileCheck %s --check-prefix=AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=-prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=-prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefix=AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefix=AVX
@a64 = common global [8 x i64] zeroinitializer, align 64 @a64 = common global [8 x i64] zeroinitializer, align 64
@b64 = common global [8 x i64] zeroinitializer, align 64 @b64 = common global [8 x i64] zeroinitializer, align 64
@c64 = common global [8 x i64] zeroinitializer, align 64 @c64 = common global [8 x i64] zeroinitializer, align 64
@a32 = common global [16 x i32] zeroinitializer, align 64 @a32 = common global [16 x i32] zeroinitializer, align 64
@b32 = common global [16 x i32] zeroinitializer, align 64 @b32 = common global [16 x i32] zeroinitializer, align 64
@c32 = common global [16 x i32] zeroinitializer, align 64 @c32 = common global [16 x i32] zeroinitializer, align 64
@a16 = common global [32 x i16] zeroinitializer, align 64 @a16 = common global [32 x i16] zeroinitializer, align 64
▲ Show 20 Lines • Show All 654 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/arith-umin.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=SSE ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -S | FileCheck %s --check-prefix=SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=SSE ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -slp-vectorizer -S | FileCheck %s --check-prefix=SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -S | FileCheck %s --check-prefix=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -S | FileCheck %s --check-prefix=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -slp-vectorizer -S | FileCheck %s --check-prefix=AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=-prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=-prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefix=AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefix=AVX
@a64 = common global [8 x i64] zeroinitializer, align 64 @a64 = common global [8 x i64] zeroinitializer, align 64
@b64 = common global [8 x i64] zeroinitializer, align 64 @b64 = common global [8 x i64] zeroinitializer, align 64
@c64 = common global [8 x i64] zeroinitializer, align 64 @c64 = common global [8 x i64] zeroinitializer, align 64
@a32 = common global [16 x i32] zeroinitializer, align 64 @a32 = common global [16 x i32] zeroinitializer, align 64
@b32 = common global [16 x i32] zeroinitializer, align 64 @b32 = common global [16 x i32] zeroinitializer, align 64
@c32 = common global [16 x i32] zeroinitializer, align 64 @c32 = common global [16 x i32] zeroinitializer, align 64
@a16 = common global [32 x i16] zeroinitializer, align 64 @a16 = common global [32 x i16] zeroinitializer, align 64
▲ Show 20 Lines • Show All 654 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/atomics.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -S |FileCheck %s ; RUN: opt < %s -slp-vectorizer -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"
@x = global [4 x i32] zeroinitializer, align 16 @x = global [4 x i32] zeroinitializer, align 16
@a = global [4 x i32] zeroinitializer, align 16 @a = global [4 x i32] zeroinitializer, align 16
; The SLPVectorizer should not vectorize atomic stores and it should not ; The SLPVectorizer should not vectorize atomic stores and it should not
; schedule regular stores around atomic stores. ; schedule regular stores around atomic stores.
Show All 25 Lines

llvm/test/Transforms/SLPVectorizer/X86/bad_types.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -S -mcpu=corei7-avx | FileCheck %s ; RUN: opt < %s -slp-vectorizer -S -mcpu=corei7-avx | 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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @test1(x86_mmx %a, x86_mmx %b, i64* %ptr) { define void @test1(x86_mmx %a, x86_mmx %b, i64* %ptr) {
; Ensure we can handle x86_mmx values which are primitive and can be bitcast ; Ensure we can handle x86_mmx values which are primitive and can be bitcast
; with integer types but can't be put into a vector. ; with integer types but can't be put into a vector.
; ;
▲ Show 20 Lines • Show All 129 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/barriercall.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | FileCheck %s ; RUN: opt < %s -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | 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"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
define i32 @foo(i32* nocapture %A, i32 %n) { define i32 @foo(i32* nocapture %A, i32 %n) {
; CHECK-LABEL: @foo( ; CHECK-LABEL: @foo(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[CALL:%.*]] = tail call i32 (...) @bar() ; CHECK-NEXT: [[CALL:%.*]] = tail call i32 (...) @bar()
Show All 33 Lines

llvm/test/Transforms/SLPVectorizer/X86/bitreverse.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=SSE ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=bdver2 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=XOP ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=bdver2 -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=XOP
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=bdver4 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=XOP ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=bdver4 -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=XOP
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"
@src64 = common global [4 x i64] zeroinitializer, align 32 @src64 = common global [4 x i64] zeroinitializer, align 32
@dst64 = common global [4 x i64] zeroinitializer, align 32 @dst64 = common global [4 x i64] zeroinitializer, align 32
@src32 = common global [8 x i32] zeroinitializer, align 32 @src32 = common global [8 x i32] zeroinitializer, align 32
@dst32 = common global [8 x i32] zeroinitializer, align 32 @dst32 = common global [8 x i32] zeroinitializer, align 32
@src16 = common global [16 x i16] zeroinitializer, align 32 @src16 = common global [16 x i16] zeroinitializer, align 32
▲ Show 20 Lines • Show All 421 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/bool-mask.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -S -mtriple=x86_64-unknown -mcpu=x86-64 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=SSE,SSE2 ; RUN: opt < %s -slp-vectorizer -S -mtriple=x86_64-unknown -mcpu=x86-64 -slp-vectorizer -S | FileCheck %s --check-prefixes=SSE,SSE2
; RUN: opt < %s -basic-aa -slp-vectorizer -S -mtriple=x86_64-unknown -mcpu=x86-64-v2 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=SSE,SSE4 ; RUN: opt < %s -slp-vectorizer -S -mtriple=x86_64-unknown -mcpu=x86-64-v2 -slp-vectorizer -S | FileCheck %s --check-prefixes=SSE,SSE4
; RUN: opt < %s -basic-aa -slp-vectorizer -S -mtriple=x86_64-unknown -mcpu=x86-64-v3 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX ; RUN: opt < %s -slp-vectorizer -S -mtriple=x86_64-unknown -mcpu=x86-64-v3 -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX
; RUN: opt < %s -basic-aa -slp-vectorizer -S -mtriple=x86_64-unknown -mcpu=x86-64-v4 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX512 ; RUN: opt < %s -slp-vectorizer -S -mtriple=x86_64-unknown -mcpu=x86-64-v4 -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX512
; // PR42652 ; // PR42652
; unsigned long bitmask_16xi8(const char *src) { ; unsigned long bitmask_16xi8(const char *src) {
; unsigned long mask = 0; ; unsigned long mask = 0;
; for (unsigned i = 0; i != 16; ++i) { ; for (unsigned i = 0; i != 16; ++i) {
; if (src[i]) ; if (src[i])
; mask |= (1ull << i); ; mask |= (1ull << i);
; } ; }
▲ Show 20 Lines • Show All 602 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/bswap.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=SSE ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX
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"
@src64 = common global [4 x i64] zeroinitializer, align 32 @src64 = common global [4 x i64] zeroinitializer, align 32
@dst64 = common global [4 x i64] zeroinitializer, align 32 @dst64 = common global [4 x i64] zeroinitializer, align 32
@src32 = common global [8 x i32] zeroinitializer, align 32 @src32 = common global [8 x i32] zeroinitializer, align 32
@dst32 = common global [8 x i32] zeroinitializer, align 32 @dst32 = common global [8 x i32] zeroinitializer, align 32
@src16 = common global [16 x i16] zeroinitializer, align 32 @src16 = common global [16 x i16] zeroinitializer, align 32
▲ Show 20 Lines • Show All 235 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/call.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -slp-threshold=-999 -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | FileCheck %s ; RUN: opt < %s -slp-vectorizer -slp-threshold=-999 -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | 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"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
declare double @sin(double) nounwind willreturn declare double @sin(double) nounwind willreturn
declare double @cos(double) nounwind willreturn declare double @cos(double) nounwind willreturn
declare double @pow(double, double) nounwind willreturn declare double @pow(double, double) nounwind willreturn
declare double @exp2(double) nounwind willreturn declare double @exp2(double) nounwind willreturn
▲ Show 20 Lines • Show All 162 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/cast.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7 -basic-aa -slp-vectorizer -dce -S | FileCheck %s --check-prefixes=CHECK,SSE42 ; RUN: opt < %s -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7 -slp-vectorizer -dce -S | FileCheck %s --check-prefixes=CHECK,SSE42
; RUN: opt < %s -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx -basic-aa -slp-vectorizer -dce -S | FileCheck %s --check-prefixes=CHECK,AVX ; RUN: opt < %s -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx -slp-vectorizer -dce -S | FileCheck %s --check-prefixes=CHECK,AVX
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"
; int test_sext_4i8_to_4i32(int * restrict A, char * restrict B) { ; int test_sext_4i8_to_4i32(int * restrict A, char * restrict B) {
; A[0] = B[0]; ; A[0] = B[0];
; A[1] = B[1]; ; A[1] = B[1];
; A[2] = B[2]; ; A[2] = B[2];
; A[3] = B[3]; ; A[3] = B[3];
▲ Show 20 Lines • Show All 113 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/cmp_sel.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | FileCheck %s ; RUN: opt < %s -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | FileCheck %s
; int foo(double * restrict A, double * restrict B, double G) { ; int foo(double * restrict A, double * restrict B, double G) {
; A[0] = (B[10] ? G : 1); ; A[0] = (B[10] ? G : 1);
; A[1] = (B[11] ? G : 1); ; A[1] = (B[11] ? G : 1);
; } ; }
define i32 @foo(double* noalias nocapture %A, double* noalias nocapture %B, double %G) { define i32 @foo(double* noalias nocapture %A, double* noalias nocapture %B, double %G) {
; CHECK-LABEL: @foo( ; CHECK-LABEL: @foo(
Show All 27 Lines

llvm/test/Transforms/SLPVectorizer/X86/compare-reduce.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | FileCheck %s ; RUN: opt < %s -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | 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"
target triple = "x86_64-apple-macosx10.7.0" target triple = "x86_64-apple-macosx10.7.0"
@.str = private unnamed_addr constant [6 x i8] c"bingo\00", align 1 @.str = private unnamed_addr constant [6 x i8] c"bingo\00", align 1
define void @reduce_compare(double* nocapture %A, i32 %n) { define void @reduce_compare(double* nocapture %A, i32 %n) {
; CHECK-LABEL: @reduce_compare( ; CHECK-LABEL: @reduce_compare(
▲ Show 20 Lines • Show All 186 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/consecutive-access.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -slp-vectorizer -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"
target triple = "x86_64-apple-macosx10.9.0" target triple = "x86_64-apple-macosx10.9.0"
@A = common global [2000 x double] zeroinitializer, align 16 @A = common global [2000 x double] zeroinitializer, align 16
@B = common global [2000 x double] zeroinitializer, align 16 @B = common global [2000 x double] zeroinitializer, align 16
@C = common global [2000 x float] zeroinitializer, align 16 @C = common global [2000 x float] zeroinitializer, align 16
@D = common global [2000 x float] zeroinitializer, align 16 @D = common global [2000 x float] zeroinitializer, align 16
▲ Show 20 Lines • Show All 536 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/continue_vectorizing.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | FileCheck %s ; RUN: opt < %s -slp-vectorizer -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | 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"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
; We will keep trying to vectorize the basic block even we already find vectorized store. ; We will keep trying to vectorize the basic block even we already find vectorized store.
define void @test1(double* %a, double* %b, double* %c, double* %d) { define void @test1(double* %a, double* %b, double* %c, double* %d) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
Show All 37 Lines

llvm/test/Transforms/SLPVectorizer/X86/crash_7zip.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7 | FileCheck %s ; RUN: opt < %s -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7 | 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"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
%struct.CLzmaDec.1.28.55.82.103.124.145.166.181.196.229.259.334 = type { %struct._CLzmaProps.0.27.54.81.102.123.144.165.180.195.228.258.333, i16*, i8*, i8*, i32, i32, i64, i64, i32, i32, i32, [4 x i32], i32, i32, i32, i32, i32, [20 x i8] } %struct.CLzmaDec.1.28.55.82.103.124.145.166.181.196.229.259.334 = type { %struct._CLzmaProps.0.27.54.81.102.123.144.165.180.195.228.258.333, i16*, i8*, i8*, i32, i32, i64, i64, i32, i32, i32, [4 x i32], i32, i32, i32, i32, i32, [20 x i8] }
%struct._CLzmaProps.0.27.54.81.102.123.144.165.180.195.228.258.333 = type { i32, i32, i32, i32 } %struct._CLzmaProps.0.27.54.81.102.123.144.165.180.195.228.258.333 = type { i32, i32, i32, i32 }
define fastcc void @LzmaDec_DecodeReal2(%struct.CLzmaDec.1.28.55.82.103.124.145.166.181.196.229.259.334* %p) { define fastcc void @LzmaDec_DecodeReal2(%struct.CLzmaDec.1.28.55.82.103.124.145.166.181.196.229.259.334* %p) {
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/crash_binaryop.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7 | FileCheck %s ; RUN: opt < %s -slp-vectorizer -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7 | 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"
target triple = "x86_64-apple-darwin13.3.0" target triple = "x86_64-apple-darwin13.3.0"
@a = common global double 0.000000e+00, align 8 @a = common global double 0.000000e+00, align 8
define i32 @fn1() { define i32 @fn1() {
; CHECK-LABEL: @fn1( ; CHECK-LABEL: @fn1(
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/crash_bullet.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7 | FileCheck %s ; RUN: opt < %s -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7 | 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"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
%"struct.btTypedConstraint::btConstraintInfo1.17.157.357.417.477.960" = type { i32, i32 } %"struct.btTypedConstraint::btConstraintInfo1.17.157.357.417.477.960" = type { i32, i32 }
define void @_ZN23btGeneric6DofConstraint8getInfo1EPN17btTypedConstraint17btConstraintInfo1E(%"struct.btTypedConstraint::btConstraintInfo1.17.157.357.417.477.960"* nocapture %info) { define void @_ZN23btGeneric6DofConstraint8getInfo1EPN17btTypedConstraint17btConstraintInfo1E(%"struct.btTypedConstraint::btConstraintInfo1.17.157.357.417.477.960"* nocapture %info) {
; CHECK-LABEL: @_ZN23btGeneric6DofConstraint8getInfo1EPN17btTypedConstraint17btConstraintInfo1E( ; CHECK-LABEL: @_ZN23btGeneric6DofConstraint8getInfo1EPN17btTypedConstraint17btConstraintInfo1E(
▲ Show 20 Lines • Show All 198 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/crash_bullet3.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7 | FileCheck %s ; RUN: opt < %s -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7 | 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"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
%class.btVector3.23.221.463.485.507.573.595.683.727.749.815.837.991.1585.1607.1629.1651.1849.2047.2069.2091.2113 = type { [4 x float] } %class.btVector3.23.221.463.485.507.573.595.683.727.749.815.837.991.1585.1607.1629.1651.1849.2047.2069.2091.2113 = type { [4 x float] }
; Function Attrs: ssp uwtable ; Function Attrs: ssp uwtable
define void @_ZN11HullLibrary15CleanupVerticesEjPK9btVector3jRjPS0_fRS0_(%class.btVector3.23.221.463.485.507.573.595.683.727.749.815.837.991.1585.1607.1629.1651.1849.2047.2069.2091.2113* %vertices) #0 align 2 { define void @_ZN11HullLibrary15CleanupVerticesEjPK9btVector3jRjPS0_fRS0_(%class.btVector3.23.221.463.485.507.573.595.683.727.749.815.837.991.1585.1607.1629.1651.1849.2047.2069.2091.2113* %vertices) #0 align 2 {
▲ Show 20 Lines • Show All 124 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/crash_cmpop.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -slp-vectorizer -S | FileCheck %s
; RUN: opt < %s -basic-aa -slp-vectorizer -S -mattr=+avx | FileCheck %s ; RUN: opt < %s -slp-vectorizer -S -mattr=+avx | 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"
target triple = "x86_64-apple-macosx10.10.0" target triple = "x86_64-apple-macosx10.10.0"
define void @testfunc(float* nocapture %dest, float* nocapture readonly %src) { define void @testfunc(float* nocapture %dest, float* nocapture readonly %src) {
; CHECK-LABEL: @testfunc( ; CHECK-LABEL: @testfunc(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[FOR_BODY:%.*]] ; CHECK-NEXT: br label [[FOR_BODY:%.*]]
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/crash_dequeue.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7 | FileCheck %s ; RUN: opt < %s -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7 | 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"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
%"struct.std::_Deque_iterator.4.157.174.208.259.276.344.731" = type { double*, double*, double*, double** } %"struct.std::_Deque_iterator.4.157.174.208.259.276.344.731" = type { double*, double*, double*, double** }
; Function Attrs: nounwind ssp uwtable ; Function Attrs: nounwind ssp uwtable
define void @_ZSt6uniqueISt15_Deque_iteratorIdRdPdEET_S4_S4_(%"struct.std::_Deque_iterator.4.157.174.208.259.276.344.731"* %__first, %"struct.std::_Deque_iterator.4.157.174.208.259.276.344.731"* nocapture %__last) { define void @_ZSt6uniqueISt15_Deque_iteratorIdRdPdEET_S4_S4_(%"struct.std::_Deque_iterator.4.157.174.208.259.276.344.731"* %__first, %"struct.std::_Deque_iterator.4.157.174.208.259.276.344.731"* nocapture %__last) {
; CHECK-LABEL: @_ZSt6uniqueISt15_Deque_iteratorIdRdPdEET_S4_S4_( ; CHECK-LABEL: @_ZSt6uniqueISt15_Deque_iteratorIdRdPdEET_S4_S4_(
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/crash_flop7.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7 | FileCheck %s ; RUN: opt < %s -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7 | 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"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
; Function Attrs: nounwind ssp uwtable ; Function Attrs: nounwind ssp uwtable
define void @main() #0 { define void @main() #0 {
; CHECK-LABEL: @main( ; CHECK-LABEL: @main(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/crash_gep.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -dce -S -mtriple=x86_64-unknown-linux-gnu | FileCheck %s ; RUN: opt < %s -slp-vectorizer -dce -S -mtriple=x86_64-unknown-linux-gnu | 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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
@a = common global i64* null, align 8 @a = common global i64* null, align 8
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
define i32 @fn1() { define i32 @fn1() {
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/crash_lencod-inseltpoison.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7 | FileCheck %s ; RUN: opt < %s -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7 | 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"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
; Function Attrs: nounwind ssp uwtable ; Function Attrs: nounwind ssp uwtable
define void @RCModelEstimator() { define void @RCModelEstimator() {
; CHECK-LABEL: @RCModelEstimator( ; CHECK-LABEL: @RCModelEstimator(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
▲ Show 20 Lines • Show All 138 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/crash_lencod.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7 | FileCheck %s ; RUN: opt < %s -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7 | 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"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
; Function Attrs: nounwind ssp uwtable ; Function Attrs: nounwind ssp uwtable
define void @RCModelEstimator() { define void @RCModelEstimator() {
; CHECK-LABEL: @RCModelEstimator( ; CHECK-LABEL: @RCModelEstimator(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
▲ Show 20 Lines • Show All 138 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/crash_mandeltext.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7 | FileCheck %s ; RUN: opt < %s -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7 | 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"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
define void @main() { define void @main() {
; CHECK-LABEL: @main( ; CHECK-LABEL: @main(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[FOR_BODY:%.*]] ; CHECK-NEXT: br label [[FOR_BODY:%.*]]
▲ Show 20 Lines • Show All 170 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/crash_netbsd_decompress.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7 | FileCheck %s ; RUN: opt < %s -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7 | 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"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
%struct.DState = type { i32, i32 } %struct.DState = type { i32, i32 }
@b = common global %struct.DState zeroinitializer, align 4 @b = common global %struct.DState zeroinitializer, align 4
@d = common global i32 0, align 4 @d = common global i32 0, align 4
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/crash_scheduling-inseltpoison.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7 | FileCheck %s ; RUN: opt < %s -slp-vectorizer -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7 | 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"
target triple = "x86_64-apple-darwin13.3.0" target triple = "x86_64-apple-darwin13.3.0"
define void @_foo(double %p1, double %p2, double %p3) #0 { define void @_foo(double %p1, double %p2, double %p3) #0 {
; CHECK-LABEL: @_foo( ; CHECK-LABEL: @_foo(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[TAB1:%.*]] = alloca [256 x i32], align 16 ; CHECK-NEXT: [[TAB1:%.*]] = alloca [256 x i32], align 16
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/crash_scheduling.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7 | FileCheck %s ; RUN: opt < %s -slp-vectorizer -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7 | 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"
target triple = "x86_64-apple-darwin13.3.0" target triple = "x86_64-apple-darwin13.3.0"
define void @_foo(double %p1, double %p2, double %p3) #0 { define void @_foo(double %p1, double %p2, double %p3) #0 {
; CHECK-LABEL: @_foo( ; CHECK-LABEL: @_foo(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[TAB1:%.*]] = alloca [256 x i32], align 16 ; CHECK-NEXT: [[TAB1:%.*]] = alloca [256 x i32], align 16
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/crash_sim4b1.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7 | FileCheck %s ; RUN: opt < %s -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7 | 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"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
%struct._exon_t.12.103.220.363.480.649.740.857.1039.1065.1078.1091.1117.1130.1156.1169.1195.1221.1234.1286.1299.1312.1338.1429.1455.1468.1494.1520.1884.1897.1975.2066.2105.2170.2171 = type { i32, i32, i32, i32, i32, i32, [8 x i8] } %struct._exon_t.12.103.220.363.480.649.740.857.1039.1065.1078.1091.1117.1130.1156.1169.1195.1221.1234.1286.1299.1312.1338.1429.1455.1468.1494.1520.1884.1897.1975.2066.2105.2170.2171 = type { i32, i32, i32, i32, i32, i32, [8 x i8] }
define void @SIM4() { define void @SIM4() {
; CHECK-LABEL: @SIM4( ; CHECK-LABEL: @SIM4(
▲ Show 20 Lines • Show All 178 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/crash_smallpt.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7 | FileCheck %s ; RUN: opt < %s -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7 | 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"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
%struct.Ray.5.11.53.113.119.137.149.185.329.389.416 = type { %struct.Vec.0.6.48.108.114.132.144.180.324.384.414, %struct.Vec.0.6.48.108.114.132.144.180.324.384.414 } %struct.Ray.5.11.53.113.119.137.149.185.329.389.416 = type { %struct.Vec.0.6.48.108.114.132.144.180.324.384.414, %struct.Vec.0.6.48.108.114.132.144.180.324.384.414 }
%struct.Vec.0.6.48.108.114.132.144.180.324.384.414 = type { double, double, double } %struct.Vec.0.6.48.108.114.132.144.180.324.384.414 = type { double, double, double }
; Function Attrs: ssp uwtable ; Function Attrs: ssp uwtable
▲ Show 20 Lines • Show All 159 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/crash_vectorizeTree.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -basic-aa -slp-vectorizer -mtriple=x86_64-apple-macosx10.9.0 -mcpu=corei7-avx -S < %s | FileCheck %s ; RUN: opt -slp-vectorizer -mtriple=x86_64-apple-macosx10.9.0 -mcpu=corei7-avx -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"
target triple = "x86_64-apple-macosx10.9.0" target triple = "x86_64-apple-macosx10.9.0"
; This test used to crash because we were following phi chains incorrectly. ; This test used to crash because we were following phi chains incorrectly.
; We used indices to get the incoming value of two phi nodes rather than ; We used indices to get the incoming value of two phi nodes rather than
; incoming block lookup. ; incoming block lookup.
; This can give wrong results when the ordering of incoming ; This can give wrong results when the ordering of incoming
▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/cross_block_slp.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | FileCheck %s ; RUN: opt < %s -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | 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"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
; int foo(double *A, float *B, int g) { ; int foo(double *A, float *B, int g) {
; float B0 = B[0]; ; float B0 = B[0];
; float B1 = B[1]; <----- BasicBlock #1 ; float B1 = B[1]; <----- BasicBlock #1
; B0 += 5; ; B0 += 5;
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/cse.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -S -mtriple=i386-apple-macosx10.8.0 -mcpu=corei7-avx | FileCheck %s ; RUN: opt < %s -slp-vectorizer -S -mtriple=i386-apple-macosx10.8.0 -mcpu=corei7-avx | 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:128:128-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:128:128-n8:16:32-S128"
target triple = "i386-apple-macosx10.8.0" target triple = "i386-apple-macosx10.8.0"
;int test(double *G) { ;int test(double *G) {
; G[0] = 1+G[5]*4; ; G[0] = 1+G[5]*4;
; G[1] = 6+G[6]*3; ; G[1] = 6+G[6]*3;
; G[2] = 7+G[5]*4; ; G[2] = 7+G[5]*4;
▲ Show 20 Lines • Show All 383 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/ctlz.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SSE ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SSE ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7 -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX1 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX1
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX2 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX2
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=icelake-server -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=icelake-server -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX512
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"
@src64 = common global [4 x i64] zeroinitializer, align 32 @src64 = common global [4 x i64] zeroinitializer, align 32
@dst64 = common global [4 x i64] zeroinitializer, align 32 @dst64 = common global [4 x i64] zeroinitializer, align 32
@src32 = common global [8 x i32] zeroinitializer, align 32 @src32 = common global [8 x i32] zeroinitializer, align 32
@dst32 = common global [8 x i32] zeroinitializer, align 32 @dst32 = common global [8 x i32] zeroinitializer, align 32
@src16 = common global [16 x i16] zeroinitializer, align 32 @src16 = common global [16 x i16] zeroinitializer, align 32
▲ Show 20 Lines • Show All 1,003 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/ctpop.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -mattr=+sse2 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=SSE --check-prefix=SSE2 ; RUN: opt < %s -mtriple=x86_64-unknown -mattr=+sse2 -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=SSE --check-prefix=SSE2
; RUN: opt < %s -mtriple=x86_64-unknown -mattr=+sse4.2,+popcnt -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=SSE --check-prefix=SSE42 ; RUN: opt < %s -mtriple=x86_64-unknown -mattr=+sse4.2,+popcnt -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=SSE --check-prefix=SSE42
; RUN: opt < %s -mtriple=x86_64-unknown -mattr=+avx,+popcnt -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX1 ; RUN: opt < %s -mtriple=x86_64-unknown -mattr=+avx,+popcnt -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX1
; RUN: opt < %s -mtriple=x86_64-unknown -mattr=+avx2,+popcnt -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX2 ; RUN: opt < %s -mtriple=x86_64-unknown -mattr=+avx2,+popcnt -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX2
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"
@src64 = common global [4 x i64] zeroinitializer, align 32 @src64 = common global [4 x i64] zeroinitializer, align 32
@dst64 = common global [4 x i64] zeroinitializer, align 32 @dst64 = common global [4 x i64] zeroinitializer, align 32
@src32 = common global [8 x i32] zeroinitializer, align 32 @src32 = common global [8 x i32] zeroinitializer, align 32
@dst32 = common global [8 x i32] zeroinitializer, align 32 @dst32 = common global [8 x i32] zeroinitializer, align 32
@src16 = common global [16 x i16] zeroinitializer, align 32 @src16 = common global [16 x i16] zeroinitializer, align 32
▲ Show 20 Lines • Show All 499 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/cttz.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SSE ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SSE ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7 -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX1 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX1
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX2 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX2
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=icelake-server -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=icelake-server -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX512
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"
@src64 = common global [4 x i64] zeroinitializer, align 32 @src64 = common global [4 x i64] zeroinitializer, align 32
@dst64 = common global [4 x i64] zeroinitializer, align 32 @dst64 = common global [4 x i64] zeroinitializer, align 32
@src32 = common global [8 x i32] zeroinitializer, align 32 @src32 = common global [8 x i32] zeroinitializer, align 32
@dst32 = common global [8 x i32] zeroinitializer, align 32 @dst32 = common global [8 x i32] zeroinitializer, align 32
@src16 = common global [16 x i16] zeroinitializer, align 32 @src16 = common global [16 x i16] zeroinitializer, align 32
▲ Show 20 Lines • Show All 1,018 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/cycle_dup.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | FileCheck %s ; RUN: opt < %s -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | 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"
target triple = "x86_64-apple-macosx10.9.0" target triple = "x86_64-apple-macosx10.9.0"
; int foo(int *A) { ; int foo(int *A) {
; int r = A[0], g = A[1], b = A[2], a = A[3]; ; int r = A[0], g = A[1], b = A[2], a = A[3];
; for (int i=0; i < A[13]; i++) { ; for (int i=0; i < A[13]; i++) {
; r*=18; g*=19; b*=12; a *=9; ; r*=18; g*=19; b*=12; a *=9;
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/debug_info.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | FileCheck %s ; RUN: opt < %s -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | 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"
target triple = "x86_64-apple-macosx10.7.0" target triple = "x86_64-apple-macosx10.7.0"
; int depth(double *A, int m) { ; int depth(double *A, int m) {
; double y0 = 0; double y1 = 1; ; double y0 = 0; double y1 = 1;
; for (int i=0; i < m; i++) { ; for (int i=0; i < m; i++) {
; y0 = A[4]; ; y0 = A[4];
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/diamond.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | FileCheck %s ; RUN: opt < %s -slp-vectorizer -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | 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"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
; int foo(int * restrict B, int * restrict A, int n, int m) { ; int foo(int * restrict B, int * restrict A, int n, int m) {
; B[0] = n * A[0] + m * A[0]; ; B[0] = n * A[0] + m * A[0];
; B[1] = n * A[1] + m * A[1]; ; B[1] = n * A[1] + m * A[1];
; B[2] = n * A[2] + m * A[2]; ; B[2] = n * A[2] + m * A[2];
▲ Show 20 Lines • Show All 123 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/dot-product.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7 -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7 -slp-vectorizer -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -S | FileCheck %s
; ;
; dot4(float *x, float *y) - ((x[0]*y[0])+(x[1]*y[1])+(x[2]*y[2])+(x[3]*y[3])) ; dot4(float *x, float *y) - ((x[0]*y[0])+(x[1]*y[1])+(x[2]*y[2])+(x[3]*y[3]))
; ;
define double @dot4f64(double* dereferenceable(32) %ptrx, double* dereferenceable(32) %ptry) { define double @dot4f64(double* dereferenceable(32) %ptrx, double* dereferenceable(32) %ptry) {
; CHECK-LABEL: @dot4f64( ; CHECK-LABEL: @dot4f64(
; CHECK-NEXT: [[PTRX2:%.*]] = getelementptr inbounds double, double* [[PTRX:%.*]], i64 2 ; CHECK-NEXT: [[PTRX2:%.*]] = getelementptr inbounds double, double* [[PTRX:%.*]], i64 2
▲ Show 20 Lines • Show All 406 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/external_user.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | FileCheck %s ; RUN: opt < %s -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | 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"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
; double foo(double * restrict b, double * restrict a, int n, int m) { ; double foo(double * restrict b, double * restrict a, int n, int m) {
; double r=a[1]; ; double r=a[1];
; double g=a[0]; ; double g=a[0];
; double x; ; double x;
▲ Show 20 Lines • Show All 122 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/extract.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | FileCheck %s ; RUN: opt < %s -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | 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"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
define void @fextr(double* %ptr) { define void @fextr(double* %ptr) {
; CHECK-LABEL: @fextr( ; CHECK-LABEL: @fextr(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[LD:%.*]] = load <2 x double>, <2 x double>* undef, align 16 ; CHECK-NEXT: [[LD:%.*]] = load <2 x double>, <2 x double>* undef, align 16
; CHECK-NEXT: [[P0:%.*]] = getelementptr inbounds double, double* [[PTR:%.*]], i64 0 ; CHECK-NEXT: [[P0:%.*]] = getelementptr inbounds double, double* [[PTR:%.*]], i64 0
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/extract_in_tree_user.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -S -mtriple=i386-apple-macosx10.9.0 -mcpu=corei7-avx | FileCheck %s ; RUN: opt < %s -slp-vectorizer -S -mtriple=i386-apple-macosx10.9.0 -mcpu=corei7-avx | 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"
@a = common global i64* null, align 8 @a = common global i64* null, align 8
; Function Attrs: nounwind ssp uwtable ; Function Attrs: nounwind ssp uwtable
define i32 @fn1() { define i32 @fn1() {
; CHECK-LABEL: @fn1( ; CHECK-LABEL: @fn1(
▲ Show 20 Lines • Show All 112 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/extractcost.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | FileCheck %s ; RUN: opt < %s -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | 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"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
define i32 @foo(i32* nocapture %A, i32 %n, i32 %m) { define i32 @foo(i32* nocapture %A, i32 %n, i32 %m) {
; CHECK-LABEL: @foo( ; CHECK-LABEL: @foo(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP0:%.*]] = insertelement <4 x i32> poison, i32 [[N:%.*]], i32 0 ; CHECK-NEXT: [[TMP0:%.*]] = insertelement <4 x i32> poison, i32 [[N:%.*]], i32 0
Show All 34 Lines

llvm/test/Transforms/SLPVectorizer/X86/fabs.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=SSE ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX256 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX256
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=bdver1 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX256 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=bdver1 -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX256
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX256 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX256
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=-prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=-prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=+prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX256 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=+prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX256
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"
@src64 = common global [8 x double] zeroinitializer, align 64 @src64 = common global [8 x double] zeroinitializer, align 64
@src32 = common global [16 x float] zeroinitializer, align 64 @src32 = common global [16 x float] zeroinitializer, align 64
@dst64 = common global [8 x double] zeroinitializer, align 64 @dst64 = common global [8 x double] zeroinitializer, align 64
@dst32 = common global [16 x float] zeroinitializer, align 64 @dst32 = common global [16 x float] zeroinitializer, align 64
▲ Show 20 Lines • Show All 260 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/fcopysign.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=SSE ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX256 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX256
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=bdver1 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX256 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=bdver1 -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX256
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX256 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX256
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=-prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=-prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=+prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX256 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=+prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX256
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"
@srcA64 = common global [8 x double] zeroinitializer, align 64 @srcA64 = common global [8 x double] zeroinitializer, align 64
@srcB64 = common global [8 x double] zeroinitializer, align 64 @srcB64 = common global [8 x double] zeroinitializer, align 64
@srcC64 = common global [8 x double] zeroinitializer, align 64 @srcC64 = common global [8 x double] zeroinitializer, align 64
@srcA32 = common global [16 x float] zeroinitializer, align 64 @srcA32 = common global [16 x float] zeroinitializer, align 64
@srcB32 = common global [16 x float] zeroinitializer, align 64 @srcB32 = common global [16 x float] zeroinitializer, align 64
▲ Show 20 Lines • Show All 328 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/flag.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -slp-threshold=1000 -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | FileCheck %s ; RUN: opt < %s -slp-vectorizer -slp-threshold=1000 -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | 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"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
; Check that the command line flag works. ; Check that the command line flag works.
define i32 @rollable(i32* noalias nocapture %in, i32* noalias nocapture %out, i64 %n) { define i32 @rollable(i32* noalias nocapture %in, i32* noalias nocapture %out, i64 %n) {
; CHECK-LABEL: @rollable( ; CHECK-LABEL: @rollable(
; CHECK-NEXT: [[TMP1:%.*]] = icmp eq i64 [[N:%.*]], 0 ; CHECK-NEXT: [[TMP1:%.*]] = icmp eq i64 [[N:%.*]], 0
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/fma.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=NO-FMA ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -S | FileCheck %s --check-prefix=NO-FMA
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=NO-FMA ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -S | FileCheck %s --check-prefix=NO-FMA
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=bdver1 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=FMA --check-prefix=FMA256 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=bdver1 -slp-vectorizer -S | FileCheck %s --check-prefix=FMA --check-prefix=FMA256
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=FMA --check-prefix=FMA256 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -S | FileCheck %s --check-prefix=FMA --check-prefix=FMA256
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=-prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=FMA --check-prefix=FMA512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=-prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefix=FMA --check-prefix=FMA512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=+prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=FMA --check-prefix=FMA256 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=+prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefix=FMA --check-prefix=FMA256
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"
@srcA64 = common global [8 x double] zeroinitializer, align 64 @srcA64 = common global [8 x double] zeroinitializer, align 64
@srcB64 = common global [8 x double] zeroinitializer, align 64 @srcB64 = common global [8 x double] zeroinitializer, align 64
@srcC64 = common global [8 x double] zeroinitializer, align 64 @srcC64 = common global [8 x double] zeroinitializer, align 64
@srcA32 = common global [16 x float] zeroinitializer, align 64 @srcA32 = common global [16 x float] zeroinitializer, align 64
@srcB32 = common global [16 x float] zeroinitializer, align 64 @srcB32 = common global [16 x float] zeroinitializer, align 64
▲ Show 20 Lines • Show All 548 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/fmaxnum.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SSE ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=bdver1 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=bdver1 -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=-prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=-prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=+prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=+prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256
@srcA64 = common global [8 x double] zeroinitializer, align 64 @srcA64 = common global [8 x double] zeroinitializer, align 64
@srcB64 = common global [8 x double] zeroinitializer, align 64 @srcB64 = common global [8 x double] zeroinitializer, align 64
@srcC64 = common global [8 x double] zeroinitializer, align 64 @srcC64 = common global [8 x double] zeroinitializer, align 64
@srcA32 = common global [16 x float] zeroinitializer, align 64 @srcA32 = common global [16 x float] zeroinitializer, align 64
@srcB32 = common global [16 x float] zeroinitializer, align 64 @srcB32 = common global [16 x float] zeroinitializer, align 64
@srcC32 = common global [16 x float] zeroinitializer, align 64 @srcC32 = common global [16 x float] zeroinitializer, align 64
@dst64 = common global [8 x double] zeroinitializer, align 64 @dst64 = common global [8 x double] zeroinitializer, align 64
▲ Show 20 Lines • Show All 491 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/fminnum.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SSE ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=bdver1 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=bdver1 -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=-prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=-prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=+prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=+prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256
@srcA64 = common global [8 x double] zeroinitializer, align 64 @srcA64 = common global [8 x double] zeroinitializer, align 64
@srcB64 = common global [8 x double] zeroinitializer, align 64 @srcB64 = common global [8 x double] zeroinitializer, align 64
@srcC64 = common global [8 x double] zeroinitializer, align 64 @srcC64 = common global [8 x double] zeroinitializer, align 64
@srcA32 = common global [16 x float] zeroinitializer, align 64 @srcA32 = common global [16 x float] zeroinitializer, align 64
@srcB32 = common global [16 x float] zeroinitializer, align 64 @srcB32 = common global [16 x float] zeroinitializer, align 64
@srcC32 = common global [16 x float] zeroinitializer, align 64 @srcC32 = common global [16 x float] zeroinitializer, align 64
@dst64 = common global [8 x double] zeroinitializer, align 64 @dst64 = common global [8 x double] zeroinitializer, align 64
▲ Show 20 Lines • Show All 491 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/fmuladd.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SSE ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=bdver1 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=bdver1 -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=-prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=-prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=+prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=+prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256
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"
@srcA64 = common global [8 x double] zeroinitializer, align 64 @srcA64 = common global [8 x double] zeroinitializer, align 64
@srcB64 = common global [8 x double] zeroinitializer, align 64 @srcB64 = common global [8 x double] zeroinitializer, align 64
@srcC64 = common global [8 x double] zeroinitializer, align 64 @srcC64 = common global [8 x double] zeroinitializer, align 64
@srcA32 = common global [16 x float] zeroinitializer, align 64 @srcA32 = common global [16 x float] zeroinitializer, align 64
@srcB32 = common global [16 x float] zeroinitializer, align 64 @srcB32 = common global [16 x float] zeroinitializer, align 64
▲ Show 20 Lines • Show All 392 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/fptosi-inseltpoison.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=SSE ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX256NODQ ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX256NODQ
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=bdver1 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX256NODQ ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=bdver1 -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX256NODQ
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX256NODQ ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX256NODQ
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=-prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=-prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=+prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX256DQ ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=+prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX256DQ
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"
@src64 = common global [8 x double] zeroinitializer, align 64 @src64 = common global [8 x double] zeroinitializer, align 64
@src32 = common global [16 x float] zeroinitializer, align 64 @src32 = common global [16 x float] zeroinitializer, align 64
@dst64 = common global [8 x i64] zeroinitializer, align 64 @dst64 = common global [8 x i64] zeroinitializer, align 64
@dst32 = common global [16 x i32] zeroinitializer, align 64 @dst32 = common global [16 x i32] zeroinitializer, align 64
@dst16 = common global [32 x i16] zeroinitializer, align 64 @dst16 = common global [32 x i16] zeroinitializer, align 64
▲ Show 20 Lines • Show All 471 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/fptosi.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=SSE ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX256NODQ ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX256NODQ
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=bdver1 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX256NODQ ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=bdver1 -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX256NODQ
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX256NODQ ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX256NODQ
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=-prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=-prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=+prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX256DQ ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=+prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX256DQ
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"
@src64 = common global [8 x double] zeroinitializer, align 64 @src64 = common global [8 x double] zeroinitializer, align 64
@src32 = common global [16 x float] zeroinitializer, align 64 @src32 = common global [16 x float] zeroinitializer, align 64
@dst64 = common global [8 x i64] zeroinitializer, align 64 @dst64 = common global [8 x i64] zeroinitializer, align 64
@dst32 = common global [16 x i32] zeroinitializer, align 64 @dst32 = common global [16 x i32] zeroinitializer, align 64
@dst16 = common global [32 x i16] zeroinitializer, align 64 @dst16 = common global [32 x i16] zeroinitializer, align 64
▲ Show 20 Lines • Show All 471 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/fptoui.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SSE ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256NODQ ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256NODQ
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=bdver1 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256NODQ ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=bdver1 -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256NODQ
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256NODQ ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256NODQ
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=-prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX512F ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=-prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX512F
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=+prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256DQ ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=+prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256DQ
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"
@src64 = common global [8 x double] zeroinitializer, align 64 @src64 = common global [8 x double] zeroinitializer, align 64
@src32 = common global [16 x float] zeroinitializer, align 64 @src32 = common global [16 x float] zeroinitializer, align 64
@dst64 = common global [8 x i64] zeroinitializer, align 64 @dst64 = common global [8 x i64] zeroinitializer, align 64
@dst32 = common global [16 x i32] zeroinitializer, align 64 @dst32 = common global [16 x i32] zeroinitializer, align 64
@dst16 = common global [32 x i16] zeroinitializer, align 64 @dst16 = common global [32 x i16] zeroinitializer, align 64
▲ Show 20 Lines • Show All 427 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/fround.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=SSE2 ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -S | FileCheck %s --check-prefix=SSE2
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=SSE41 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7 -slp-vectorizer -S | FileCheck %s --check-prefix=SSE41
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX --check-prefix=AVX1 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -S | FileCheck %s --check-prefix=AVX --check-prefix=AVX1
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX --check-prefix=AVX2 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -S | FileCheck %s --check-prefix=AVX --check-prefix=AVX2
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=-prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX --check-prefix=AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=-prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefix=AVX --check-prefix=AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=+prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX --check-prefix=AVX2 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=+prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefix=AVX --check-prefix=AVX2
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"
@src64 = common global [8 x double] zeroinitializer, align 64 @src64 = common global [8 x double] zeroinitializer, align 64
@dst64 = common global [8 x double] zeroinitializer, align 64 @dst64 = common global [8 x double] zeroinitializer, align 64
@src32 = common global [16 x float] zeroinitializer, align 64 @src32 = common global [16 x float] zeroinitializer, align 64
@dst32 = common global [16 x float] zeroinitializer, align 64 @dst32 = common global [16 x float] zeroinitializer, align 64
▲ Show 20 Lines • Show All 2,144 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/gep.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -S |FileCheck %s ; RUN: opt < %s -slp-vectorizer -S |FileCheck %s
; RUN: opt < %s -aa-pipeline=basic-aa -passes=slp-vectorizer -S |FileCheck %s ; RUN: opt < %s -aa-pipeline=basic-aa -passes=slp-vectorizer -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"
target triple = "x86_64-unknown-unknown" target triple = "x86_64-unknown-unknown"
; Test if SLP can handle GEP expressions. ; Test if SLP can handle GEP expressions.
; The test perform the following action: ; The test perform the following action:
; x->first = y->first + 16 ; x->first = y->first + 16
; x->second = y->second + 16 ; x->second = y->second + 16
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/hadd-inseltpoison.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=SSE ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=SLM ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=SLM
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX
; ;
; 128-bit vectors ; 128-bit vectors
; ;
define <2 x double> @test_v2f64(<2 x double> %a, <2 x double> %b) { define <2 x double> @test_v2f64(<2 x double> %a, <2 x double> %b) {
; CHECK-LABEL: @test_v2f64( ; CHECK-LABEL: @test_v2f64(
; CHECK-NEXT: [[TMP1:%.*]] = shufflevector <2 x double> [[A:%.*]], <2 x double> [[B:%.*]], <2 x i32> <i32 0, i32 2> ; CHECK-NEXT: [[TMP1:%.*]] = shufflevector <2 x double> [[A:%.*]], <2 x double> [[B:%.*]], <2 x i32> <i32 0, i32 2>
▲ Show 20 Lines • Show All 442 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/hadd.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=SSE ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=SLM ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=SLM
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX
; ;
; 128-bit vectors ; 128-bit vectors
; ;
define <2 x double> @test_v2f64(<2 x double> %a, <2 x double> %b) { define <2 x double> @test_v2f64(<2 x double> %a, <2 x double> %b) {
; CHECK-LABEL: @test_v2f64( ; CHECK-LABEL: @test_v2f64(
; CHECK-NEXT: [[TMP1:%.*]] = shufflevector <2 x double> [[A:%.*]], <2 x double> [[B:%.*]], <2 x i32> <i32 0, i32 2> ; CHECK-NEXT: [[TMP1:%.*]] = shufflevector <2 x double> [[A:%.*]], <2 x double> [[B:%.*]], <2 x i32> <i32 0, i32 2>
▲ Show 20 Lines • Show All 442 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/hoist.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -dce -S -mtriple=i386-apple-macosx10.8.0 -mcpu=corei7-avx | FileCheck %s ; RUN: opt < %s -slp-vectorizer -dce -S -mtriple=i386-apple-macosx10.8.0 -mcpu=corei7-avx | 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:128:128-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:128:128-n8:16:32-S128"
target triple = "i386-apple-macosx10.9.0" target triple = "i386-apple-macosx10.9.0"
;int foo(int *A, int n, int k) { ;int foo(int *A, int n, int k) {
; for (int i=0; i < 10000; i+=4) { ; for (int i=0; i < 10000; i+=4) {
; A[i] += n; ; A[i] += n;
; A[i+1] += k; ; A[i+1] += k;
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/hsub-inseltpoison.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=SSE ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=SLM ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=SLM
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX
; ;
; 128-bit vectors ; 128-bit vectors
; ;
define <2 x double> @test_v2f64(<2 x double> %a, <2 x double> %b) { define <2 x double> @test_v2f64(<2 x double> %a, <2 x double> %b) {
; CHECK-LABEL: @test_v2f64( ; CHECK-LABEL: @test_v2f64(
; CHECK-NEXT: [[TMP1:%.*]] = shufflevector <2 x double> [[A:%.*]], <2 x double> [[B:%.*]], <2 x i32> <i32 0, i32 2> ; CHECK-NEXT: [[TMP1:%.*]] = shufflevector <2 x double> [[A:%.*]], <2 x double> [[B:%.*]], <2 x i32> <i32 0, i32 2>
▲ Show 20 Lines • Show All 392 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/hsub.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=SSE ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=SLM ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=SLM
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -basic-aa -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -slp-vectorizer -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX
; ;
; 128-bit vectors ; 128-bit vectors
; ;
define <2 x double> @test_v2f64(<2 x double> %a, <2 x double> %b) { define <2 x double> @test_v2f64(<2 x double> %a, <2 x double> %b) {
; CHECK-LABEL: @test_v2f64( ; CHECK-LABEL: @test_v2f64(
; CHECK-NEXT: [[TMP1:%.*]] = shufflevector <2 x double> [[A:%.*]], <2 x double> [[B:%.*]], <2 x i32> <i32 0, i32 2> ; CHECK-NEXT: [[TMP1:%.*]] = shufflevector <2 x double> [[A:%.*]], <2 x double> [[B:%.*]], <2 x i32> <i32 0, i32 2>
▲ Show 20 Lines • Show All 392 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/implicitfloat.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | FileCheck %s ; RUN: opt < %s -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | 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"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
; Don't vectorize when noimplicitfloat is used. ; Don't vectorize when noimplicitfloat is used.
define void @test1(double* %a, double* %b, double* %c) noimplicitfloat { ; <------ noimplicitfloat attribute here! define void @test1(double* %a, double* %b, double* %c) noimplicitfloat { ; <------ noimplicitfloat attribute here!
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
Show All 28 Lines

llvm/test/Transforms/SLPVectorizer/X86/in-tree-user.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | FileCheck %s ; RUN: opt < %s -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | 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"
target triple = "x86_64-apple-macosx10.7.0" target triple = "x86_64-apple-macosx10.7.0"
@.str = private unnamed_addr constant [6 x i8] c"bingo\00", align 1 @.str = private unnamed_addr constant [6 x i8] c"bingo\00", align 1
; Uses inside the tree must be scheduled after the corresponding tree bundle. ; Uses inside the tree must be scheduled after the corresponding tree bundle.
define void @in_tree_user(double* nocapture %A, i32 %n) { define void @in_tree_user(double* nocapture %A, i32 %n) {
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/insertvalue.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -S -mtriple=x86_64-unknown-linux-gnu -mcpu=corei7-avx | FileCheck %s ; RUN: opt < %s -slp-vectorizer -S -mtriple=x86_64-unknown-linux-gnu -mcpu=corei7-avx | FileCheck %s
define void @julia_2xdouble([2 x double]* sret([2 x double]), [2 x double]*, [2 x double]*, [2 x double]*) { define void @julia_2xdouble([2 x double]* sret([2 x double]), [2 x double]*, [2 x double]*, [2 x double]*) {
; CHECK-LABEL: @julia_2xdouble( ; CHECK-LABEL: @julia_2xdouble(
; CHECK-NEXT: top: ; CHECK-NEXT: top:
; CHECK-NEXT: [[PX0:%.*]] = getelementptr inbounds [2 x double], [2 x double]* [[TMP2:%.*]], i64 0, i64 0 ; CHECK-NEXT: [[PX0:%.*]] = getelementptr inbounds [2 x double], [2 x double]* [[TMP2:%.*]], i64 0, i64 0
; CHECK-NEXT: [[PY0:%.*]] = getelementptr inbounds [2 x double], [2 x double]* [[TMP3:%.*]], i64 0, i64 0 ; CHECK-NEXT: [[PY0:%.*]] = getelementptr inbounds [2 x double], [2 x double]* [[TMP3:%.*]], i64 0, i64 0
; CHECK-NEXT: [[PZ0:%.*]] = getelementptr inbounds [2 x double], [2 x double]* [[TMP1:%.*]], i64 0, i64 0 ; CHECK-NEXT: [[PZ0:%.*]] = getelementptr inbounds [2 x double], [2 x double]* [[TMP1:%.*]], i64 0, i64 0
; CHECK-NEXT: [[TMP4:%.*]] = bitcast double* [[PX0]] to <2 x double>* ; CHECK-NEXT: [[TMP4:%.*]] = bitcast double* [[PX0]] to <2 x double>*
▲ Show 20 Lines • Show All 279 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/intrinsic.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -slp-threshold=-999 -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | FileCheck %s ; RUN: opt < %s -slp-vectorizer -slp-threshold=-999 -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | 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"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
declare double @llvm.fabs.f64(double) nounwind readnone declare double @llvm.fabs.f64(double) nounwind readnone
define void @vec_fabs_f64(double* %a, double* %b, double* %c) { define void @vec_fabs_f64(double* %a, double* %b, double* %c) {
; CHECK-LABEL: @vec_fabs_f64( ; CHECK-LABEL: @vec_fabs_f64(
▲ Show 20 Lines • Show All 505 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/long_chains.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | FileCheck %s ; RUN: opt < %s -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | 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"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
; At this point we can't vectorize only parts of the tree. ; At this point we can't vectorize only parts of the tree.
define i32 @test(double* nocapture %A, i8* nocapture %B) { define i32 @test(double* nocapture %A, i8* nocapture %B) {
; CHECK-LABEL: @test( ; CHECK-LABEL: @test(
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/loopinvariant.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -S -mcpu=corei7-avx | FileCheck %s ; RUN: opt < %s -slp-vectorizer -S -mcpu=corei7-avx | 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"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
define i32 @foo(i32* nocapture %A, i32 %n) { define i32 @foo(i32* nocapture %A, i32 %n) {
; CHECK-LABEL: @foo( ; CHECK-LABEL: @foo(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[CMP62:%.*]] = icmp sgt i32 [[N:%.*]], 0 ; CHECK-NEXT: [[CMP62:%.*]] = icmp sgt i32 [[N:%.*]], 0
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/metadata.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | FileCheck %s ; RUN: opt < %s -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | 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"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
define void @test1(double* %a, double* %b, double* %c) { define void @test1(double* %a, double* %b, double* %c) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP0:%.*]] = bitcast double* [[A:%.*]] to <2 x double>* ; CHECK-NEXT: [[TMP0:%.*]] = bitcast double* [[A:%.*]] to <2 x double>*
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/multi_block.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | FileCheck %s ; RUN: opt < %s -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | 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"
target triple = "x86_64-apple-macosx10.7.0" target triple = "x86_64-apple-macosx10.7.0"
; int bar(double *A, int d) { ; int bar(double *A, int d) {
; double A0 = A[0]; ; double A0 = A[0];
; double A1 = A[1]; ; double A1 = A[1];
; float F0 = A0; ; float F0 = A0;
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/multi_user.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | FileCheck %s ; RUN: opt < %s -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | 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"
target triple = "x86_64-apple-macosx10.7.0" target triple = "x86_64-apple-macosx10.7.0"
;int foo (int *A, int n) { ;int foo (int *A, int n) {
; A[0] += n * 5 + 7; ; A[0] += n * 5 + 7;
; A[1] += n * 5 + 8; ; A[1] += n * 5 + 8;
; A[2] += n * 5 + 9; ; A[2] += n * 5 + 9;
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/odd_store.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | FileCheck %s ; RUN: opt < %s -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | FileCheck %s
;int foo(char * restrict A, float * restrict B, float T) { ;int foo(char * restrict A, float * restrict B, float T) {
; A[0] = (T * B[10] + 4.0); ; A[0] = (T * B[10] + 4.0);
; A[1] = (T * B[11] + 5.0); ; A[1] = (T * B[11] + 5.0);
; A[2] = (T * B[12] + 6.0); ; A[2] = (T * B[12] + 6.0);
;} ;}
define i32 @foo(i8* noalias nocapture %A, float* noalias nocapture %B, float %T) { define i32 @foo(i8* noalias nocapture %A, float* noalias nocapture %B, float %T) {
▲ Show 20 Lines • Show All 168 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/operandorder.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -slp-threshold=-100 -instcombine -dce -S -mtriple=i386-apple-macosx10.8.0 -mcpu=corei7-avx | FileCheck %s ; RUN: opt < %s -slp-vectorizer -slp-threshold=-100 -instcombine -dce -S -mtriple=i386-apple-macosx10.8.0 -mcpu=corei7-avx | FileCheck %s
; RUN: opt < %s -basic-aa -slp-vectorizer -slp-threshold=-100 -instcombine -dce -S -mtriple=i386-apple-macosx10.8.0 -mattr=+sse2 | FileCheck %s --check-prefix=SSE2 ; RUN: opt < %s -slp-vectorizer -slp-threshold=-100 -instcombine -dce -S -mtriple=i386-apple-macosx10.8.0 -mattr=+sse2 | FileCheck %s --check-prefix=SSE2
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:128:128-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:128:128-n8:16:32-S128"
; Make sure we order the operands of commutative operations so that we get ; Make sure we order the operands of commutative operations so that we get
; bigger vectorizable trees. ; bigger vectorizable trees.
define void @shuffle_operands1(double * noalias %from, double * noalias %to, double %v1, double %v2) { define void @shuffle_operands1(double * noalias %from, double * noalias %to, double %v1, double %v2) {
; CHECK-LABEL: @shuffle_operands1( ; CHECK-LABEL: @shuffle_operands1(
▲ Show 20 Lines • Show All 638 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/ordering.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7 | FileCheck %s ; RUN: opt < %s -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7 | 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"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
define void @updateModelQPFrame(i32 %m_Bits) { define void @updateModelQPFrame(i32 %m_Bits) {
; CHECK-LABEL: @updateModelQPFrame( ; CHECK-LABEL: @updateModelQPFrame(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
▲ Show 20 Lines • Show All 93 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/phi.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -slp-threshold=-100 -dce -S -mtriple=i386-apple-macosx10.8.0 -mcpu=corei7-avx | FileCheck %s ; RUN: opt < %s -slp-vectorizer -slp-threshold=-100 -dce -S -mtriple=i386-apple-macosx10.8.0 -mcpu=corei7-avx | 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:128:128-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:128:128-n8:16:32-S128"
target triple = "i386-apple-macosx10.9.0" target triple = "i386-apple-macosx10.9.0"
;int foo(double *A, int k) { ;int foo(double *A, int k) {
; double A0; ; double A0;
; double A1; ; double A1;
; if (k) { ; if (k) {
▲ Show 20 Lines • Show All 320 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/phi3.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7 | FileCheck %s ; RUN: opt < %s -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7 | 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"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
%struct.GPar.0.16.26 = type { [0 x double], double } %struct.GPar.0.16.26 = type { [0 x double], double }
@d = external global double, align 8 @d = external global double, align 8
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/phi_overalignedtype.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -slp-threshold=-100 -dce -S -mtriple=i386-apple-macosx10.8.0 -mcpu=corei7-avx | FileCheck %s ; RUN: opt < %s -slp-vectorizer -slp-threshold=-100 -dce -S -mtriple=i386-apple-macosx10.8.0 -mcpu=corei7-avx | FileCheck %s
; We purposely over-align f64 to 128bit here. ; We purposely over-align f64 to 128bit here.
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:128:128-v64:64:64-v128:128:128-a0:0:64-f80:128:128-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:128:128-v64:64:64-v128:128:128-a0:0:64-f80:128:128-n8:16:32-S128"
target triple = "i386-apple-macosx10.9.0" target triple = "i386-apple-macosx10.9.0"
define void @test(double* %i1, double* %i2, double* %o) { define void @test(double* %i1, double* %i2, double* %o) {
; CHECK-LABEL: @test( ; CHECK-LABEL: @test(
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/powi-regression.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-linux-gnu -mcpu=x86-64-v2 -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-linux-gnu -mcpu=x86-64-v2 -slp-vectorizer -S | FileCheck %s
; FIXME: Ensure llvm.powi.* intrinsics are vectorized. ; FIXME: Ensure llvm.powi.* intrinsics are vectorized.
define <2 x double> @PR53887_v2f64(<2 x double> noundef %x) { define <2 x double> @PR53887_v2f64(<2 x double> noundef %x) {
; CHECK-LABEL: @PR53887_v2f64( ; CHECK-LABEL: @PR53887_v2f64(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP0:%.*]] = call fast <2 x double> @llvm.powi.v2f64.i32(<2 x double> [[X:%.*]], i32 6) ; CHECK-NEXT: [[TMP0:%.*]] = call fast <2 x double> @llvm.powi.v2f64.i32(<2 x double> [[X:%.*]], i32 6)
; CHECK-NEXT: ret <2 x double> [[TMP0]] ; CHECK-NEXT: ret <2 x double> [[TMP0]]
Show All 34 Lines

llvm/test/Transforms/SLPVectorizer/X86/powi.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-linux-gnu -mcpu=x86-64 -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-linux-gnu -mcpu=x86-64 -slp-vectorizer -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-linux-gnu -mcpu=x86-64-v2 -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-linux-gnu -mcpu=x86-64-v2 -slp-vectorizer -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-linux-gnu -mcpu=x86-64-v3 -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-linux-gnu -mcpu=x86-64-v3 -slp-vectorizer -S | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-linux-gnu -mcpu=x86-64-v4 -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-linux-gnu -mcpu=x86-64-v4 -slp-vectorizer -S | FileCheck %s
define <2 x double> @buildvector_powi_2f64_6(<2 x double> %a) { define <2 x double> @buildvector_powi_2f64_6(<2 x double> %a) {
; CHECK-LABEL: @buildvector_powi_2f64_6( ; CHECK-LABEL: @buildvector_powi_2f64_6(
; CHECK-NEXT: [[TMP1:%.*]] = call <2 x double> @llvm.powi.v2f64.i32(<2 x double> [[A:%.*]], i32 6) ; CHECK-NEXT: [[TMP1:%.*]] = call <2 x double> @llvm.powi.v2f64.i32(<2 x double> [[A:%.*]], i32 6)
; CHECK-NEXT: ret <2 x double> [[TMP1]] ; CHECK-NEXT: ret <2 x double> [[TMP1]]
; ;
%a0 = extractelement <2 x double> %a, i32 0 %a0 = extractelement <2 x double> %a, i32 0
%a1 = extractelement <2 x double> %a, i32 1 %a1 = extractelement <2 x double> %a, i32 1
▲ Show 20 Lines • Show All 251 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/powof2div.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -S -mtriple=x86_64-unknown-linux-gnu -mattr=+sse2 | FileCheck %s --check-prefixes=CHECK,SSE ; RUN: opt < %s -slp-vectorizer -S -mtriple=x86_64-unknown-linux-gnu -mattr=+sse2 | FileCheck %s --check-prefixes=CHECK,SSE
; RUN: opt < %s -basic-aa -slp-vectorizer -S -mtriple=x86_64-unknown-linux-gnu -mattr=+avx | FileCheck %s --check-prefixes=CHECK,AVX ; RUN: opt < %s -slp-vectorizer -S -mtriple=x86_64-unknown-linux-gnu -mattr=+avx | FileCheck %s --check-prefixes=CHECK,AVX
; RUN: opt < %s -basic-aa -slp-vectorizer -S -mtriple=x86_64-unknown-linux-gnu -mattr=+avx2 | FileCheck %s --check-prefixes=CHECK,AVX ; RUN: opt < %s -slp-vectorizer -S -mtriple=x86_64-unknown-linux-gnu -mattr=+avx2 | FileCheck %s --check-prefixes=CHECK,AVX
define void @powof2div_uniform(i32* noalias nocapture %a, i32* noalias nocapture readonly %b, i32* noalias nocapture readonly %c){ define void @powof2div_uniform(i32* noalias nocapture %a, i32* noalias nocapture readonly %b, i32* noalias nocapture readonly %c){
; CHECK-LABEL: @powof2div_uniform( ; CHECK-LABEL: @powof2div_uniform(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP0:%.*]] = bitcast i32* [[B:%.*]] to <4 x i32>* ; CHECK-NEXT: [[TMP0:%.*]] = bitcast i32* [[B:%.*]] to <4 x i32>*
; CHECK-NEXT: [[TMP1:%.*]] = load <4 x i32>, <4 x i32>* [[TMP0]], align 4 ; CHECK-NEXT: [[TMP1:%.*]] = load <4 x i32>, <4 x i32>* [[TMP0]], align 4
; CHECK-NEXT: [[TMP2:%.*]] = bitcast i32* [[C:%.*]] to <4 x i32>* ; CHECK-NEXT: [[TMP2:%.*]] = bitcast i32* [[C:%.*]] to <4 x i32>*
; CHECK-NEXT: [[TMP3:%.*]] = load <4 x i32>, <4 x i32>* [[TMP2]], align 4 ; CHECK-NEXT: [[TMP3:%.*]] = load <4 x i32>, <4 x i32>* [[TMP2]], align 4
▲ Show 20 Lines • Show All 118 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/powof2mul.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -S -mtriple=x86_64-unknown-linux-gnu -mattr=+sse2 | FileCheck %s --check-prefixes=CHECK,SSE ; RUN: opt < %s -slp-vectorizer -S -mtriple=x86_64-unknown-linux-gnu -mattr=+sse2 | FileCheck %s --check-prefixes=CHECK,SSE
; RUN: opt < %s -basic-aa -slp-vectorizer -S -mtriple=x86_64-unknown-linux-gnu -mattr=+avx | FileCheck %s --check-prefixes=CHECK,AVX ; RUN: opt < %s -slp-vectorizer -S -mtriple=x86_64-unknown-linux-gnu -mattr=+avx | FileCheck %s --check-prefixes=CHECK,AVX
; RUN: opt < %s -basic-aa -slp-vectorizer -S -mtriple=x86_64-unknown-linux-gnu -mattr=+avx2 | FileCheck %s --check-prefixes=CHECK,AVX ; RUN: opt < %s -slp-vectorizer -S -mtriple=x86_64-unknown-linux-gnu -mattr=+avx2 | FileCheck %s --check-prefixes=CHECK,AVX
define void @powof2mul_uniform(i32* noalias nocapture %a, i32* noalias nocapture readonly %b, i32* noalias nocapture readonly %c){ define void @powof2mul_uniform(i32* noalias nocapture %a, i32* noalias nocapture readonly %b, i32* noalias nocapture readonly %c){
; CHECK-LABEL: @powof2mul_uniform( ; CHECK-LABEL: @powof2mul_uniform(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP0:%.*]] = bitcast i32* [[B:%.*]] to <4 x i32>* ; CHECK-NEXT: [[TMP0:%.*]] = bitcast i32* [[B:%.*]] to <4 x i32>*
; CHECK-NEXT: [[TMP1:%.*]] = load <4 x i32>, <4 x i32>* [[TMP0]], align 4 ; CHECK-NEXT: [[TMP1:%.*]] = load <4 x i32>, <4 x i32>* [[TMP0]], align 4
; CHECK-NEXT: [[TMP2:%.*]] = bitcast i32* [[C:%.*]] to <4 x i32>* ; CHECK-NEXT: [[TMP2:%.*]] = bitcast i32* [[C:%.*]] to <4 x i32>*
; CHECK-NEXT: [[TMP3:%.*]] = load <4 x i32>, <4 x i32>* [[TMP2]], align 4 ; CHECK-NEXT: [[TMP3:%.*]] = load <4 x i32>, <4 x i32>* [[TMP2]], align 4
▲ Show 20 Lines • Show All 268 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/pr16628.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7 | FileCheck %s ; RUN: opt < %s -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7 | 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"
target triple = "x86_64-apple-macosx10.9.0" target triple = "x86_64-apple-macosx10.9.0"
@c = common global i32 0, align 4 @c = common global i32 0, align 4
@a = common global i16 0, align 2 @a = common global i16 0, align 2
@b = common global i16 0, align 2 @b = common global i16 0, align 2
Show All 33 Lines

llvm/test/Transforms/SLPVectorizer/X86/pr19657.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -S -mcpu=corei7-avx | FileCheck %s --check-prefixes=ANY,AVX ; RUN: opt < %s -slp-vectorizer -S -mcpu=corei7-avx | FileCheck %s --check-prefixes=ANY,AVX
; RUN: opt < %s -basic-aa -slp-vectorizer -slp-max-reg-size=128 -S -mcpu=corei7-avx | FileCheck %s --check-prefixes=ANY,MAX128 ; RUN: opt < %s -slp-vectorizer -slp-max-reg-size=128 -S -mcpu=corei7-avx | FileCheck %s --check-prefixes=ANY,MAX128
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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @store_chains(double* %x) { define void @store_chains(double* %x) {
; AVX-LABEL: @store_chains( ; AVX-LABEL: @store_chains(
; AVX-NEXT: [[TMP1:%.*]] = bitcast double* [[X:%.*]] to <4 x double>* ; AVX-NEXT: [[TMP1:%.*]] = bitcast double* [[X:%.*]] to <4 x double>*
; AVX-NEXT: [[TMP2:%.*]] = load <4 x double>, <4 x double>* [[TMP1]], align 8 ; AVX-NEXT: [[TMP2:%.*]] = load <4 x double>, <4 x double>* [[TMP1]], align 8
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/pr23510.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; PR23510 ; PR23510
; RUN: opt < %s -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -slp-vectorizer -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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
@total = global i64 0, align 8 @total = global i64 0, align 8
define void @_Z3fooPml(i64* nocapture %a, i64 %i) { define void @_Z3fooPml(i64* nocapture %a, i64 %i) {
; CHECK-LABEL: @_Z3fooPml( ; CHECK-LABEL: @_Z3fooPml(
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/propagate_ir_flags.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -slp-vectorizer -S | FileCheck %s
; Check propagation of optional IR flags (PR20802). For a flag to ; Check propagation of optional IR flags (PR20802). For a flag to
; propagate from scalar instructions to their vector replacement, ; propagate from scalar instructions to their vector replacement,
; *all* scalar instructions must have the flag. ; *all* scalar instructions must have the flag.
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"
target triple = "x86_64-unknown-unknown" target triple = "x86_64-unknown-unknown"
▲ Show 20 Lines • Show All 653 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/reduction.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -dce -S -mtriple=i386-apple-macosx10.8.0 -mcpu=corei7-avx | FileCheck %s ; RUN: opt < %s -slp-vectorizer -dce -S -mtriple=i386-apple-macosx10.8.0 -mcpu=corei7-avx | 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:128:128-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:128:128-n8:16:32-S128"
target triple = "i386-apple-macosx10.8.0" target triple = "i386-apple-macosx10.8.0"
; int foo(double *A, int n, int m) { ; int foo(double *A, int n, int m) {
; double sum = 0, v1 = 2, v0 = 3; ; double sum = 0, v1 = 2, v0 = 3;
; for (int i=0; i < n; ++i) ; for (int i=0; i < n; ++i)
; sum += 7*A[i*2] + 7*A[i*2+1]; ; sum += 7*A[i*2] + 7*A[i*2+1];
▲ Show 20 Lines • Show All 138 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/reduction2.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -dce -S -mtriple=i386-apple-macosx10.8.0 -mcpu=corei7-avx | FileCheck %s ; RUN: opt < %s -slp-vectorizer -dce -S -mtriple=i386-apple-macosx10.8.0 -mcpu=corei7-avx | 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:128:128-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:128:128-n8:16:32-S128"
target triple = "i386-apple-macosx10.8.0" target triple = "i386-apple-macosx10.8.0"
define double @foo(double* nocapture %D) { define double @foo(double* nocapture %D) {
; CHECK-LABEL: @foo( ; CHECK-LABEL: @foo(
; CHECK-NEXT: br label [[TMP1:%.*]] ; CHECK-NEXT: br label [[TMP1:%.*]]
; CHECK: 1: ; CHECK: 1:
▲ Show 20 Lines • Show All 154 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/reorder_phi.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -S -mtriple=x86_64-unknown -mcpu=corei7-avx | FileCheck %s ; RUN: opt < %s -slp-vectorizer -S -mtriple=x86_64-unknown -mcpu=corei7-avx | FileCheck %s
%struct.complex = type { float, float } %struct.complex = type { float, float }
define void @foo (%struct.complex* %A, %struct.complex* %B, %struct.complex* %Result) { define void @foo (%struct.complex* %A, %struct.complex* %B, %struct.complex* %Result) {
; CHECK-LABEL: @foo( ; CHECK-LABEL: @foo(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP0:%.*]] = add i64 256, 0 ; CHECK-NEXT: [[TMP0:%.*]] = add i64 256, 0
; CHECK-NEXT: br label [[LOOP:%.*]] ; CHECK-NEXT: br label [[LOOP:%.*]]
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/return.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -S | FileCheck %s ; RUN: opt < %s -slp-vectorizer -S | FileCheck %s
target datalayout = "e-m:e-p:32:32-f64:32:64-f80:32-n8:16:32-S128" target datalayout = "e-m:e-p:32:32-f64:32:64-f80:32-n8:16:32-S128"
target triple = "x86_64--linux-gnu" target triple = "x86_64--linux-gnu"
@a = common global [4 x double] zeroinitializer, align 8 @a = common global [4 x double] zeroinitializer, align 8
@b = common global [4 x double] zeroinitializer, align 8 @b = common global [4 x double] zeroinitializer, align 8
; [4], b[4]; ; [4], b[4];
; double foo() { ; double foo() {
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/rgb_phi.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -dce -S -mtriple=i386-apple-macosx10.8.0 -mcpu=corei7-avx | FileCheck %s ; RUN: opt < %s -slp-vectorizer -dce -S -mtriple=i386-apple-macosx10.8.0 -mcpu=corei7-avx | 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:128:128-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:128:128-n8:16:32-S128"
target triple = "i386-apple-macosx10.9.0" target triple = "i386-apple-macosx10.9.0"
; We disable the vectorization of <3 x float> for now ; We disable the vectorization of <3 x float> for now
; float foo(float *A) { ; float foo(float *A) {
; ;
▲ Show 20 Lines • Show All 95 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/saxpy.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | FileCheck %s ; RUN: opt < %s -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | 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"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
; SLP vectorization example from http://cs.stanford.edu/people/eschkufz/research/asplos291-schkufza.pdf ; SLP vectorization example from http://cs.stanford.edu/people/eschkufz/research/asplos291-schkufza.pdf
define void @SAXPY(i32* noalias nocapture %x, i32* noalias nocapture %y, i32 %a, i64 %i) { define void @SAXPY(i32* noalias nocapture %x, i32* noalias nocapture %y, i32 %a, i64 %i) {
; CHECK-LABEL: @SAXPY( ; CHECK-LABEL: @SAXPY(
; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds i32, i32* [[X:%.*]], i64 [[I:%.*]] ; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds i32, i32* [[X:%.*]], i64 [[I:%.*]]
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/schedule_budget.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -S -slp-schedule-budget=16 -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | FileCheck %s ; RUN: opt < %s -slp-vectorizer -S -slp-schedule-budget=16 -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | 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"
target triple = "x86_64-apple-macosx10.9.0" target triple = "x86_64-apple-macosx10.9.0"
; Test if the budget for the scheduling region size works. ; Test if the budget for the scheduling region size works.
; We test with a reduced budget of 16 which should prevent vectorizing the loads. ; We test with a reduced budget of 16 which should prevent vectorizing the loads.
declare void @unknown() declare void @unknown()
▲ Show 20 Lines • Show All 112 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/scheduling.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -S -mtriple=i386-apple-macosx10.8.0 -mcpu=corei7-avx | FileCheck %s ; RUN: opt < %s -slp-vectorizer -S -mtriple=i386-apple-macosx10.8.0 -mcpu=corei7-avx | FileCheck %s
define i32 @foo(i32* nocapture readonly %diff) #0 { define i32 @foo(i32* nocapture readonly %diff) #0 {
; CHECK-LABEL: @foo( ; CHECK-LABEL: @foo(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[M2:%.*]] = alloca [8 x [8 x i32]], align 16 ; CHECK-NEXT: [[M2:%.*]] = alloca [8 x [8 x i32]], align 16
; CHECK-NEXT: [[TMP0:%.*]] = bitcast [8 x [8 x i32]]* [[M2]] to i8* ; CHECK-NEXT: [[TMP0:%.*]] = bitcast [8 x [8 x i32]]* [[M2]] to i8*
; CHECK-NEXT: br label [[FOR_BODY:%.*]] ; CHECK-NEXT: br label [[FOR_BODY:%.*]]
; CHECK: for.body: ; CHECK: for.body:
▲ Show 20 Lines • Show All 85 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/sext-inseltpoison.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=SSE,SSE2 ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -S | FileCheck %s --check-prefixes=SSE,SSE2
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=SSE,SLM ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -slp-vectorizer -S | FileCheck %s --check-prefixes=SSE,SLM
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+avx512bw -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+avx512bw -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX
; ;
; vXi8 ; vXi8
; ;
define <2 x i64> @loadext_2i8_to_2i64(i8* %p0) { define <2 x i64> @loadext_2i8_to_2i64(i8* %p0) {
; SSE2-LABEL: @loadext_2i8_to_2i64( ; SSE2-LABEL: @loadext_2i8_to_2i64(
; SSE2-NEXT: [[P1:%.*]] = getelementptr inbounds i8, i8* [[P0:%.*]], i64 1 ; SSE2-NEXT: [[P1:%.*]] = getelementptr inbounds i8, i8* [[P0:%.*]], i64 1
▲ Show 20 Lines • Show All 458 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/sext.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=SSE,SSE2 ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -S | FileCheck %s --check-prefixes=SSE,SSE2
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=SSE,SLM ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -slp-vectorizer -S | FileCheck %s --check-prefixes=SSE,SLM
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+avx512bw -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+avx512bw -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX
; ;
; vXi8 ; vXi8
; ;
define <2 x i64> @loadext_2i8_to_2i64(i8* %p0) { define <2 x i64> @loadext_2i8_to_2i64(i8* %p0) {
; SSE2-LABEL: @loadext_2i8_to_2i64( ; SSE2-LABEL: @loadext_2i8_to_2i64(
; SSE2-NEXT: [[P1:%.*]] = getelementptr inbounds i8, i8* [[P0:%.*]], i64 1 ; SSE2-NEXT: [[P1:%.*]] = getelementptr inbounds i8, i8* [[P0:%.*]], i64 1
▲ Show 20 Lines • Show All 458 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/shift-ashr.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=SSE ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -S | FileCheck %s --check-prefix=SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX,AVX1 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX,AVX1
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX,AVX2 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX,AVX2
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -slp-vectorizer -S | FileCheck %s --check-prefix=AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=-prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=-prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefix=AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX,AVX2 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX,AVX2
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=bdver4 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=XOP ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=bdver4 -slp-vectorizer -S | FileCheck %s --check-prefix=XOP
@a64 = common global [8 x i64] zeroinitializer, align 64 @a64 = common global [8 x i64] zeroinitializer, align 64
@b64 = common global [8 x i64] zeroinitializer, align 64 @b64 = common global [8 x i64] zeroinitializer, align 64
@c64 = common global [8 x i64] zeroinitializer, align 64 @c64 = common global [8 x i64] zeroinitializer, align 64
@a32 = common global [16 x i32] zeroinitializer, align 64 @a32 = common global [16 x i32] zeroinitializer, align 64
@b32 = common global [16 x i32] zeroinitializer, align 64 @b32 = common global [16 x i32] zeroinitializer, align 64
@c32 = common global [16 x i32] zeroinitializer, align 64 @c32 = common global [16 x i32] zeroinitializer, align 64
@a16 = common global [32 x i16] zeroinitializer, align 64 @a16 = common global [32 x i16] zeroinitializer, align 64
▲ Show 20 Lines • Show All 744 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/shift-lshr.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=SSE ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -S | FileCheck %s --check-prefix=SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -slp-vectorizer -S | FileCheck %s --check-prefix=AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=-prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=-prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefix=AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=bdver4 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=XOP ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=bdver4 -slp-vectorizer -S | FileCheck %s --check-prefix=XOP
@a64 = common global [8 x i64] zeroinitializer, align 64 @a64 = common global [8 x i64] zeroinitializer, align 64
@b64 = common global [8 x i64] zeroinitializer, align 64 @b64 = common global [8 x i64] zeroinitializer, align 64
@c64 = common global [8 x i64] zeroinitializer, align 64 @c64 = common global [8 x i64] zeroinitializer, align 64
@a32 = common global [16 x i32] zeroinitializer, align 64 @a32 = common global [16 x i32] zeroinitializer, align 64
@b32 = common global [16 x i32] zeroinitializer, align 64 @b32 = common global [16 x i32] zeroinitializer, align 64
@c32 = common global [16 x i32] zeroinitializer, align 64 @c32 = common global [16 x i32] zeroinitializer, align 64
@a16 = common global [32 x i16] zeroinitializer, align 64 @a16 = common global [32 x i16] zeroinitializer, align 64
▲ Show 20 Lines • Show All 693 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/shift-shl.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=SSE ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -S | FileCheck %s --check-prefix=SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -slp-vectorizer -S | FileCheck %s --check-prefix=AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=-prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=-prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefix=AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=bdver4 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=XOP ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=bdver4 -slp-vectorizer -S | FileCheck %s --check-prefix=XOP
@a64 = common global [8 x i64] zeroinitializer, align 64 @a64 = common global [8 x i64] zeroinitializer, align 64
@b64 = common global [8 x i64] zeroinitializer, align 64 @b64 = common global [8 x i64] zeroinitializer, align 64
@c64 = common global [8 x i64] zeroinitializer, align 64 @c64 = common global [8 x i64] zeroinitializer, align 64
@a32 = common global [16 x i32] zeroinitializer, align 64 @a32 = common global [16 x i32] zeroinitializer, align 64
@b32 = common global [16 x i32] zeroinitializer, align 64 @b32 = common global [16 x i32] zeroinitializer, align 64
@c32 = common global [16 x i32] zeroinitializer, align 64 @c32 = common global [16 x i32] zeroinitializer, align 64
@a16 = common global [32 x i16] zeroinitializer, align 64 @a16 = common global [32 x i16] zeroinitializer, align 64
▲ Show 20 Lines • Show All 741 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/simple-loop.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | FileCheck %s ; RUN: opt < %s -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | 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"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
define i32 @rollable(i32* noalias nocapture %in, i32* noalias nocapture %out, i64 %n) { define i32 @rollable(i32* noalias nocapture %in, i32* noalias nocapture %out, i64 %n) {
; CHECK-LABEL: @rollable( ; CHECK-LABEL: @rollable(
; CHECK-NEXT: [[TMP1:%.*]] = icmp eq i64 [[N:%.*]], 0 ; CHECK-NEXT: [[TMP1:%.*]] = icmp eq i64 [[N:%.*]], 0
; CHECK-NEXT: br i1 [[TMP1]], label [[DOT_CRIT_EDGE:%.*]], label [[DOTLR_PH:%.*]] ; CHECK-NEXT: br i1 [[TMP1]], label [[DOT_CRIT_EDGE:%.*]], label [[DOTLR_PH:%.*]]
▲ Show 20 Lines • Show All 132 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/simplebb.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | FileCheck %s ; RUN: opt < %s -slp-vectorizer -dce -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | 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"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
; Simple 3-pair chain with loads and stores ; Simple 3-pair chain with loads and stores
define void @test1(double* %a, double* %b, double* %c) { define void @test1(double* %a, double* %b, double* %c) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: [[TMP1:%.*]] = bitcast double* [[A:%.*]] to <2 x double>* ; CHECK-NEXT: [[TMP1:%.*]] = bitcast double* [[A:%.*]] to <2 x double>*
▲ Show 20 Lines • Show All 113 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/sitofp-inseltpoison.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SSE ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256,AVX256NODQ ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256,AVX256NODQ
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=bdver1 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256,AVX256NODQ ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=bdver1 -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256,AVX256NODQ
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256,AVX256NODQ ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256,AVX256NODQ
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=-prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=-prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=+prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256,AVX256DQ ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=+prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256,AVX256DQ
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"
@src64 = common global [8 x i64] zeroinitializer, align 64 @src64 = common global [8 x i64] zeroinitializer, align 64
@src32 = common global [16 x i32] zeroinitializer, align 64 @src32 = common global [16 x i32] zeroinitializer, align 64
@src16 = common global [32 x i16] zeroinitializer, align 64 @src16 = common global [32 x i16] zeroinitializer, align 64
@src8 = common global [64 x i8] zeroinitializer, align 64 @src8 = common global [64 x i8] zeroinitializer, align 64
▲ Show 20 Lines • Show All 1,124 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/sitofp.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SSE ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256,AVX256NODQ ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256,AVX256NODQ
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=bdver1 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256,AVX256NODQ ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=bdver1 -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256,AVX256NODQ
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256,AVX256NODQ ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256,AVX256NODQ
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=-prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=-prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=+prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256,AVX256DQ ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=+prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256,AVX256DQ
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"
@src64 = common global [8 x i64] zeroinitializer, align 64 @src64 = common global [8 x i64] zeroinitializer, align 64
@src32 = common global [16 x i32] zeroinitializer, align 64 @src32 = common global [16 x i32] zeroinitializer, align 64
@src16 = common global [32 x i16] zeroinitializer, align 64 @src16 = common global [32 x i16] zeroinitializer, align 64
@src8 = common global [64 x i8] zeroinitializer, align 64 @src8 = common global [64 x i8] zeroinitializer, align 64
▲ Show 20 Lines • Show All 1,157 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/sqrt.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=SSE ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mattr=avx -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX256 ; RUN: opt < %s -mtriple=x86_64-unknown -mattr=avx -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX256
; RUN: opt < %s -mtriple=x86_64-unknown -mattr=avx2 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX256 ; RUN: opt < %s -mtriple=x86_64-unknown -mattr=avx2 -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX256
; RUN: opt < %s -mtriple=x86_64-unknown -mattr=avx512vl,avx512dq,avx512bw -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mattr=avx512vl,avx512dq,avx512bw -slp-vectorizer -S | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX512
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"
@src64 = common global [8 x double] zeroinitializer, align 64 @src64 = common global [8 x double] zeroinitializer, align 64
@src32 = common global [16 x float] zeroinitializer, align 64 @src32 = common global [16 x float] zeroinitializer, align 64
@dst64 = common global [8 x double] zeroinitializer, align 64 @dst64 = common global [8 x double] zeroinitializer, align 64
@dst32 = common global [16 x float] zeroinitializer, align 64 @dst32 = common global [16 x float] zeroinitializer, align 64
▲ Show 20 Lines • Show All 260 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/tiny-tree.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | FileCheck %s ; RUN: opt < %s -slp-vectorizer -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx | FileCheck %s
define void @tiny_tree_fully_vectorizable(double* noalias nocapture %dst, double* noalias nocapture readonly %src, i64 %count) #0 { define void @tiny_tree_fully_vectorizable(double* noalias nocapture %dst, double* noalias nocapture readonly %src, i64 %count) #0 {
; CHECK-LABEL: @tiny_tree_fully_vectorizable( ; CHECK-LABEL: @tiny_tree_fully_vectorizable(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[CMP12:%.*]] = icmp eq i64 [[COUNT:%.*]], 0 ; CHECK-NEXT: [[CMP12:%.*]] = icmp eq i64 [[COUNT:%.*]], 0
; CHECK-NEXT: br i1 [[CMP12]], label [[FOR_END:%.*]], label [[FOR_BODY:%.*]] ; CHECK-NEXT: br i1 [[CMP12]], label [[FOR_END:%.*]], label [[FOR_BODY:%.*]]
; CHECK: for.body: ; CHECK: for.body:
; CHECK-NEXT: [[I_015:%.*]] = phi i64 [ [[INC:%.*]], [[FOR_BODY]] ], [ 0, [[ENTRY:%.*]] ] ; CHECK-NEXT: [[I_015:%.*]] = phi i64 [ [[INC:%.*]], [[FOR_BODY]] ], [ 0, [[ENTRY:%.*]] ]
▲ Show 20 Lines • Show All 316 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/uitofp.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SSE ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,SSE
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256,AVX1 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256,AVX1
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=bdver1 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256,AVX1 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=bdver1 -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256,AVX1
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256,AVX2 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256,AVX2
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=-prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX512 ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=-prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX512
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=+prefer-256-bit -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256,AVX256DQ ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skylake-avx512 -mattr=+prefer-256-bit -slp-vectorizer -S | FileCheck %s --check-prefixes=CHECK,AVX,AVX256,AVX256DQ
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"
@src64 = common global [8 x i64] zeroinitializer, align 64 @src64 = common global [8 x i64] zeroinitializer, align 64
@src32 = common global [16 x i32] zeroinitializer, align 64 @src32 = common global [16 x i32] zeroinitializer, align 64
@src16 = common global [32 x i16] zeroinitializer, align 64 @src16 = common global [32 x i16] zeroinitializer, align 64
@src8 = common global [64 x i8] zeroinitializer, align 64 @src8 = common global [64 x i8] zeroinitializer, align 64
▲ Show 20 Lines • Show All 1,014 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/unreachable.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7 | FileCheck %s ; RUN: opt < %s -slp-vectorizer -S -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7 | FileCheck %s
; Check if the SLPVectorizer does not crash when handling ; Check if the SLPVectorizer does not crash when handling
; unreachable blocks with unscheduleable instructions. ; unreachable blocks with unscheduleable instructions.
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"
target triple = "x86_64-apple-macosx10.9.0" target triple = "x86_64-apple-macosx10.9.0"
define void @foo(i32* nocapture %x) #0 { define void @foo(i32* nocapture %x) #0 {
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/zext-inseltpoison.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=SSE2 ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -S | FileCheck %s --check-prefixes=SSE2
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=SLM ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -slp-vectorizer -S | FileCheck %s --check-prefixes=SLM
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+avx512bw -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+avx512bw -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX
; ;
; vXi8 ; vXi8
; ;
define <2 x i64> @loadext_2i8_to_2i64(i8* %p0) { define <2 x i64> @loadext_2i8_to_2i64(i8* %p0) {
; SSE2-LABEL: @loadext_2i8_to_2i64( ; SSE2-LABEL: @loadext_2i8_to_2i64(
; SSE2-NEXT: [[P1:%.*]] = getelementptr inbounds i8, i8* [[P0:%.*]], i64 1 ; SSE2-NEXT: [[P1:%.*]] = getelementptr inbounds i8, i8* [[P0:%.*]], i64 1
▲ Show 20 Lines • Show All 524 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/X86/zext.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-unknown -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=SSE2 ; RUN: opt < %s -mtriple=x86_64-unknown -slp-vectorizer -S | FileCheck %s --check-prefixes=SSE2
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=SLM ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=slm -slp-vectorizer -S | FileCheck %s --check-prefixes=SLM
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=corei7-avx -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=core-avx2 -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=knl -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX
; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+avx512bw -basic-aa -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX ; RUN: opt < %s -mtriple=x86_64-unknown -mcpu=skx -mattr=+avx512bw -slp-vectorizer -S | FileCheck %s --check-prefixes=AVX
; ;
; vXi8 ; vXi8
; ;
define <2 x i64> @loadext_2i8_to_2i64(i8* %p0) { define <2 x i64> @loadext_2i8_to_2i64(i8* %p0) {
; SSE2-LABEL: @loadext_2i8_to_2i64( ; SSE2-LABEL: @loadext_2i8_to_2i64(
; SSE2-NEXT: [[P1:%.*]] = getelementptr inbounds i8, i8* [[P0:%.*]], i64 1 ; SSE2-NEXT: [[P1:%.*]] = getelementptr inbounds i8, i8* [[P0:%.*]], i64 1
▲ Show 20 Lines • Show All 524 Lines • Show Last 20 Lines

llvm/test/Transforms/SLPVectorizer/XCore/no-vector-registers.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -slp-vectorizer -dce -S -mtriple=xcore | FileCheck %s ; RUN: opt < %s -slp-vectorizer -dce -S -mtriple=xcore | FileCheck %s
target datalayout = "e-p:32:32:32-a0:0:32-n32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:32-f16:16:32-f32:32:32-f64:32:32" target datalayout = "e-p:32:32:32-a0:0:32-n32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:32-f16:16:32-f32:32:32-f64:32:32"
target triple = "xcore" target triple = "xcore"
; Simple 3-pair chain with loads and stores ; Simple 3-pair chain with loads and stores
define void @test1(double* %a, double* %b, double* %c) { define void @test1(double* %a, double* %b, double* %c) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
Show All 28 Lines

llvm/test/Transforms/SimpleLoopUnswitch/2012-04-30-LoopUnswitch-LPad-Crash.ll

; RUN: opt < %s -basic-aa -instcombine -inline -function-attrs -licm -simple-loop-unswitch -gvn -verify ; RUN: opt < %s -instcombine -inline -function-attrs -licm -simple-loop-unswitch -gvn -verify
; PR12573 ; PR12573
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"
target triple = "x86_64-apple-macosx10.7.0" target triple = "x86_64-apple-macosx10.7.0"
%class.D.22.42.66.102.138.158.178.198.238.242.246.250.262.294.302.338.346.379 = type { %class.C.23.43.67.103.139.159.179.199.239.243.247.251.263.295.303.339.347.376*, %class.B.21.41.65.101.137.157.177.197.237.241.245.249.261.293.301.337.345.378 } %class.D.22.42.66.102.138.158.178.198.238.242.246.250.262.294.302.338.346.379 = type { %class.C.23.43.67.103.139.159.179.199.239.243.247.251.263.295.303.339.347.376*, %class.B.21.41.65.101.137.157.177.197.237.241.245.249.261.293.301.337.345.378 }
%class.C.23.43.67.103.139.159.179.199.239.243.247.251.263.295.303.339.347.376 = type { %class.D.22.42.66.102.138.158.178.198.238.242.246.250.262.294.302.338.346.379* } %class.C.23.43.67.103.139.159.179.199.239.243.247.251.263.295.303.339.347.376 = type { %class.D.22.42.66.102.138.158.178.198.238.242.246.250.262.294.302.338.346.379* }
%class.B.21.41.65.101.137.157.177.197.237.241.245.249.261.293.301.337.345.378 = type { %class.A.20.40.64.100.136.156.176.196.236.240.244.248.260.292.300.336.344.377* } %class.B.21.41.65.101.137.157.177.197.237.241.245.249.261.293.301.337.345.378 = type { %class.A.20.40.64.100.136.156.176.196.236.240.244.248.260.292.300.336.344.377* }
%class.A.20.40.64.100.136.156.176.196.236.240.244.248.260.292.300.336.344.377 = type { i8 } %class.A.20.40.64.100.136.156.176.196.236.240.244.248.260.292.300.336.344.377 = type { i8 }
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines

llvm/test/Transforms/Sink/badloadsink.ll

; RUN: opt < %s -basic-aa -sink -S | FileCheck %s ; RUN: opt < %s -sink -S | FileCheck %s
declare void @foo(i64 *) declare void @foo(i64 *)
declare i8* @llvm.load.relative.i32(i8* %ptr, i32 %offset) argmemonly nounwind readonly declare i8* @llvm.load.relative.i32(i8* %ptr, i32 %offset) argmemonly nounwind readonly
define i64 @sinkload(i1 %cmp, i8* %ptr, i32 %off) { define i64 @sinkload(i1 %cmp, i8* %ptr, i32 %off) {
; CHECK-LABEL: @sinkload ; CHECK-LABEL: @sinkload
top: top:
%a = alloca i64 %a = alloca i64
; CHECK: call void @foo(i64* %a) ; CHECK: call void @foo(i64* %a)
; CHECK-NEXT: %x = load i64, i64* %a ; CHECK-NEXT: %x = load i64, i64* %a
Show All 17 Lines

llvm/test/Transforms/Sink/basic.ll

; RUN: opt < %s -basic-aa -sink -S | FileCheck %s ; RUN: opt < %s -sink -S | FileCheck %s
; RUN: opt < %s -aa-pipeline='basic-aa' -passes='sink' -S | FileCheck %s ; RUN: opt < %s -aa-pipeline='basic-aa' -passes='sink' -S | FileCheck %s
@A = external global i32 @A = external global i32
@B = external global i32 @B = external global i32
; Sink should sink the load past the store (which doesn't overlap) into ; Sink should sink the load past the store (which doesn't overlap) into
; the block that uses it. ; the block that uses it.
▲ Show 20 Lines • Show All 135 Lines • Show Last 20 Lines

llvm/test/Transforms/Sink/call.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basic-aa -sink -S | FileCheck %s ; RUN: opt < %s -sink -S | FileCheck %s
declare i32 @f_load_global() nounwind willreturn readonly declare i32 @f_load_global() nounwind willreturn readonly
declare i32 @f_load_global_throwable() willreturn readonly declare i32 @f_load_global_throwable() willreturn readonly
declare i32 @f_load_global_may_not_return() nounwind readonly declare i32 @f_load_global_may_not_return() nounwind readonly
declare i32 @f_load_arg(i32*) nounwind willreturn readonly argmemonly declare i32 @f_load_arg(i32*) nounwind willreturn readonly argmemonly
declare void @f_store_global(i32) nounwind willreturn declare void @f_store_global(i32) nounwind willreturn
declare void @f_store_arg(i32*) nounwind willreturn argmemonly declare void @f_store_arg(i32*) nounwind willreturn argmemonly
declare void @f_readonly_arg(i32* readonly, i32*) nounwind willreturn argmemonly declare void @f_readonly_arg(i32* readonly, i32*) nounwind willreturn argmemonly
▲ Show 20 Lines • Show All 173 Lines • Show Last 20 Lines

llvm/test/Transforms/Util/combine-alias-scope-metadata.ll

; RUN: opt < %s -S -basic-aa -memcpyopt | FileCheck %s ; RUN: opt < %s -S -memcpyopt | 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"
define void @test(ptr noalias dereferenceable(1) %in, ptr noalias dereferenceable(1) %out) { define void @test(ptr noalias dereferenceable(1) %in, ptr noalias dereferenceable(1) %out) {
%tmp = alloca i8 %tmp = alloca i8
%tmp2 = alloca i8 %tmp2 = alloca i8
; CHECK: call void @llvm.memcpy.p0.p0.i64(ptr align 8 %out, ptr align 8 %in, i64 1, i1 false) ; CHECK: call void @llvm.memcpy.p0.p0.i64(ptr align 8 %out, ptr align 8 %in, i64 1, i1 false)
call void @llvm.memcpy.p0.p0.i64(ptr align 8 %tmp, ptr align 8 %in, i64 1, i1 false), !alias.scope !4 call void @llvm.memcpy.p0.p0.i64(ptr align 8 %tmp, ptr align 8 %in, i64 1, i1 false), !alias.scope !4
call void @llvm.memcpy.p0.p0.i64(ptr align 8 %tmp2, ptr align 8 %tmp, i64 1, i1 false), !alias.scope !5 call void @llvm.memcpy.p0.p0.i64(ptr align 8 %tmp2, ptr align 8 %tmp, i64 1, i1 false), !alias.scope !5
Show All 15 Lines

llvm/tools/opt/NewPMDriver.cpp

Show First 20 Lines • Show All 417 Lines • ▼ Show 20 Lines if (auto Err = PB.parsePassPipeline(MPM, PassPipeline)) {
return false; return false;
} }
} }
// Add passes specified using the legacy PM syntax (i.e. not using // Add passes specified using the legacy PM syntax (i.e. not using
// -passes). This should be removed later when such support has been // -passes). This should be removed later when such support has been
// deprecated, i.e. when all lit tests running opt (and not using // deprecated, i.e. when all lit tests running opt (and not using
// -enable-new-pm=0) have been updated to use -passes. // -enable-new-pm=0) have been updated to use -passes.
for (auto PassName : Passes) { for (auto PassName : Passes) {
std::string ModifiedPassName(PassName.begin(), PassName.end()); if (auto Err = PB.parsePassPipeline(MPM, PassName)) {
if (PB.isAnalysisPassName(PassName))
ModifiedPassName = "require<" + ModifiedPassName + ">";
if (auto Err = PB.parsePassPipeline(MPM, ModifiedPassName)) {
errs() << Arg0 << ": " << toString(std::move(Err)) << "\n"; errs() << Arg0 << ": " << toString(std::move(Err)) << "\n";
return false; return false;
} }
} }
if (VK > VK_NoVerifier) if (VK > VK_NoVerifier)
MPM.addPass(VerifierPass()); MPM.addPass(VerifierPass());
if (EnableDebugify) if (EnableDebugify)
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines
llvm/test/DebugInfo/check-debugify-preserves-analyses.ll