This is an archive of the discontinued LLVM Phabricator instance.

Differential D141912

[AsmParser] Remove typed pointer auto-detection
ClosedPublic

Authored by nikic on Jan 17 2023, 3:38 AM.

Details

Reviewers
arsenm
bollu
aartbik
ftynse
ributzka
jdoerfert
sstefan1
dcaballe
aeubanks
fhahn
Group Reviewers
Restricted Project
Commits
rG9ed2f14c8717: [AsmParser] Remove typed pointer auto-detection
Summary

IR is now always parsed in opaque pointer mode, unless -opaque-pointers=0 is explicitly given. There is no automatic detection of typed pointers anymore.

The -opaque-pointers=0 option is added to any remaining IR tests that haven't been migrated yet.

Diff Detail

Event Timeline

nikic created this revision.Jan 17 2023, 3:38 AM
Herald added a reviewer: bollu. · View Herald TranscriptJan 17 2023, 3:38 AM
Herald added a reviewer: aartbik. · View Herald Transcript
Herald added a reviewer: ftynse. · View Herald Transcript
Herald added a reviewer: ributzka. · View Herald Transcript
Herald added a project: Restricted Project. · View Herald Transcript
Herald added subscribers: luke, Moerafaat, kmitropoulou and 66 others. · View Herald Transcript
nikic requested review of this revision.Jan 17 2023, 3:38 AM
Herald added a reviewer: jdoerfert. · View Herald TranscriptJan 17 2023, 3:38 AM
Herald added a reviewer: sstefan1. · View Herald Transcript
Herald added a reviewer: dcaballe. · View Herald Transcript
Herald added projects: Restricted Project, Restricted Project. · View Herald Transcript
Herald added subscribers: llvm-commits, • pcwang-thead, stephenneuendorffer and 4 others. · View Herald Transcript
Harbormaster completed remote builds in B208199: Diff 489752.Jan 17 2023, 4:34 AM
arsenm added inline comments.Jan 17 2023, 8:25 AM
llvm/test/CodeGen/AMDGPU/lower-kernel-lds.ll
2

The test diff is bigger than I expected, what is holding this set of tests back? For example these AMDGPU tests weren't converted with the others to avoid a merge conflict issue which we're past now

nikic added inline comments.Jan 17 2023, 8:42 AM
llvm/test/CodeGen/AMDGPU/lower-kernel-lds.ll
2

Just a matter of time. I want to land this change before LLVM 16 branches, and don't have time to convert all the remaining tests.

I haven't looked into AMDGPU tests in particular because I assumed that you are taking care of them.

aeubanks accepted this revision.Jan 17 2023, 10:09 AM
This revision is now accepted and ready to land.Jan 17 2023, 10:09 AM
fhahn accepted this revision.Jan 17 2023, 1:02 PM
fhahn added a subscriber: fhahn.

LGTM, thanks! This makes it also very easy to grep for tests that still need converting .

This revision was landed with ongoing or failed builds.Jan 18 2023, 12:58 AM
Closed by commit rG9ed2f14c8717: [AsmParser] Remove typed pointer auto-detection (authored by nikic). · Explain Why
This revision was automatically updated to reflect the committed changes.
nikic added a commit: rG9ed2f14c8717: [AsmParser] Remove typed pointer auto-detection.

Revision Contents

PathSize
llvm/
docs/
7 lines
lib/
AsmParser/
5 lines
22 lines
test/
CodeGen/
AMDGPU/
4 lines
8 lines
4 lines
6 lines
4 lines
6 lines
4 lines
6 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
ARM/
2 lines
2 lines
2 lines
2 lines
6 lines
Hexagon/
2 lines
autohvx/
2 lines
2 lines
2 lines
PowerPC/
4 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
4 lines
4 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
4 lines
4 lines
2 lines
4 lines
Thumb2/
LowOverheadLoops/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
mve-intrinsics/
2 lines
2 lines
WebAssembly/
2 lines
4 lines
6 lines
2 lines
6 lines
4 lines
6 lines
4 lines
WinEH/
4 lines
X86/
2 lines
6 lines
8 lines
4 lines
4 lines
8 lines
4 lines
2 lines
4 lines
4 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
4 lines
4 lines
4 lines
XCore/
4 lines
DebugInfo/
Generic/
assignment-tracking/
instcombine/
4 lines
2 lines
2 lines
4 lines
X86/
2 lines
2 lines
LTO/
X86/
6 lines
Linker/
2 lines
Other/
2 lines
SafepointIRVerifier/
2 lines
Transforms/
Attributor/
ArgumentPromotion/
4 lines
IPConstantProp/
4 lines
4 lines
4 lines
4 lines
4 lines
2 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
ConstantHoisting/
AArch64/
2 lines
ARM/
2 lines
2 lines
Coroutines/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 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
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
GVN/
PRE/
2 lines
GVNHoist/
2 lines
Inline/
AArch64/
2 lines
4 lines
4 lines
4 lines
4 lines
4 lines
InstCombine/
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
LoopDistribute/
6 lines
2 lines
2 lines
2 lines
LoopReroll/
2 lines
2 lines
2 lines
2 lines
LoopStrengthReduce/
2 lines
2 lines
AArch64/
2 lines
AMDGPU/
2 lines
2 lines
2 lines
2 lines
ARM/
4 lines
2 lines
X86/
2 lines
4 lines
6 lines
6 lines
12 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
LoopVectorize/
AArch64/
2 lines
4 lines
12 lines
10 lines
2 lines
2 lines
14 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
ARM/
8 lines
4 lines
PowerPC/
4 lines
RISCV/
4 lines
SystemZ/
2 lines
X86/
4 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
4 lines
2 lines
4 lines
2 lines
4 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
LoopVersioning/
2 lines
4 lines
2 lines
2 lines
2 lines
NewGVN/
2 lines
2 lines
2 lines
2 lines
2 lines
RewriteStatepointsForGC/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
mlir/
test/
Target/
LLVMIR/
Import/
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
polly/
test/
CodeGen/
LoopParallelMD/
4 lines
MemAccess/
2 lines
2 lines
2 lines
2 lines
4 lines
4 lines
4 lines
4 lines
2 lines
4 lines
2 lines
4 lines
2 lines
2 lines
OpenMP/
2 lines
4 lines
4 lines
2 lines
4 lines
2 lines
18 lines
RuntimeDebugBuilder/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
6 lines
2 lines
2 lines
2 lines
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
4 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
6 lines
4 lines
2 lines
2 lines
2 lines
GPGPU/
2 lines
6 lines
6 lines
4 lines
4 lines
6 lines
4 lines
4 lines
4 lines
2 lines
ScopDetect/
2 lines
ScopInfo/
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines

Diff 490068

llvm/docs/OpaquePointers.rst

Show First 20 Lines • Show All 271 Lines • ▼ Show 20 Lines
supported on a best-effort basis only and not tested. supported on a best-effort basis only and not tested.
**LLVM 17:** Only opaque pointers are supported. Typed pointers are not **LLVM 17:** Only opaque pointers are supported. Typed pointers are not
supported. supported.
Transition State Transition State
================ ================
As of December 2022: As of January 2023:
Tests are in the process of being converted to opaque pointers. All new tests Tests are in the process of being converted to opaque pointers. All new tests
must use opaque pointers. must use opaque pointers.
Typed pointers are supported on a best-effort basis in LLVM 16, but are *not* Typed pointers are supported on a best-effort basis in LLVM 16, but are *not*
supported in LLVM 17. Fixes for typed pointer support will be accepted on the supported in LLVM 17. Fixes for typed pointer support will be accepted on the
``main`` branch only until the creation of the ``release/16.x`` branch ``main`` branch only until the creation of the ``release/16.x`` branch
(expected on Jan 24th 2023). After that point, typed pointer support on the (expected on Jan 24th 2023). After that point, typed pointer support on the
``main`` branch will only be retained to the degree that is necessary to not ``main`` branch will only be retained to the degree that is necessary to not
break tests that haven't been migrated yet. break tests that haven't been migrated yet.
The following typed pointer functionality has already been removed: The following typed pointer functionality has already been removed:
* The ``CLANG_ENABLE_OPAQUE_POINTERS`` cmake flag is no longer supported. * The ``CLANG_ENABLE_OPAQUE_POINTERS`` cmake flag is no longer supported.
* C APIs that do not support opaque pointers (like ``LLVMBuildLoad``) are no * C APIs that do not support opaque pointers (like ``LLVMBuildLoad``) are no
longer supported. longer supported.
* Typed pointer bitcode is implicitly upgraded to use opaque pointers, unless * Typed pointer IR and bitcode is implicitly upgraded to use opaque pointers,
``-opaque-pointers=0`` is passed. unless ``-opaque-pointers=0`` is passed.
The following typed pointer functionality is still to be removed: The following typed pointer functionality is still to be removed:
* The ``-no-opaque-pointers`` cc1 flag, ``-opaque-pointers=0`` opt flag and * The ``-no-opaque-pointers`` cc1 flag, ``-opaque-pointers=0`` opt flag and
``-plugin-opt=no-opaque-pointers`` lto flag. ``-plugin-opt=no-opaque-pointers`` lto flag.
* Auto-detection of typed pointers in textual IR.
* Support for typed pointers in LLVM libraries. * Support for typed pointers in LLVM libraries.

llvm/lib/AsmParser/LLLexer.cpp

Show First 20 Lines • Show All 801 Lines • ▼ Show 20 Lines#define TYPEKEYWORD(STR, LLVMTY) \
TYPEKEYWORD("ppc_fp128", Type::getPPC_FP128Ty(Context)); TYPEKEYWORD("ppc_fp128", Type::getPPC_FP128Ty(Context));
TYPEKEYWORD("label", Type::getLabelTy(Context)); TYPEKEYWORD("label", Type::getLabelTy(Context));
TYPEKEYWORD("metadata", Type::getMetadataTy(Context)); TYPEKEYWORD("metadata", Type::getMetadataTy(Context));
TYPEKEYWORD("x86_mmx", Type::getX86_MMXTy(Context)); TYPEKEYWORD("x86_mmx", Type::getX86_MMXTy(Context));
TYPEKEYWORD("x86_amx", Type::getX86_AMXTy(Context)); TYPEKEYWORD("x86_amx", Type::getX86_AMXTy(Context));
TYPEKEYWORD("token", Type::getTokenTy(Context)); TYPEKEYWORD("token", Type::getTokenTy(Context));
if (Keyword == "ptr") { if (Keyword == "ptr") {
// setOpaquePointers() must be called before creating any pointer types. if (Context.supportsTypedPointers()) {
if (!Context.hasSetOpaquePointersValue()) {
Context.setOpaquePointers(true);
} else if (Context.supportsTypedPointers()) {
Warning("ptr type is only supported in -opaque-pointers mode"); Warning("ptr type is only supported in -opaque-pointers mode");
return lltok::Error; return lltok::Error;
} }
TyVal = PointerType::getUnqual(Context); TyVal = PointerType::getUnqual(Context);
return lltok::Type; return lltok::Type;
} }
#undef TYPEKEYWORD #undef TYPEKEYWORD
▲ Show 20 Lines • Show All 326 Lines • Show Last 20 Lines

llvm/lib/AsmParser/LLParser.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 55 Lines • ▼ Show 20 Lines
static std::string getTypeString(Type *T) { static std::string getTypeString(Type *T) {
std::string Result; std::string Result;
raw_string_ostream Tmp(Result); raw_string_ostream Tmp(Result);
Tmp << *T; Tmp << *T;
return Tmp.str(); return Tmp.str();
} }
static void setContextOpaquePointers(LLLexer &L, LLVMContext &C) {
while (true) {
lltok::Kind K = L.Lex();
// LLLexer will set the opaque pointers option in LLVMContext if it sees an
// explicit "ptr".
if (K == lltok::star || K == lltok::Error || K == lltok::Eof ||
isa_and_nonnull<PointerType>(L.getTyVal())) {
if (K == lltok::star)
C.setOpaquePointers(false);
return;
}
}
}
/// Run: module ::= toplevelentity* /// Run: module ::= toplevelentity*
bool LLParser::Run(bool UpgradeDebugInfo, bool LLParser::Run(bool UpgradeDebugInfo,
DataLayoutCallbackTy DataLayoutCallback) { DataLayoutCallbackTy DataLayoutCallback) {
// If we haven't decided on whether or not we're using opaque pointers, do a
// quick lex over the tokens to see if we explicitly construct any typed or
// opaque pointer types.
// Don't bail out on an error so we do the same work in the parsing below
// regardless of if --opaque-pointers is set.
if (!Context.hasSetOpaquePointersValue())
setContextOpaquePointers(OPLex, Context);
// Prime the lexer. // Prime the lexer.
Lex.Lex(); Lex.Lex();
if (Context.shouldDiscardValueNames()) if (Context.shouldDiscardValueNames())
return error( return error(
Lex.getLoc(), Lex.getLoc(),
"Can't read textual IR with a Context that discards named Values"); "Can't read textual IR with a Context that discards named Values");
▲ Show 20 Lines • Show All 9,919 Lines • Show Last 20 Lines

llvm/test/CodeGen/AMDGPU/lower-kernel-and-module-lds.ll

; RUN: opt -S -mtriple=amdgcn-- -amdgpu-lower-module-lds --amdgpu-lower-module-lds-strategy=module < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -S -mtriple=amdgcn-- -amdgpu-lower-module-lds --amdgpu-lower-module-lds-strategy=module < %s | FileCheck %s
; RUN: opt -S -mtriple=amdgcn-- -passes=amdgpu-lower-module-lds --amdgpu-lower-module-lds-strategy=module < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -S -mtriple=amdgcn-- -passes=amdgpu-lower-module-lds --amdgpu-lower-module-lds-strategy=module < %s | FileCheck %s
@lds.size.1.align.1 = internal unnamed_addr addrspace(3) global [1 x i8] undef, align 1 @lds.size.1.align.1 = internal unnamed_addr addrspace(3) global [1 x i8] undef, align 1
@lds.size.2.align.2 = internal unnamed_addr addrspace(3) global [2 x i8] undef, align 2 @lds.size.2.align.2 = internal unnamed_addr addrspace(3) global [2 x i8] undef, align 2
@lds.size.4.align.4 = internal unnamed_addr addrspace(3) global [4 x i8] undef, align 4 @lds.size.4.align.4 = internal unnamed_addr addrspace(3) global [4 x i8] undef, align 4
@lds.size.8.align.8 = internal unnamed_addr addrspace(3) global [8 x i8] undef, align 8 @lds.size.8.align.8 = internal unnamed_addr addrspace(3) global [8 x i8] undef, align 8
@lds.size.16.align.16 = internal unnamed_addr addrspace(3) global [16 x i8] undef, align 16 @lds.size.16.align.16 = internal unnamed_addr addrspace(3) global [16 x i8] undef, align 16
; CHECK: %llvm.amdgcn.module.lds.t = type { [8 x i8], [1 x i8] } ; CHECK: %llvm.amdgcn.module.lds.t = type { [8 x i8], [1 x i8] }
▲ Show 20 Lines • Show All 111 Lines • Show Last 20 Lines

llvm/test/CodeGen/AMDGPU/lower-kernel-lds-super-align.ll

; RUN: opt -S -mtriple=amdgcn-- -amdgpu-lower-module-lds --amdgpu-super-align-lds-globals=true --amdgpu-lower-module-lds-strategy=module < %s | FileCheck --check-prefixes=CHECK,SUPER-ALIGN_ON %s ; RUN: opt -opaque-pointers=0 -S -mtriple=amdgcn-- -amdgpu-lower-module-lds --amdgpu-super-align-lds-globals=true --amdgpu-lower-module-lds-strategy=module < %s | FileCheck --check-prefixes=CHECK,SUPER-ALIGN_ON %s
; RUN: opt -S -mtriple=amdgcn-- -passes=amdgpu-lower-module-lds --amdgpu-super-align-lds-globals=true --amdgpu-lower-module-lds-strategy=module < %s | FileCheck --check-prefixes=CHECK,SUPER-ALIGN_ON %s ; RUN: opt -opaque-pointers=0 -S -mtriple=amdgcn-- -passes=amdgpu-lower-module-lds --amdgpu-super-align-lds-globals=true --amdgpu-lower-module-lds-strategy=module < %s | FileCheck --check-prefixes=CHECK,SUPER-ALIGN_ON %s
; RUN: opt -S -mtriple=amdgcn-- -amdgpu-lower-module-lds --amdgpu-super-align-lds-globals=false --amdgpu-lower-module-lds-strategy=module < %s | FileCheck --check-prefixes=CHECK,SUPER-ALIGN_OFF %s ; RUN: opt -opaque-pointers=0 -S -mtriple=amdgcn-- -amdgpu-lower-module-lds --amdgpu-super-align-lds-globals=false --amdgpu-lower-module-lds-strategy=module < %s | FileCheck --check-prefixes=CHECK,SUPER-ALIGN_OFF %s
; RUN: opt -S -mtriple=amdgcn-- -passes=amdgpu-lower-module-lds --amdgpu-super-align-lds-globals=false --amdgpu-lower-module-lds-strategy=module < %s | FileCheck --check-prefixes=CHECK,SUPER-ALIGN_OFF %s ; RUN: opt -opaque-pointers=0 -S -mtriple=amdgcn-- -passes=amdgpu-lower-module-lds --amdgpu-super-align-lds-globals=false --amdgpu-lower-module-lds-strategy=module < %s | FileCheck --check-prefixes=CHECK,SUPER-ALIGN_OFF %s
; CHECK: %llvm.amdgcn.kernel.k1.lds.t = type { [32 x i8] } ; CHECK: %llvm.amdgcn.kernel.k1.lds.t = type { [32 x i8] }
; CHECK: %llvm.amdgcn.kernel.k2.lds.t = type { i16, [2 x i8], i16 } ; CHECK: %llvm.amdgcn.kernel.k2.lds.t = type { i16, [2 x i8], i16 }
; CHECK: %llvm.amdgcn.kernel.k3.lds.t = type { [32 x i64], [32 x i32] } ; CHECK: %llvm.amdgcn.kernel.k3.lds.t = type { [32 x i64], [32 x i32] }
; CHECK: %llvm.amdgcn.kernel.k4.lds.t = type { [2 x i32 addrspace(3)*] } ; CHECK: %llvm.amdgcn.kernel.k4.lds.t = type { [2 x i32 addrspace(3)*] }
; SUPER-ALIGN_ON: @lds.unused = addrspace(3) global i32 undef, align 4 ; SUPER-ALIGN_ON: @lds.unused = addrspace(3) global i32 undef, align 4
; SUPER-ALIGN_OFF: @lds.unused = addrspace(3) global i32 undef, align 2 ; SUPER-ALIGN_OFF: @lds.unused = addrspace(3) global i32 undef, align 2
▲ Show 20 Lines • Show All 148 Lines • Show Last 20 Lines

llvm/test/CodeGen/AMDGPU/lower-kernel-lds.ll

; RUN: opt -S -mtriple=amdgcn-- -amdgpu-lower-module-lds --amdgpu-lower-module-lds-strategy=module < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -S -mtriple=amdgcn-- -amdgpu-lower-module-lds --amdgpu-lower-module-lds-strategy=module < %s | FileCheck %s
; RUN: opt -S -mtriple=amdgcn-- -passes=amdgpu-lower-module-lds --amdgpu-lower-module-lds-strategy=module < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -S -mtriple=amdgcn-- -passes=amdgpu-lower-module-lds --amdgpu-lower-module-lds-strategy=module < %s | FileCheck %s
arsenmUnsubmitted
Not Done
ReplyInline Actions

The test diff is bigger than I expected, what is holding this set of tests back? For example these AMDGPU tests weren't converted with the others to avoid a merge conflict issue which we're past now

arsenm: The test diff is bigger than I expected, what is holding this set of tests back? For example…
nikicAuthorUnsubmitted
Done
ReplyInline Actions

Just a matter of time. I want to land this change before LLVM 16 branches, and don't have time to convert all the remaining tests.

I haven't looked into AMDGPU tests in particular because I assumed that you are taking care of them.

nikic: Just a matter of time. I want to land this change before LLVM 16 branches, and don't have time…
@lds.size.1.align.1 = internal unnamed_addr addrspace(3) global [1 x i8] undef, align 1 @lds.size.1.align.1 = internal unnamed_addr addrspace(3) global [1 x i8] undef, align 1
@lds.size.2.align.2 = internal unnamed_addr addrspace(3) global [2 x i8] undef, align 2 @lds.size.2.align.2 = internal unnamed_addr addrspace(3) global [2 x i8] undef, align 2
@lds.size.4.align.4 = internal unnamed_addr addrspace(3) global [4 x i8] undef, align 4 @lds.size.4.align.4 = internal unnamed_addr addrspace(3) global [4 x i8] undef, align 4
@lds.size.16.align.16 = internal unnamed_addr addrspace(3) global [16 x i8] undef, align 16 @lds.size.16.align.16 = internal unnamed_addr addrspace(3) global [16 x i8] undef, align 16
; CHECK: %llvm.amdgcn.kernel.k0.lds.t = type { [16 x i8], [4 x i8], [2 x i8], [1 x i8] } ; CHECK: %llvm.amdgcn.kernel.k0.lds.t = type { [16 x i8], [4 x i8], [2 x i8], [1 x i8] }
; CHECK: %llvm.amdgcn.kernel.k1.lds.t = type { [16 x i8], [4 x i8], [2 x i8] } ; CHECK: %llvm.amdgcn.kernel.k1.lds.t = type { [16 x i8], [4 x i8], [2 x i8] }
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

llvm/test/CodeGen/AMDGPU/lower-lds-struct-aa-memcpy.ll

; RUN: llc -march=amdgcn -mcpu=gfx900 -O3 --amdgpu-lower-module-lds-strategy=module < %s | FileCheck -check-prefix=GCN %s ; RUN: llc -opaque-pointers=0 -march=amdgcn -mcpu=gfx900 -O3 --amdgpu-lower-module-lds-strategy=module < %s | FileCheck -check-prefix=GCN %s
; RUN: opt -S -mtriple=amdgcn-- -amdgpu-lower-module-lds --amdgpu-lower-module-lds-strategy=module < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -S -mtriple=amdgcn-- -amdgpu-lower-module-lds --amdgpu-lower-module-lds-strategy=module < %s | FileCheck %s
; RUN: opt -S -mtriple=amdgcn-- -passes=amdgpu-lower-module-lds --amdgpu-lower-module-lds-strategy=module < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -S -mtriple=amdgcn-- -passes=amdgpu-lower-module-lds --amdgpu-lower-module-lds-strategy=module < %s | FileCheck %s
%vec_type = type { %vec_base } %vec_type = type { %vec_base }
%vec_base = type { %union.anon } %vec_base = type { %union.anon }
%union.anon = type { %"vec_base<char, 3>::n_vec_" } %union.anon = type { %"vec_base<char, 3>::n_vec_" }
%"vec_base<char, 3>::n_vec_" = type { [3 x i8] } %"vec_base<char, 3>::n_vec_" = type { [3 x i8] }
$_f1 = comdat any $_f1 = comdat any
$_f2 = comdat any $_f2 = comdat any
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

llvm/test/CodeGen/AMDGPU/lower-lds-struct-aa-merge.ll

; RUN: opt -S -mtriple=amdgcn-- -amdgpu-lower-module-lds --amdgpu-lower-module-lds-strategy=module < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -S -mtriple=amdgcn-- -amdgpu-lower-module-lds --amdgpu-lower-module-lds-strategy=module < %s | FileCheck %s
; RUN: opt -S -mtriple=amdgcn-- -passes=amdgpu-lower-module-lds --amdgpu-lower-module-lds-strategy=module < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -S -mtriple=amdgcn-- -passes=amdgpu-lower-module-lds --amdgpu-lower-module-lds-strategy=module < %s | FileCheck %s
@a = internal unnamed_addr addrspace(3) global [64 x i32] undef, align 4 @a = internal unnamed_addr addrspace(3) global [64 x i32] undef, align 4
@b = internal unnamed_addr addrspace(3) global [64 x i32] undef, align 4 @b = internal unnamed_addr addrspace(3) global [64 x i32] undef, align 4
; CHECK-LABEL: @no_clobber_ds_load_stores_x2_preexisting_aa ; CHECK-LABEL: @no_clobber_ds_load_stores_x2_preexisting_aa
; CHECK: store i32 1, i32 addrspace(3)* %0, align 16, !tbaa !0, !noalias !5 ; CHECK: store i32 1, i32 addrspace(3)* %0, align 16, !tbaa !0, !noalias !5
; CHECK: %val.a = load i32, i32 addrspace(3)* %gep.a, align 4, !tbaa !0, !noalias !5 ; CHECK: %val.a = load i32, i32 addrspace(3)* %gep.a, align 4, !tbaa !0, !noalias !5
; CHECK: store i32 2, i32 addrspace(3)* %1, align 16, !tbaa !0, !noalias !5 ; CHECK: store i32 2, i32 addrspace(3)* %1, align 16, !tbaa !0, !noalias !5
Show All 32 Lines

llvm/test/CodeGen/AMDGPU/lower-lds-struct-aa.ll

; RUN: llc -march=amdgcn -mcpu=gfx900 -O3 < %s | FileCheck -check-prefix=GCN %s ; RUN: llc -opaque-pointers=0 -march=amdgcn -mcpu=gfx900 -O3 < %s | FileCheck -check-prefix=GCN %s
; RUN: opt -S -mtriple=amdgcn-- -amdgpu-lower-module-lds < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -S -mtriple=amdgcn-- -amdgpu-lower-module-lds < %s | FileCheck %s
; RUN: opt -S -mtriple=amdgcn-- -passes=amdgpu-lower-module-lds < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -S -mtriple=amdgcn-- -passes=amdgpu-lower-module-lds < %s | FileCheck %s
@a = internal unnamed_addr addrspace(3) global [64 x i32] undef, align 4 @a = internal unnamed_addr addrspace(3) global [64 x i32] undef, align 4
@b = internal unnamed_addr addrspace(3) global [64 x i32] undef, align 4 @b = internal unnamed_addr addrspace(3) global [64 x i32] undef, align 4
@c = internal unnamed_addr addrspace(3) global [64 x i32] undef, align 4 @c = internal unnamed_addr addrspace(3) global [64 x i32] undef, align 4
; FIXME: Should combine the DS instructions into ds_write2 and ds_read2. This ; FIXME: Should combine the DS instructions into ds_write2 and ds_read2. This
; does not happen because when SILoadStoreOptimizer is run, the reads and writes ; does not happen because when SILoadStoreOptimizer is run, the reads and writes
; are not adjacent. They are only moved later by MachineScheduler. ; are not adjacent. They are only moved later by MachineScheduler.
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

llvm/test/CodeGen/AMDGPU/lower-module-lds-constantexpr.ll

; RUN: opt -S -mtriple=amdgcn-- -amdgpu-lower-module-lds --amdgpu-lower-module-lds-strategy=module < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -S -mtriple=amdgcn-- -amdgpu-lower-module-lds --amdgpu-lower-module-lds-strategy=module < %s | FileCheck %s
; RUN: opt -S -mtriple=amdgcn-- -passes=amdgpu-lower-module-lds --amdgpu-lower-module-lds-strategy=module < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -S -mtriple=amdgcn-- -passes=amdgpu-lower-module-lds --amdgpu-lower-module-lds-strategy=module < %s | FileCheck %s
; CHECK: %llvm.amdgcn.module.lds.t = type { float, float } ; CHECK: %llvm.amdgcn.module.lds.t = type { float, float }
; CHECK: %llvm.amdgcn.kernel.timestwo.lds.t = type { float, float } ; CHECK: %llvm.amdgcn.kernel.timestwo.lds.t = type { float, float }
@a_func = addrspace(3) global float undef, align 4 @a_func = addrspace(3) global float undef, align 4
@kern = addrspace(3) global float undef, align 4 @kern = addrspace(3) global float undef, align 4
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

llvm/test/CodeGen/AMDGPU/lower-module-lds-via-table.ll

; RUN: opt -S -mtriple=amdgcn--amdhsa -passes=amdgpu-lower-module-lds < %s --amdgpu-lower-module-lds-strategy=table | FileCheck -check-prefix=OPT %s ; RUN: opt -opaque-pointers=0 -S -mtriple=amdgcn--amdhsa -passes=amdgpu-lower-module-lds < %s --amdgpu-lower-module-lds-strategy=table | FileCheck -check-prefix=OPT %s
; RUN: llc -mtriple=amdgcn--amdhsa -verify-machineinstrs < %s --amdgpu-lower-module-lds-strategy=table | FileCheck -check-prefix=GCN %s ; RUN: llc -opaque-pointers=0 -mtriple=amdgcn--amdhsa -verify-machineinstrs < %s --amdgpu-lower-module-lds-strategy=table | FileCheck -check-prefix=GCN %s
; Opt checks from utils/update_test_checks.py, llc checks from utils/update_llc_test_checks.py, both modified. ; Opt checks from utils/update_test_checks.py, llc -opaque-pointers=0 checks from utils/update_llc_test_checks.py, both modified.
; Define four variables and four non-kernel functions which access exactly one variable each ; Define four variables and four non-kernel functions which access exactly one variable each
@v0 = addrspace(3) global float undef @v0 = addrspace(3) global float undef
@v1 = addrspace(3) global i16 undef, align 16 @v1 = addrspace(3) global i16 undef, align 16
@v2 = addrspace(3) global i64 undef @v2 = addrspace(3) global i64 undef
@v3 = addrspace(3) global i8 undef @v3 = addrspace(3) global i8 undef
@unused = addrspace(3) global i16 undef @unused = addrspace(3) global i16 undef
▲ Show 20 Lines • Show All 358 Lines • Show Last 20 Lines

llvm/test/CodeGen/AMDGPU/lower-module-lds.ll

; RUN: opt -S -mtriple=amdgcn-- -amdgpu-lower-module-lds --amdgpu-lower-module-lds-strategy=module < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -S -mtriple=amdgcn-- -amdgpu-lower-module-lds --amdgpu-lower-module-lds-strategy=module < %s | FileCheck %s
; RUN: opt -S -mtriple=amdgcn-- -passes=amdgpu-lower-module-lds --amdgpu-lower-module-lds-strategy=module < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -S -mtriple=amdgcn-- -passes=amdgpu-lower-module-lds --amdgpu-lower-module-lds-strategy=module < %s | FileCheck %s
; Padding to meet alignment, so references to @var1 replaced with gep ptr, 0, 2 ; Padding to meet alignment, so references to @var1 replaced with gep ptr, 0, 2
; No i64 as addrspace(3) types with initializers are ignored. Likewise no addrspace(4). ; No i64 as addrspace(3) types with initializers are ignored. Likewise no addrspace(4).
; CHECK: %llvm.amdgcn.module.lds.t = type { float, [4 x i8], i32 } ; CHECK: %llvm.amdgcn.module.lds.t = type { float, [4 x i8], i32 }
; Variable removed by pass ; Variable removed by pass
; CHECK-NOT: @var0 ; CHECK-NOT: @var0
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

llvm/test/CodeGen/AMDGPU/replace-lds-by-ptr-call-diamond-shape.ll

; RUN: opt -S -mtriple=amdgcn-- -amdgpu-replace-lds-use-with-pointer -amdgpu-enable-lds-replace-with-pointer=true < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -S -mtriple=amdgcn-- -amdgpu-replace-lds-use-with-pointer -amdgpu-enable-lds-replace-with-pointer=true < %s | FileCheck %s
; DESCRIPTION: ; DESCRIPTION:
; ;
; The lds global @lds_used_within_func is used within non-kernel function @func_uses_lds ; The lds global @lds_used_within_func is used within non-kernel function @func_uses_lds
; which is recheable from kernel @kernel_reaches_lds, hence pointer replacement takes place ; which is recheable from kernel @kernel_reaches_lds, hence pointer replacement takes place
; for @lds_used_within_func. ; for @lds_used_within_func.
; ;
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

llvm/test/CodeGen/AMDGPU/replace-lds-by-ptr-call-selected_functions.ll

; RUN: opt -S -mtriple=amdgcn-- -amdgpu-replace-lds-use-with-pointer -amdgpu-enable-lds-replace-with-pointer=true < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -S -mtriple=amdgcn-- -amdgpu-replace-lds-use-with-pointer -amdgpu-enable-lds-replace-with-pointer=true < %s | FileCheck %s
; DESCRIPTION: ; DESCRIPTION:
; ;
; There are three lds globals defined here, and these three lds are used respectively within ; There are three lds globals defined here, and these three lds are used respectively within
; three non-kernel functions. There are three kernels, which call two of the non-kernel functions. ; three non-kernel functions. There are three kernels, which call two of the non-kernel functions.
; Hence pointer replacement should take place for all three lds, and pointer initialization within ; Hence pointer replacement should take place for all three lds, and pointer initialization within
; kernel should selectively happen depending on which lds is reachable from the kernel. ; kernel should selectively happen depending on which lds is reachable from the kernel.
; ;
▲ Show 20 Lines • Show All 121 Lines • Show Last 20 Lines

llvm/test/CodeGen/AMDGPU/replace-lds-by-ptr-indirect-call-diamond-shape.ll

; RUN: opt -S -mtriple=amdgcn-- -amdgpu-replace-lds-use-with-pointer -amdgpu-enable-lds-replace-with-pointer=true < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -S -mtriple=amdgcn-- -amdgpu-replace-lds-use-with-pointer -amdgpu-enable-lds-replace-with-pointer=true < %s | FileCheck %s
; DESCRIPTION: ; DESCRIPTION:
; ;
; The lds global @lds_used_within_func is used within non-kernel function @func_uses_lds ; The lds global @lds_used_within_func is used within non-kernel function @func_uses_lds
; which is *indirectly* recheable from kernel @kernel_reaches_lds, hence pointer replacement ; which is *indirectly* recheable from kernel @kernel_reaches_lds, hence pointer replacement
; takes place for @lds_used_within_func. ; takes place for @lds_used_within_func.
; Original LDS should exit. ; Original LDS should exit.
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

llvm/test/CodeGen/AMDGPU/replace-lds-by-ptr-indirect-call-selected_functions.ll

; RUN: opt -S -mtriple=amdgcn-- -amdgpu-replace-lds-use-with-pointer -amdgpu-enable-lds-replace-with-pointer=true < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -S -mtriple=amdgcn-- -amdgpu-replace-lds-use-with-pointer -amdgpu-enable-lds-replace-with-pointer=true < %s | FileCheck %s
; DESCRIPTION: ; DESCRIPTION:
; ;
; There are three lds globals defined here, and these three lds are used respectively within ; There are three lds globals defined here, and these three lds are used respectively within
; three non-kernel functions. There are three kernels, which *indirectly* call two of the ; three non-kernel functions. There are three kernels, which *indirectly* call two of the
; non-kernel functions. Hence pointer replacement should take place for all three lds, and ; non-kernel functions. Hence pointer replacement should take place for all three lds, and
; pointer initialization within kernel should selectively happen depending on which lds is ; pointer initialization within kernel should selectively happen depending on which lds is
; reachable from the kernel. ; reachable from the kernel.
▲ Show 20 Lines • Show All 142 Lines • Show Last 20 Lines

llvm/test/CodeGen/AMDGPU/replace-lds-by-ptr-indirect-call-signature-match.ll

; RUN: opt -S -mtriple=amdgcn-- -amdgpu-replace-lds-use-with-pointer -amdgpu-enable-lds-replace-with-pointer=true < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -S -mtriple=amdgcn-- -amdgpu-replace-lds-use-with-pointer -amdgpu-enable-lds-replace-with-pointer=true < %s | FileCheck %s
; DESCRIPTION: ; DESCRIPTION:
; ;
; There are three lds globals defined here, and these three lds are used respectively within ; There are three lds globals defined here, and these three lds are used respectively within
; three non-kernel functions. There is one kernel which *indirectly* calls one of the non-kernel ; three non-kernel functions. There is one kernel which *indirectly* calls one of the non-kernel
; functions. But since all the three non-kernel functions have same signature, all three ; functions. But since all the three non-kernel functions have same signature, all three
; non-kernel functions are resolved as potential callees for indirect call-site. Hence we land-up ; non-kernel functions are resolved as potential callees for indirect call-site. Hence we land-up
; pointer replacement for three lds globals. ; pointer replacement for three lds globals.
▲ Show 20 Lines • Show All 85 Lines • Show Last 20 Lines

llvm/test/CodeGen/AMDGPU/replace-lds-by-ptr-use-multiple-lds.ll

; RUN: opt -S -mtriple=amdgcn-- -amdgpu-replace-lds-use-with-pointer -amdgpu-enable-lds-replace-with-pointer=true < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -S -mtriple=amdgcn-- -amdgpu-replace-lds-use-with-pointer -amdgpu-enable-lds-replace-with-pointer=true < %s | FileCheck %s
; DESCRIPTION: ; DESCRIPTION:
; ;
; There are three lds globals defined here, and these three lds are used within a single ; There are three lds globals defined here, and these three lds are used within a single
; non-kernel function, and this non-kernel function is reachable from kernel. Hence pointer ; non-kernel function, and this non-kernel function is reachable from kernel. Hence pointer
; replacement is required for all three lds globals. ; replacement is required for all three lds globals.
; ;
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

llvm/test/CodeGen/AMDGPU/replace-lds-by-ptr-use-same-lds.ll

; RUN: opt -S -mtriple=amdgcn-- -amdgpu-replace-lds-use-with-pointer -amdgpu-enable-lds-replace-with-pointer=true < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -S -mtriple=amdgcn-- -amdgpu-replace-lds-use-with-pointer -amdgpu-enable-lds-replace-with-pointer=true < %s | FileCheck %s
; DESCRIPTION: ; DESCRIPTION:
; ;
; There is one lds global defined here, and this lds is used within a single non-kernel ; There is one lds global defined here, and this lds is used within a single non-kernel
; function multiple times, and this non-kernel function is reachable from kernel. Hence ; function multiple times, and this non-kernel function is reachable from kernel. Hence
; pointer takes place. But important note is - store-to/load-from pointer should happen ; pointer takes place. But important note is - store-to/load-from pointer should happen
; only once irrespective of number of uses. ; only once irrespective of number of uses.
; ;
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

llvm/test/CodeGen/AMDGPU/replace-lds-by-ptr-use-within-phi-inst.ll

; RUN: opt -S -mtriple=amdgcn-- -amdgpu-replace-lds-use-with-pointer -amdgpu-enable-lds-replace-with-pointer=true < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -S -mtriple=amdgcn-- -amdgpu-replace-lds-use-with-pointer -amdgpu-enable-lds-replace-with-pointer=true < %s | FileCheck %s
; DESCRIPTION: ; DESCRIPTION:
; ;
; Replace lds globals used within phi instruction. ; Replace lds globals used within phi instruction.
; ;
; Original LDS should exist. ; Original LDS should exist.
; CHECK: @lds.1 = addrspace(3) global i32 undef, align 4 ; CHECK: @lds.1 = addrspace(3) global i32 undef, align 4
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

llvm/test/CodeGen/ARM/combine-movc-sub.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc %s -o - -verify-machineinstrs | FileCheck %s ; RUN: llc -opaque-pointers=0 %s -o - -verify-machineinstrs | FileCheck %s
target datalayout = "e-m:o-p:32:32-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32" target datalayout = "e-m:o-p:32:32-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32"
target triple = "thumbv7s-apple-unknown" target triple = "thumbv7s-apple-unknown"
; The subtract instruction %3 will be optimized (combined and predicated) with the select ; The subtract instruction %3 will be optimized (combined and predicated) with the select
; inside the loop. In this case, the kill flag on the subtract should be removed or else ; inside the loop. In this case, the kill flag on the subtract should be removed or else
; it will fail verification. ; it will fail verification.
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

llvm/test/CodeGen/ARM/fast-isel-inline-asm.ll

; RUN: llc -fast-isel < %s | FileCheck %s ; RUN: llc -opaque-pointers=0 -fast-isel < %s | FileCheck %s
target datalayout = "e-m:o-p:32:32-i1:8:32-i8:8:32-i16:16:32-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32" target datalayout = "e-m:o-p:32:32-i1:8:32-i8:8:32-i16:16:32-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32"
target triple = "thumbv7-apple-ios5.0.0" target triple = "thumbv7-apple-ios5.0.0"
%0 = type opaque %0 = type opaque
; Make sure that the inline asm starts right after the call to bar. ; Make sure that the inline asm starts right after the call to bar.
define void @test_inline_asm_sideeffect(%0* %call) { define void @test_inline_asm_sideeffect(%0* %call) {
; CHECK: bl _bar ; CHECK: bl _bar
Show All 9 Lines

llvm/test/CodeGen/ARM/inlineasm-X-constraint.ll

; RUN: llc -mtriple=armv7-none-eabi -mattr=+neon < %s -o - | FileCheck %s ; RUN: llc -opaque-pointers=0 -mtriple=armv7-none-eabi -mattr=+neon < %s -o - | FileCheck %s
; The following functions test the use case where an X constraint is used to ; The following functions test the use case where an X constraint is used to
; add a dependency between an assembly instruction (vmsr in this case) and ; add a dependency between an assembly instruction (vmsr in this case) and
; another instruction. In each function, we use a different type for the ; another instruction. In each function, we use a different type for the
; X constraint argument. ; X constraint argument.
; ;
; We can something similar from the following C code: ; We can something similar from the following C code:
; double f1(double f, int pscr_value) { ; double f1(double f, int pscr_value) {
▲ Show 20 Lines • Show All 148 Lines • Show Last 20 Lines

llvm/test/CodeGen/ARM/lsr-setupcost.ll

; 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=thumbv6m-none-eabi -loop-reduce %s -S -o - | FileCheck %s ; RUN: opt -opaque-pointers=0 -mtriple=thumbv6m-none-eabi -loop-reduce %s -S -o - | 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"
%struct.arm_matrix_instance_q15 = type { i16, i16, i16* } %struct.arm_matrix_instance_q15 = type { i16, i16, i16* }
define i32 @arm_mat_add_q15(%struct.arm_matrix_instance_q15* nocapture readonly %pSrcA, %struct.arm_matrix_instance_q15* nocapture readonly %pSrcB, %struct.arm_matrix_instance_q15* nocapture readonly %pDst) { define i32 @arm_mat_add_q15(%struct.arm_matrix_instance_q15* nocapture readonly %pSrcA, %struct.arm_matrix_instance_q15* nocapture readonly %pSrcB, %struct.arm_matrix_instance_q15* nocapture readonly %pDst) {
; CHECK-LABEL: @arm_mat_add_q15( ; CHECK-LABEL: @arm_mat_add_q15(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
▲ Show 20 Lines • Show All 90 Lines • Show Last 20 Lines

llvm/test/CodeGen/ARM/shifter_operand.ll

; RUN: llc < %s -mtriple=armv7-apple-darwin -mcpu=cortex-a8 | FileCheck %s -check-prefix=CHECK -check-prefix=CHECK-ARM ; RUN: llc -opaque-pointers=0 < %s -mtriple=armv7-apple-darwin -mcpu=cortex-a8 | FileCheck %s -check-prefix=CHECK -check-prefix=CHECK-ARM
; RUN: llc < %s -mtriple=armv7-apple-darwin -mcpu=cortex-a9 | FileCheck %s -check-prefix=CHECK -check-prefix=CHECK-ARM ; RUN: llc -opaque-pointers=0 < %s -mtriple=armv7-apple-darwin -mcpu=cortex-a9 | FileCheck %s -check-prefix=CHECK -check-prefix=CHECK-ARM
; RUN: llc < %s -mtriple=thumbv7m-none-eabi | FileCheck %s -check-prefix=CHECK -check-prefix=CHECK-THUMB ; RUN: llc -opaque-pointers=0 < %s -mtriple=thumbv7m-none-eabi | FileCheck %s -check-prefix=CHECK -check-prefix=CHECK-THUMB
; rdar://8576755 ; rdar://8576755
define i32 @test1(i32 %X, i32 %Y, i8 %sh) { define i32 @test1(i32 %X, i32 %Y, i8 %sh) {
; CHECK-LABEL: test1: ; CHECK-LABEL: test1:
; CHECK-ARM: add r0, r0, r1, lsl r2 ; CHECK-ARM: add r0, r0, r1, lsl r2
; CHECK-THUMB: lsls r1, r2 ; CHECK-THUMB: lsls r1, r2
; CHECK-THUMB: add r0, r1 ; CHECK-THUMB: add r0, r1
▲ Show 20 Lines • Show All 352 Lines • Show Last 20 Lines

llvm/test/CodeGen/Hexagon/addrmode.ll

; RUN: llc -O3 -march=hexagon < %s | FileCheck %s ; RUN: llc -opaque-pointers=0 -O3 -march=hexagon < %s | FileCheck %s
; CHECK-NOT: memb(r{{[0-9]+}}+#375) = #4 ; CHECK-NOT: memb(r{{[0-9]+}}+#375) = #4
; CHECK: [[REG0:(r[0-9]+)]] = add(r{{[0-9]+}},{{#?}}#374) ; CHECK: [[REG0:(r[0-9]+)]] = add(r{{[0-9]+}},{{#?}}#374)
; CHECK: memb([[REG0]]+#1) = #4 ; CHECK: memb([[REG0]]+#1) = #4
%s.0 = type { %s.1, %s.2*, %s.2*, %s.3, %s.5, i32, i32, i16, i8, i8, i8, [7 x i8], i16, i8, i8, i16, i8, i8, i16, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i32, i16, i16, i16, [14 x i8], %s.6, i8, i8, %s.8, [2 x [16 x %s.9]], i32 (i8*, i8*, i8*, i8*, i8*)*, [80 x i8], i8, i8, i8*, i8*, i8*, i32*, i8*, i8*, i8*, [4 x i8], i8*, i8*, i8*, i8*, i8*, i8*, %s.18*, %s.18*, %s.6*, [4 x i8], [2 x [80 x [8 x i8]]], [56 x i8], [2 x [81 x %s.10]], [2 x %s.10], %s.10*, %s.10*, i32, [32 x i32], i8*, %s.12*, i8, i8, %s.18, i64*, i32, %s.19, %s.20, %s.21*, i8, [19 x i8] } %s.0 = type { %s.1, %s.2*, %s.2*, %s.3, %s.5, i32, i32, i16, i8, i8, i8, [7 x i8], i16, i8, i8, i16, i8, i8, i16, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i32, i16, i16, i16, [14 x i8], %s.6, i8, i8, %s.8, [2 x [16 x %s.9]], i32 (i8*, i8*, i8*, i8*, i8*)*, [80 x i8], i8, i8, i8*, i8*, i8*, i32*, i8*, i8*, i8*, [4 x i8], i8*, i8*, i8*, i8*, i8*, i8*, %s.18*, %s.18*, %s.6*, [4 x i8], [2 x [80 x [8 x i8]]], [56 x i8], [2 x [81 x %s.10]], [2 x %s.10], %s.10*, %s.10*, i32, [32 x i32], i8*, %s.12*, i8, i8, %s.18, i64*, i32, %s.19, %s.20, %s.21*, i8, [19 x i8] }
%s.1 = type { i32, i32, i8* } %s.1 = type { i32, i32, i8* }
%s.2 = type { i8, i8 } %s.2 = type { i8, i8 }
▲ Show 20 Lines • Show All 98 Lines • Show Last 20 Lines

llvm/test/CodeGen/Hexagon/autohvx/vector-align-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 -mtriple=hexagon -S -hexagon-vc -instcombine < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -mtriple=hexagon -S -hexagon-vc -instcombine < %s | FileCheck %s
; Check that Hexagon Vector Combine propagates (TBAA) metadata to the ; Check that Hexagon Vector Combine propagates (TBAA) metadata to the
; generated output. (Use instcombine to clean the output up a bit.) ; generated output. (Use instcombine to clean the output up a bit.)
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"
target triple = "hexagon" target triple = "hexagon"
; Two unaligned loads, both with the same TBAA tag. ; Two unaligned loads, both with the same TBAA tag.
▲ Show 20 Lines • Show All 289 Lines • Show Last 20 Lines

llvm/test/CodeGen/Hexagon/common-gep-inbounds.ll

; RUN: llc -march=hexagon -debug-only=commgep 2>&1 < %s | FileCheck %s ; RUN: llc -opaque-pointers=0 -march=hexagon -debug-only=commgep 2>&1 < %s | FileCheck %s
; REQUIRES: asserts ; REQUIRES: asserts
; We should generate new GEPs with "inbounds" flag. ; We should generate new GEPs with "inbounds" flag.
; CHECK: new GEP:{{.*}}inbounds ; CHECK: new GEP:{{.*}}inbounds
; CHECK: new GEP:{{.*}}inbounds ; CHECK: new GEP:{{.*}}inbounds
target triple = "hexagon" target triple = "hexagon"
Show All 11 Lines

llvm/test/CodeGen/Hexagon/swp-epilog-phi7.ll

; RUN: llc -march=hexagon -O2 -enable-pipeliner -disable-block-placement=0 < %s | FileCheck %s ; RUN: llc -opaque-pointers=0 -march=hexagon -O2 -enable-pipeliner -disable-block-placement=0 < %s | FileCheck %s
; For the Phis generated in the epilog, test that we generate the correct ; For the Phis generated in the epilog, test that we generate the correct
; names for the values coming from the prolog stages. The test belows ; names for the values coming from the prolog stages. The test belows
; checks that the value loaded in the first prolog block gets propagated ; checks that the value loaded in the first prolog block gets propagated
; through the first epilog to the use after the loop. ; through the first epilog to the use after the loop.
; CHECK: if ({{.*}}) jump ; CHECK: if ({{.*}}) jump
; CHECK: [[VREG:v([0-9]+)]]{{.*}} = {{.*}}vmem(r{{[0-9]+}}++#1) ; CHECK: [[VREG:v([0-9]+)]]{{.*}} = {{.*}}vmem(r{{[0-9]+}}++#1)
▲ Show 20 Lines • Show All 266 Lines • Show Last 20 Lines

llvm/test/CodeGen/PowerPC/aix32-cc-abi-vaarg.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc -O2 -verify-machineinstrs -mcpu=pwr4 -mattr=-altivec -mtriple powerpc-ibm-aix-xcoff < %s | FileCheck --check-prefix=ASM32 %s ; RUN: llc -opaque-pointers=0 -O2 -verify-machineinstrs -mcpu=pwr4 -mattr=-altivec -mtriple powerpc-ibm-aix-xcoff < %s | FileCheck --check-prefix=ASM32 %s
; RUN: llc -O2 -mtriple powerpc-ibm-aix-xcoff -stop-after=machine-cp -verify-machineinstrs < %s | FileCheck --check-prefix=32BIT %s ; RUN: llc -opaque-pointers=0 -O2 -mtriple powerpc-ibm-aix-xcoff -stop-after=machine-cp -verify-machineinstrs < %s | FileCheck --check-prefix=32BIT %s
define i32 @int_va_arg(i32 %a, ...) local_unnamed_addr { define i32 @int_va_arg(i32 %a, ...) local_unnamed_addr {
; ASM32-LABEL: int_va_arg: ; ASM32-LABEL: int_va_arg:
; ASM32: # %bb.0: # %entry ; ASM32: # %bb.0: # %entry
; ASM32-NEXT: addi 11, 1, 28 ; ASM32-NEXT: addi 11, 1, 28
; ASM32-NEXT: stw 4, 28(1) ; ASM32-NEXT: stw 4, 28(1)
; ASM32-NEXT: addi 4, 1, 32 ; ASM32-NEXT: addi 4, 1, 32
; ASM32-NEXT: stw 6, 36(1) ; ASM32-NEXT: stw 6, 36(1)
▲ Show 20 Lines • Show All 377 Lines • Show Last 20 Lines

llvm/test/CodeGen/PowerPC/aix32-vector-vararg-callee-split.ll

; NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py
; RUN: llc -verify-machineinstrs -stop-before=ppc-vsx-copy -vec-extabi \ ; RUN: llc -opaque-pointers=0 -verify-machineinstrs -stop-before=ppc-vsx-copy -vec-extabi \
; RUN: -mcpu=pwr7 -mtriple powerpc-ibm-aix-xcoff < %s | \ ; RUN: -mcpu=pwr7 -mtriple powerpc-ibm-aix-xcoff < %s | \
; RUN: FileCheck %s ; RUN: FileCheck %s
;; Testing a variadic callee where a vector argument passed through ellipsis ;; Testing a variadic callee where a vector argument passed through ellipsis
;; is passed partially in registers and on the stack. The 3 fixed double ;; is passed partially in registers and on the stack. The 3 fixed double
;; arguments shadow r3-r8, and a vector int <4 x i32> is passed in R9/R10 and ;; arguments shadow r3-r8, and a vector int <4 x i32> is passed in R9/R10 and
;; on the stack starting at the shadow of R9. ;; on the stack starting at the shadow of R9.
define <4 x i32> @split_spill(double %d1, double %d2, double %d3, ...) { define <4 x i32> @split_spill(double %d1, double %d2, double %d3, ...) {
Show All 39 Lines

llvm/test/CodeGen/PowerPC/aix32-vector-vararg-callee.ll

; NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py
; RUN: llc -verify-machineinstrs -stop-before=ppc-vsx-copy -vec-extabi \ ; RUN: llc -opaque-pointers=0 -verify-machineinstrs -stop-before=ppc-vsx-copy -vec-extabi \
; RUN: -mcpu=pwr7 -mtriple powerpc-ibm-aix-xcoff < %s | \ ; RUN: -mcpu=pwr7 -mtriple powerpc-ibm-aix-xcoff < %s | \
; RUN: FileCheck %s ; RUN: FileCheck %s
; Testing passing a vector <4 x i32> through ellipses of a variadic function. ; Testing passing a vector <4 x i32> through ellipses of a variadic function.
define <4 x i32> @callee(i32 %count, ...) { define <4 x i32> @callee(i32 %count, ...) {
; CHECK-LABEL: name: callee ; CHECK-LABEL: name: callee
; CHECK: bb.0.entry: ; CHECK: bb.0.entry:
; CHECK: liveins: $r4, $r5, $r6, $r7, $r8, $r9, $r10 ; CHECK: liveins: $r4, $r5, $r6, $r7, $r8, $r9, $r10
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

llvm/test/CodeGen/PowerPC/aix32-vector-vararg-fixed-callee.ll

; NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py
; RUN: llc -verify-machineinstrs -stop-before=ppc-vsx-copy -vec-extabi \ ; RUN: llc -opaque-pointers=0 -verify-machineinstrs -stop-before=ppc-vsx-copy -vec-extabi \
; RUN: -mcpu=pwr7 -mtriple powerpc-ibm-aix-xcoff < %s | \ ; RUN: -mcpu=pwr7 -mtriple powerpc-ibm-aix-xcoff < %s | \
; RUN: FileCheck %s ; RUN: FileCheck %s
;; Fixed vector arguments to variadic functions are passed differently than ;; Fixed vector arguments to variadic functions are passed differently than
;; either arguments to non-variadic functions or arguments passed through ;; either arguments to non-variadic functions or arguments passed through
;; ellipses. ;; ellipses.
define double @callee(i32 %count, <4 x i32> %vsi, double %next, ...) { define double @callee(i32 %count, <4 x i32> %vsi, double %next, ...) {
; CHECK-LABEL: name: callee ; CHECK-LABEL: name: callee
Show All 38 Lines

llvm/test/CodeGen/PowerPC/aix64-cc-abi-vaarg.ll

; RUN: llc -O2 -mtriple powerpc64-ibm-aix-xcoff -stop-after=machine-cp -verify-machineinstrs < %s | \ ; RUN: llc -opaque-pointers=0 -O2 -mtriple powerpc64-ibm-aix-xcoff -stop-after=machine-cp -verify-machineinstrs < %s | \
; RUN: FileCheck --check-prefix=64BIT %s ; RUN: FileCheck --check-prefix=64BIT %s
; RUN: llc -O2 -verify-machineinstrs -mcpu=pwr4 -mattr=-altivec \ ; RUN: llc -opaque-pointers=0 -O2 -verify-machineinstrs -mcpu=pwr4 -mattr=-altivec \
; RUN: -mtriple powerpc64-ibm-aix-xcoff < %s | \ ; RUN: -mtriple powerpc64-ibm-aix-xcoff < %s | \
; RUN: FileCheck --check-prefix=ASM64 %s ; RUN: FileCheck --check-prefix=ASM64 %s
define i32 @int_va_arg(i32 %a, ...) local_unnamed_addr { define i32 @int_va_arg(i32 %a, ...) local_unnamed_addr {
entry: entry:
%arg1 = alloca i8*, align 8 %arg1 = alloca i8*, align 8
%arg2 = alloca i8*, align 8 %arg2 = alloca i8*, align 8
%0 = bitcast i8** %arg1 to i8* %0 = bitcast i8** %arg1 to i8*
▲ Show 20 Lines • Show All 345 Lines • Show Last 20 Lines

llvm/test/CodeGen/PowerPC/aix64-vector-vararg-callee.ll

; NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py
; RUN: llc -verify-machineinstrs -stop-before=ppc-vsx-copy -vec-extabi \ ; RUN: llc -opaque-pointers=0 -verify-machineinstrs -stop-before=ppc-vsx-copy -vec-extabi \
; RUN: -mcpu=pwr7 -mtriple powerpc64-ibm-aix-xcoff < %s | \ ; RUN: -mcpu=pwr7 -mtriple powerpc64-ibm-aix-xcoff < %s | \
; RUN: FileCheck %s ; RUN: FileCheck %s
; Testing passing a vector <4 x i32> through ellipses of a variadic function. ; Testing passing a vector <4 x i32> through ellipses of a variadic function.
define <4 x i32> @callee(i32 signext %count, ...) { define <4 x i32> @callee(i32 signext %count, ...) {
; CHECK-LABEL: name: callee ; CHECK-LABEL: name: callee
; CHECK: bb.0.entry: ; CHECK: bb.0.entry:
; CHECK: liveins: $x4, $x5, $x6, $x7, $x8, $x9, $x10 ; CHECK: liveins: $x4, $x5, $x6, $x7, $x8, $x9, $x10
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

llvm/test/CodeGen/PowerPC/aix64-vector-vararg-fixed-callee.ll

; NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py
; RUN: llc -verify-machineinstrs -stop-before=ppc-vsx-copy -vec-extabi \ ; RUN: llc -opaque-pointers=0 -verify-machineinstrs -stop-before=ppc-vsx-copy -vec-extabi \
; RUN: -mcpu=pwr7 -mtriple powerpc64-ibm-aix-xcoff < %s | \ ; RUN: -mcpu=pwr7 -mtriple powerpc64-ibm-aix-xcoff < %s | \
; RUN: FileCheck %s ; RUN: FileCheck %s
;; Fixed vector arguments to variadic functions are passed differently than ;; Fixed vector arguments to variadic functions are passed differently than
;; either arguments to non-variadic functions or arguments passed through ;; either arguments to non-variadic functions or arguments passed through
;; ellipses. ;; ellipses.
define double @callee(i32 signext %count, <4 x i32> %vsi, double %next, ...) { define double @callee(i32 signext %count, <4 x i32> %vsi, double %next, ...) {
; CHECK-LABEL: name: callee ; CHECK-LABEL: name: callee
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

llvm/test/CodeGen/PowerPC/common-chain.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc -ppc-asm-full-reg-names -verify-machineinstrs -ppc-formprep-chain-commoning \ ; RUN: llc -opaque-pointers=0 -ppc-asm-full-reg-names -verify-machineinstrs -ppc-formprep-chain-commoning \
; RUN: -mtriple=powerpc64le-unknown-linux-gnu -mcpu=pwr9 < %s | FileCheck %s ; RUN: -mtriple=powerpc64le-unknown-linux-gnu -mcpu=pwr9 < %s | FileCheck %s
; addresses: ; addresses:
; 1: base1 + offset ; 1: base1 + offset
; 2: + offset ; 2: + offset
; 3: + offset ; 3: + offset
; 4: + offset ; 4: + offset
; ;
▲ Show 20 Lines • Show All 1,209 Lines • Show Last 20 Lines

llvm/test/CodeGen/PowerPC/fast-isel-branch.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc -mtriple=powerpc64le-unknown-linux-gnu < %s | FileCheck %s -check-prefix=ELF64 ; RUN: llc -opaque-pointers=0 -mtriple=powerpc64le-unknown-linux-gnu < %s | FileCheck %s -check-prefix=ELF64
; RUN: llc -mtriple=powerpc64-ibm-aix-xcoff < %s | FileCheck %s -check-prefix=AIX64 ; RUN: llc -opaque-pointers=0 -mtriple=powerpc64-ibm-aix-xcoff < %s | FileCheck %s -check-prefix=AIX64
@x = global i32 1000, align 4 @x = global i32 1000, align 4
define signext i32 @bar() #0 { define signext i32 @bar() #0 {
; ELF64-LABEL: bar: ; ELF64-LABEL: bar:
; ELF64: # %bb.0: # %entry ; ELF64: # %bb.0: # %entry
; ELF64-NEXT: mflr 0 ; ELF64-NEXT: mflr 0
; ELF64-NEXT: stdu 1, -48(1) ; ELF64-NEXT: stdu 1, -48(1)
▲ Show 20 Lines • Show All 94 Lines • Show Last 20 Lines

llvm/test/CodeGen/PowerPC/func-alias.ll

; RUN: llc -verify-machineinstrs -mtriple=powerpc64le-unknown-linux-gnu \ ; RUN: llc -opaque-pointers=0 -verify-machineinstrs -mtriple=powerpc64le-unknown-linux-gnu \
; RUN: -mcpu=pwr9 -ppc-asm-full-reg-names < %s | FileCheck %s --check-prefix=P9 ; RUN: -mcpu=pwr9 -ppc-asm-full-reg-names < %s | FileCheck %s --check-prefix=P9
; RUN: llc -verify-machineinstrs -mtriple=powerpc64le-unknown-linux-gnu \ ; RUN: llc -opaque-pointers=0 -verify-machineinstrs -mtriple=powerpc64le-unknown-linux-gnu \
; RUN: -mcpu=pwr10 -ppc-asm-full-reg-names < %s | FileCheck %s --check-prefix=P10 ; RUN: -mcpu=pwr10 -ppc-asm-full-reg-names < %s | FileCheck %s --check-prefix=P10
@newname = dso_local alias i32 (...), bitcast (i32 ()* @oldname to i32 (...)*) @newname = dso_local alias i32 (...), bitcast (i32 ()* @oldname to i32 (...)*)
; Function Attrs: noinline nounwind optnone ; Function Attrs: noinline nounwind optnone
define dso_local signext i32 @oldname() #0 { define dso_local signext i32 @oldname() #0 {
entry: entry:
ret i32 55 ret i32 55
Show All 35 Lines

llvm/test/CodeGen/PowerPC/loop-instr-form-prepare.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc -ppc-asm-full-reg-names -verify-machineinstrs -mtriple=powerpc64le-unknown-linux-gnu -mcpu=pwr9 < %s | FileCheck %s ; RUN: llc -opaque-pointers=0 -ppc-asm-full-reg-names -verify-machineinstrs -mtriple=powerpc64le-unknown-linux-gnu -mcpu=pwr9 < %s | FileCheck %s
; test_no_prep: ; test_no_prep:
; unsigned long test_no_prep(char *p, int count) { ; unsigned long test_no_prep(char *p, int count) {
; unsigned long i=0, res=0; ; unsigned long i=0, res=0;
; int DISP1 = 4001; ; int DISP1 = 4001;
; int DISP2 = 4002; ; int DISP2 = 4002;
; int DISP3 = 4003; ; int DISP3 = 4003;
; int DISP4 = 4004; ; int DISP4 = 4004;
▲ Show 20 Lines • Show All 1,013 Lines • Show Last 20 Lines

llvm/test/CodeGen/PowerPC/lsr-postinc-pos.ll

; RUN: llc -verify-machineinstrs < %s -print-lsr-output 2>&1 | FileCheck %s ; RUN: llc -opaque-pointers=0 -verify-machineinstrs < %s -print-lsr-output 2>&1 | FileCheck %s
; The icmp is a post-inc use, and the increment is in %bb11, but the ; The icmp is a post-inc use, and the increment is in %bb11, but the
; scevgep needs to be inserted in %bb so that it is dominated by %t. ; scevgep needs to be inserted in %bb so that it is dominated by %t.
; CHECK: %t = load i8*, i8** %inp ; CHECK: %t = load i8*, i8** %inp
; CHECK: %scevgep = getelementptr i8, i8* %t, i32 %lsr.iv.next ; CHECK: %scevgep = getelementptr i8, i8* %t, i32 %lsr.iv.next
; CHECK: %c1 = icmp ult i8* %scevgep, %inp2 ; CHECK: %c1 = icmp ult i8* %scevgep, %inp2
Show All 23 Lines

llvm/test/CodeGen/PowerPC/lsr-profitable-chain.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc -verify-machineinstrs -mtriple=powerpc64le-unknown-linux-gnu \ ; RUN: llc -opaque-pointers=0 -verify-machineinstrs -mtriple=powerpc64le-unknown-linux-gnu \
; RUN: -mcpu=pwr9 < %s | FileCheck %s ; RUN: -mcpu=pwr9 < %s | FileCheck %s
define void @foo(double* readonly %0, double* %1, i64 %2, i64 %3, i64 %4, i64 %5, i64 %6, i64 %7) { define void @foo(double* readonly %0, double* %1, i64 %2, i64 %3, i64 %4, i64 %5, i64 %6, i64 %7) {
; CHECK-LABEL: foo: ; CHECK-LABEL: foo:
; CHECK: # %bb.0: ; CHECK: # %bb.0:
; CHECK-NEXT: cmpd 5, 7 ; CHECK-NEXT: cmpd 5, 7
; CHECK-NEXT: std 22, -80(1) # 8-byte Folded Spill ; CHECK-NEXT: std 22, -80(1) # 8-byte Folded Spill
; CHECK-NEXT: std 23, -72(1) # 8-byte Folded Spill ; CHECK-NEXT: std 23, -72(1) # 8-byte Folded Spill
▲ Show 20 Lines • Show All 208 Lines • Show Last 20 Lines

llvm/test/CodeGen/PowerPC/memcmp-mergeexpand.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc -verify-machineinstrs -mcpu=pwr8 -mtriple=powerpc64le-unknown-gnu-linux < %s | FileCheck %s -check-prefix=PPC64LE ; RUN: llc -opaque-pointers=0 -verify-machineinstrs -mcpu=pwr8 -mtriple=powerpc64le-unknown-gnu-linux < %s | FileCheck %s -check-prefix=PPC64LE
; This tests interaction between MergeICmp and ExpandMemCmp. ; This tests interaction between MergeICmp and ExpandMemCmp.
%"struct.std::pair" = type { i32, i32 } %"struct.std::pair" = type { i32, i32 }
define zeroext i1 @opeq1( define zeroext i1 @opeq1(
; PPC64LE-LABEL: opeq1: ; PPC64LE-LABEL: opeq1:
; PPC64LE: # %bb.0: # %"entry+land.rhs.i" ; PPC64LE: # %bb.0: # %"entry+land.rhs.i"
Show All 30 Lines

llvm/test/CodeGen/PowerPC/memcmpIR.ll

; RUN: llc -o - -mtriple=powerpc64le-unknown-gnu-linux -stop-after codegenprepare %s | FileCheck %s ; RUN: llc -opaque-pointers=0 -o - -mtriple=powerpc64le-unknown-gnu-linux -stop-after codegenprepare %s | FileCheck %s
; RUN: llc -o - -mtriple=powerpc64-unknown-gnu-linux -stop-after codegenprepare %s | FileCheck %s --check-prefix=CHECK-BE ; RUN: llc -opaque-pointers=0 -o - -mtriple=powerpc64-unknown-gnu-linux -stop-after codegenprepare %s | FileCheck %s --check-prefix=CHECK-BE
define signext i32 @test1(i32* nocapture readonly %buffer1, i32* nocapture readonly %buffer2) { define signext i32 @test1(i32* nocapture readonly %buffer1, i32* nocapture readonly %buffer2) {
entry: entry:
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK: [[LOAD1:%[0-9]+]] = load i64, i64* ; CHECK: [[LOAD1:%[0-9]+]] = load i64, i64*
; CHECK-NEXT: [[LOAD2:%[0-9]+]] = load i64, i64* ; CHECK-NEXT: [[LOAD2:%[0-9]+]] = load i64, i64*
; CHECK-NEXT: [[BSWAP1:%[0-9]+]] = call i64 @llvm.bswap.i64(i64 [[LOAD1]]) ; CHECK-NEXT: [[BSWAP1:%[0-9]+]] = call i64 @llvm.bswap.i64(i64 [[LOAD1]])
; CHECK-NEXT: [[BSWAP2:%[0-9]+]] = call i64 @llvm.bswap.i64(i64 [[LOAD2]]) ; CHECK-NEXT: [[BSWAP2:%[0-9]+]] = call i64 @llvm.bswap.i64(i64 [[LOAD2]])
▲ Show 20 Lines • Show All 182 Lines • Show Last 20 Lines

llvm/test/CodeGen/PowerPC/more-dq-form-prepare.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc -verify-machineinstrs -mcpu=pwr10 < %s | FileCheck %s ; RUN: llc -opaque-pointers=0 -verify-machineinstrs -mcpu=pwr10 < %s | FileCheck %s
target datalayout = "e-m:e-i64:64-p:64:64-n32:64-v256:256:256-v512:512:512" target datalayout = "e-m:e-i64:64-p:64:64-n32:64-v256:256:256-v512:512:512"
target triple = "powerpc64le-unknown-linux-gnu" target triple = "powerpc64le-unknown-linux-gnu"
%_elem_type_of_a = type <{ double }> %_elem_type_of_a = type <{ double }>
%_elem_type_of_x = type <{ double }> %_elem_type_of_x = type <{ double }>
define void @foo(i32* %.m, i32* %.n, [0 x %_elem_type_of_a]* %.a, [0 x %_elem_type_of_x]* %.x, i32* %.l, <2 x double>* %.vy01, <2 x double>* %.vy02, <2 x double>* %.vy03, <2 x double>* %.vy04, <2 x double>* %.vy05, <2 x double>* %.vy06, <2 x double>* %.vy07, <2 x double>* %.vy08, <2 x double>* %.vy09, <2 x double>* %.vy0a, <2 x double>* %.vy0b, <2 x double>* %.vy0c, <2 x double>* %.vy21, <2 x double>* %.vy22, <2 x double>* %.vy23, <2 x double>* %.vy24, <2 x double>* %.vy25, <2 x double>* %.vy26, <2 x double>* %.vy27, <2 x double>* %.vy28, <2 x double>* %.vy29, <2 x double>* %.vy2a, <2 x double>* %.vy2b, <2 x double>* %.vy2c) { define void @foo(i32* %.m, i32* %.n, [0 x %_elem_type_of_a]* %.a, [0 x %_elem_type_of_x]* %.x, i32* %.l, <2 x double>* %.vy01, <2 x double>* %.vy02, <2 x double>* %.vy03, <2 x double>* %.vy04, <2 x double>* %.vy05, <2 x double>* %.vy06, <2 x double>* %.vy07, <2 x double>* %.vy08, <2 x double>* %.vy09, <2 x double>* %.vy0a, <2 x double>* %.vy0b, <2 x double>* %.vy0c, <2 x double>* %.vy21, <2 x double>* %.vy22, <2 x double>* %.vy23, <2 x double>* %.vy24, <2 x double>* %.vy25, <2 x double>* %.vy26, <2 x double>* %.vy27, <2 x double>* %.vy28, <2 x double>* %.vy29, <2 x double>* %.vy2a, <2 x double>* %.vy2b, <2 x double>* %.vy2c) {
▲ Show 20 Lines • Show All 634 Lines • Show Last 20 Lines

llvm/test/CodeGen/PowerPC/p10-fi-elim.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc -verify-machineinstrs -mtriple=powerpc64le-unknown-linux-gnu \ ; RUN: llc -opaque-pointers=0 -verify-machineinstrs -mtriple=powerpc64le-unknown-linux-gnu \
; RUN: -mcpu=pwr10 -ppc-asm-full-reg-names -ppc-vsr-nums-as-vr < %s | \ ; RUN: -mcpu=pwr10 -ppc-asm-full-reg-names -ppc-vsr-nums-as-vr < %s | \
; RUN: FileCheck %s ; RUN: FileCheck %s
; RUN: llc -verify-machineinstrs -mtriple=powerpc64-unknown-linux-gnu \ ; RUN: llc -opaque-pointers=0 -verify-machineinstrs -mtriple=powerpc64-unknown-linux-gnu \
; RUN: -mcpu=pwr10 -ppc-asm-full-reg-names -ppc-vsr-nums-as-vr < %s | \ ; RUN: -mcpu=pwr10 -ppc-asm-full-reg-names -ppc-vsr-nums-as-vr < %s | \
; RUN: FileCheck %s --check-prefix=CHECK-BE ; RUN: FileCheck %s --check-prefix=CHECK-BE
%96 = type <{ i32 }> %96 = type <{ i32 }>
%97 = type <{ i32 }> %97 = type <{ i32 }>
%98 = type <{ i32 }> %98 = type <{ i32 }>
%100 = type <{ i8, i8, i8, i8, i32, i64, i64, [1 x i64], [1 x i64], [1 x i64] }> %100 = type <{ i8, i8, i8, i8, i32, i64, i64, [1 x i64], [1 x i64], [1 x i64] }>
%101 = type <{ i8, i8, i8, i8, i32, i64, i64, [1 x i64], [1 x i64], [1 x i64], [24 x i8] }> %101 = type <{ i8, i8, i8, i8, i32, i64, i64, [1 x i64], [1 x i64], [1 x i64], [24 x i8] }>
▲ Show 20 Lines • Show All 146 Lines • Show Last 20 Lines

llvm/test/CodeGen/PowerPC/ppc64-gep-opt.ll

; RUN: llc -verify-machineinstrs -O3 -mcpu=pwr7 < %s | FileCheck %s ; RUN: llc -opaque-pointers=0 -verify-machineinstrs -O3 -mcpu=pwr7 < %s | FileCheck %s
; RUN: llc -verify-machineinstrs -O3 -print-after=codegenprepare -mcpu=pwr7 < %s >%t 2>&1 && FileCheck --check-prefix=CHECK-UseAA <%t %s ; RUN: llc -opaque-pointers=0 -verify-machineinstrs -O3 -print-after=codegenprepare -mcpu=pwr7 < %s >%t 2>&1 && FileCheck --check-prefix=CHECK-UseAA <%t %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"
; Following test cases test enabling SeparateConstOffsetFromGEP pass in the PPC ; Following test cases test enabling SeparateConstOffsetFromGEP pass in the PPC
; backend. If useAA() returns true, it will lower a GEP with multiple indices ; backend. If useAA() returns true, it will lower a GEP with multiple indices
; into GEPs with a single index, otherwise it will lower it into a ; into GEPs with a single index, otherwise it will lower it into a
; "ptrtoint+arithmetics+inttoptr" form. ; "ptrtoint+arithmetics+inttoptr" form.
▲ Show 20 Lines • Show All 118 Lines • Show Last 20 Lines

llvm/test/CodeGen/PowerPC/pr47373.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc -mtriple=powerpc64-unknown-freebsd13.0 -verify-machineinstrs \ ; RUN: llc -opaque-pointers=0 -mtriple=powerpc64-unknown-freebsd13.0 -verify-machineinstrs \
; RUN: -mcpu=ppc64 -ppc-asm-full-reg-names < %s | FileCheck %s ; RUN: -mcpu=ppc64 -ppc-asm-full-reg-names < %s | FileCheck %s
@a = local_unnamed_addr global float* null, align 8 @a = local_unnamed_addr global float* null, align 8
; Function Attrs: nounwind ; Function Attrs: nounwind
define void @d() local_unnamed_addr #0 { define void @d() local_unnamed_addr #0 {
; CHECK-LABEL: d: ; CHECK-LABEL: d:
; CHECK: # %bb.0: # %entry ; CHECK: # %bb.0: # %entry
; CHECK-NEXT: mflr r0 ; CHECK-NEXT: mflr r0
▲ Show 20 Lines • Show All 170 Lines • Show Last 20 Lines

llvm/test/CodeGen/PowerPC/prefer-dqform.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc -verify-machineinstrs -disable-ppc-instr-form-prep=true -mcpu=pwr9 < %s \ ; RUN: llc -opaque-pointers=0 -verify-machineinstrs -disable-ppc-instr-form-prep=true -mcpu=pwr9 < %s \
; RUN: -ppc-vsr-nums-as-vr -ppc-asm-full-reg-names | FileCheck %s -check-prefix=CHECK-P9 ; RUN: -ppc-vsr-nums-as-vr -ppc-asm-full-reg-names | FileCheck %s -check-prefix=CHECK-P9
; RUN: llc -verify-machineinstrs -disable-ppc-instr-form-prep=true -mcpu=pwr10 < %s \ ; RUN: llc -opaque-pointers=0 -verify-machineinstrs -disable-ppc-instr-form-prep=true -mcpu=pwr10 < %s \
; RUN: -ppc-vsr-nums-as-vr -ppc-asm-full-reg-names | FileCheck %s -check-prefix=CHECK-P10 ; RUN: -ppc-vsr-nums-as-vr -ppc-asm-full-reg-names | FileCheck %s -check-prefix=CHECK-P10
target triple = "powerpc64le-unknown-linux-gnu" target triple = "powerpc64le-unknown-linux-gnu"
%_elem_type_of_a = type <{ double }> %_elem_type_of_a = type <{ double }>
%_elem_type_of_x = type <{ double }> %_elem_type_of_x = type <{ double }>
%_elem_type_of_y = type <{ double }> %_elem_type_of_y = type <{ double }>
▲ Show 20 Lines • Show All 166 Lines • Show Last 20 Lines

llvm/test/CodeGen/Thumb2/LowOverheadLoops/begin-vpt-without-inst.mir

# NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py # NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py
# RUN: llc -mtriple=thumbv8.1m.main -mattr=+mve -run-pass=arm-low-overhead-loops %s -o - | FileCheck %s # RUN: llc -opaque-pointers=0 -mtriple=thumbv8.1m.main -mattr=+mve -run-pass=arm-low-overhead-loops %s -o - | FileCheck %s
--- | --- |
@arr = external dso_local local_unnamed_addr global [0 x i32], align 4 @arr = external dso_local local_unnamed_addr global [0 x i32], align 4
define dso_local arm_aapcs_vfpcc void @foo(i32 %i) { define dso_local arm_aapcs_vfpcc void @foo(i32 %i) {
entry: entry:
%tobool.not11 = icmp eq i32 %i, 0 %tobool.not11 = icmp eq i32 %i, 0
br i1 %tobool.not11, label %for.end5, label %vector.ph.preheader br i1 %tobool.not11, label %for.end5, label %vector.ph.preheader
▲ Show 20 Lines • Show All 107 Lines • Show Last 20 Lines

llvm/test/CodeGen/Thumb2/LowOverheadLoops/fast-fp-loops.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc -mtriple=thumbv8.1m.main -mattr=+mve.fp,+fp-armv8d16sp,+fp16,+fullfp16 -tail-predication=enabled %s -o - | FileCheck %s ; RUN: llc -opaque-pointers=0 -mtriple=thumbv8.1m.main -mattr=+mve.fp,+fp-armv8d16sp,+fp16,+fullfp16 -tail-predication=enabled %s -o - | FileCheck %s
define arm_aapcs_vfpcc void @fast_float_mul(float* nocapture %a, float* nocapture readonly %b, float* nocapture readonly %c, i32 %N) { define arm_aapcs_vfpcc void @fast_float_mul(float* nocapture %a, float* nocapture readonly %b, float* nocapture readonly %c, i32 %N) {
; CHECK-LABEL: fast_float_mul: ; CHECK-LABEL: fast_float_mul:
; CHECK: @ %bb.0: @ %entry ; CHECK: @ %bb.0: @ %entry
; CHECK-NEXT: push {r4, r5, r6, r7, lr} ; CHECK-NEXT: push {r4, r5, r6, r7, lr}
; CHECK-NEXT: cmp r3, #0 ; CHECK-NEXT: cmp r3, #0
; CHECK-NEXT: beq.w .LBB0_11 ; CHECK-NEXT: beq.w .LBB0_11
; CHECK-NEXT: @ %bb.1: @ %vector.memcheck ; CHECK-NEXT: @ %bb.1: @ %vector.memcheck
▲ Show 20 Lines • Show All 499 Lines • Show Last 20 Lines

llvm/test/CodeGen/Thumb2/LowOverheadLoops/memcall.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc --arm-memtransfer-tploop=allow -mtriple=thumbv8.1m.main-none-none-eabi -mattr=+mve.fp -verify-machineinstrs -tail-predication=enabled -o - %s | FileCheck %s ; RUN: llc -opaque-pointers=0 --arm-memtransfer-tploop=allow -mtriple=thumbv8.1m.main-none-none-eabi -mattr=+mve.fp -verify-machineinstrs -tail-predication=enabled -o - %s | FileCheck %s
define void @test_memcpy(i32* nocapture %x, i32* nocapture readonly %y, i32 %n, i32 %m) { define void @test_memcpy(i32* nocapture %x, i32* nocapture readonly %y, i32 %n, i32 %m) {
; CHECK-LABEL: test_memcpy: ; CHECK-LABEL: test_memcpy:
; CHECK: @ %bb.0: @ %entry ; CHECK: @ %bb.0: @ %entry
; CHECK-NEXT: .save {r4, r5, r6, r7, lr} ; CHECK-NEXT: .save {r4, r5, r6, r7, lr}
; CHECK-NEXT: push {r4, r5, r6, r7, lr} ; CHECK-NEXT: push {r4, r5, r6, r7, lr}
; CHECK-NEXT: cmp r2, #1 ; CHECK-NEXT: cmp r2, #1
; CHECK-NEXT: blt .LBB0_5 ; CHECK-NEXT: blt .LBB0_5
▲ Show 20 Lines • Show All 325 Lines • Show Last 20 Lines

llvm/test/CodeGen/Thumb2/LowOverheadLoops/spillingmove.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc -mtriple=thumbv8.1m.main -mattr=+mve --verify-machineinstrs %s -o - | FileCheck %s ; RUN: llc -opaque-pointers=0 -mtriple=thumbv8.1m.main -mattr=+mve --verify-machineinstrs %s -o - | FileCheck %s
%struct.arm_2d_size_t = type { i16, i16 } %struct.arm_2d_size_t = type { i16, i16 }
define void @__arm_2d_impl_rgb16_colour_filling_with_alpha(i16* noalias nocapture %phwTargetBase, i16 signext %iTargetStride, %struct.arm_2d_size_t* noalias nocapture readonly %ptCopySize, i16 zeroext %hwColour, i32 %chRatio) { define void @__arm_2d_impl_rgb16_colour_filling_with_alpha(i16* noalias nocapture %phwTargetBase, i16 signext %iTargetStride, %struct.arm_2d_size_t* noalias nocapture readonly %ptCopySize, i16 zeroext %hwColour, i32 %chRatio) {
; CHECK-LABEL: __arm_2d_impl_rgb16_colour_filling_with_alpha: ; CHECK-LABEL: __arm_2d_impl_rgb16_colour_filling_with_alpha:
; CHECK: @ %bb.0: @ %entry ; CHECK: @ %bb.0: @ %entry
; CHECK-NEXT: push {r4, r5, r6, r7, lr} ; CHECK-NEXT: push {r4, r5, r6, r7, lr}
; CHECK-NEXT: sub sp, #4 ; CHECK-NEXT: sub sp, #4
; CHECK-NEXT: vpush {d8, d9, d10, d11, d12, d13, d14, d15} ; CHECK-NEXT: vpush {d8, d9, d10, d11, d12, d13, d14, d15}
▲ Show 20 Lines • Show All 361 Lines • Show Last 20 Lines

llvm/test/CodeGen/Thumb2/LowOverheadLoops/tail-pred-reduce.ll

; RUN: opt -mtriple=thumbv8.1m.main -mve-tail-predication -tail-predication=enabled -mattr=+mve %s -S -o - | FileCheck %s ; RUN: opt -opaque-pointers=0 -mtriple=thumbv8.1m.main -mve-tail-predication -tail-predication=enabled -mattr=+mve %s -S -o - | FileCheck %s
; CHECK-LABEL: reduction_i32 ; CHECK-LABEL: reduction_i32
; CHECK: phi i32 [ 0, %vector.ph ] ; CHECK: phi i32 [ 0, %vector.ph ]
; CHECK: phi <8 x i16> [ zeroinitializer, %vector.ph ] ; CHECK: phi <8 x i16> [ zeroinitializer, %vector.ph ]
; CHECK: phi i32 ; CHECK: phi i32
; CHECK: [[PHI:%[^ ]+]] = phi i32 [ %N, %vector.ph ], [ [[ELEMS:%[^ ]+]], %vector.body ] ; CHECK: [[PHI:%[^ ]+]] = phi i32 [ %N, %vector.ph ], [ [[ELEMS:%[^ ]+]], %vector.body ]
; CHECK: [[VCTP:%[^ ]+]] = call <8 x i1> @llvm.arm.mve.vctp16(i32 [[PHI]]) ; CHECK: [[VCTP:%[^ ]+]] = call <8 x i1> @llvm.arm.mve.vctp16(i32 [[PHI]])
; CHECK: [[ELEMS]] = sub i32 [[PHI]], 8 ; CHECK: [[ELEMS]] = sub i32 [[PHI]], 8
▲ Show 20 Lines • Show All 253 Lines • Show Last 20 Lines

llvm/test/CodeGen/Thumb2/mve-float16regloops.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc -mtriple=thumbv8.1m.main-none-none-eabi -mattr=+mve.fp -verify-machineinstrs %s -o - | FileCheck %s ; RUN: llc -opaque-pointers=0 -mtriple=thumbv8.1m.main-none-none-eabi -mattr=+mve.fp -verify-machineinstrs %s -o - | FileCheck %s
define arm_aapcs_vfpcc void @test_fadd(half* noalias nocapture readonly %A, half %B, half* noalias nocapture %C, i32 %n) { define arm_aapcs_vfpcc void @test_fadd(half* noalias nocapture readonly %A, half %B, half* noalias nocapture %C, i32 %n) {
; CHECK-LABEL: test_fadd: ; CHECK-LABEL: test_fadd:
; CHECK: @ %bb.0: @ %entry ; CHECK: @ %bb.0: @ %entry
; CHECK-NEXT: cmp r2, #1 ; CHECK-NEXT: cmp r2, #1
; CHECK-NEXT: it lt ; CHECK-NEXT: it lt
; CHECK-NEXT: bxlt lr ; CHECK-NEXT: bxlt lr
; CHECK-NEXT: .LBB0_1: @ %vector.ph ; CHECK-NEXT: .LBB0_1: @ %vector.ph
▲ Show 20 Lines • Show All 1,631 Lines • Show Last 20 Lines

llvm/test/CodeGen/Thumb2/mve-float32regloops.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc -mtriple=thumbv8.1m.main-none-none-eabi -mattr=+mve.fp -verify-machineinstrs %s -o - | FileCheck %s ; RUN: llc -opaque-pointers=0 -mtriple=thumbv8.1m.main-none-none-eabi -mattr=+mve.fp -verify-machineinstrs %s -o - | FileCheck %s
define arm_aapcs_vfpcc void @test_fadd(float* noalias nocapture readonly %A, float %B, float* noalias nocapture %C, i32 %n) { define arm_aapcs_vfpcc void @test_fadd(float* noalias nocapture readonly %A, float %B, float* noalias nocapture %C, i32 %n) {
; CHECK-LABEL: test_fadd: ; CHECK-LABEL: test_fadd:
; CHECK: @ %bb.0: @ %entry ; CHECK: @ %bb.0: @ %entry
; CHECK-NEXT: cmp r2, #1 ; CHECK-NEXT: cmp r2, #1
; CHECK-NEXT: it lt ; CHECK-NEXT: it lt
; CHECK-NEXT: bxlt lr ; CHECK-NEXT: bxlt lr
; CHECK-NEXT: .LBB0_1: @ %vector.ph ; CHECK-NEXT: .LBB0_1: @ %vector.ph
▲ Show 20 Lines • Show All 2,221 Lines • Show Last 20 Lines

llvm/test/CodeGen/Thumb2/mve-gather-ptrs.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc -mtriple=thumbv8.1m.main-none-none-eabi -mattr=+mve.fp -enable-arm-maskedldst %s -o - | FileCheck %s --check-prefixes=CHECK,CHECK-STD ; RUN: llc -opaque-pointers=0 -mtriple=thumbv8.1m.main-none-none-eabi -mattr=+mve.fp -enable-arm-maskedldst %s -o - | FileCheck %s --check-prefixes=CHECK,CHECK-STD
; RUN: llc -mtriple=thumbv8.1m.main-none-none-eabi -mattr=+mve.fp -enable-arm-maskedldst -opaque-pointers %s -o - | FileCheck %s --check-prefixes=CHECK,CHECK-OPAQ ; RUN: llc -opaque-pointers=0 -mtriple=thumbv8.1m.main-none-none-eabi -mattr=+mve.fp -enable-arm-maskedldst -opaque-pointers %s -o - | FileCheck %s --check-prefixes=CHECK,CHECK-OPAQ
; i32 ; i32
define arm_aapcs_vfpcc <2 x i32> @ptr_v2i32(<2 x i32*>* %offptr) { define arm_aapcs_vfpcc <2 x i32> @ptr_v2i32(<2 x i32*>* %offptr) {
; CHECK-LABEL: ptr_v2i32: ; CHECK-LABEL: ptr_v2i32:
; CHECK: @ %bb.0: @ %entry ; CHECK: @ %bb.0: @ %entry
; CHECK-NEXT: ldrd r1, r0, [r0] ; CHECK-NEXT: ldrd r1, r0, [r0]
; CHECK-NEXT: ldr r0, [r0] ; CHECK-NEXT: ldr r0, [r0]
▲ Show 20 Lines • Show All 920 Lines • Show Last 20 Lines

llvm/test/CodeGen/Thumb2/mve-intrinsics/v2i1-upgrade.ll

; 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 - %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -S -o - %s | FileCheck %s
declare <4 x i1> @llvm.arm.mve.vctp64(i32) declare <4 x i1> @llvm.arm.mve.vctp64(i32)
declare <4 x i1> @llvm.arm.mve.pred.i2v.v4i1(i32) declare <4 x i1> @llvm.arm.mve.pred.i2v.v4i1(i32)
declare i32 @llvm.arm.mve.pred.v2i.v4i1(<4 x i1>) declare i32 @llvm.arm.mve.pred.v2i.v4i1(<4 x i1>)
declare <2 x i64> @llvm.arm.mve.mull.int.predicated.v2i64.v4i32.v4i1(<4 x i32>, <4 x i32>, i32, i32, <4 x i1>, <2 x i64>) declare <2 x i64> @llvm.arm.mve.mull.int.predicated.v2i64.v4i32.v4i1(<4 x i32>, <4 x i32>, i32, i32, <4 x i1>, <2 x i64>)
declare <2 x i64> @llvm.arm.mve.vqdmull.predicated.v2i64.v4i32.v4i1(<4 x i32>, <4 x i32>, i32, <4 x i1>, <2 x i64>) declare <2 x i64> @llvm.arm.mve.vqdmull.predicated.v2i64.v4i32.v4i1(<4 x i32>, <4 x i32>, i32, <4 x i1>, <2 x i64>)
declare <2 x i64> @llvm.arm.mve.vldr.gather.base.predicated.v2i64.v2i64.v4i1(<2 x i64>, i32, <4 x i1>) declare <2 x i64> @llvm.arm.mve.vldr.gather.base.predicated.v2i64.v2i64.v4i1(<2 x i64>, i32, <4 x i1>)
▲ Show 20 Lines • Show All 322 Lines • Show Last 20 Lines

llvm/test/CodeGen/Thumb2/mve-postinc-dct.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc -mtriple=thumbv8.1m.main-none-none-eabi -mattr=+mve.fp %s -o - | FileCheck %s ; RUN: llc -opaque-pointers=0 -mtriple=thumbv8.1m.main-none-none-eabi -mattr=+mve.fp %s -o - | FileCheck %s
%struct.DCT_InstanceTypeDef = type { float*, i32, i32 } %struct.DCT_InstanceTypeDef = type { float*, i32, i32 }
define void @DCT_mve1(%struct.DCT_InstanceTypeDef* nocapture readonly %S, float* nocapture readonly %pIn, float* nocapture %pOut) { define void @DCT_mve1(%struct.DCT_InstanceTypeDef* nocapture readonly %S, float* nocapture readonly %pIn, float* nocapture %pOut) {
; CHECK-LABEL: DCT_mve1: ; CHECK-LABEL: DCT_mve1:
; CHECK: @ %bb.0: @ %entry ; CHECK: @ %bb.0: @ %entry
; CHECK-NEXT: .save {r4, r5, r6, r7, r8, r9, lr} ; CHECK-NEXT: .save {r4, r5, r6, r7, r8, r9, lr}
; CHECK-NEXT: push.w {r4, r5, r6, r7, r8, r9, lr} ; CHECK-NEXT: push.w {r4, r5, r6, r7, r8, r9, lr}
▲ Show 20 Lines • Show All 1,648 Lines • Show Last 20 Lines

llvm/test/CodeGen/WebAssembly/add-prototypes-conflict.ll

; RUN: opt -S -wasm-add-missing-prototypes -o %t.ll %s 2>&1 | FileCheck %s -check-prefix=WARNING ; RUN: opt -opaque-pointers=0 -S -wasm-add-missing-prototypes -o %t.ll %s 2>&1 | FileCheck %s -check-prefix=WARNING
; RUN: cat %t.ll | FileCheck %s ; RUN: cat %t.ll | FileCheck %s
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown" target triple = "wasm32-unknown-unknown"
; WARNING: warning: prototype-less function used with conflicting signatures: foo ; WARNING: warning: prototype-less function used with conflicting signatures: foo
; CHECK-LABEL: @call_with_conflicting_prototypes ; CHECK-LABEL: @call_with_conflicting_prototypes
Show All 13 Lines

llvm/test/CodeGen/WebAssembly/lower-em-ehsjlj.ll

; RUN: opt < %s -wasm-lower-em-ehsjlj -enable-emscripten-cxx-exceptions -enable-emscripten-sjlj -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -wasm-lower-em-ehsjlj -enable-emscripten-cxx-exceptions -enable-emscripten-sjlj -S | FileCheck %s
; RUN: llc < %s -enable-emscripten-cxx-exceptions -enable-emscripten-sjlj -verify-machineinstrs ; RUN: llc -opaque-pointers=0 < %s -enable-emscripten-cxx-exceptions -enable-emscripten-sjlj -verify-machineinstrs
; Tests for cases when exception handling and setjmp/longjmp handling are mixed. ; Tests for cases when exception handling and setjmp/longjmp handling are mixed.
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown" target triple = "wasm32-unknown-unknown"
%struct.__jmp_buf_tag = type { [6 x i32], i32, [32 x i32] } %struct.__jmp_buf_tag = type { [6 x i32], i32, [32 x i32] }
@_ZTIi = external constant i8* @_ZTIi = external constant i8*
▲ Show 20 Lines • Show All 274 Lines • Show Last 20 Lines

llvm/test/CodeGen/WebAssembly/lower-em-exceptions.ll

; RUN: opt < %s -wasm-lower-em-ehsjlj -enable-emscripten-cxx-exceptions -S | FileCheck %s -DPTR=i32 ; RUN: opt -opaque-pointers=0 < %s -wasm-lower-em-ehsjlj -enable-emscripten-cxx-exceptions -S | FileCheck %s -DPTR=i32
; RUN: opt < %s -wasm-lower-em-ehsjlj -enable-emscripten-cxx-exceptions -S --mattr=+atomics,+bulk-memory | FileCheck %s -DPTR=i32 ; RUN: opt -opaque-pointers=0 < %s -wasm-lower-em-ehsjlj -enable-emscripten-cxx-exceptions -S --mattr=+atomics,+bulk-memory | FileCheck %s -DPTR=i32
; RUN: opt < %s -wasm-lower-em-ehsjlj -enable-emscripten-cxx-exceptions --mtriple=wasm64-unknown-unknown -data-layout="e-m:e-p:64:64-i64:64-n32:64-S128" -S | FileCheck %s -DPTR=i64 ; RUN: opt -opaque-pointers=0 < %s -wasm-lower-em-ehsjlj -enable-emscripten-cxx-exceptions --mtriple=wasm64-unknown-unknown -data-layout="e-m:e-p:64:64-i64:64-n32:64-S128" -S | FileCheck %s -DPTR=i64
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown" target triple = "wasm32-unknown-unknown"
@_ZTIi = external constant i8* @_ZTIi = external constant i8*
@_ZTIc = external constant i8* @_ZTIc = external constant i8*
; CHECK: @__THREW__ = external thread_local global [[PTR]] ; CHECK: @__THREW__ = external thread_local global [[PTR]]
; __threwValue is only used in Emscripten SjLj, so it shouldn't be generated. ; __threwValue is only used in Emscripten SjLj, so it shouldn't be generated.
▲ Show 20 Lines • Show All 165 Lines • Show Last 20 Lines

llvm/test/CodeGen/WebAssembly/lower-em-sjlj-debuginfo.ll

; RUN: opt < %s -wasm-lower-em-ehsjlj -enable-emscripten-sjlj -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -wasm-lower-em-ehsjlj -enable-emscripten-sjlj -S | FileCheck %s
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown" target triple = "wasm32-unknown-unknown"
%struct.__jmp_buf_tag = type { [6 x i32], i32, [32 x i32] } %struct.__jmp_buf_tag = type { [6 x i32], i32, [32 x i32] }
; Basic debug info test. All existing instructions have debug info and inserted ; Basic debug info test. All existing instructions have debug info and inserted
; 'malloc' and 'free' calls take debug info from the next instruction. ; 'malloc' and 'free' calls take debug info from the next instruction.
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

llvm/test/CodeGen/WebAssembly/lower-em-sjlj.ll

; RUN: opt < %s -wasm-lower-em-ehsjlj -enable-emscripten-sjlj -S | FileCheck %s -DPTR=i32 ; RUN: opt -opaque-pointers=0 < %s -wasm-lower-em-ehsjlj -enable-emscripten-sjlj -S | FileCheck %s -DPTR=i32
; RUN: opt < %s -wasm-lower-em-ehsjlj -enable-emscripten-sjlj -S --mattr=+atomics,+bulk-memory | FileCheck %s -DPTR=i32 ; RUN: opt -opaque-pointers=0 < %s -wasm-lower-em-ehsjlj -enable-emscripten-sjlj -S --mattr=+atomics,+bulk-memory | FileCheck %s -DPTR=i32
; RUN: opt < %s -wasm-lower-em-ehsjlj -enable-emscripten-sjlj --mtriple=wasm64-unknown-unknown -data-layout="e-m:e-p:64:64-i64:64-n32:64-S128" -S | FileCheck %s -DPTR=i64 ; RUN: opt -opaque-pointers=0 < %s -wasm-lower-em-ehsjlj -enable-emscripten-sjlj --mtriple=wasm64-unknown-unknown -data-layout="e-m:e-p:64:64-i64:64-n32:64-S128" -S | FileCheck %s -DPTR=i64
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown" target triple = "wasm32-unknown-unknown"
%struct.__jmp_buf_tag = type { [6 x i32], i32, [32 x i32] } %struct.__jmp_buf_tag = type { [6 x i32], i32, [32 x i32] }
@global_var = global i32 0, align 4 @global_var = global i32 0, align 4
@global_longjmp_ptr = global void (%struct.__jmp_buf_tag*, i32)* @longjmp, align 4 @global_longjmp_ptr = global void (%struct.__jmp_buf_tag*, i32)* @longjmp, align 4
▲ Show 20 Lines • Show All 337 Lines • Show Last 20 Lines

llvm/test/CodeGen/WebAssembly/lower-wasm-ehsjlj.ll

; RUN: opt < %s -wasm-lower-em-ehsjlj -wasm-enable-eh -wasm-enable-sjlj -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -wasm-lower-em-ehsjlj -wasm-enable-eh -wasm-enable-sjlj -S | FileCheck %s
; RUN: llc < %s -wasm-enable-eh -wasm-enable-sjlj -exception-model=wasm -mattr=+exception-handling -verify-machineinstrs ; RUN: llc -opaque-pointers=0 < %s -wasm-enable-eh -wasm-enable-sjlj -exception-model=wasm -mattr=+exception-handling -verify-machineinstrs
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown" target triple = "wasm32-unknown-unknown"
%struct.__jmp_buf_tag = type { [6 x i32], i32, [32 x i32] } %struct.__jmp_buf_tag = type { [6 x i32], i32, [32 x i32] }
%struct.Temp = type { i8 } %struct.Temp = type { i8 }
@_ZL3buf = internal global [1 x %struct.__jmp_buf_tag] zeroinitializer, align 16 @_ZL3buf = internal global [1 x %struct.__jmp_buf_tag] zeroinitializer, align 16
▲ Show 20 Lines • Show All 306 Lines • Show Last 20 Lines

llvm/test/CodeGen/WebAssembly/lower-wasm-sjlj.ll

; RUN: opt < %s -wasm-lower-em-ehsjlj -wasm-enable-sjlj -S | FileCheck %s -DPTR=i32 ; RUN: opt -opaque-pointers=0 < %s -wasm-lower-em-ehsjlj -wasm-enable-sjlj -S | FileCheck %s -DPTR=i32
; RUN: opt < %s -wasm-lower-em-ehsjlj -wasm-enable-sjlj -S --mattr=+atomics,+bulk-memory | FileCheck %s -DPTR=i32 ; RUN: opt -opaque-pointers=0 < %s -wasm-lower-em-ehsjlj -wasm-enable-sjlj -S --mattr=+atomics,+bulk-memory | FileCheck %s -DPTR=i32
; RUN: opt < %s -wasm-lower-em-ehsjlj -wasm-enable-sjlj --mtriple=wasm64-unknown-unknown -data-layout="e-m:e-p:64:64-i64:64-n32:64-S128" -S | FileCheck %s -DPTR=i64 ; RUN: opt -opaque-pointers=0 < %s -wasm-lower-em-ehsjlj -wasm-enable-sjlj --mtriple=wasm64-unknown-unknown -data-layout="e-m:e-p:64:64-i64:64-n32:64-S128" -S | FileCheck %s -DPTR=i64
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown" target triple = "wasm32-unknown-unknown"
%struct.__jmp_buf_tag = type { [6 x i32], i32, [32 x i32] } %struct.__jmp_buf_tag = type { [6 x i32], i32, [32 x i32] }
; These variables are only used in Emscripten EH/SjLj, so they shouldn't be ; These variables are only used in Emscripten EH/SjLj, so they shouldn't be
; generated. ; generated.
▲ Show 20 Lines • Show All 154 Lines • Show Last 20 Lines

llvm/test/CodeGen/WebAssembly/wasmehprepare.ll

; RUN: opt < %s -winehprepare -demote-catchswitch-only -wasmehprepare -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -winehprepare -demote-catchswitch-only -wasmehprepare -S | FileCheck %s
; RUN: opt < %s -winehprepare -demote-catchswitch-only -wasmehprepare -S --mattr=+atomics,+bulk-memory | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -winehprepare -demote-catchswitch-only -wasmehprepare -S --mattr=+atomics,+bulk-memory | FileCheck %s
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown" target triple = "wasm32-unknown-unknown"
; CHECK: @__wasm_lpad_context = external thread_local global { i32, i8*, i32 } ; CHECK: @__wasm_lpad_context = external thread_local global { i32, i8*, i32 }
@_ZTIi = external constant i8* @_ZTIi = external constant i8*
%struct.Temp = type { i8 } %struct.Temp = type { i8 }
▲ Show 20 Lines • Show All 268 Lines • Show Last 20 Lines

llvm/test/CodeGen/WinEH/wineh-intrinsics-invalid.ll

; RUN: sed -e s/.T1:// %s | not opt -passes=lint -disable-output 2>&1 | FileCheck --check-prefix=CHECK1 %s ; RUN: sed -e s/.T1:// %s | not opt -opaque-pointers=0 -passes=lint -disable-output 2>&1 | FileCheck --check-prefix=CHECK1 %s
; RUN: sed -e s/.T2:// %s | not opt -passes=lint -disable-output 2>&1 | FileCheck --check-prefix=CHECK2 %s ; RUN: sed -e s/.T2:// %s | not opt -opaque-pointers=0 -passes=lint -disable-output 2>&1 | FileCheck --check-prefix=CHECK2 %s
target triple = "x86_64-pc-windows-msvc" target triple = "x86_64-pc-windows-msvc"
declare void @f() declare void @f()
;T1: declare i8* @llvm.eh.exceptionpointer.p0i8(i32) ;T1: declare i8* @llvm.eh.exceptionpointer.p0i8(i32)
;T1: ;T1:
;T1: define void @test1() personality i32 (...)* @__CxxFrameHandler3 { ;T1: define void @test1() personality i32 (...)* @__CxxFrameHandler3 {
Show All 16 Lines

llvm/test/CodeGen/X86/StackColoring-use-between-allocas.mir

# NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py # NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py
# RUN: llc -run-pass=stack-coloring %s -o - | FileCheck %s # RUN: llc -opaque-pointers=0 -run-pass=stack-coloring %s -o - | FileCheck %s
## %tmpcast is between 2 allocas. %ref.tmp will replaced by %tmp. Make sure ## %tmpcast is between 2 allocas. %ref.tmp will replaced by %tmp. Make sure
## that we reorder %tmp to be before the use in %tmpcast. ## that we reorder %tmp to be before the use in %tmpcast.
# CHECK: %a = alloca %struct.e, align 1 # CHECK: %a = alloca %struct.e, align 1
# CHECK: %tmp = alloca %"struct.e::f", align 8 # CHECK: %tmp = alloca %"struct.e::f", align 8
# CHECK: %0 = bitcast %"struct.e::f"* %tmp to { <2 x float>, <2 x float> }* # CHECK: %0 = bitcast %"struct.e::f"* %tmp to { <2 x float>, <2 x float> }*
# CHECK: %ref.tmp = alloca { <2 x float>, <2 x float> }, align 8 # CHECK: %ref.tmp = alloca { <2 x float>, <2 x float> }, align 8
▲ Show 20 Lines • Show All 202 Lines • Show Last 20 Lines

llvm/test/CodeGen/X86/addrsig.ll

; RUN: llc < %s -mtriple=x86_64-unknown-linux | FileCheck --check-prefix=NO-ADDRSIG %s ; RUN: llc -opaque-pointers=0 < %s -mtriple=x86_64-unknown-linux | FileCheck --check-prefix=NO-ADDRSIG %s
; RUN: llc < %s -mtriple=x86_64-unknown-linux -addrsig | FileCheck %s ; RUN: llc -opaque-pointers=0 < %s -mtriple=x86_64-unknown-linux -addrsig | FileCheck %s
; RUN: llc %s -filetype=obj -mtriple=x86_64-unknown-linux -addrsig -o %t ; RUN: llc -opaque-pointers=0 %s -filetype=obj -mtriple=x86_64-unknown-linux -addrsig -o %t
; RUN: llvm-readobj --addrsig %t | FileCheck %s --check-prefix=SYM ; RUN: llvm-readobj --addrsig %t | FileCheck %s --check-prefix=SYM
; NO-ADDRSIG-NOT: .addrsig ; NO-ADDRSIG-NOT: .addrsig
; SYM: Addrsig [ ; SYM: Addrsig [
; SYM-NEXT: Sym: f1 ; SYM-NEXT: Sym: f1
; SYM-NEXT: Sym: metadata_f2 ; SYM-NEXT: Sym: metadata_f2
; SYM-NEXT: Sym: g1 ; SYM-NEXT: Sym: g1
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

llvm/test/CodeGen/X86/atomic-unordered.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc -O0 < %s -mtriple=x86_64-linux-generic -verify-machineinstrs -mcpu=skylake -x86-experimental-unordered-atomic-isel=0 | FileCheck --check-prefixes=CHECK,CHECK-O0,CHECK-O0-CUR %s ; RUN: llc -opaque-pointers=0 -O0 < %s -mtriple=x86_64-linux-generic -verify-machineinstrs -mcpu=skylake -x86-experimental-unordered-atomic-isel=0 | FileCheck --check-prefixes=CHECK,CHECK-O0,CHECK-O0-CUR %s
; RUN: llc -O3 < %s -mtriple=x86_64-linux-generic -verify-machineinstrs -mcpu=skylake -x86-experimental-unordered-atomic-isel=0 | FileCheck --check-prefixes=CHECK,CHECK-O3,CHECK-O3-CUR %s ; RUN: llc -opaque-pointers=0 -O3 < %s -mtriple=x86_64-linux-generic -verify-machineinstrs -mcpu=skylake -x86-experimental-unordered-atomic-isel=0 | FileCheck --check-prefixes=CHECK,CHECK-O3,CHECK-O3-CUR %s
; RUN: llc -O0 < %s -mtriple=x86_64-linux-generic -verify-machineinstrs -mcpu=skylake -x86-experimental-unordered-atomic-isel=1 | FileCheck --check-prefixes=CHECK,CHECK-O0,CHECK-O0-EX %s ; RUN: llc -opaque-pointers=0 -O0 < %s -mtriple=x86_64-linux-generic -verify-machineinstrs -mcpu=skylake -x86-experimental-unordered-atomic-isel=1 | FileCheck --check-prefixes=CHECK,CHECK-O0,CHECK-O0-EX %s
; RUN: llc -O3 < %s -mtriple=x86_64-linux-generic -verify-machineinstrs -mcpu=skylake -x86-experimental-unordered-atomic-isel=1 | FileCheck --check-prefixes=CHECK,CHECK-O3,CHECK-O3-EX %s ; RUN: llc -opaque-pointers=0 -O3 < %s -mtriple=x86_64-linux-generic -verify-machineinstrs -mcpu=skylake -x86-experimental-unordered-atomic-isel=1 | FileCheck --check-prefixes=CHECK,CHECK-O3,CHECK-O3-EX %s
define i8 @load_i8(i8* %ptr) { define i8 @load_i8(i8* %ptr) {
; CHECK-O0-LABEL: load_i8: ; CHECK-O0-LABEL: load_i8:
; CHECK-O0: # %bb.0: ; CHECK-O0: # %bb.0:
; CHECK-O0-NEXT: movb (%rdi), %al ; CHECK-O0-NEXT: movb (%rdi), %al
; CHECK-O0-NEXT: retq ; CHECK-O0-NEXT: retq
; ;
; CHECK-O3-LABEL: load_i8: ; CHECK-O3-LABEL: load_i8:
▲ Show 20 Lines • Show All 2,699 Lines • Show Last 20 Lines

llvm/test/CodeGen/X86/atomic64.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc < %s -O0 -mtriple=x86_64-- -mcpu=corei7 -verify-machineinstrs | FileCheck %s --check-prefix X64 ; RUN: llc -opaque-pointers=0 < %s -O0 -mtriple=x86_64-- -mcpu=corei7 -verify-machineinstrs | FileCheck %s --check-prefix X64
; RUN: llc < %s -O0 -mtriple=i386-- -mcpu=i486 -verify-machineinstrs | FileCheck %s --check-prefix I486 ; RUN: llc -opaque-pointers=0 < %s -O0 -mtriple=i386-- -mcpu=i486 -verify-machineinstrs | FileCheck %s --check-prefix I486
@sc64 = external dso_local global i64 @sc64 = external dso_local global i64
@fsc64 = external dso_local global double @fsc64 = external dso_local global double
@psc64 = external dso_local global i8* @psc64 = external dso_local global i8*
define void @atomic_fetch_add64() nounwind { define void @atomic_fetch_add64() nounwind {
; X64-LABEL: atomic_fetch_add64: ; X64-LABEL: atomic_fetch_add64:
; X64: # %bb.0: # %entry ; X64: # %bb.0: # %entry
▲ Show 20 Lines • Show All 782 Lines • Show Last 20 Lines

llvm/test/CodeGen/X86/catchpad-lifetime.ll

; RUN: llc -mtriple=x86_64-windows-msvc < %s | FileCheck %s --check-prefix=X64 ; RUN: llc -opaque-pointers=0 -mtriple=x86_64-windows-msvc < %s | FileCheck %s --check-prefix=X64
; RUN: llc -mtriple=i686-windows-msvc < %s | FileCheck %s --check-prefix=X86 ; RUN: llc -opaque-pointers=0 -mtriple=i686-windows-msvc < %s | FileCheck %s --check-prefix=X86
declare void @throw() declare void @throw()
declare i32 @__CxxFrameHandler3(...) declare i32 @__CxxFrameHandler3(...)
declare void @llvm.trap() declare void @llvm.trap()
define void @test1() personality i32 (...)* @__CxxFrameHandler3 { define void @test1() personality i32 (...)* @__CxxFrameHandler3 {
▲ Show 20 Lines • Show All 120 Lines • Show Last 20 Lines

llvm/test/CodeGen/X86/cfguard-checks.ll

; RUN: llc < %s -mtriple=i686-pc-windows-msvc | FileCheck %s -check-prefix=X32 ; RUN: llc -opaque-pointers=0 < %s -mtriple=i686-pc-windows-msvc | FileCheck %s -check-prefix=X32
; RUN: llc < %s -mtriple=x86_64-pc-windows-msvc | FileCheck %s -check-prefixes=X64,X64_MSVC ; RUN: llc -opaque-pointers=0 < %s -mtriple=x86_64-pc-windows-msvc | FileCheck %s -check-prefixes=X64,X64_MSVC
; RUN: llc < %s -mtriple=i686-w64-windows-gnu | FileCheck %s -check-prefixes=X32,X32_MINGW ; RUN: llc -opaque-pointers=0 < %s -mtriple=i686-w64-windows-gnu | FileCheck %s -check-prefixes=X32,X32_MINGW
; RUN: llc < %s -mtriple=x86_64-w64-windows-gnu | FileCheck %s -check-prefixes=X64,X64_MINGW ; RUN: llc -opaque-pointers=0 < %s -mtriple=x86_64-w64-windows-gnu | FileCheck %s -check-prefixes=X64,X64_MINGW
; Control Flow Guard is currently only available on Windows ; Control Flow Guard is currently only available on Windows
; Test that Control Flow Guard checks are correctly added when required. ; Test that Control Flow Guard checks are correctly added when required.
declare i32 @target_func() declare i32 @target_func()
▲ Show 20 Lines • Show All 259 Lines • Show Last 20 Lines

llvm/test/CodeGen/X86/codegen-prepare-cast.ll

; RUN: llc < %s ; RUN: llc -opaque-pointers=0 < %s
; PR4297 ; PR4297
; RUN: opt -S < %s -codegenprepare | FileCheck %s ; RUN: opt -opaque-pointers=0 -S < %s -codegenprepare | 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" "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-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-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
%"byte[]" = type { i64, i8* } %"byte[]" = type { i64, i8* }
%"char[][]" = type { i64, %"byte[]"* } %"char[][]" = type { i64, %"byte[]"* }
@.str = external dso_local constant [7 x i8] ; <[7 x i8]*> [#uses=1] @.str = external dso_local constant [7 x i8] ; <[7 x i8]*> [#uses=1]
Show All 17 Lines

llvm/test/CodeGen/X86/dag-update-nodetomatch.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc < %s -mtriple=x86_64-unknown-linux-gnu | FileCheck %s ; RUN: llc -opaque-pointers=0 < %s -mtriple=x86_64-unknown-linux-gnu | FileCheck %s
%struct.i = type { i32, i24 } %struct.i = type { i32, i24 }
%struct.m = type { %struct.i } %struct.m = type { %struct.i }
@a = local_unnamed_addr global i32 0, align 4 @a = local_unnamed_addr global i32 0, align 4
@b = local_unnamed_addr global i16 0, align 2 @b = local_unnamed_addr global i16 0, align 2
@c = local_unnamed_addr global i16 0, align 2 @c = local_unnamed_addr global i16 0, align 2
@e = local_unnamed_addr global i16 0, align 2 @e = local_unnamed_addr global i16 0, align 2
▲ Show 20 Lines • Show All 442 Lines • Show Last 20 Lines

llvm/test/CodeGen/X86/fold-call-3.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc < %s -mtriple=x86_64-apple-darwin | FileCheck %s ; RUN: llc -opaque-pointers=0 < %s -mtriple=x86_64-apple-darwin | FileCheck %s
; rdar://6522427 ; rdar://6522427
; This command line used to crash due to dangling nodes left after PreprocessISelDAG ; This command line used to crash due to dangling nodes left after PreprocessISelDAG
; RUN: llc < %s -mtriple=x86_64-apple-darwin -pre-RA-sched=linearize | FileCheck %s --check-prefix=pre-RA ; RUN: llc -opaque-pointers=0 < %s -mtriple=x86_64-apple-darwin -pre-RA-sched=linearize | FileCheck %s --check-prefix=pre-RA
%"struct.clang::Action" = type { %"struct.clang::ActionBase" } %"struct.clang::Action" = type { %"struct.clang::ActionBase" }
%"struct.clang::ActionBase" = type { i32 (...)** } %"struct.clang::ActionBase" = type { i32 (...)** }
%"struct.clang::ActionBase::ActionResult<0u>" = type { i8*, i8 } %"struct.clang::ActionBase::ActionResult<0u>" = type { i8*, i8 }
@NumTrials = internal global i32 10000000 ; <i32*> [#uses=2] @NumTrials = internal global i32 10000000 ; <i32*> [#uses=2]
@llvm.used = appending global [1 x i8*] [ i8* bitcast (void (i8*, %"struct.clang::Action"*)* @_Z25RawPointerPerformanceTestPvRN5clang6ActionE to i8*) ], section "llvm.metadata" ; <[1 x i8*]*> [#uses=0] @llvm.used = appending global [1 x i8*] [ i8* bitcast (void (i8*, %"struct.clang::Action"*)* @_Z25RawPointerPerformanceTestPvRN5clang6ActionE to i8*) ], section "llvm.metadata" ; <[1 x i8*]*> [#uses=0]
define void @_Z25RawPointerPerformanceTestPvRN5clang6ActionE(i8* %Val, %"struct.clang::Action"* %Actions) nounwind { define void @_Z25RawPointerPerformanceTestPvRN5clang6ActionE(i8* %Val, %"struct.clang::Action"* %Actions) nounwind {
▲ Show 20 Lines • Show All 92 Lines • Show Last 20 Lines

llvm/test/CodeGen/X86/fold-sext-trunc.ll

; RUN: llc < %s -mtriple=x86_64-- | FileCheck %s ; RUN: llc -opaque-pointers=0 < %s -mtriple=x86_64-- | FileCheck %s
; RUN: llc < %s -O0 -mtriple=x86_64-unknown-unknown -mcpu=x86-64 -stop-after livedebugvalues -o - | FileCheck %s -check-prefix=MIR ; RUN: llc -opaque-pointers=0 < %s -O0 -mtriple=x86_64-unknown-unknown -mcpu=x86-64 -stop-after livedebugvalues -o - | FileCheck %s -check-prefix=MIR
; PR4050 ; PR4050
%0 = type { i64 } %0 = type { i64 }
%struct.S1 = type { i16, i32 } %struct.S1 = type { i16, i32 }
@g_10 = external dso_local global %struct.S1, align 8 @g_10 = external dso_local global %struct.S1, align 8
declare void @func_28(i64, i64) declare void @func_28(i64, i64)
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

llvm/test/CodeGen/X86/pr32610.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc -mtriple=i386-apple-macosx10.13.0 -o - %s | FileCheck %s ; RUN: llc -opaque-pointers=0 -mtriple=i386-apple-macosx10.13.0 -o - %s | FileCheck %s
target datalayout = "e-m:o-p:32:32-f64:32:64-f80:128-n8:16:32-S128" target datalayout = "e-m:o-p:32:32-f64:32:64-f80:128-n8:16:32-S128"
@c = external local_unnamed_addr global i32, align 4 @c = external local_unnamed_addr global i32, align 4
@b = external local_unnamed_addr global [1 x i32], align 4 @b = external local_unnamed_addr global [1 x i32], align 4
@d = external local_unnamed_addr global i32, align 4 @d = external local_unnamed_addr global i32, align 4
define void @pr32610(i32 %a0, i32 %a1) #0 { define void @pr32610(i32 %a0, i32 %a1) #0 {
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

llvm/test/CodeGen/X86/pr38217.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc < %s -mtriple=x86_64-unknown-unknown | FileCheck %s ; RUN: llc -opaque-pointers=0 < %s -mtriple=x86_64-unknown-unknown | FileCheck %s
@_ZL11DIGIT_TABLE = dso_local constant [201 x i8] c"00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899\00", align 16 @_ZL11DIGIT_TABLE = dso_local constant [201 x i8] c"00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899\00", align 16
define dso_local void @_Z12d2s_bufferedmPc(i64, i8* nocapture) { define dso_local void @_Z12d2s_bufferedmPc(i64, i8* nocapture) {
; CHECK-LABEL: _Z12d2s_bufferedmPc: ; CHECK-LABEL: _Z12d2s_bufferedmPc:
; CHECK: # %bb.0: ; CHECK: # %bb.0:
; CHECK-NEXT: cmpq $10000, %rdi # imm = 0x2710 ; CHECK-NEXT: cmpq $10000, %rdi # imm = 0x2710
; CHECK-NEXT: jb .LBB0_3 ; CHECK-NEXT: jb .LBB0_3
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

llvm/test/CodeGen/X86/scheduler-asm-moves.mir

# NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py # NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py
# RUN: llc -run-pass=machine-scheduler -mcpu=sandybridge %s -o - | FileCheck %s # RUN: llc -opaque-pointers=0 -run-pass=machine-scheduler -mcpu=sandybridge %s -o - | FileCheck %s
--- | --- |
; ModuleID = 'crash.ll' ; ModuleID = 'crash.ll'
source_filename = "crash.c" source_filename = "crash.c"
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"
target triple = "i386-unknown-linux-gnu" target triple = "i386-unknown-linux-gnu"
%struct.in6_addr = type { %struct.anon } %struct.in6_addr = type { %struct.anon }
▲ Show 20 Lines • Show All 146 Lines • Show Last 20 Lines

llvm/test/CodeGen/X86/sink-gep-before-mem-inst.ll

; RUN: opt < %s -S -codegenprepare -mtriple=x86_64-unknown-linux-gnu | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -S -codegenprepare -mtriple=x86_64-unknown-linux-gnu | FileCheck %s
define i64 @test.after(i8 addrspace(1)* readonly align 8) { define i64 @test.after(i8 addrspace(1)* readonly align 8) {
; CHECK-LABEL: test.after ; CHECK-LABEL: test.after
; CHECK: sunkaddr ; CHECK: sunkaddr
entry: entry:
%.0 = getelementptr inbounds i8, i8 addrspace(1)* %0, i64 8 %.0 = getelementptr inbounds i8, i8 addrspace(1)* %0, i64 8
%addr = bitcast i8 addrspace(1)* %.0 to i32 addrspace(1)* %addr = bitcast i8 addrspace(1)* %.0 to i32 addrspace(1)*
br label %header br label %header
Show All 16 Lines

llvm/test/CodeGen/X86/stack-protector-no-return.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc %s -mtriple=x86_64-unknown-linux-gnu -o - -verify-dom-info | FileCheck %s ; RUN: llc -opaque-pointers=0 %s -mtriple=x86_64-unknown-linux-gnu -o - -verify-dom-info | FileCheck %s
; RUN: llc %s -mtriple=x86_64-unknown-linux-gnu -disable-check-noreturn-call=true -o - -verify-dom-info | FileCheck --check-prefix=DISNOTET %s ; RUN: llc -opaque-pointers=0 %s -mtriple=x86_64-unknown-linux-gnu -disable-check-noreturn-call=true -o - -verify-dom-info | FileCheck --check-prefix=DISNOTET %s
; Function Attrs: sspreq ; Function Attrs: sspreq
define void @_Z7catchesv() #0 personality i8* null { define void @_Z7catchesv() #0 personality i8* null {
; CHECK-LABEL: _Z7catchesv: ; CHECK-LABEL: _Z7catchesv:
; CHECK: # %bb.0: # %entry ; CHECK: # %bb.0: # %entry
; CHECK-NEXT: pushq %rax ; CHECK-NEXT: pushq %rax
; CHECK-NEXT: .cfi_def_cfa_offset 16 ; CHECK-NEXT: .cfi_def_cfa_offset 16
; CHECK-NEXT: movq %fs:40, %rax ; CHECK-NEXT: movq %fs:40, %rax
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

llvm/test/CodeGen/X86/statepoint-invoke-ra-inline-spiller.mir

# NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py # NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py
# RUN: llc -x mir -run-pass=simple-register-coalescing,greedy -verify-machineinstrs < %s | FileCheck %s # RUN: llc -opaque-pointers=0 -x mir -run-pass=simple-register-coalescing,greedy -verify-machineinstrs < %s | FileCheck %s
## Check that Inline Spiller cannot insert spill after last insertion point. ## Check that Inline Spiller cannot insert spill after last insertion point.
--- | --- |
; ModuleID = 'inline-spiller' ; ModuleID = 'inline-spiller'
source_filename = "inline-spiller.ll" source_filename = "inline-spiller.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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
▲ Show 20 Lines • Show All 398 Lines • Show Last 20 Lines

llvm/test/CodeGen/X86/statepoint-invoke-ra.mir

# RUN: llc -x mir -o - %s -run-pass=twoaddressinstruction,simple-register-coalescing,greedy -verify-regalloc 2>&1 | FileCheck %s # RUN: llc -opaque-pointers=0 -x mir -o - %s -run-pass=twoaddressinstruction,simple-register-coalescing,greedy -verify-regalloc 2>&1 | FileCheck %s
# The test checks no verification errors happen in the case of # The test checks no verification errors happen in the case of
# statepoint invoke instruction with tied-defs. # statepoint invoke instruction with tied-defs.
# CHECK: bb.0.bb: # CHECK: bb.0.bb:
# CHECK: successors: %bb.1(0x80000000), %bb.2(0x00000000) # CHECK: successors: %bb.1(0x80000000), %bb.2(0x00000000)
# CHECK: liveins: $rdi, $esi, $rdx # CHECK: liveins: $rdi, $esi, $rdx
# CHECK: %8:gr64 = COPY $rdx # CHECK: %8:gr64 = COPY $rdx
▲ Show 20 Lines • Show All 266 Lines • Show Last 20 Lines

llvm/test/CodeGen/X86/tailcall-extract.ll

; RUN: llc -mtriple=x86_64-linux < %s | FileCheck %s ; RUN: llc -opaque-pointers=0 -mtriple=x86_64-linux < %s | FileCheck %s
; RUN: opt -codegenprepare -S -mtriple=x86_64-linux < %s | FileCheck %s --check-prefix OPT ; RUN: opt -opaque-pointers=0 -codegenprepare -S -mtriple=x86_64-linux < %s | FileCheck %s --check-prefix OPT
; The exit block containing extractvalue can be duplicated into the BB ; The exit block containing extractvalue can be duplicated into the BB
; containing call. And later tail call can be generated. ; containing call. And later tail call can be generated.
; CHECK-LABEL: test1: ; CHECK-LABEL: test1:
; CHECK: jmp bar # TAILCALL ; CHECK: jmp bar # TAILCALL
; CHECK: jmp foo # TAILCALL ; CHECK: jmp foo # TAILCALL
▲ Show 20 Lines • Show All 180 Lines • Show Last 20 Lines

llvm/test/CodeGen/X86/tls-loads-control.ll

; RUN: llc -mtriple=x86_64-unknown-unknown -O2 --relocation-model=pic --tls-load-hoist=true --stop-after=tlshoist -o - %s | FileCheck %s ; RUN: llc -opaque-pointers=0 -mtriple=x86_64-unknown-unknown -O2 --relocation-model=pic --tls-load-hoist=true --stop-after=tlshoist -o - %s | FileCheck %s
; RUN: llc -mtriple=x86_64-unknown-unknown -O2 --relocation-model=pic --stop-after=tlshoist -o - %s | FileCheck %s ; RUN: llc -opaque-pointers=0 -mtriple=x86_64-unknown-unknown -O2 --relocation-model=pic --stop-after=tlshoist -o - %s | FileCheck %s
; This test come from compiling clang/test/CodeGen/intel/tls_loads.cpp with: ; This test come from compiling clang/test/CodeGen/intel/tls_loads.cpp with:
; (clang tls_loads.cpp -fPIC -ftls-model=global-dynamic -O2 -S -emit-llvm) ; (clang tls_loads.cpp -fPIC -ftls-model=global-dynamic -O2 -S -emit-llvm)
; // Variable declaration and definition: ; // Variable declaration and definition:
; thread_local int thl_x; ; thread_local int thl_x;
; thread_local int thl_x2; ; thread_local int thl_x2;
; ;
▲ Show 20 Lines • Show All 238 Lines • Show Last 20 Lines

llvm/test/CodeGen/X86/tls-loads-control2.ll

; RUN: opt -S -mtriple=x86_64-unknown-unknown -passes=tlshoist --relocation-model=pic --tls-load-hoist=true -o - %s | FileCheck %s --check-prefix=HOIST0 ; RUN: opt -opaque-pointers=0 -S -mtriple=x86_64-unknown-unknown -passes=tlshoist --relocation-model=pic --tls-load-hoist=true -o - %s | FileCheck %s --check-prefix=HOIST0
; RUN: opt -S -mtriple=x86_64-unknown-unknown -passes=tlshoist --relocation-model=pic -o - %s | FileCheck %s --check-prefix=HOIST2 ; RUN: opt -opaque-pointers=0 -S -mtriple=x86_64-unknown-unknown -passes=tlshoist --relocation-model=pic -o - %s | FileCheck %s --check-prefix=HOIST2
$_ZTW5thl_x = comdat any $_ZTW5thl_x = comdat any
@thl_x = thread_local global i32 0, align 4 @thl_x = thread_local global i32 0, align 4
; Function Attrs: mustprogress uwtable ; Function Attrs: mustprogress uwtable
define i32 @_Z2f1i(i32 %c) local_unnamed_addr #0 { define i32 @_Z2f1i(i32 %c) local_unnamed_addr #0 {
entry: entry:
Show All 40 Lines

llvm/test/CodeGen/XCore/threads.ll

; RUN: llc -mtriple=xcore-unknown-unknown < %s | FileCheck %s ; RUN: llc -opaque-pointers=0 -mtriple=xcore-unknown-unknown < %s | FileCheck %s
; RUN: llc -mtriple=xcore-unknown-unknown -O=0 < %s | FileCheck %s -check-prefix=PHINODE ; RUN: llc -opaque-pointers=0 -mtriple=xcore-unknown-unknown -O=0 < %s | FileCheck %s -check-prefix=PHINODE
declare i8 addrspace(1)* @llvm.xcore.getst.p1i8.p1i8(i8 addrspace(1)* %r) declare i8 addrspace(1)* @llvm.xcore.getst.p1i8.p1i8(i8 addrspace(1)* %r)
declare void @llvm.xcore.msync.p1i8(i8 addrspace(1)* %r) declare void @llvm.xcore.msync.p1i8(i8 addrspace(1)* %r)
declare void @llvm.xcore.ssync() declare void @llvm.xcore.ssync()
declare void @llvm.xcore.mjoin.p1i8(i8 addrspace(1)* %r) declare void @llvm.xcore.mjoin.p1i8(i8 addrspace(1)* %r)
declare void @llvm.xcore.initsp.p1i8(i8 addrspace(1)* %r, i8* %value) declare void @llvm.xcore.initsp.p1i8(i8 addrspace(1)* %r, i8* %value)
declare void @llvm.xcore.initpc.p1i8(i8 addrspace(1)* %r, i8* %value) declare void @llvm.xcore.initpc.p1i8(i8 addrspace(1)* %r, i8* %value)
declare void @llvm.xcore.initlr.p1i8(i8 addrspace(1)* %r, i8* %value) declare void @llvm.xcore.initlr.p1i8(i8 addrspace(1)* %r, i8* %value)
▲ Show 20 Lines • Show All 135 Lines • Show Last 20 Lines

llvm/test/DebugInfo/Generic/assignment-tracking/instcombine/alloca-bitcast.ll

; RUN: opt -passes=instcombine -S %s -o - -experimental-assignment-tracking \ ; RUN: opt -opaque-pointers=0 -passes=instcombine -S %s -o - -experimental-assignment-tracking \
; RUN: | FileCheck %s ; RUN: | FileCheck %s
;; NOTE: This test uses typed pointers because it is testing a code path that ;; NOTE: This test uses typed pointers because it is testing a code path that
;; doesn't get exercised with opaque pointers. If/when PromoteCastOfAllocation ;; doesn't get exercised with opaque pointers. If/when PromoteCastOfAllocation
;; is removed from visitBitCast this test should just be deleted. ;; is removed from visitBitCast this test should just be deleted.
;; Check that allocas generated in InstCombine's PromoteCastOfAllocation ;; Check that allocas generated in InstCombine's PromoteCastOfAllocation
;; have DIAssignID copied from the original alloca. ;; have DIAssignID copied from the original alloca.
;; ;;
;; $ cat reduce.cpp ;; $ cat reduce.cpp
;; struct c { ;; struct c {
;; c(int); ;; c(int);
;; int a, b; ;; int a, b;
;; }; ;; };
;; c d() { ;; c d() {
;; c e(1); ;; c e(1);
;; return e; ;; return e;
;; } ;; }
;; $ clang -O2 -c -g reduce.cpp -fno-inline -Xclang -disable-llvm-passes -emit-llvm -S \ ;; $ clang -O2 -c -g reduce.cpp -fno-inline -Xclang -disable-llvm-passes -emit-llvm -S \
;; | opt -passes=declare-to-assign -S ;; | opt -opaque-pointers=0 -passes=declare-to-assign -S
; CHECK: entry: ; CHECK: entry:
; CHECK-NEXT: %retval = alloca i64, align 8, !DIAssignID ![[ID:[0-9]+]] ; CHECK-NEXT: %retval = alloca i64, align 8, !DIAssignID ![[ID:[0-9]+]]
; CHECK-NEXT: %tmpcast = bitcast i64* %retval to %struct.c* ; CHECK-NEXT: %tmpcast = bitcast i64* %retval to %struct.c*
; CHECK-NEXT: call void @llvm.dbg.assign(metadata i1 undef, metadata ![[e:[0-9]+]], metadata !DIExpression(), metadata ![[ID]], metadata i64* %retval, metadata !DIExpression()), !dbg ; CHECK-NEXT: call void @llvm.dbg.assign(metadata i1 undef, metadata ![[e:[0-9]+]], metadata !DIExpression(), metadata ![[ID]], metadata i64* %retval, metadata !DIExpression()), !dbg
; CHECK: ![[e]] = !DILocalVariable(name: "e", ; CHECK: ![[e]] = !DILocalVariable(name: "e",
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"
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

llvm/test/DebugInfo/Generic/assignment-tracking/track-assignments.ll

; RUN: opt -passes='declare-to-assign,verify' %s -S -o - -experimental-assignment-tracking \ ; RUN: opt -opaque-pointers=0 -passes='declare-to-assign,verify' %s -S -o - -experimental-assignment-tracking \
; RUN: | FileCheck %s --implicit-check-not="call void @llvm.dbg" ; RUN: | FileCheck %s --implicit-check-not="call void @llvm.dbg"
;; This test checks that `trackAssignments` is working correctly by using the ;; This test checks that `trackAssignments` is working correctly by using the
;; pass-wrapper `declare-to-assign`. Each function checks some specific ;; pass-wrapper `declare-to-assign`. Each function checks some specific
;; functionality and has its checks inline. ;; functionality and has its checks inline.
;; $ cat test.cpp ;; $ cat test.cpp
;; struct Inner { int A, B; }; ;; struct Inner { int A, B; };
▲ Show 20 Lines • Show All 496 Lines • Show Last 20 Lines

llvm/test/DebugInfo/Generic/instcombine-replaced-select-with-operand.ll

; RUN: opt -passes=instcombine -S %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -passes=instcombine -S %s | FileCheck %s
;; Ensure that debug uses of a select are replaced when the select is replaced ;; Ensure that debug uses of a select are replaced when the select is replaced
;; with one of its operands in InstCombine's replacedSelectWithOperand. ;; with one of its operands in InstCombine's replacedSelectWithOperand.
;; Based on IR generated from this source, compiled with -O2 -g: ;; Based on IR generated from this source, compiled with -O2 -g:
;; ;;
;; extern void* glob; ;; extern void* glob;
;; struct Thing { ;; struct Thing {
▲ Show 20 Lines • Show All 118 Lines • Show Last 20 Lines

llvm/test/DebugInfo/Generic/mem2reg-promote-alloca-3.ll

; RUN: opt -passes=mem2reg %s -S -o - | FileCheck %s ; RUN: opt -opaque-pointers=0 -passes=mem2reg %s -S -o - | FileCheck %s
;; Check that mem2reg removes dbg.value(%local, DIExpression(DW_OP_deref...)) ;; Check that mem2reg removes dbg.value(%local, DIExpression(DW_OP_deref...))
;; that instcombine LowerDbgDeclare inserted before the call to 'esc' when ;; that instcombine LowerDbgDeclare inserted before the call to 'esc' when
;; promoting the alloca %local after 'esc' has been inlined. Without this we ;; promoting the alloca %local after 'esc' has been inlined. Without this we
;; provide no location for 'local', even though it is provably constant ;; provide no location for 'local', even though it is provably constant
;; throughout after inlining. ;; throughout after inlining.
;; ;;
;; $ clang reduce.c -O2 -g -emit-llvm -S -o tmp.ll -Xclang -disable-llvm-passes ;; $ clang reduce.c -O2 -g -emit-llvm -S -o tmp.ll -Xclang -disable-llvm-passes
;; $ opt tmp.ll -o - -instcombine -inline -S ;; $ opt -opaque-pointers=0 tmp.ll -o - -instcombine -inline -S
;; $ cat reduce.c ;; $ cat reduce.c
;; __attribute__((__always_inline__)) ;; __attribute__((__always_inline__))
;; static void esc(unsigned char **c) { ;; static void esc(unsigned char **c) {
;; *c += 4; ;; *c += 4;
;; } ;; }
;; void fun() { ;; void fun() {
;; unsigned char *local = 0; ;; unsigned char *local = 0;
;; esc(&local); ;; esc(&local);
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

llvm/test/DebugInfo/X86/bitcast-di.ll

; RUN: opt -mtriple=x86_64-unknown-linux-gnu -S -debugify -codegenprepare < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -mtriple=x86_64-unknown-linux-gnu -S -debugify -codegenprepare < %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" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-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-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
@x = external global [1 x [2 x <4 x float>]] @x = external global [1 x [2 x <4 x float>]]
declare void @foo(i32) declare void @foo(i32)
Show All 31 Lines
load.i145: load.i145:
; CHECK: bitcast [1 x [2 x <4 x float>]]* @x to [2 x <4 x float>]*, !dbg ![[castLoc2:[0-9]+]] ; CHECK: bitcast [1 x [2 x <4 x float>]]* @x to [2 x <4 x float>]*, !dbg ![[castLoc2:[0-9]+]]
%x_offset = getelementptr [1 x [2 x <4 x float>]], [1 x [2 x <4 x float>]]* @x, i32 0, i64 0 %x_offset = getelementptr [1 x [2 x <4 x float>]], [1 x [2 x <4 x float>]]* @x, i32 0, i64 0
ret void ret void
} }
; CHECK: ![[castLoc]] = !DILocation(line: 2 ; CHECK: ![[castLoc]] = !DILocation(line: 2
; CHECK: ![[castLoc2]] = !DILocation(line: 11 ; CHECK: ![[castLoc2]] = !DILocation(line: 11
No newline at end of file No newline at end of file

llvm/test/DebugInfo/X86/undef-type-md.ll

; RUN: opt -S -passes=ipsccp %S/undef-type-md.ll | FileCheck %s ; RUN: opt -opaque-pointers=0 -S -passes=ipsccp %S/undef-type-md.ll | FileCheck %s
; CHECK: llvm.nondebug.metadata = !{[[NONDEBUG_METADATA:![0-9]+]]} ; CHECK: llvm.nondebug.metadata = !{[[NONDEBUG_METADATA:![0-9]+]]}
; CHECK: [[NONDEBUG_METADATA]] = distinct !{null} ; CHECK: [[NONDEBUG_METADATA]] = distinct !{null}
; CHECK: !DITemplateValueParameter({{.*}} value: %class.1 addrspace(1)* undef) ; CHECK: !DITemplateValueParameter({{.*}} value: %class.1 addrspace(1)* undef)
; ModuleID = '<stdin>' ; ModuleID = '<stdin>'
source_filename = "test.cpp" source_filename = "test.cpp"
%"struct.1" = type <{ float, i32, i8, [3 x i8] }> %"struct.1" = type <{ float, i32, i8, [3 x i8] }>
Show All 27 Lines

llvm/test/LTO/X86/type-mapping-bug4.ll

; RUN: opt -module-summary -o %t0.o %S/Inputs/type-mapping-bug4_0.ll ; RUN: opt -opaque-pointers=0 -module-summary -o %t0.o %S/Inputs/type-mapping-bug4_0.ll
; RUN: opt -module-summary -o %t1.o %S/Inputs/type-mapping-bug4_1.ll ; RUN: opt -opaque-pointers=0 -module-summary -o %t1.o %S/Inputs/type-mapping-bug4_1.ll
; RUN: opt -module-summary -o %t2.o %s ; RUN: opt -opaque-pointers=0 -module-summary -o %t2.o %s
; RUN: llvm-lto2 run -save-temps -o %t3 %t0.o %t1.o %t2.o -r %t1.o,a,px -r %t2.o,d,px -r %t1.o,h,x -r %t2.o,h,x -r %t1.o,j,px ; RUN: llvm-lto2 run -save-temps -o %t3 %t0.o %t1.o %t2.o -r %t1.o,a,px -r %t2.o,d,px -r %t1.o,h,x -r %t2.o,h,x -r %t1.o,j,px
; RUN: llvm-dis < %t3.0.0.preopt.bc | FileCheck %s ; RUN: llvm-dis < %t3.0.0.preopt.bc | FileCheck %s
; stage0: linking t0.o ; stage0: linking t0.o
; stage1: linking t1.o ; stage1: linking t1.o
; stage2: during linking t1.o, mapping @d ; stage2: during linking t1.o, mapping @d
; stage3: linking t2.o ; stage3: linking t2.o
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

llvm/test/Linker/type-unique-name.ll

; RUN: llvm-link -S %s %p/Inputs/type-unique-name.ll | FileCheck %s ; RUN: llvm-link -opaque-pointers=0 -S %s %p/Inputs/type-unique-name.ll | FileCheck %s
; Test that we keep the type name ; Test that we keep the type name
; CHECK: %abc = type { i8 } ; CHECK: %abc = type { i8 }
%abc = type opaque %abc = type opaque
declare %abc* @f() declare %abc* @f()
define %abc* @g() { define %abc* @g() {
%x = call %abc* @f() %x = call %abc* @f()
ret %abc* %x ret %abc* %x
} }

llvm/test/Other/mixed-opaque-ptrs.ll

; RUN: not llvm-as -disable-output %s 2>&1 | FileCheck %s ; RUN: not llvm-as -opaque-pointers=0 -disable-output %s 2>&1 | FileCheck %s
; CHECK: ptr type is only supported in -opaque-pointers mode ; CHECK: ptr type is only supported in -opaque-pointers mode
define void @f(i32*) { define void @f(i32*) {
%a = alloca ptr %a = alloca ptr
ret void ret void
} }

llvm/test/SafepointIRVerifier/uses-in-phi-nodes.ll

; RUN: opt -safepoint-ir-verifier-print-only -verify-safepoint-ir -S %s 2>&1 | FileCheck %s ; RUN: opt -opaque-pointers=0 -safepoint-ir-verifier-print-only -verify-safepoint-ir -S %s 2>&1 | FileCheck %s
define i8 addrspace(1)* @test.not.ok.0(i8 addrspace(1)* %arg) gc "statepoint-example" { define i8 addrspace(1)* @test.not.ok.0(i8 addrspace(1)* %arg) gc "statepoint-example" {
; CHECK-LABEL: Verifying gc pointers in function: test.not.ok.0 ; CHECK-LABEL: Verifying gc pointers in function: test.not.ok.0
bci_0: bci_0:
br i1 undef, label %left, label %right br i1 undef, label %left, label %right
left: left:
%safepoint_token = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void ()* elementtype(void ()) undef, i32 0, i32 0, i32 0, i32 0) %safepoint_token = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void ()* elementtype(void ()) undef, i32 0, i32 0, i32 0, i32 0)
▲ Show 20 Lines • Show All 163 Lines • Show Last 20 Lines

llvm/test/Transforms/Attributor/ArgumentPromotion/fp80.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -opaque-pointers=0 -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -opaque-pointers=0 -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
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"
%union.u = type { x86_fp80 } %union.u = type { x86_fp80 }
%struct.s = type { double, i16, i8, [5 x i8] } %struct.s = type { double, i16, i8, [5 x i8] }
@b = internal global %struct.s { double 3.14, i16 9439, i8 25, [5 x i8] undef }, align 16 @b = internal global %struct.s { double 3.14, i16 9439, i8 25, [5 x i8] undef }, align 16
▲ Show 20 Lines • Show All 103 Lines • Show Last 20 Lines

llvm/test/Transforms/Attributor/IPConstantProp/arg-count-mismatch.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -opaque-pointers=0 -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -opaque-pointers=0 -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
; The original C source looked like this: ; The original C source looked like this:
; ;
; long long a101, b101, e101; ; long long a101, b101, e101;
; volatile long c101; ; volatile long c101;
; int d101; ; int d101;
; ;
; static inline int bar(p1, p2) ; static inline int bar(p1, p2)
▲ Show 20 Lines • Show All 132 Lines • Show Last 20 Lines

llvm/test/Transforms/Attributor/call-simplify-pointer-info.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=7 -S < %s | FileCheck %s --check-prefixes=TUNIT ; RUN: opt -opaque-pointers=0 -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=7 -S < %s | FileCheck %s --check-prefixes=TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CGSCC ; RUN: opt -opaque-pointers=0 -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CGSCC
; ;
define internal i8 @read_arg(i8* %p) { define internal i8 @read_arg(i8* %p) {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read)
; CGSCC-LABEL: define {{[^@]+}}@read_arg ; CGSCC-LABEL: define {{[^@]+}}@read_arg
; CGSCC-SAME: (i8* nocapture nofree noundef nonnull readonly dereferenceable(1022) [[P:%.*]]) #[[ATTR0:[0-9]+]] { ; CGSCC-SAME: (i8* nocapture nofree noundef nonnull readonly dereferenceable(1022) [[P:%.*]]) #[[ATTR0:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[L:%.*]] = load i8, i8* [[P]], align 1 ; CGSCC-NEXT: [[L:%.*]] = load i8, i8* [[P]], align 1
▲ Show 20 Lines • Show All 286 Lines • Show Last 20 Lines

llvm/test/Transforms/Attributor/heap_to_stack.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=8 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -opaque-pointers=0 -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=8 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -opaque-pointers=0 -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
declare noalias i8* @malloc(i64) allockind("alloc,uninitialized") allocsize(0) declare noalias i8* @malloc(i64) allockind("alloc,uninitialized") allocsize(0)
declare void @nocapture_func_frees_pointer(i8* nocapture) declare void @nocapture_func_frees_pointer(i8* nocapture)
declare void @func_throws(...) declare void @func_throws(...)
declare void @sync_func(i8* %p) declare void @sync_func(i8* %p)
▲ Show 20 Lines • Show All 656 Lines • Show Last 20 Lines

llvm/test/Transforms/Attributor/heap_to_stack_gpu.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=5 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -opaque-pointers=0 -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=5 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -opaque-pointers=0 -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
; FIXME: amdgpu doesn't claim malloc is a thing, so the test is somewhat ; FIXME: amdgpu doesn't claim malloc is a thing, so the test is somewhat
; useless except the __kmpc_alloc_shared part which now also covers the important ; useless except the __kmpc_alloc_shared part which now also covers the important
; part this test was initially designed for, make sure the "is freed" check is ; part this test was initially designed for, make sure the "is freed" check is
; not sufficient on a GPU. ; not sufficient on a GPU.
target triple = "amdgcn-amd-amdhsa" target triple = "amdgcn-amd-amdhsa"
target datalayout = "A5" target datalayout = "A5"
▲ Show 20 Lines • Show All 660 Lines • Show Last 20 Lines

llvm/test/Transforms/Attributor/liveness.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=16 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -opaque-pointers=0 -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=16 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -opaque-pointers=0 -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
; NOT_CGSCC___: @dead_with_blockaddress_users.l = constant [2 x i8*] [i8* inttoptr (i32 1 to i8*), i8* inttoptr (i32 1 to i8*)] ; NOT_CGSCC___: @dead_with_blockaddress_users.l = constant [2 x i8*] [i8* inttoptr (i32 1 to i8*), i8* inttoptr (i32 1 to i8*)]
; IS__CGSCC___: @dead_with_blockaddress_users.l = constant [2 x i8*] [i8* blockaddress(@dead_with_blockaddress_users, %lab0), i8* blockaddress(@dead_with_blockaddress_users, %end)] ; IS__CGSCC___: @dead_with_blockaddress_users.l = constant [2 x i8*] [i8* blockaddress(@dead_with_blockaddress_users, %lab0), i8* blockaddress(@dead_with_blockaddress_users, %end)]
@dead_with_blockaddress_users.l = constant [2 x i8*] [i8* blockaddress(@dead_with_blockaddress_users, %lab0), i8* blockaddress(@dead_with_blockaddress_users, %end)] @dead_with_blockaddress_users.l = constant [2 x i8*] [i8* blockaddress(@dead_with_blockaddress_users, %lab0), i8* blockaddress(@dead_with_blockaddress_users, %end)]
declare void @no_return_call() nofree noreturn nounwind nosync declare void @no_return_call() nofree noreturn nounwind nosync
declare void @normal_call() readnone declare void @normal_call() readnone
▲ Show 20 Lines • Show All 2,642 Lines • Show Last 20 Lines

llvm/test/Transforms/Attributor/misc_crash.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -passes=attributor -S %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -passes=attributor -S %s | FileCheck %s
@var1 = internal global [1 x i32] undef @var1 = internal global [1 x i32] undef
@var2 = internal global i32 0 @var2 = internal global i32 0
;. ;.
; CHECK: @[[VAR1:[a-zA-Z0-9_$"\\.-]+]] = internal global [1 x i32] undef ; CHECK: @[[VAR1:[a-zA-Z0-9_$"\\.-]+]] = internal global [1 x i32] undef
; CHECK: @[[VAR2:[a-zA-Z0-9_$"\\.-]+]] = internal global i32 0 ; CHECK: @[[VAR2:[a-zA-Z0-9_$"\\.-]+]] = internal global i32 0
;. ;.
▲ Show 20 Lines • Show All 126 Lines • Show Last 20 Lines

llvm/test/Transforms/Attributor/nocapture-2.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=6 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -opaque-pointers=0 -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=6 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -opaque-pointers=0 -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
; ;
; Test cases specifically designed for the "no-capture" argument attribute. ; Test cases specifically designed for the "no-capture" argument attribute.
; We use FIXME's to indicate problems and missing attributes. ; We use FIXME's to indicate problems and missing attributes.
; ;
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"
declare i32* @unknown() declare i32* @unknown()
; TEST comparison against NULL ; TEST comparison against NULL
▲ Show 20 Lines • Show All 844 Lines • Show Last 20 Lines

llvm/test/Transforms/Attributor/nodelete.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=4 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -opaque-pointers=0 -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=4 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -opaque-pointers=0 -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
%"a" = type { i64 } %"a" = type { i64 }
%"b" = type { i8 } %"b" = type { i8 }
define hidden i64 @f1() align 2 { define hidden i64 @f1() align 2 {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@f1 ; TUNIT-LABEL: define {{[^@]+}}@f1
; TUNIT-SAME: () #[[ATTR0:[0-9]+]] align 2 { ; TUNIT-SAME: () #[[ATTR0:[0-9]+]] align 2 {
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

llvm/test/Transforms/Attributor/nofree.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -opaque-pointers=0 -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -opaque-pointers=0 -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
; Test cases specifically designed for the "nofree" function attribute. ; Test cases specifically designed for the "nofree" function attribute.
; We use FIXME's to indicate problems and missing attributes. ; We use FIXME's to indicate problems and missing attributes.
; Free functions ; Free functions
declare void @free(i8* nocapture) local_unnamed_addr #1 declare void @free(i8* nocapture) local_unnamed_addr #1
▲ Show 20 Lines • Show All 454 Lines • Show Last 20 Lines

llvm/test/Transforms/Attributor/norecurse.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=8 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -opaque-pointers=0 -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=8 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -opaque-pointers=0 -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
define i32 @leaf() { define i32 @leaf() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@leaf ; CHECK-LABEL: define {{[^@]+}}@leaf
; CHECK-SAME: () #[[ATTR0:[0-9]+]] { ; CHECK-SAME: () #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: ret i32 1 ; CHECK-NEXT: ret i32 1
; ;
ret i32 1 ret i32 1
▲ Show 20 Lines • Show All 321 Lines • Show Last 20 Lines

llvm/test/Transforms/Attributor/nosync.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=3 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -opaque-pointers=0 -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=3 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -opaque-pointers=0 -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
; Test cases designed for the nosync function attribute. ; Test cases designed for the nosync function attribute.
; FIXME's are used to indicate problems and missing attributes. ; FIXME's are used to indicate problems and missing attributes.
; struct RT { ; struct RT {
; char A; ; char A;
; int B[10][20]; ; int B[10][20];
▲ Show 20 Lines • Show All 456 Lines • Show Last 20 Lines

llvm/test/Transforms/Attributor/willreturn.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=14 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -opaque-pointers=0 -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=14 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -opaque-pointers=0 -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
target datalayout = "e-m:e-i54:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i54:64-f80:128-n8:16:32:64-S128"
; Test cases specifically designed for the "willreturn" function attribute. ; Test cases specifically designed for the "willreturn" function attribute.
; We use FIXME's to indicate problems and missing attributes. ; We use FIXME's to indicate problems and missing attributes.
; TEST 1 (positive case) ; TEST 1 (positive case)
▲ Show 20 Lines • Show All 1,333 Lines • Show Last 20 Lines

llvm/test/Transforms/ConstantHoisting/AArch64/const-hoist-gep.ll

; RUN: opt -passes=consthoist -consthoist-gep -S -o - %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -passes=consthoist -consthoist-gep -S -o - %s | FileCheck %s
target triple = "aarch64-none--musleabi" target triple = "aarch64-none--musleabi"
; Check that constant GEP expressions are rewritten to one-dimensional ; Check that constant GEP expressions are rewritten to one-dimensional
; (single-index) GEPs, whose base poiner is a multi-dimensional GEP. ; (single-index) GEPs, whose base poiner is a multi-dimensional GEP.
; CHECK: %const = bitcast i32* getelementptr inbounds (%0, %0* @global, i32 0, i32 4, i32 0, i32 0) to i32* ; CHECK: %const = bitcast i32* getelementptr inbounds (%0, %0* @global, i32 0, i32 4, i32 0, i32 0) to i32*
; CHECK-NEXT: store i32 undef, i32* %const, align 4 ; CHECK-NEXT: store i32 undef, i32* %const, align 4
Show All 35 Lines

llvm/test/Transforms/ConstantHoisting/ARM/const-hoist-gep-overindexing.ll

; 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=consthoist -consthoist-gep -S -o - %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -passes=consthoist -consthoist-gep -S -o - %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 = "thumbv6m-none--musleabi" target triple = "thumbv6m-none--musleabi"
%0 = type { [10 x i32], [10 x i16] } %0 = type { [10 x i32], [10 x i16] }
@global = external local_unnamed_addr global %0, align 4 @global = external local_unnamed_addr global %0, align 4
Show All 35 Lines

llvm/test/Transforms/ConstantHoisting/ARM/const-hoist-gep.ll

; RUN: opt -passes=consthoist -consthoist-gep -S -o - %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -passes=consthoist -consthoist-gep -S -o - %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 = "thumbv6m-none--musleabi" target triple = "thumbv6m-none--musleabi"
; Check that constant GEP expressions are rewritten to one-dimensional ; Check that constant GEP expressions are rewritten to one-dimensional
; (single-index) GEPs, whose base poiner is a multi-dimensional GEP. ; (single-index) GEPs, whose base poiner is a multi-dimensional GEP.
; CHECK-DAG: %[[C1:const[0-9]?]] = bitcast i32* getelementptr inbounds (%0, %0* @global, i32 0, i32 4, i32 11, i32 0) to i32* ; CHECK-DAG: %[[C1:const[0-9]?]] = bitcast i32* getelementptr inbounds (%0, %0* @global, i32 0, i32 4, i32 11, i32 0) to i32*
; CHECK-DAG: %[[C2:const[0-9]?]] = bitcast i32* getelementptr inbounds (%0, %0* @global, i32 0, i32 4, i32 0, i32 0) to i32* ; CHECK-DAG: %[[C2:const[0-9]?]] = bitcast i32* getelementptr inbounds (%0, %0* @global, i32 0, i32 4, i32 0, i32 0) to i32*
Show All 33 Lines

llvm/test/Transforms/Coroutines/ArgAddr.ll

; Need to move users of allocas that were moved into the coroutine frame after ; Need to move users of allocas that were moved into the coroutine frame after
; coro.begin. ; coro.begin.
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
define nonnull i8* @f(i32 %n) presplitcoroutine { define nonnull i8* @f(i32 %n) presplitcoroutine {
; CHECK-LABEL: @f( ; CHECK-LABEL: @f(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[ID:%.*]] = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* bitcast ([3 x void (%f.Frame*)*]* @f.resumers to i8*)) ; CHECK-NEXT: [[ID:%.*]] = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* bitcast ([3 x void (%f.Frame*)*]* @f.resumers to i8*))
; CHECK-NEXT: [[N_ADDR:%.*]] = alloca i32, align 4 ; CHECK-NEXT: [[N_ADDR:%.*]] = alloca i32, align 4
; CHECK-NEXT: store i32 [[N:%.*]], i32* [[N_ADDR]], align 4 ; CHECK-NEXT: store i32 [[N:%.*]], i32* [[N_ADDR]], align 4
; CHECK-NEXT: [[CALL:%.*]] = tail call i8* @malloc(i32 24) ; CHECK-NEXT: [[CALL:%.*]] = tail call i8* @malloc(i32 24)
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-alloc-with-param-O0.ll

; Check that we can handle the case when both alloc function and ; Check that we can handle the case when both alloc function and
; the user body consume the same argument. ; the user body consume the same argument.
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
; using copy of this (as it would happen under -O0) ; using copy of this (as it would happen under -O0)
define i8* @f_copy(i64 %this_arg) presplitcoroutine { define i8* @f_copy(i64 %this_arg) presplitcoroutine {
entry: entry:
%this.addr = alloca i64 %this.addr = alloca i64
store i64 %this_arg, i64* %this.addr store i64 %this_arg, i64* %this.addr
%this = load i64, i64* %this.addr %this = load i64, i64* %this.addr
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-alloc-with-param-O2.ll

; Check that we can handle the case when both alloc function and ; Check that we can handle the case when both alloc function and
; the user body consume the same argument. ; the user body consume the same argument.
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
; using this directly (as it would happen under -O2) ; using this directly (as it would happen under -O2)
define i8* @f_direct(i64 %this) presplitcoroutine { define i8* @f_direct(i64 %this) presplitcoroutine {
entry: entry:
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
%alloc = call i8* @myAlloc(i64 %this, i32 %size) %alloc = call i8* @myAlloc(i64 %this, i32 %size)
%hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc) %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-alloca-01.ll

; Tests that CoroSplit can succesfully determine allocas should live on the frame ; Tests that CoroSplit can succesfully determine allocas should live on the frame
; if their aliases are used across suspension points through PHINode. ; if their aliases are used across suspension points through PHINode.
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
define i8* @f(i1 %n) presplitcoroutine { define i8* @f(i1 %n) presplitcoroutine {
entry: entry:
%x = alloca i64 %x = alloca i64
%y = alloca i64 %y = alloca i64
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
%alloc = call i8* @malloc(i32 %size) %alloc = call i8* @malloc(i32 %size)
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-alloca-02.ll

; Tests that if an alloca is escaped through storing the address, ; Tests that if an alloca is escaped through storing the address,
; the alloac will be put on the frame. ; the alloac will be put on the frame.
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
define i8* @f() presplitcoroutine { define i8* @f() presplitcoroutine {
entry: entry:
%x = alloca i64 %x = alloca i64
%y = alloca i32* %y = alloca i32*
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
%alloc = call i8* @malloc(i32 %size) %alloc = call i8* @malloc(i32 %size)
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-alloca-03.ll

; Tests that allocas escaped through function calls will live on the frame. ; Tests that allocas escaped through function calls will live on the frame.
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
define i8* @f() presplitcoroutine { define i8* @f() presplitcoroutine {
entry: entry:
%x = alloca i64 %x = alloca i64
%y = alloca i64 %y = alloca i64
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
%alloc = call i8* @malloc(i32 %size) %alloc = call i8* @malloc(i32 %size)
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-alloca-04.ll

; Tests that CoroSplit can succesfully determine allocas should live on the frame ; Tests that CoroSplit can succesfully determine allocas should live on the frame
; if their aliases are used across suspension points through PHINode. ; if their aliases are used across suspension points through PHINode.
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
define i8* @f(i1 %n) presplitcoroutine { define i8* @f(i1 %n) presplitcoroutine {
entry: entry:
%x = alloca i64 %x = alloca i64
br i1 %n, label %flag_true, label %flag_false br i1 %n, label %flag_true, label %flag_false
flag_true: flag_true:
%x.alias1 = bitcast i64* %x to i32* %x.alias1 = bitcast i64* %x to i32*
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-alloca-07.ll

; Tests that CoroSplit can succesfully determine allocas should live on the frame ; Tests that CoroSplit can succesfully determine allocas should live on the frame
; if their aliases are used across suspension points through PHINode. ; if their aliases are used across suspension points through PHINode.
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
define i8* @f(i1 %n) presplitcoroutine { define i8* @f(i1 %n) presplitcoroutine {
entry: entry:
%x = alloca i64 %x = alloca i64
%y = alloca i64 %y = alloca i64
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
%alloc = call i8* @malloc(i32 %size) %alloc = call i8* @malloc(i32 %size)
▲ Show 20 Lines • Show All 92 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-async-dyn-align.ll

; RUN: opt < %s -O0 -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -O0 -S | FileCheck %s
target datalayout = "p:64:64:64" target datalayout = "p:64:64:64"
%async.task = type { i64 } %async.task = type { i64 }
%async.actor = type { i64 } %async.actor = type { i64 }
%async.fp = type <{ i32, i32 }> %async.fp = type <{ i32, i32 }>
%async.ctxt = type { i8*, void (i8*)* } %async.ctxt = type { i8*, void (i8*)* }
▲ Show 20 Lines • Show All 93 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-async-nomerge.ll

; RUN: opt < %s -O2 -S ; RUN: opt -opaque-pointers=0 < %s -O2 -S
; RUN: opt -S -hoist-common-insts -hoist-common-insts -passes=simplifycfg < %s | FileCheck %s --check-prefixes=CHECK ; RUN: opt -opaque-pointers=0 -S -hoist-common-insts -hoist-common-insts -passes=simplifycfg < %s | FileCheck %s --check-prefixes=CHECK
target datalayout = "p:64:64:64" target datalayout = "p:64:64:64"
%swift.async_func_pointer = type <{ i32, i32 }> %swift.async_func_pointer = type <{ i32, i32 }>
%swift.context = type { %swift.context*, void (%swift.context*)* } %swift.context = type { %swift.context*, void (%swift.context*)* }
declare void @f() declare void @f()
declare void @g() declare void @g()
declare i8* @llvm.coro.async.resume() declare i8* @llvm.coro.async.resume()
declare { i8* } @llvm.coro.suspend.async.sl_p0i8s(i32, i8*, i8*, ...) declare { i8* } @llvm.coro.suspend.async.sl_p0i8s(i32, i8*, i8*, ...)
▲ Show 20 Lines • Show All 111 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-async.ll

; RUN: opt < %s -passes='default<O2>' -S | FileCheck --check-prefixes=CHECK %s ; RUN: opt -opaque-pointers=0 < %s -passes='default<O2>' -S | FileCheck --check-prefixes=CHECK %s
; RUN: opt < %s -O0 -S | FileCheck --check-prefixes=CHECK-O0 %s ; RUN: opt -opaque-pointers=0 < %s -O0 -S | FileCheck --check-prefixes=CHECK-O0 %s
target datalayout = "p:64:64:64" target datalayout = "p:64:64:64"
%async.task = type { i64 } %async.task = type { i64 }
%async.actor = type { i64 } %async.actor = type { i64 }
%async.fp = type <{ i32, i32 }> %async.fp = type <{ i32, i32 }>
%async.ctxt = type { i8*, void (i8*, %async.task*, %async.actor*)* } %async.ctxt = type { i8*, void (i8*, %async.task*, %async.actor*)* }
▲ Show 20 Lines • Show All 607 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-catchswitch.ll

; Verifies that we can insert the spill for a PHI preceding the catchswitch ; Verifies that we can insert the spill for a PHI preceding the catchswitch
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -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"
; CHECK-LABEL: define void @f( ; CHECK-LABEL: define void @f(
define void @f(i1 %cond) presplitcoroutine personality i32 0 { define void @f(i1 %cond) presplitcoroutine personality i32 0 {
entry: entry:
%id = call token @llvm.coro.id(i32 8, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 8, i8* null, i8* null, i8* null)
▲ Show 20 Lines • Show All 78 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-debug-O2.ll

; RUN: opt < %s -passes='module(coro-early),cgscc(coro-split<reuse-storage>),function(sroa)' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='module(coro-early),cgscc(coro-split<reuse-storage>),function(sroa)' -S | FileCheck %s
; Checks whether the dbg.declare for `__promise` remains valid under O2. ; Checks whether the dbg.declare for `__promise` remains valid under O2.
; CHECK-LABEL: define internal fastcc void @f.resume({{.*}}) ; CHECK-LABEL: define internal fastcc void @f.resume({{.*}})
; CHECK: entry.resume: ; CHECK: entry.resume:
; CHECK: call void @llvm.dbg.declare(metadata %f.Frame* %FramePtr, metadata ![[PROMISEVAR_RESUME:[0-9]+]], metadata !DIExpression( ; CHECK: call void @llvm.dbg.declare(metadata %f.Frame* %FramePtr, metadata ![[PROMISEVAR_RESUME:[0-9]+]], metadata !DIExpression(
; ;
; CHECK: ![[PROMISEVAR_RESUME]] = !DILocalVariable(name: "__promise" ; CHECK: ![[PROMISEVAR_RESUME]] = !DILocalVariable(name: "__promise"
▲ Show 20 Lines • Show All 163 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-debug-coro-frame.ll

; RUN: opt < %s -passes='module(coro-early),cgscc(coro-split,coro-split)' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='module(coro-early),cgscc(coro-split,coro-split)' -S | FileCheck %s
; Checks whether the dbg.declare for `__coro_frame` are created. ; Checks whether the dbg.declare for `__coro_frame` are created.
; CHECK-LABEL: define void @f( ; CHECK-LABEL: define void @f(
; CHECK: coro.init: ; CHECK: coro.init:
; CHECK: %[[begin:.*]] = call noalias nonnull i8* @llvm.coro.begin( ; CHECK: %[[begin:.*]] = call noalias nonnull i8* @llvm.coro.begin(
; CHECK: call void @llvm.dbg.declare(metadata i8* %[[begin]], metadata ![[CORO_FRAME:[0-9]+]], metadata !DIExpression()) ; CHECK: call void @llvm.dbg.declare(metadata i8* %[[begin]], metadata ![[CORO_FRAME:[0-9]+]], metadata !DIExpression())
; CHECK: %[[FramePtr:.*]] = bitcast i8* %[[begin]] to ; CHECK: %[[FramePtr:.*]] = bitcast i8* %[[begin]] to
▲ Show 20 Lines • Show All 391 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-debug-dbg.addr-swift.ll

; Tests whether we properly setup llvm.dbg.addr for Swift. ; Tests whether we properly setup llvm.dbg.addr for Swift.
; ;
; Since we do not have any guarantees around the usage of llvm.dbg.addr, we can ; Since we do not have any guarantees around the usage of llvm.dbg.addr, we can
; not propagate them like we do llvm.dbg.declare into funclets. But if users ; not propagate them like we do llvm.dbg.declare into funclets. But if users
; create the debug_value for us, make sure that we propagate llvm.dbg.addr into ; create the debug_value for us, make sure that we propagate llvm.dbg.addr into
; the beginning coroutine and all other funclets. ; the beginning coroutine and all other funclets.
; RUN: opt %s -passes='module(coro-early),cgscc(coro-split,simplifycfg)' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 %s -passes='module(coro-early),cgscc(coro-split,simplifycfg)' -S | FileCheck %s
; CHECK-LABEL: define swifttailcc void @"$s10async_args14withGenericArgyyxnYalF"(%swift.context* swiftasync %0, %swift.opaque* noalias %1, %swift.type* %T){{.*}} { ; CHECK-LABEL: define swifttailcc void @"$s10async_args14withGenericArgyyxnYalF"(%swift.context* swiftasync %0, %swift.opaque* noalias %1, %swift.type* %T){{.*}} {
; CHECK: call void @llvm.dbg.declare(metadata %swift.context** [[CORO_CTX:%[a-z0-9\.]+]], ; CHECK: call void @llvm.dbg.declare(metadata %swift.context** [[CORO_CTX:%[a-z0-9\.]+]],
; CHECK: call void @llvm.dbg.addr(metadata %swift.context** [[CORO_CTX]], ; CHECK: call void @llvm.dbg.addr(metadata %swift.context** [[CORO_CTX]],
; CHECK-NOT: llvm.dbg.value ; CHECK-NOT: llvm.dbg.value
; CHECK-NOT: llvm.dbg.addr ; CHECK-NOT: llvm.dbg.addr
; CHECK-NOT: llvm.dbg.declare ; CHECK-NOT: llvm.dbg.declare
; CHECK: musttail call swifttailcc void @swift_task_switch(%swift.context* swiftasync %19, i8* bitcast (void (i8*)* @"$s10async_args14withGenericArgyyxnYalFTY0_" to i8*), i64 0, i64 0) ; CHECK: musttail call swifttailcc void @swift_task_switch(%swift.context* swiftasync %19, i8* bitcast (void (i8*)* @"$s10async_args14withGenericArgyyxnYalFTY0_" to i8*), i64 0, i64 0)
▲ Show 20 Lines • Show All 425 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-debug-dbg.addr.ll

; Tests whether we properly setup llvm.dbg.addr. ; Tests whether we properly setup llvm.dbg.addr.
; ;
; Since we do not have any guarantees around the usage of llvm.dbg.addr, we can ; Since we do not have any guarantees around the usage of llvm.dbg.addr, we can
; not propagate them like we do llvm.dbg.declare into funclets. But if users ; not propagate them like we do llvm.dbg.declare into funclets. But if users
; create the debug_value for us, make sure that we propagate llvm.dbg.addr into ; create the debug_value for us, make sure that we propagate llvm.dbg.addr into
; the beginning coroutine and all other funclets. ; the beginning coroutine and all other funclets.
; RUN: opt < %s -passes='module(coro-early),cgscc(coro-split,coro-split)' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='module(coro-early),cgscc(coro-split,coro-split)' -S | FileCheck %s
; This file is based on coro-debug-frame-variable.ll. ; This file is based on coro-debug-frame-variable.ll.
; CHECK: define internal fastcc void @f.resume(%f.Frame* noundef nonnull align 16 dereferenceable(80) %FramePtr) !dbg ![[RESUME_FN_DBG_NUM:[0-9]+]] ; CHECK: define internal fastcc void @f.resume(%f.Frame* noundef nonnull align 16 dereferenceable(80) %FramePtr) !dbg ![[RESUME_FN_DBG_NUM:[0-9]+]]
; CHECK-NEXT: entry.resume: ; CHECK-NEXT: entry.resume:
; CHECK: call void @llvm.dbg.addr(metadata %f.Frame** %FramePtr.debug, metadata ![[XVAR_RESUME:[0-9]+]], ; CHECK: call void @llvm.dbg.addr(metadata %f.Frame** %FramePtr.debug, metadata ![[XVAR_RESUME:[0-9]+]],
; CHECK: call void @llvm.dbg.addr(metadata %f.Frame** %FramePtr.debug, metadata ![[YVAR_RESUME:[0-9]+]], ; CHECK: call void @llvm.dbg.addr(metadata %f.Frame** %FramePtr.debug, metadata ![[YVAR_RESUME:[0-9]+]],
; CHECK: call void @llvm.dbg.addr(metadata %f.Frame** %FramePtr.debug, metadata ![[ZVAR_RESUME:[0-9]+]], ; CHECK: call void @llvm.dbg.addr(metadata %f.Frame** %FramePtr.debug, metadata ![[ZVAR_RESUME:[0-9]+]],
▲ Show 20 Lines • Show All 241 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-debug-dbg.values-not_used_in_frame.ll

; Tests whether resume function would remain dbg.value infomation if corresponding values are not used in the frame. ; Tests whether resume function would remain dbg.value infomation if corresponding values are not used in the frame.
; RUN: opt < %s -passes='module(coro-early),cgscc(coro-split,coro-split)' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='module(coro-early),cgscc(coro-split,coro-split)' -S | FileCheck %s
; ;
; This file is based on coro-debug-frame-variable.ll. ; This file is based on coro-debug-frame-variable.ll.
; CHECK: define internal fastcc void @f.resume(%f.Frame* noundef nonnull align 16 dereferenceable(80) %FramePtr) !dbg ![[RESUME_FN_DBG_NUM:[0-9]+]] ; CHECK: define internal fastcc void @f.resume(%f.Frame* noundef nonnull align 16 dereferenceable(80) %FramePtr) !dbg ![[RESUME_FN_DBG_NUM:[0-9]+]]
; CHECK: await.ready: ; CHECK: await.ready:
; CHECK: call void @llvm.dbg.value(metadata i32 undef, metadata ![[IVAR_RESUME:[0-9]+]], metadata !DIExpression( ; CHECK: call void @llvm.dbg.value(metadata i32 undef, metadata ![[IVAR_RESUME:[0-9]+]], metadata !DIExpression(
; CHECK: call void @llvm.dbg.value(metadata i32 undef, metadata ![[JVAR_RESUME:[0-9]+]], metadata !DIExpression( ; CHECK: call void @llvm.dbg.value(metadata i32 undef, metadata ![[JVAR_RESUME:[0-9]+]], metadata !DIExpression(
; ;
; CHECK: ![[RESUME_FN_DBG_NUM]] = distinct !DISubprogram(name: "foo", linkageName: "_Z3foov" ; CHECK: ![[RESUME_FN_DBG_NUM]] = distinct !DISubprogram(name: "foo", linkageName: "_Z3foov"
▲ Show 20 Lines • Show All 209 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-debug-dbg.values.ll

; Tests whether resume function would remain dbg.value infomation. ; Tests whether resume function would remain dbg.value infomation.
; RUN: opt < %s -passes='module(coro-early),cgscc(coro-split,coro-split)' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='module(coro-early),cgscc(coro-split,coro-split)' -S | FileCheck %s
; ;
; This file is based on coro-debug-frame-variable.ll. ; This file is based on coro-debug-frame-variable.ll.
; CHECK: define internal fastcc void @f.resume(%f.Frame* noundef nonnull align 16 dereferenceable(80) %FramePtr) !dbg ![[RESUME_FN_DBG_NUM:[0-9]+]] ; CHECK: define internal fastcc void @f.resume(%f.Frame* noundef nonnull align 16 dereferenceable(80) %FramePtr) !dbg ![[RESUME_FN_DBG_NUM:[0-9]+]]
; CHECK: init.ready: ; CHECK: init.ready:
; CHECK: call void @llvm.dbg.value(metadata %f.Frame** %FramePtr.debug, metadata ![[XVAR_RESUME:[0-9]+]], ; CHECK: call void @llvm.dbg.value(metadata %f.Frame** %FramePtr.debug, metadata ![[XVAR_RESUME:[0-9]+]],
; CHECK: await.ready: ; CHECK: await.ready:
; CHECK: call void @llvm.dbg.value(metadata %f.Frame** %FramePtr.debug, metadata ![[SPILL_RESUME:[0-9]+]] ; CHECK: call void @llvm.dbg.value(metadata %f.Frame** %FramePtr.debug, metadata ![[SPILL_RESUME:[0-9]+]]
; CHECK: call void @llvm.dbg.value(metadata %f.Frame** %FramePtr.debug, metadata ![[IVAR_RESUME:[0-9]+]], metadata !DIExpression( ; CHECK: call void @llvm.dbg.value(metadata %f.Frame** %FramePtr.debug, metadata ![[IVAR_RESUME:[0-9]+]], metadata !DIExpression(
▲ Show 20 Lines • Show All 223 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-debug-frame-variable.ll

; RUN: opt < %s -passes='default<O0>' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='default<O0>' -S | FileCheck %s
; Define a function 'f' that resembles the Clang frontend's output for the ; Define a function 'f' that resembles the Clang frontend's output for the
; following C++ coroutine: ; following C++ coroutine:
; ;
; void foo() { ; void foo() {
; int i = 0; ; int i = 0;
; ++i; ; ++i;
; int x = {}; ; int x = {};
▲ Show 20 Lines • Show All 234 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-debug.ll

; Tests that debug information is sane after coro-split ; Tests that debug information is sane after coro-split
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
source_filename = "simple-repro.c" source_filename = "simple-repro.c"
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: noinline nounwind ; Function Attrs: noinline nounwind
define i8* @f(i32 %x) #0 personality i32 0 !dbg !6 { define i8* @f(i32 %x) #0 personality i32 0 !dbg !6 {
entry: entry:
▲ Show 20 Lines • Show All 201 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-eh-aware-edge-split-00.ll

; Check that we can handle edge splits leading into a landingpad ; Check that we can handle edge splits leading into a landingpad
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -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"
; CHECK-LABEL: define internal fastcc void @f.resume( ; CHECK-LABEL: define internal fastcc void @f.resume(
define void @f(i1 %cond) presplitcoroutine personality i32 0 { define void @f(i1 %cond) presplitcoroutine personality i32 0 {
entry: entry:
%id = call token @llvm.coro.id(i32 16, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 16, i8* null, i8* null, i8* null)
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-eh-aware-edge-split-01.ll

; Check that we can handle edge splits leading into a landingpad ; Check that we can handle edge splits leading into a landingpad
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -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"
; CHECK-LABEL: define internal fastcc void @g.resume( ; CHECK-LABEL: define internal fastcc void @g.resume(
define void @g(i1 %cond, i32 %x, i32 %y) presplitcoroutine personality i32 0 { define void @g(i1 %cond, i32 %x, i32 %y) presplitcoroutine personality i32 0 {
entry: entry:
%id = call token @llvm.coro.id(i32 16, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 16, i8* null, i8* null, i8* null)
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-eh-aware-edge-split-02.ll

; Check that we can handle edge splits leading into a landingpad ; Check that we can handle edge splits leading into a landingpad
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -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"
; CHECK-LABEL: define internal fastcc void @h.resume( ; CHECK-LABEL: define internal fastcc void @h.resume(
define void @h(i1 %cond, i32 %x, i32 %y) presplitcoroutine personality i32 0 { define void @h(i1 %cond, i32 %x, i32 %y) presplitcoroutine personality i32 0 {
entry: entry:
%id = call token @llvm.coro.id(i32 16, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 16, i8* null, i8* null, i8* null)
▲ Show 20 Lines • Show All 78 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-elide-musttail.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; Only run with new pass manager since old pass manager's alias analysis isn't ; Only run with new pass manager since old pass manager's alias analysis isn't
; powerful enough to tell that the tailcall's arguments don't alias the frame. ; powerful enough to tell that the tailcall's arguments don't alias the frame.
; ;
; RUN: opt < %s -passes='coro-elide' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='coro-elide' -S | FileCheck %s
; RUN: opt < %s -aa-pipeline= -passes='coro-elide' -S | FileCheck %s -check-prefix=NOAA ; RUN: opt -opaque-pointers=0 < %s -aa-pipeline= -passes='coro-elide' -S | FileCheck %s -check-prefix=NOAA
%"bar.Frame" = type { void (%"bar.Frame"*)*, void (%"bar.Frame"*)*, %"struct.coroutine<false, int>::promise_type", i1 } %"bar.Frame" = type { void (%"bar.Frame"*)*, void (%"bar.Frame"*)*, %"struct.coroutine<false, int>::promise_type", i1 }
%"struct.coroutine<false, int>::promise_type" = type { i32 } %"struct.coroutine<false, int>::promise_type" = type { i32 }
%"foo.Frame" = type { void (%"foo.Frame"*)*, void (%"foo.Frame"*)*, %"struct.coroutine<true, int>::promise_type", i1, %"struct.coroutine<true, int>::promise_type::final_awaitable" } %"foo.Frame" = type { void (%"foo.Frame"*)*, void (%"foo.Frame"*)*, %"struct.coroutine<true, int>::promise_type", i1, %"struct.coroutine<true, int>::promise_type::final_awaitable" }
%"struct.coroutine<true, int>::promise_type" = type { i32 } %"struct.coroutine<true, int>::promise_type" = type { i32 }
%"struct.coroutine<true, int>::promise_type::final_awaitable" = type { i8 } %"struct.coroutine<true, int>::promise_type::final_awaitable" = type { i8 }
@"bar.resumers" = private constant [3 x void (%"bar.Frame"*)*] [void (%"bar.Frame"*)* @"bar.resume", void (%"bar.Frame"*)* undef, void (%"bar.Frame"*)* undef] @"bar.resumers" = private constant [3 x void (%"bar.Frame"*)*] [void (%"bar.Frame"*)* @"bar.resume", void (%"bar.Frame"*)* undef, void (%"bar.Frame"*)* undef]
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-frame-arrayalloca.ll

; Check that we can handle spills of array allocas ; Check that we can handle spills of array allocas
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
declare void @consume.double.ptr(double*) declare void @consume.double.ptr(double*)
declare void @consume.i32.ptr(i32*) declare void @consume.i32.ptr(i32*)
define i8* @f() presplitcoroutine { define i8* @f() presplitcoroutine {
entry: entry:
%prefix = alloca double %prefix = alloca double
%data = alloca i32, i32 4 %data = alloca i32, i32 4
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-frame-reuse-alloca-02.ll

; Tests that variables of different type in a Corotuine whose lifetime range is not overlapping each other ; Tests that variables of different type in a Corotuine whose lifetime range is not overlapping each other
; re-use the same slot in Coroutine frame. ; re-use the same slot in Coroutine frame.
; RUN: opt < %s -passes='cgscc(coro-split<reuse-storage>),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split<reuse-storage>),simplifycfg,early-cse' -S | FileCheck %s
%"struct.task::promise_type" = type { i8 } %"struct.task::promise_type" = type { i8 }
%struct.awaitable = type { i8 } %struct.awaitable = type { i8 }
%struct.big_structure = type { [500 x i8] } %struct.big_structure = type { [500 x i8] }
%struct.big_structure.2 = type { [300 x i8] } %struct.big_structure.2 = type { [300 x i8] }
declare i8* @malloc(i64) declare i8* @malloc(i64)
declare void @consume(%struct.big_structure*) declare void @consume(%struct.big_structure*)
declare void @consume.2(%struct.big_structure.2*) declare void @consume.2(%struct.big_structure.2*)
define void @a(i1 zeroext %cond) presplitcoroutine { define void @a(i1 zeroext %cond) presplitcoroutine {
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-frame-reuse-alloca-04.ll

; Tests that variables of different type with incompatible alignment in a Corotuine whose lifetime ; Tests that variables of different type with incompatible alignment in a Corotuine whose lifetime
; range is not overlapping each other should not re-use the same slot in Coroutine frame. ; range is not overlapping each other should not re-use the same slot in Coroutine frame.
; RUN: opt < %s -passes='cgscc(coro-split<reuse-storage>),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split<reuse-storage>),simplifycfg,early-cse' -S | FileCheck %s
%"struct.task::promise_type" = type { i8 } %"struct.task::promise_type" = type { i8 }
%struct.awaitable = type { i8 } %struct.awaitable = type { i8 }
%struct.big_structure = type { [500 x i8] } %struct.big_structure = type { [500 x i8] }
%struct.big_structure.2 = type { [300 x i8] } %struct.big_structure.2 = type { [300 x i8] }
declare i8* @malloc(i64) declare i8* @malloc(i64)
declare void @consume(%struct.big_structure*) declare void @consume(%struct.big_structure*)
declare void @consume.2(%struct.big_structure.2*) declare void @consume.2(%struct.big_structure.2*)
define void @a(i1 zeroext %cond) presplitcoroutine { define void @a(i1 zeroext %cond) presplitcoroutine {
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-frame-reuse-alloca-05.ll

; Tests that variables of different type with incompatible alignment in a Corotuine whose ; Tests that variables of different type with incompatible alignment in a Corotuine whose
; lifetime range is not overlapping each other re-use the same slot in CorotuineFrame. ; lifetime range is not overlapping each other re-use the same slot in CorotuineFrame.
; RUN: opt < %s -passes='cgscc(coro-split<reuse-storage>),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split<reuse-storage>),simplifycfg,early-cse' -S | FileCheck %s
%"struct.task::promise_type" = type { i8 } %"struct.task::promise_type" = type { i8 }
%struct.awaitable = type { i8 } %struct.awaitable = type { i8 }
%struct.big_structure = type { [500 x i8] } %struct.big_structure = type { [500 x i8] }
%struct.big_structure.2 = type { [400 x i8] } %struct.big_structure.2 = type { [400 x i8] }
declare i8* @malloc(i64) declare i8* @malloc(i64)
declare void @consume(%struct.big_structure*) declare void @consume(%struct.big_structure*)
declare void @consume.2(%struct.big_structure.2*) declare void @consume.2(%struct.big_structure.2*)
define void @a(i1 zeroext %cond) presplitcoroutine { define void @a(i1 zeroext %cond) presplitcoroutine {
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-frame.ll

; Check that we can handle spills of the result of the invoke instruction ; Check that we can handle spills of the result of the invoke instruction
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
define i8* @f(i64 %this) presplitcoroutine personality i32 0 { define i8* @f(i64 %this) presplitcoroutine personality i32 0 {
entry: entry:
%this.addr = alloca i64 %this.addr = alloca i64
store i64 %this, i64* %this.addr store i64 %this, i64* %this.addr
%this1 = load i64, i64* %this.addr %this1 = load i64, i64* %this.addr
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-heap-elide.ll

; Tests that the dynamic allocation and deallocation of the coroutine frame is ; Tests that the dynamic allocation and deallocation of the coroutine frame is
; elided and any tail calls referencing the coroutine frame has the tail ; elided and any tail calls referencing the coroutine frame has the tail
; call attribute removed. ; call attribute removed.
; RUN: opt < %s -S \ ; RUN: opt -opaque-pointers=0 < %s -S \
; RUN: -passes='cgscc(inline,function(coro-elide,instsimplify,simplifycfg))' \ ; RUN: -passes='cgscc(inline,function(coro-elide,instsimplify,simplifycfg))' \
; RUN: -aa-pipeline='basic-aa' | FileCheck %s ; RUN: -aa-pipeline='basic-aa' | FileCheck %s
declare void @print(i32) nounwind declare void @print(i32) nounwind
%f.frame = type {i32} %f.frame = type {i32}
declare void @bar(i8*) declare void @bar(i8*)
▲ Show 20 Lines • Show All 353 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-padding.ll

; Check that we will insert the correct padding if natural alignment of the ; Check that we will insert the correct padding if natural alignment of the
; spilled data does not match the alignment specified in alloca instruction. ; spilled data does not match the alignment specified in alloca instruction.
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
%PackedStruct = type <{ i64 }> %PackedStruct = type <{ i64 }>
declare void @consume(%PackedStruct*) declare void @consume(%PackedStruct*)
define i8* @f() presplitcoroutine { define i8* @f() presplitcoroutine {
entry: entry:
%data = alloca %PackedStruct, align 32 %data = alloca %PackedStruct, align 32
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-param-copy.ll

; Check that we create copy the data from the alloca into the coroutine ; Check that we create copy the data from the alloca into the coroutine
; frame slot if it was written to. ; frame slot if it was written to.
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
define i8* @f() presplitcoroutine { define i8* @f() presplitcoroutine {
entry: entry:
%a.addr = alloca i64 ; read-only before coro.begin %a.addr = alloca i64 ; read-only before coro.begin
%a = load i64, i64* %a.addr ; cannot modify the value, don't need to copy %a = load i64, i64* %a.addr ; cannot modify the value, don't need to copy
%x.addr = alloca i64 %x.addr = alloca i64
call void @use(i64* %x.addr) ; uses %x.addr before coro.begin call void @use(i64* %x.addr) ; uses %x.addr before coro.begin
▲ Show 20 Lines • Show All 85 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-resume-destroy.ll

; Tests that CoroEarly pass correctly lowers coro.resume, coro.destroy ; Tests that CoroEarly pass correctly lowers coro.resume, coro.destroy
; RUN: opt < %s -S -passes=coro-early | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -S -passes=coro-early | FileCheck %s
; CHECK-LABEL: @callResume( ; CHECK-LABEL: @callResume(
define void @callResume(i8* %hdl) { define void @callResume(i8* %hdl) {
; CHECK-NEXT: entry ; CHECK-NEXT: entry
entry: entry:
; CHECK-NEXT: %0 = call i8* @llvm.coro.subfn.addr(i8* %hdl, i8 0) ; CHECK-NEXT: %0 = call i8* @llvm.coro.subfn.addr(i8* %hdl, i8 0)
; CHECK-NEXT: %1 = bitcast i8* %0 to void (i8*)* ; CHECK-NEXT: %1 = bitcast i8* %0 to void (i8*)*
; CHECK-NEXT: call fastcc void %1(i8* %hdl) ; CHECK-NEXT: call fastcc void %1(i8* %hdl)
Show All 31 Lines

llvm/test/Transforms/Coroutines/coro-retcon-alloca.ll

; 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 -passes='default<O2>' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='default<O2>' -S | FileCheck %s
target datalayout = "p:64:64:64" target datalayout = "p:64:64:64"
declare {i8*, i8*, i32} @prototype_f(i8*, i1) declare {i8*, i8*, i32} @prototype_f(i8*, i1)
define {i8*, i8*, i32} @f(i8* %buffer, i32 %n) { define {i8*, i8*, i32} @f(i8* %buffer, i32 %n) {
; CHECK-LABEL: @f( ; CHECK-LABEL: @f(
; CHECK-NEXT: coro.return: ; CHECK-NEXT: coro.return:
; CHECK-NEXT: [[N_VAL_SPILL_ADDR:%.*]] = getelementptr inbounds i8, i8* [[BUFFER:%.*]], i64 8 ; CHECK-NEXT: [[N_VAL_SPILL_ADDR:%.*]] = getelementptr inbounds i8, i8* [[BUFFER:%.*]], i64 8
▲ Show 20 Lines • Show All 234 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-retcon-frame.ll

; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
target datalayout = "p:64:64:64" target datalayout = "p:64:64:64"
declare void @prototype_f(i8*, i1) declare void @prototype_f(i8*, i1)
declare noalias i8* @allocate(i32 %size) declare noalias i8* @allocate(i32 %size)
declare void @deallocate(i8* %ptr) declare void @deallocate(i8* %ptr)
declare void @init(i64 *%ptr) declare void @init(i64 *%ptr)
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-retcon-once-value.ll

; 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 -passes='default<O2>' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='default<O2>' -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.12.0" target triple = "x86_64-apple-macosx10.12.0"
define {i8*, i32} @f(i8* %buffer, i32* %array) { define {i8*, i32} @f(i8* %buffer, i32* %array) {
; CHECK-LABEL: @f( ; CHECK-LABEL: @f(
; CHECK-NEXT: PostSpill: ; CHECK-NEXT: PostSpill:
; CHECK-NEXT: [[ARRAY_SPILL_ADDR:%.*]] = bitcast i8* [[BUFFER:%.*]] to i32** ; CHECK-NEXT: [[ARRAY_SPILL_ADDR:%.*]] = bitcast i8* [[BUFFER:%.*]] to i32**
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-retcon-resume-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 < %s -passes="default<O2>" -aa-pipeline=default -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes="default<O2>" -aa-pipeline=default -S | FileCheck %s
define i8* @f(i8* %buffer, i32 %n) { define i8* @f(i8* %buffer, i32 %n) {
; CHECK-LABEL: @f( ; CHECK-LABEL: @f(
; CHECK-NEXT: coro.return: ; CHECK-NEXT: coro.return:
; CHECK-NEXT: [[TMP0:%.*]] = tail call i8* @allocate(i32 12) ; CHECK-NEXT: [[TMP0:%.*]] = tail call i8* @allocate(i32 12)
; CHECK-NEXT: [[TMP1:%.*]] = bitcast i8* [[BUFFER:%.*]] to i8** ; CHECK-NEXT: [[TMP1:%.*]] = bitcast i8* [[BUFFER:%.*]] to i8**
; CHECK-NEXT: store i8* [[TMP0]], i8** [[TMP1]], align 8 ; CHECK-NEXT: store i8* [[TMP0]], i8** [[TMP1]], align 8
; CHECK-NEXT: [[N_SPILL_ADDR:%.*]] = bitcast i8* [[TMP0]] to i32* ; CHECK-NEXT: [[N_SPILL_ADDR:%.*]] = bitcast i8* [[TMP0]] to i32*
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-retcon-resume-values2.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --include-generated-funcs ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --include-generated-funcs
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse,simplifycfg,coro-cleanup' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse,simplifycfg,coro-cleanup' -S | FileCheck %s
define i8* @f(i8* %buffer, i32 %n) presplitcoroutine { define i8* @f(i8* %buffer, i32 %n) presplitcoroutine {
entry: entry:
%id = call token @llvm.coro.id.retcon(i32 8, i32 4, i8* %buffer, i8* bitcast (i8* (i8*, i32)* @prototype to i8*), i8* bitcast (i8* (i32)* @allocate to i8*), i8* bitcast (void (i8*)* @deallocate to i8*)) %id = call token @llvm.coro.id.retcon(i32 8, i32 4, i8* %buffer, i8* bitcast (i8* (i8*, i32)* @prototype to i8*), i8* bitcast (i8* (i32)* @allocate to i8*), i8* bitcast (void (i8*)* @deallocate to i8*))
%hdl = call i8* @llvm.coro.begin(token %id, i8* null) %hdl = call i8* @llvm.coro.begin(token %id, i8* null)
%value0 = call i32 (...) @llvm.coro.suspend.retcon.i32() %value0 = call i32 (...) @llvm.coro.suspend.retcon.i32()
%sum0 = call i32 @add(i32 %n, i32 %value0) %sum0 = call i32 @add(i32 %n, i32 %value0)
%value1 = call i32 (...) @llvm.coro.suspend.retcon.i32() %value1 = call i32 (...) @llvm.coro.suspend.retcon.i32()
▲ Show 20 Lines • Show All 85 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-retcon.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; First example from Doc/Coroutines.rst (two block loop) converted to retcon ; First example from Doc/Coroutines.rst (two block loop) converted to retcon
; RUN: opt < %s -passes='default<O2>' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='default<O2>' -S | FileCheck %s
; RUN: opt < %s -passes='module(coro-early),cgscc(coro-split),module(coro-cleanup)' -S | FileCheck --check-prefix=CORO %s ; RUN: opt -opaque-pointers=0 < %s -passes='module(coro-early),cgscc(coro-split),module(coro-cleanup)' -S | FileCheck --check-prefix=CORO %s
define i8* @f(i8* %buffer, i32 %n) { define i8* @f(i8* %buffer, i32 %n) {
; CHECK-LABEL: @f( ; CHECK-LABEL: @f(
; CHECK-NEXT: coro.return: ; CHECK-NEXT: coro.return:
; CHECK-NEXT: [[N_VAL_SPILL_ADDR:%.*]] = bitcast i8* [[BUFFER:%.*]] to i32* ; CHECK-NEXT: [[N_VAL_SPILL_ADDR:%.*]] = bitcast i8* [[BUFFER:%.*]] to i32*
; CHECK-NEXT: store i32 [[N:%.*]], i32* [[N_VAL_SPILL_ADDR]], align 4 ; CHECK-NEXT: store i32 [[N:%.*]], i32* [[N_VAL_SPILL_ADDR]], align 4
; CHECK-NEXT: tail call void @print(i32 [[N]]) ; CHECK-NEXT: tail call void @print(i32 [[N]])
; CHECK-NEXT: ret i8* bitcast (i8* (i8*, i1)* @f.resume.0 to i8*) ; CHECK-NEXT: ret i8* bitcast (i8* (i8*, i1)* @f.resume.0 to i8*)
▲ Show 20 Lines • Show All 168 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-spill-after-phi.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; Verifies that we insert spills of PHI instruction _after) all PHI Nodes ; Verifies that we insert spills of PHI instruction _after) all PHI Nodes
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse,simplifycfg' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse,simplifycfg' -S | FileCheck %s
; Verifies that the both phis are stored correctly in the coroutine frame ; Verifies that the both phis are stored correctly in the coroutine frame
; CHECK: %f.Frame = type { void (%f.Frame*)*, void (%f.Frame*)*, i32, i32, i1 } ; CHECK: %f.Frame = type { void (%f.Frame*)*, void (%f.Frame*)*, i32, i32, i1 }
define i8* @f(i1 %n) presplitcoroutine { define i8* @f(i1 %n) presplitcoroutine {
; CHECK-LABEL: @f( ; CHECK-LABEL: @f(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[ID:%.*]] = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* bitcast ([3 x void (%f.Frame*)*]* @f.resumers to i8*)) ; CHECK-NEXT: [[ID:%.*]] = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* bitcast ([3 x void (%f.Frame*)*]* @f.resumers to i8*))
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-spill-corobegin.ll

; Check that we can spills coro.begin from an inlined inner coroutine. ; Check that we can spills coro.begin from an inlined inner coroutine.
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
%g.Frame = type { void (%g.Frame*)*, void (%g.Frame*)*, i32, i1, i32 } %g.Frame = type { void (%g.Frame*)*, void (%g.Frame*)*, i32, i1, i32 }
@g.resumers = private constant [3 x void (%g.Frame*)*] [void (%g.Frame*)* @g.dummy, void (%g.Frame*)* @g.dummy, void (%g.Frame*)* @g.dummy] @g.resumers = private constant [3 x void (%g.Frame*)*] [void (%g.Frame*)* @g.dummy, void (%g.Frame*)* @g.dummy, void (%g.Frame*)* @g.dummy]
declare void @g.dummy(%g.Frame*) declare void @g.dummy(%g.Frame*)
declare i8* @g() declare i8* @g()
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-spill-defs-before-corobegin.ll

; Verifies that phi and invoke definitions before CoroBegin are spilled properly. ; Verifies that phi and invoke definitions before CoroBegin are spilled properly.
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse,simplifycfg' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse,simplifycfg' -S | FileCheck %s
define i8* @f(i1 %n) presplitcoroutine personality i32 0 { define i8* @f(i1 %n) presplitcoroutine personality i32 0 {
entry: entry:
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%size = call i32 @llvm.coro.size.i32() %size = call i32 @llvm.coro.size.i32()
%alloc = call i8* @malloc(i32 %size) %alloc = call i8* @malloc(i32 %size)
%flag = call i1 @check(i8* %alloc) %flag = call i1 @check(i8* %alloc)
br i1 %flag, label %flag_true, label %flag_false br i1 %flag, label %flag_true, label %flag_false
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-spill-promise.ll

; Check that promise object is reloaded from the correct index of the coro frame. ; Check that promise object is reloaded from the correct index of the coro frame.
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
%"class.task::promise_type" = type { [64 x i8] } %"class.task::promise_type" = type { [64 x i8] }
declare void @consume(i32*) declare void @consume(i32*)
declare void @consume2(%"class.task::promise_type"*) declare void @consume2(%"class.task::promise_type"*)
define i8* @f() presplitcoroutine { define i8* @f() presplitcoroutine {
entry: entry:
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-split-00.ll

; Tests that coro-split pass splits the coroutine into f, f.resume and f.destroy ; Tests that coro-split pass splits the coroutine into f, f.resume and f.destroy
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
define i8* @f() presplitcoroutine !func_sanitize !0 { define i8* @f() presplitcoroutine !func_sanitize !0 {
entry: entry:
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%need.alloc = call i1 @llvm.coro.alloc(token %id) %need.alloc = call i1 @llvm.coro.alloc(token %id)
br i1 %need.alloc, label %dyn.alloc, label %begin br i1 %need.alloc, label %dyn.alloc, label %begin
dyn.alloc: dyn.alloc:
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-split-02.ll

; Tests that coro-split can handle the case when a code after coro.suspend uses ; Tests that coro-split can handle the case when a code after coro.suspend uses
; a value produces between coro.save and coro.suspend (%Result.i19) ; a value produces between coro.save and coro.suspend (%Result.i19)
; and checks whether stray coro.saves are properly removed ; and checks whether stray coro.saves are properly removed
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse,simplifycfg' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse,simplifycfg' -S | FileCheck %s
%"struct.std::coroutine_handle" = type { i8* } %"struct.std::coroutine_handle" = type { i8* }
%"struct.std::coroutine_handle.0" = type { %"struct.std::coroutine_handle" } %"struct.std::coroutine_handle.0" = type { %"struct.std::coroutine_handle" }
%"struct.lean_future<int>::Awaiter" = type { i32, %"struct.std::coroutine_handle.0" } %"struct.lean_future<int>::Awaiter" = type { i32, %"struct.std::coroutine_handle.0" }
declare i8* @malloc(i64) declare i8* @malloc(i64)
declare void @print(i32) declare void @print(i32)
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-split-eh-00.ll

; Tests that coro-split removes cleanup code after coro.end in resume functions ; Tests that coro-split removes cleanup code after coro.end in resume functions
; and retains it in the start function. ; and retains it in the start function.
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
define i8* @f(i1 %val) presplitcoroutine personality i32 3 { define i8* @f(i1 %val) presplitcoroutine personality i32 3 {
entry: entry:
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%hdl = call i8* @llvm.coro.begin(token %id, i8* null) %hdl = call i8* @llvm.coro.begin(token %id, i8* null)
call void @print(i32 0) call void @print(i32 0)
br i1 %val, label %resume, label %susp br i1 %val, label %resume, label %susp
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-split-eh-01.ll

; Tests that coro-split removes cleanup code after coro.end in resume functions ; Tests that coro-split removes cleanup code after coro.end in resume functions
; and retains it in the start function. ; and retains it in the start function.
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
define i8* @f2(i1 %val) presplitcoroutine personality i32 4 { define i8* @f2(i1 %val) presplitcoroutine personality i32 4 {
entry: entry:
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%hdl = call i8* @llvm.coro.begin(token %id, i8* null) %hdl = call i8* @llvm.coro.begin(token %id, i8* null)
call void @print(i32 0) call void @print(i32 0)
br i1 %val, label %resume, label %susp br i1 %val, label %resume, label %susp
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-split-hidden.ll

; Tests that coro-split can convert functions with hidden visibility. ; Tests that coro-split can convert functions with hidden visibility.
; These may be generated by a frontend such as Clang, when inlining with ; These may be generated by a frontend such as Clang, when inlining with
; '-fvisibility-inlines-hidden'. ; '-fvisibility-inlines-hidden'.
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
define hidden i8* @f() presplitcoroutine { define hidden i8* @f() presplitcoroutine {
entry: entry:
%id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null) %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
%need.alloc = call i1 @llvm.coro.alloc(token %id) %need.alloc = call i1 @llvm.coro.alloc(token %id)
br i1 %need.alloc, label %dyn.alloc, label %begin br i1 %need.alloc, label %dyn.alloc, label %begin
dyn.alloc: dyn.alloc:
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-split-sink-lifetime-01.ll

; Tests that coro-split will optimize the lifetime.start maker of each local variable, ; Tests that coro-split will optimize the lifetime.start maker of each local variable,
; sink them to the places after the suspend block. ; sink them to the places after the suspend block.
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse,simplifycfg' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse,simplifycfg' -S | FileCheck %s
%"struct.std::coroutine_handle" = type { i8* } %"struct.std::coroutine_handle" = type { i8* }
%"struct.std::coroutine_handle.0" = type { %"struct.std::coroutine_handle" } %"struct.std::coroutine_handle.0" = type { %"struct.std::coroutine_handle" }
%"struct.lean_future<int>::Awaiter" = type { i32, %"struct.std::coroutine_handle.0" } %"struct.lean_future<int>::Awaiter" = type { i32, %"struct.std::coroutine_handle.0" }
declare i8* @malloc(i64) declare i8* @malloc(i64)
declare void @print(i32) declare void @print(i32)
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-split-sink-lifetime-03.ll

; Corresponding to coro-split-sink-lifetime-01.ll. This file tests that whether the CoroFrame ; Corresponding to coro-split-sink-lifetime-01.ll. This file tests that whether the CoroFrame
; pass knows the operand of lifetime.start intrinsic may be GEP as well. ; pass knows the operand of lifetime.start intrinsic may be GEP as well.
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse,simplifycfg' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse,simplifycfg' -S | FileCheck %s
%"struct.std::coroutine_handle" = type { i8* } %"struct.std::coroutine_handle" = type { i8* }
%"struct.std::coroutine_handle.0" = type { %"struct.std::coroutine_handle" } %"struct.std::coroutine_handle.0" = type { %"struct.std::coroutine_handle" }
%"struct.lean_future<int>::Awaiter" = type { i32, %"struct.std::coroutine_handle.0" } %"struct.lean_future<int>::Awaiter" = type { i32, %"struct.std::coroutine_handle.0" }
declare i8* @malloc(i64) declare i8* @malloc(i64)
declare void @print(i32) declare void @print(i32)
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-split-sink-lifetime-04.ll

; Tests that coro-split will optimize the lifetime.start maker of each local variable, ; Tests that coro-split will optimize the lifetime.start maker of each local variable,
; sink them to the places after the suspend block. ; sink them to the places after the suspend block.
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse,simplifycfg' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse,simplifycfg' -S | FileCheck %s
%"struct.std::coroutine_handle" = type { i8* } %"struct.std::coroutine_handle" = type { i8* }
%"struct.std::coroutine_handle.0" = type { %"struct.std::coroutine_handle" } %"struct.std::coroutine_handle.0" = type { %"struct.std::coroutine_handle" }
%"struct.lean_future<int>::Awaiter" = type { i32, %"struct.std::coroutine_handle.0" } %"struct.lean_future<int>::Awaiter" = type { i32, %"struct.std::coroutine_handle.0" }
declare i8* @malloc(i64) declare i8* @malloc(i64)
declare void @print(i32) declare void @print(i32)
declare void @consume.i8(i8) declare void @consume.i8(i8)
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-swifterror.ll

; 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 -passes='default<O2>' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='default<O2>' -S | FileCheck %s
target datalayout = "E-p:32:32" target datalayout = "E-p:32:32"
define i8* @f(i8* %buffer, i32 %n, i8** swifterror %errorslot) { define i8* @f(i8* %buffer, i32 %n, i8** swifterror %errorslot) {
; CHECK-LABEL: @f( ; CHECK-LABEL: @f(
; CHECK-NEXT: coro.return: ; CHECK-NEXT: coro.return:
; CHECK-NEXT: [[N_VAL_SPILL_ADDR:%.*]] = bitcast i8* [[BUFFER:%.*]] to i32* ; CHECK-NEXT: [[N_VAL_SPILL_ADDR:%.*]] = bitcast i8* [[BUFFER:%.*]] to i32*
; CHECK-NEXT: store i32 [[N:%.*]], i32* [[N_VAL_SPILL_ADDR]], align 4 ; CHECK-NEXT: store i32 [[N:%.*]], i32* [[N_VAL_SPILL_ADDR]], align 4
; CHECK-NEXT: tail call void @print(i32 [[N]]) ; CHECK-NEXT: tail call void @print(i32 [[N]])
▲ Show 20 Lines • Show All 93 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-zero-alloca.ll

; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
declare i8* @malloc(i64) declare i8* @malloc(i64)
declare void @free(i8*) declare void @free(i8*)
declare void @usePointer(i8*) declare void @usePointer(i8*)
declare void @usePointer2([0 x i8]*) declare void @usePointer2([0 x i8]*)
declare token @llvm.coro.id(i32, i8* readnone, i8* nocapture readonly, i8*) declare token @llvm.coro.id(i32, i8* readnone, i8* nocapture readonly, i8*)
declare i64 @llvm.coro.size.i64() declare i64 @llvm.coro.size.i64()
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/no-suspend.ll

; Test no suspend coroutines ; Test no suspend coroutines
; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse,simplifycfg' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(coro-split),simplifycfg,early-cse,simplifycfg' -S | FileCheck %s
; Coroutine with no-suspends will turn into: ; Coroutine with no-suspends will turn into:
; ;
; CHECK-LABEL: define void @no_suspends( ; CHECK-LABEL: define void @no_suspends(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: alloca ; CHECK-NEXT: alloca
; CHECK-NEXT: bitcast ; CHECK-NEXT: bitcast
; CHECK-NEXT: call void @print(i32 %n) ; CHECK-NEXT: call void @print(i32 %n)
▲ Show 20 Lines • Show All 422 Lines • Show Last 20 Lines

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

; RUN: opt -S -passes=gvn < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -S -passes=gvn < %s | FileCheck %s
define i32 @test1(i32* %p, i1 %C) { define i32 @test1(i32* %p, i1 %C) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
block1: block1:
br i1 %C, label %block2, label %block3 br i1 %C, label %block2, label %block3
block2: block2:
br label %block4 br label %block4
Show All 15 Lines

llvm/test/Transforms/GVNHoist/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 -passes=gvn-hoist -S < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -passes=gvn-hoist -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"
@GlobalVar = internal global float 1.000000e+00 @GlobalVar = internal global float 1.000000e+00
; Check that all scalar expressions are hoisted. ; Check that all scalar expressions are hoisted.
define float @scalarsHoisting(float %d, float %min, float %max, float %a) { define float @scalarsHoisting(float %d, float %min, float %max, float %a) {
; CHECK-LABEL: @scalarsHoisting( ; CHECK-LABEL: @scalarsHoisting(
▲ Show 20 Lines • Show All 876 Lines • Show Last 20 Lines

llvm/test/Transforms/Inline/AArch64/sve-alloca-merge.ll

; RUN: opt -mtriple=aarch64--linux-gnu -mattr=+sve < %s -passes=inline -S | FileCheck %s ; RUN: opt -opaque-pointers=0 -mtriple=aarch64--linux-gnu -mattr=+sve < %s -passes=inline -S | FileCheck %s
define void @bar(<vscale x 2 x i64>* %a) { define void @bar(<vscale x 2 x i64>* %a) {
entry: entry:
%b = alloca <vscale x 2 x i64>, align 16 %b = alloca <vscale x 2 x i64>, align 16
store <vscale x 2 x i64> zeroinitializer, <vscale x 2 x i64>* %b, align 16 store <vscale x 2 x i64> zeroinitializer, <vscale x 2 x i64>* %b, align 16
%c = load <vscale x 2 x i64>, <vscale x 2 x i64>* %a, align 16 %c = load <vscale x 2 x i64>, <vscale x 2 x i64>* %a, align 16
%d = load <vscale x 2 x i64>, <vscale x 2 x i64>* %b, align 16 %d = load <vscale x 2 x i64>, <vscale x 2 x i64>* %b, align 16
%e = add <vscale x 2 x i64> %c, %d %e = add <vscale x 2 x i64> %c, %d
Show All 20 Lines

llvm/test/Transforms/Inline/alloca-dbgdeclare.ll

; RUN: opt -passes=inline -S < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -passes=inline -S < %s | FileCheck %s
; RUN: opt -passes='cgscc(inline)' -S < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -passes='cgscc(inline)' -S < %s | FileCheck %s
; struct A { ; struct A {
; int arg0; ; int arg0;
; double arg1[2]; ; double arg1[2];
; } a, b; ; } a, b;
; ;
; void fn3(A p1) { ; void fn3(A p1) {
; if (p1.arg0) ; if (p1.arg0)
; a = p1; ; a = p1;
▲ Show 20 Lines • Show All 125 Lines • Show Last 20 Lines

llvm/test/Transforms/Inline/inline-skip-use-empty-alloca.ll

; RUN: opt < %s -S -passes=inline | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -S -passes=inline | FileCheck %s
; RUN: opt < %s -S -strip-debug -passes=inline | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -S -strip-debug -passes=inline | FileCheck %s
; https://bugs.llvm.org/show_bug.cgi?id=43291 ; https://bugs.llvm.org/show_bug.cgi?id=43291
; The purpose of this test is to check if there is use_empty in the inner loop when scanning ; The purpose of this test is to check if there is use_empty in the inner loop when scanning
; blocks of allocas, if the alloca is use_empty, skip it when allocas inlining. ; blocks of allocas, if the alloca is use_empty, skip it when allocas inlining.
define void @foo(i16 %k) !dbg !6 { define void @foo(i16 %k) !dbg !6 {
call void @llvm.dbg.value(metadata i16 %k, metadata !14, metadata !DIExpression()), !dbg !15 call void @llvm.dbg.value(metadata i16 %k, metadata !14, metadata !DIExpression()), !dbg !15
%alloca_a = alloca i32 %alloca_a = alloca i32
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

llvm/test/Transforms/Inline/inline-tail.ll

; RUN: opt < %s -passes=inline -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes=inline -S | FileCheck %s
; RUN: opt < %s -passes='cgscc(inline)' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='cgscc(inline)' -S | FileCheck %s
; We have to apply the less restrictive TailCallKind of the call site being ; We have to apply the less restrictive TailCallKind of the call site being
; inlined and any call sites cloned into the caller. ; inlined and any call sites cloned into the caller.
; No tail marker after inlining, since test_capture_c captures an alloca. ; No tail marker after inlining, since test_capture_c captures an alloca.
; CHECK: define void @test_capture_a( ; CHECK: define void @test_capture_a(
; CHECK-NOT: tail ; CHECK-NOT: tail
; CHECK: call void @test_capture_c( ; CHECK: call void @test_capture_c(
▲ Show 20 Lines • Show All 209 Lines • Show Last 20 Lines

llvm/test/Transforms/Inline/lifetime-no-datalayout.ll

; RUN: opt -passes=inline -S < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -passes=inline -S < %s | FileCheck %s
; RUN: opt -passes='cgscc(inline)' -S < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -passes='cgscc(inline)' -S < %s | FileCheck %s
declare void @use(i8* %a) declare void @use(i8* %a)
define void @helper() { define void @helper() {
%a = alloca i8 %a = alloca i8
call void @use(i8* %a) call void @use(i8* %a)
ret void ret void
} }
Show All 14 Lines

llvm/test/Transforms/Inline/lifetime.ll

; RUN: opt -passes=inline -S < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -passes=inline -S < %s | FileCheck %s
; RUN: opt -passes='cgscc(inline)' -S < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -passes='cgscc(inline)' -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"
declare void @llvm.lifetime.start.p0i8(i64, i8*) declare void @llvm.lifetime.start.p0i8(i64, i8*)
declare void @llvm.lifetime.end.p0i8(i64, i8*) declare void @llvm.lifetime.end.p0i8(i64, i8*)
define void @helper_both_markers() { define void @helper_both_markers() {
%a = alloca i8 %a = alloca i8
; Size in llvm.lifetime.start / llvm.lifetime.end differs from ; Size in llvm.lifetime.start / llvm.lifetime.end differs from
▲ Show 20 Lines • Show All 108 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/2011-06-13-nsw-alloca.ll

; RUN: opt -S -passes=instcombine < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -S -passes=instcombine < %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-darwin10.0.0" target triple = "i386-apple-darwin10.0.0"
; CHECK-LABEL: define void @fu1( ; CHECK-LABEL: define void @fu1(
define void @fu1(i32 %parm) #0 { define void @fu1(i32 %parm) #0 {
bb: bb:
%i = alloca i32, align 4 %i = alloca i32, align 4
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/2011-09-03-Trampoline.ll

; RUN: opt -passes=instcombine -S < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -passes=instcombine -S < %s | FileCheck %s
declare void @llvm.init.trampoline(i8*, i8*, i8*) declare void @llvm.init.trampoline(i8*, i8*, i8*)
declare i8* @llvm.adjust.trampoline(i8*) declare i8* @llvm.adjust.trampoline(i8*)
declare i32 @f(i8 * nest, i32) declare i32 @f(i8 * nest, i32)
; Most common case ; Most common case
define i32 @test0(i32 %n) !dbg !4 { define i32 @test0(i32 %n) !dbg !4 {
%alloca = alloca [10 x i8], align 16 %alloca = alloca [10 x i8], align 16
▲ Show 20 Lines • Show All 93 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/2011-10-07-AlignPromotion.ll

; RUN: opt -S -passes=instcombine < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -S -passes=instcombine < %s | FileCheck %s
; rdar://problem/10063307 ; rdar://problem/10063307
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"
target triple = "thumbv7-apple-ios5.0.0" target triple = "thumbv7-apple-ios5.0.0"
%0 = type { [2 x i32] } %0 = type { [2 x i32] }
%struct.CGPoint = type { float, float } %struct.CGPoint = type { float, float }
define void @t(%struct.CGPoint* %a) nounwind { define void @t(%struct.CGPoint* %a) nounwind {
Show All 11 Lines

llvm/test/Transforms/InstCombine/bitcast-function.ll

; RUN: opt -S -passes=instcombine -o - %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -S -passes=instcombine -o - %s | FileCheck %s
target datalayout = "e-p:32:32:32-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v16:16:16-v24:32:32-v32:32:32-v64:64:64-v128:128:128-a0:0:64" target datalayout = "e-p:32:32:32-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v16:16:16-v24:32:32-v32:32:32-v64:64:64-v128:128:128-a0:0:64"
define internal <2 x i32> @func_v2i32(<2 x i32> %v) noinline nounwind { define internal <2 x i32> @func_v2i32(<2 x i32> %v) noinline nounwind {
entry: entry:
ret <2 x i32> %v ret <2 x i32> %v
} }
define internal <2 x float> @func_v2f32(<2 x float> %v) noinline nounwind { define internal <2 x float> @func_v2f32(<2 x float> %v) noinline nounwind {
▲ Show 20 Lines • Show All 197 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/bitcast-store.ll

; RUN: opt -S -passes=instcombine < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -S -passes=instcombine < %s | FileCheck %s
; Instcombine should preserve metadata and alignment while ; Instcombine should preserve metadata and alignment while
; folding a bitcast into a store. ; folding a bitcast into a store.
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32: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"
%struct.A = type { i32 (...)** } %struct.A = type { i32 (...)** }
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/call-cast-target-inalloca.ll

; RUN: opt < %s -passes=instcombine -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes=instcombine -S | FileCheck %s
target datalayout = "e-p:32:32" target datalayout = "e-p:32:32"
target triple = "i686-pc-linux-gnu" target triple = "i686-pc-linux-gnu"
declare void @takes_i32(i32) declare void @takes_i32(i32)
declare void @takes_i32_inalloca(i32* inalloca(i32)) declare void @takes_i32_inalloca(i32* inalloca(i32))
define void @f() { define void @f() {
Show All 13 Lines

llvm/test/Transforms/InstCombine/call-cast-target-preallocated.ll

; RUN: opt < %s -passes=instcombine -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes=instcombine -S | FileCheck %s
target datalayout = "e-p:32:32" target datalayout = "e-p:32:32"
target triple = "i686-pc-win32" target triple = "i686-pc-win32"
declare token @llvm.call.preallocated.setup(i32) declare token @llvm.call.preallocated.setup(i32)
declare i8* @llvm.call.preallocated.arg(token, i32) declare i8* @llvm.call.preallocated.arg(token, i32)
Show All 19 Lines

llvm/test/Transforms/InstCombine/call.ll

; Ignore stderr, we expect warnings there ; Ignore stderr, we expect warnings there
; RUN: opt < %s -passes=instcombine 2> /dev/null -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes=instcombine 2> /dev/null -S | FileCheck %s
target datalayout = "E-p:64:64:64-p1:16:16:16-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-p1:16:16:16-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"
; Simple case, argument translatable without changing the value ; Simple case, argument translatable without changing the value
declare void @test1a(i8*) declare void @test1a(i8*)
define void @test1(i32* %A) { define void @test1(i32* %A) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
▲ Show 20 Lines • Show All 290 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/callsite_nonnull_args_through_casts.ll

; RUN: opt -passes=instcombine -S < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -passes=instcombine -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"
declare void @foo(i8*) declare void @foo(i8*)
declare void @bar(i8 addrspace(1)*) declare void @bar(i8 addrspace(1)*)
define void @nonnullAfterBitCast() { define void @nonnullAfterBitCast() {
entry: entry:
▲ Show 20 Lines • Show All 90 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/dbg-cast-of-allocation.ll

; RUN: opt -S --passes=instcombine %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -S --passes=instcombine %s | FileCheck %s
; https://github.com/llvm/llvm-project/issues/56807 ; https://github.com/llvm/llvm-project/issues/56807
%si16 = type { i8, i8 } %si16 = type { i8, i8 }
declare void @foo(i16* %pixels) declare void @foo(i16* %pixels)
declare void @llvm.dbg.declare(metadata, metadata, metadata) declare void @llvm.dbg.declare(metadata, metadata, metadata)
Show All 33 Lines

llvm/test/Transforms/InstCombine/debuginfo-dce.ll

; RUN: opt -passes=instcombine %s -S -o - | FileCheck %s ; RUN: opt -opaque-pointers=0 -passes=instcombine %s -S -o - | FileCheck %s
; Verify that the eliminated instructions (bitcast, gep, load) are salvaged into ; Verify that the eliminated instructions (bitcast, gep, load) are salvaged into
; a DIExpression. ; a DIExpression.
; ;
; Originally created from the following C source and then heavily isolated/reduced. ; Originally created from the following C source and then heavily isolated/reduced.
; ;
; struct entry { ; struct entry {
; struct entry *next; ; struct entry *next;
; }; ; };
▲ Show 20 Lines • Show All 132 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/do-not-clone-dbg-declare.ll

; RUN: opt < %s -passes=instcombine,verify -S -o - | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes=instcombine,verify -S -o - | FileCheck %s
; Hand-reduced from this example. ; Hand-reduced from this example.
; -g -O -mllvm -disable-llvm-optzns -gno-column-info ; -g -O -mllvm -disable-llvm-optzns -gno-column-info
; plus opt -sroa -passes=instcombine -inline ; plus opt -opaque-pointers=0 -sroa -passes=instcombine -inline
; #include <stdio.h> ; #include <stdio.h>
; ;
; struct S1 { ; struct S1 {
; int p1; ; int p1;
; int p2; ; int p2;
; ;
; bool IsNull ( ) { ; bool IsNull ( ) {
▲ Show 20 Lines • Show All 130 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/gep-combine-loop-invariant.ll

; 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 -passes='require<loops>,instcombine' -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes='require<loops>,instcombine' -S | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define i32 @foo(i8* nocapture readnone %match, i32 %cur_match, i32 %best_len, i32 %scan_end, i32* nocapture readonly %prev, i32 %limit, i32 %chain_length, i8* nocapture readonly %win, i32 %wmask) { define i32 @foo(i8* nocapture readnone %match, i32 %cur_match, i32 %best_len, i32 %scan_end, i32* nocapture readonly %prev, i32 %limit, i32 %chain_length, i8* nocapture readonly %win, i32 %wmask) {
; CHECK-LABEL: @foo( ; CHECK-LABEL: @foo(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[IDX_EXT2:%.*]] = zext i32 [[CUR_MATCH:%.*]] to i64 ; CHECK-NEXT: [[IDX_EXT2:%.*]] = zext i32 [[CUR_MATCH:%.*]] to i64
; CHECK-NEXT: [[ADD_PTR4:%.*]] = getelementptr inbounds i8, i8* [[WIN:%.*]], i64 [[IDX_EXT2]] ; CHECK-NEXT: [[ADD_PTR4:%.*]] = getelementptr inbounds i8, i8* [[WIN:%.*]], i64 [[IDX_EXT2]]
▲ Show 20 Lines • Show All 330 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/intptr2.ll

; RUN: opt < %s -passes=instcombine -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes=instcombine -S | FileCheck %s
define void @test1(float* %a, float* readnone %a_end, i32* %b.i) { define void @test1(float* %a, float* readnone %a_end, i32* %b.i) {
; CHECK-LABEL: @test1 ; CHECK-LABEL: @test1
entry: entry:
%cmp1 = icmp ult float* %a, %a_end %cmp1 = icmp ult float* %a, %a_end
br i1 %cmp1, label %for.body.preheader, label %for.end br i1 %cmp1, label %for.body.preheader, label %for.end
for.body.preheader: ; preds = %entry for.body.preheader: ; preds = %entry
Show All 30 Lines

llvm/test/Transforms/InstCombine/memset2.ll

; RUN: opt < %s -passes=instcombine -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes=instcombine -S | FileCheck %s
; Test to check that instcombine doesn't drop the address space when optimizing ; Test to check that instcombine doesn't drop the address space when optimizing
; memset. ; memset.
%struct.Moves = type { [9 x i8], i8, i8, i8, [5 x i8] } %struct.Moves = type { [9 x i8], i8, i8, i8, [5 x i8] }
define i32 @test(%struct.Moves addrspace(1)* nocapture %moves) { define i32 @test(%struct.Moves addrspace(1)* nocapture %moves) {
entry: entry:
; CHECK: bitcast i8 addrspace(1)* %gep to i64 addrspace(1)* ; CHECK: bitcast i8 addrspace(1)* %gep to i64 addrspace(1)*
%gep = getelementptr inbounds %struct.Moves, %struct.Moves addrspace(1)* %moves, i32 1, i32 0, i32 9 %gep = getelementptr inbounds %struct.Moves, %struct.Moves addrspace(1)* %moves, i32 1, i32 0, i32 9
call void @llvm.memset.p1i8.i64(i8 addrspace(1)* %gep, i8 0, i64 8, i1 false) call void @llvm.memset.p1i8.i64(i8 addrspace(1)* %gep, i8 0, i64 8, i1 false)
ret i32 0 ret i32 0
} }
declare void @llvm.memset.p1i8.i64(i8addrspace(1)* nocapture, i8, i64, i1) nounwind declare void @llvm.memset.p1i8.i64(i8addrspace(1)* nocapture, i8, i64, i1) nounwind

llvm/test/Transforms/LoopDistribute/basic-with-memchecks.ll

; RUN: opt -aa-pipeline=basic-aa -passes=loop-distribute -enable-loop-distribute -verify-loop-info -verify-dom-info -S \ ; RUN: opt -opaque-pointers=0 -aa-pipeline=basic-aa -passes=loop-distribute -enable-loop-distribute -verify-loop-info -verify-dom-info -S \
; RUN: < %s | FileCheck %s ; RUN: < %s | FileCheck %s
; RUN: opt -aa-pipeline=basic-aa -passes='loop-distribute,loop-vectorize' -enable-loop-distribute -force-vector-width=4 \ ; RUN: opt -opaque-pointers=0 -aa-pipeline=basic-aa -passes='loop-distribute,loop-vectorize' -enable-loop-distribute -force-vector-width=4 \
; RUN: -verify-loop-info -verify-dom-info -S < %s | \ ; RUN: -verify-loop-info -verify-dom-info -S < %s | \
; RUN: FileCheck --check-prefix=VECTORIZE %s ; RUN: FileCheck --check-prefix=VECTORIZE %s
; RUN: opt -aa-pipeline=basic-aa -passes='loop-distribute,print<access-info>' -enable-loop-distribute \ ; RUN: opt -opaque-pointers=0 -aa-pipeline=basic-aa -passes='loop-distribute,print<access-info>' -enable-loop-distribute \
; RUN: -verify-loop-info -verify-dom-info -disable-output < %s 2>&1 | FileCheck %s --check-prefix=ANALYSIS ; RUN: -verify-loop-info -verify-dom-info -disable-output < %s 2>&1 | FileCheck %s --check-prefix=ANALYSIS
; The memcheck version of basic.ll. We should distribute and vectorize the ; The memcheck version of basic.ll. We should distribute and vectorize the
; second part of this loop with 5 memchecks (A+1 x {C, D, E} + C x {A, B}) ; second part of this loop with 5 memchecks (A+1 x {C, D, E} + C x {A, B})
; ;
; 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 272 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopDistribute/followup.ll

; RUN: opt -passes=loop-distribute -S < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -passes=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/outside-use.ll

; RUN: opt -passes=loop-distribute -enable-loop-distribute -verify-loop-info -verify-dom-info -S < %s \ ; RUN: opt -opaque-pointers=0 -passes=loop-distribute -enable-loop-distribute -verify-loop-info -verify-dom-info -S < %s \
; RUN: | FileCheck %s ; RUN: | FileCheck %s
; Check that definitions used outside the loop are handled correctly: (1) they ; Check that definitions used outside the loop are handled correctly: (1) they
; are not dropped (2) when version the loop, a phi is added to merge the value ; are not dropped (2) when version the loop, a phi is added to merge the value
; from the non-distributed loop and the distributed loop. ; from the non-distributed loop and the distributed loop.
; ;
; 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 64 Lines • Show Last 20 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 -passes=loop-distribute -enable-loop-distribute -S -enable-mem-access-versioning=0 < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -passes=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/LoopReroll/basic.ll

; RUN: opt < %s -passes=loop-reroll -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes=loop-reroll -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"
; int foo(int a); ; int foo(int a);
; void bar(int *x) { ; void bar(int *x) {
; for (int i = 0; i < 500; i += 3) { ; for (int i = 0; i < 500; i += 3) {
; foo(i); ; foo(i);
; foo(i+1); ; foo(i+1);
▲ Show 20 Lines • Show All 826 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopReroll/complex_reroll.ll

; 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 -passes=loop-reroll %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -S -passes=loop-reroll %s | FileCheck %s
declare i32 @goo(i32, i32) declare i32 @goo(i32, i32)
@buf = external global i8* @buf = external global i8*
@aaa = global [16 x i8] c"\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F\10", align 1 @aaa = global [16 x i8] c"\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F\10", align 1
define i32 @test1(i32 %len) { define i32 @test1(i32 %len) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
▲ Show 20 Lines • Show All 226 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopReroll/extra_instr.ll

; RUN: opt -S -passes=loop-reroll %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -S -passes=loop-reroll %s | FileCheck %s
target triple = "aarch64--linux-gnu" target triple = "aarch64--linux-gnu"
define void @rerollable1([2 x i32]* nocapture %a) { define void @rerollable1([2 x i32]* nocapture %a) {
entry: entry:
br label %loop br label %loop
loop: loop:
▲ Show 20 Lines • Show All 259 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopReroll/ptrindvar.ll

; RUN: opt -S -passes=loop-reroll %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -S -passes=loop-reroll %s | FileCheck %s
target triple = "aarch64--linux-gnu" target triple = "aarch64--linux-gnu"
define i32 @test(i32* readonly %buf, i32* readnone %end) #0 { define i32 @test(i32* readonly %buf, i32* readnone %end) #0 {
entry: entry:
%cmp.9 = icmp eq i32* %buf, %end %cmp.9 = icmp eq i32* %buf, %end
br i1 %cmp.9, label %while.end, label %while.body.preheader br i1 %cmp.9, label %while.end, label %while.body.preheader
while.body.preheader: while.body.preheader:
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopStrengthReduce/2011-10-06-ReusePhi.ll

; RUN: opt -loop-reduce -S < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -loop-reduce -S < %s | FileCheck %s
; ;
; Test LSR's intelligence regarding phi reuse. ; Test LSR's intelligence regarding phi reuse.
; Verify that scaled GEPs are not reused. rdar://5064068 ; Verify that scaled GEPs are not reused. rdar://5064068
target triple = "x86_64-apple-darwin" target triple = "x86_64-apple-darwin"
; Provide legal integer types. ; Provide legal integer types.
target datalayout = "n8:16:32:64" target datalayout = "n8:16:32:64"
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopStrengthReduce/2011-12-19-PostincQuadratic.ll

; RUN: opt -loop-reduce -S < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -loop-reduce -S < %s | FileCheck %s
; ;
; PR11571: handle a postinc user outside of for.body7 that requires ; PR11571: handle a postinc user outside of for.body7 that requires
; recursive expansion of a quadratic recurrence within for.body7. LSR ; recursive expansion of a quadratic recurrence within for.body7. LSR
; needs to forget that for.body7 is a postinc loop during expansion. ; needs to forget that for.body7 is a postinc loop during expansion.
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32-n8:16:32-S128" target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32-n8:16:32-S128"
target triple = "i386-unknown-freebsd10.0" target triple = "i386-unknown-freebsd10.0"
Show All 30 Lines

llvm/test/Transforms/LoopStrengthReduce/AArch64/lsr-memcpy.ll

; RUN: llc -mtriple=arm64-unknown-unknown -mcpu=cyclone -pre-RA-sched=list-hybrid < %s | FileCheck %s ; RUN: llc -opaque-pointers=0 -mtriple=arm64-unknown-unknown -mcpu=cyclone -pre-RA-sched=list-hybrid < %s | FileCheck %s
; rdar://10232252 ; rdar://10232252
; Prevent LSR of doing poor choice that cannot be folded in addressing mode ; Prevent LSR of doing poor choice that cannot be folded in addressing mode
; Remove the -pre-RA-sched=list-hybrid option after fixing: ; Remove the -pre-RA-sched=list-hybrid option after fixing:
; <rdar://problem/12702735> [ARM64][coalescer] need better register ; <rdar://problem/12702735> [ARM64][coalescer] need better register
; coalescing for simple unit tests. ; coalescing for simple unit tests.
; CHECK: testCase ; CHECK: testCase
Show All 24 Lines

llvm/test/Transforms/LoopStrengthReduce/AMDGPU/atomics.ll

; RUN: opt -S -mtriple=amdgcn-- -mcpu=bonaire -loop-reduce < %s | FileCheck -check-prefix=OPT %s ; RUN: opt -opaque-pointers=0 -S -mtriple=amdgcn-- -mcpu=bonaire -loop-reduce < %s | FileCheck -check-prefix=OPT %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 the pointer / address space of AtomicRMW is considered ; Make sure the pointer / address space of AtomicRMW is considered
; OPT-LABEL: @test_local_atomicrmw_addressing_loop_uniform_index_max_offset_i32( ; OPT-LABEL: @test_local_atomicrmw_addressing_loop_uniform_index_max_offset_i32(
; OPT: .lr.ph.preheader: ; OPT: .lr.ph.preheader:
▲ Show 20 Lines • Show All 164 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopStrengthReduce/AMDGPU/different-addrspace-addressing-mode-loops.ll

; RUN: opt -S -mtriple=amdgcn-- -mcpu=bonaire -loop-reduce < %s | FileCheck -check-prefix=OPT %s ; RUN: opt -opaque-pointers=0 -S -mtriple=amdgcn-- -mcpu=bonaire -loop-reduce < %s | FileCheck -check-prefix=OPT %s
; Test that loops with different maximum offsets for different address ; Test that loops with different maximum offsets for different address
; spaces are correctly handled. ; spaces are correctly handled.
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"
; OPT-LABEL: @test_global_addressing_loop_uniform_index_max_offset_i32( ; OPT-LABEL: @test_global_addressing_loop_uniform_index_max_offset_i32(
; OPT: .lr.ph.preheader: ; OPT: .lr.ph.preheader:
▲ Show 20 Lines • Show All 153 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopStrengthReduce/AMDGPU/lsr-invalid-ptr-extend.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -march=amdgcn -loop-reduce -S < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -march=amdgcn -loop-reduce -S < %s | FileCheck %s
; REQUIRES: asserts ; REQUIRES: asserts
; Test that LSR does not attempt to extend a pointer type to an integer type, ; Test that LSR does not attempt to extend a pointer type to an integer type,
; which causes a SCEV analysis assertion. ; which causes a SCEV analysis assertion.
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-G1-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-G1-ni:7"
target triple = "amdgcn-amd-amdhsa" target triple = "amdgcn-amd-amdhsa"
▲ Show 20 Lines • Show All 105 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopStrengthReduce/AMDGPU/preserve-addrspace-assert.ll

; RUN: opt -S -mtriple=amdgcn-amd-amdhsa -loop-reduce %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -S -mtriple=amdgcn-amd-amdhsa -loop-reduce %s | FileCheck %s
; Test for assert resulting from inconsistent isLegalAddressingMode ; Test for assert resulting from inconsistent isLegalAddressingMode
; answers when the address space was dropped from the query. ; answers when the address space was dropped from the query.
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"
%0 = type { i32, double, i32, float } %0 = type { i32, double, i32, float }
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopStrengthReduce/ARM/complexity.ll

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"
; RUN: opt -mtriple=thumbv7em %s -S -loop-reduce -lsr-complexity-limit=65536 -o - | FileCheck %s ; RUN: opt -opaque-pointers=0 -mtriple=thumbv7em %s -S -loop-reduce -lsr-complexity-limit=65536 -o - | FileCheck %s
; RUN: opt -mtriple=thumbv7em %s -S -loop-reduce -lsr-complexity-limit=2147483647 -o - | FileCheck %s ; RUN: opt -opaque-pointers=0 -mtriple=thumbv7em %s -S -loop-reduce -lsr-complexity-limit=2147483647 -o - | FileCheck %s
; CHECK-LABEL: for.body12.us.us: ; CHECK-LABEL: for.body12.us.us:
; CHECK: [[LSR_IV6:%[^ ]+]] = phi i16* [ [[SCEVGEP7:%[^ ]+]], %for.body12.us.us ], [ [[SCEVGEP5:%[^ ]+]], %for.cond9.preheader.us.us ] ; CHECK: [[LSR_IV6:%[^ ]+]] = phi i16* [ [[SCEVGEP7:%[^ ]+]], %for.body12.us.us ], [ [[SCEVGEP5:%[^ ]+]], %for.cond9.preheader.us.us ]
; CHECK: phi i32 ; CHECK: phi i32
; CHECK: [[LSR_IV:%[^ ]+]] = phi i16* [ [[SCEVGEP1:%[^ ]+]], %for.body12.us.us ], [ [[SCEVGEP:%[^ ]+]], %for.cond9.preheader.us.us ] ; CHECK: [[LSR_IV:%[^ ]+]] = phi i16* [ [[SCEVGEP1:%[^ ]+]], %for.body12.us.us ], [ [[SCEVGEP:%[^ ]+]], %for.cond9.preheader.us.us ]
; CHECK: phi i32 ; CHECK: phi i32
; CHECK: [[SCEVGEP1]] = getelementptr i16, i16* [[LSR_IV]], i32 4 ; CHECK: [[SCEVGEP1]] = getelementptr i16, i16* [[LSR_IV]], i32 4
; CHECK: [[SCEVGEP7]] = getelementptr i16, i16* [[LSR_IV6]], i32 4 ; CHECK: [[SCEVGEP7]] = getelementptr i16, i16* [[LSR_IV6]], i32 4
▲ Show 20 Lines • Show All 100 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopStrengthReduce/ARM/ivchain-ARM.ll

; RUN: llc -O3 -mtriple=thumb-eabi -mcpu=cortex-a9 %s -o - | FileCheck %s -check-prefix=A9 ; RUN: llc -opaque-pointers=0 -O3 -mtriple=thumb-eabi -mcpu=cortex-a9 %s -o - | FileCheck %s -check-prefix=A9
; @simple is the most basic chain of address induction variables. Chaining ; @simple is the most basic chain of address induction variables. Chaining
; saves at least one register and avoids complex addressing and setup ; saves at least one register and avoids complex addressing and setup
; code. ; code.
; ;
; A9: @simple ; A9: @simple
; no expensive address computation in the preheader ; no expensive address computation in the preheader
; A9: lsl ; A9: lsl
▲ Show 20 Lines • Show All 349 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopStrengthReduce/X86/expander-crashes.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -loop-reduce %s -S | FileCheck %s ; RUN: opt -opaque-pointers=0 -loop-reduce %s -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"
target triple = "x86_64-apple-macosx10.15.0" target triple = "x86_64-apple-macosx10.15.0"
; Tests for crashes during SCEV expansion. ; Tests for crashes during SCEV expansion.
%struct.hoge = type { i32, i32, i32, i32 } %struct.hoge = type { i32, i32, i32, i32 }
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopStrengthReduce/X86/ivchain-X86.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc < %s -O3 -mtriple=x86_64-unknown-unknown -mcpu=core2 | FileCheck %s -check-prefix=X64 ; RUN: llc -opaque-pointers=0 < %s -O3 -mtriple=x86_64-unknown-unknown -mcpu=core2 | FileCheck %s -check-prefix=X64
; RUN: llc < %s -O3 -mtriple=i686-unknown-unknown -mcpu=core2 | FileCheck %s -check-prefix=X32 ; RUN: llc -opaque-pointers=0 < %s -O3 -mtriple=i686-unknown-unknown -mcpu=core2 | FileCheck %s -check-prefix=X32
; @simple is the most basic chain of address induction variables. Chaining ; @simple is the most basic chain of address induction variables. Chaining
; saves at least one register and avoids complex addressing and setup ; saves at least one register and avoids complex addressing and setup
; code. ; code.
; ;
; %x * 4 ; %x * 4
; no other address computation in the preheader ; no other address computation in the preheader
; no complex address modes ; no complex address modes
▲ Show 20 Lines • Show All 561 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopStrengthReduce/X86/lsr-insns-1.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: opt < %s -loop-reduce -mtriple=x86_64 -S | FileCheck %s -check-prefix=INSN ; RUN: opt -opaque-pointers=0 < %s -loop-reduce -mtriple=x86_64 -S | FileCheck %s -check-prefix=INSN
; RUN: opt < %s -loop-reduce -mtriple=x86_64 -lsr-insns-cost=false -S | FileCheck %s -check-prefix=REGS ; RUN: opt -opaque-pointers=0 < %s -loop-reduce -mtriple=x86_64 -lsr-insns-cost=false -S | FileCheck %s -check-prefix=REGS
; RUN: llc < %s -O2 -mtriple=x86_64-unknown-unknown -lsr-insns-cost | FileCheck %s ; RUN: llc -opaque-pointers=0 < %s -O2 -mtriple=x86_64-unknown-unknown -lsr-insns-cost | FileCheck %s
; OPT test checks that LSR optimize compare for static counter to compare with 0. ; OPT test checks that LSR optimize compare for static counter to compare with 0.
; LLC test checks that LSR optimize compare for static counter. ; LLC test checks that LSR optimize compare for static counter.
; That means that instead of creating the following: ; That means that instead of creating the following:
; movl %ecx, (%rdx,%rax,4) ; movl %ecx, (%rdx,%rax,4)
; incq %rax ; incq %rax
; cmpq $1024, %rax ; cmpq $1024, %rax
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopStrengthReduce/X86/lsr-insns-2.ll

; RUN: opt < %s -loop-reduce -mtriple=x86_64-- -S | FileCheck %s -check-prefix=BOTH -check-prefix=INSN ; RUN: opt -opaque-pointers=0 < %s -loop-reduce -mtriple=x86_64-- -S | FileCheck %s -check-prefix=BOTH -check-prefix=INSN
; RUN: opt < %s -loop-reduce -mtriple=x86_64-- -lsr-insns-cost=false -S | FileCheck %s -check-prefix=BOTH -check-prefix=REGS ; RUN: opt -opaque-pointers=0 < %s -loop-reduce -mtriple=x86_64-- -lsr-insns-cost=false -S | FileCheck %s -check-prefix=BOTH -check-prefix=REGS
; RUN: llc < %s -O2 -mtriple=x86_64-- -lsr-insns-cost -asm-verbose=0 | FileCheck %s ; RUN: llc -opaque-pointers=0 < %s -O2 -mtriple=x86_64-- -lsr-insns-cost -asm-verbose=0 | FileCheck %s
; OPT checks that LSR prefers less instructions to less registers. ; OPT checks that LSR prefers less instructions to less registers.
; For x86 LSR should prefer complicated address to new lsr induction ; For x86 LSR should prefer complicated address to new lsr induction
; variables. ; variables.
; BOTH: for.body: ; BOTH: for.body:
; INSN: getelementptr i32, i32* %x, i64 %indvars.iv ; INSN: getelementptr i32, i32* %x, i64 %indvars.iv
; INSN: getelementptr i32, i32* %y, i64 %indvars.iv ; INSN: getelementptr i32, i32* %y, i64 %indvars.iv
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopStrengthReduce/X86/macro-fuse-cmp.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: opt < %s -loop-reduce -mcpu=btver2 -S | FileCheck %s --check-prefix=JAG ; RUN: opt -opaque-pointers=0 < %s -loop-reduce -mcpu=btver2 -S | FileCheck %s --check-prefix=JAG
; RUN: opt < %s -loop-reduce -mcpu=bdver2 -S | FileCheck %s --check-prefix=BUL ; RUN: opt -opaque-pointers=0 < %s -loop-reduce -mcpu=bdver2 -S | FileCheck %s --check-prefix=BUL
; RUN: opt < %s -loop-reduce -mcpu=haswell -S | FileCheck %s --check-prefix=HSW ; RUN: opt -opaque-pointers=0 < %s -loop-reduce -mcpu=haswell -S | FileCheck %s --check-prefix=HSW
; RUN: llc < %s | FileCheck %s --check-prefix=BASE ; RUN: llc -opaque-pointers=0 < %s | FileCheck %s --check-prefix=BASE
; RUN: llc < %s -mattr=macrofusion | FileCheck %s --check-prefix=FUSE ; RUN: llc -opaque-pointers=0 < %s -mattr=macrofusion | FileCheck %s --check-prefix=FUSE
; RUN: llc < %s -mattr=branchfusion | FileCheck %s --check-prefix=FUSE ; RUN: llc -opaque-pointers=0 < %s -mattr=branchfusion | FileCheck %s --check-prefix=FUSE
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-unknown" target triple = "x86_64-unknown-unknown"
; PR35681 - https://bugs.llvm.org/show_bug.cgi?id=35681 ; PR35681 - https://bugs.llvm.org/show_bug.cgi?id=35681
; FIXME: If a CPU can macro-fuse a compare and branch, then we discount that ; FIXME: If a CPU can macro-fuse a compare and branch, then we discount that
; cost in LSR and avoid generating large offsets in each memory access. ; cost in LSR and avoid generating large offsets in each memory access.
; This reduces code size and may improve decode throughput. ; This reduces code size and may improve decode throughput.
▲ Show 20 Lines • Show All 125 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopStrengthReduce/X86/nested-ptr-addrec.ll

; 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 -loop-reduce < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -S -loop-reduce < %s | FileCheck %s
; Test an assertion failure from D113349, where the SCEV for the outer phi ; Test an assertion failure from D113349, where the SCEV for the outer phi
; gets computed and registered in the value map while attempting to compute it. ; gets computed and registered in the value map while attempting to compute it.
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"
define void @test() { define void @test() {
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopStrengthReduce/addrec-gep-address-space.ll

; RUN: opt < %s -loop-reduce -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -loop-reduce -S | FileCheck %s
; CHECK: bb1: ; CHECK: bb1:
; CHECK: load double, double addrspace(1)* [[IV:%[^,]+]] ; CHECK: load double, double addrspace(1)* [[IV:%[^,]+]]
; CHECK: store double {{.*}}, double addrspace(1)* [[IV]] ; CHECK: store double {{.*}}, double addrspace(1)* [[IV]]
; CHECK-NOT: cast ; CHECK-NOT: cast
; Make sure the GEP has the right index type ; Make sure the GEP has the right index type
; CHECK: getelementptr double, double addrspace(1)* [[IV]], i16 1 ; CHECK: getelementptr double, double addrspace(1)* [[IV]], i16 1
; CHECK: br {{.*}} label %bb1 ; CHECK: br {{.*}} label %bb1
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopStrengthReduce/addrec-gep.ll

; RUN: opt < %s -loop-reduce -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -loop-reduce -S | FileCheck %s
; CHECK: bb1: ; CHECK: bb1:
; CHECK: load double, double* [[IV:%[^,]+]] ; CHECK: load double, double* [[IV:%[^,]+]]
; CHECK: store double {{.*}}, double* [[IV]] ; CHECK: store double {{.*}}, double* [[IV]]
; CHECK: getelementptr double, double* ; CHECK: getelementptr double, double*
; CHECK-NOT: cast ; CHECK-NOT: cast
; CHECK: br {{.*}} label %bb1 ; CHECK: br {{.*}} label %bb1
; This test tests several things. The load and store should use the ; This test tests several things. The load and store should use the
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopStrengthReduce/illegal-addr-modes.ll

; RUN: opt < %s -loop-reduce -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -loop-reduce -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 = "thumbv6m-arm-none-eabi" target triple = "thumbv6m-arm-none-eabi"
; These are regression tests for ; These are regression tests for
; https://bugs.llvm.org/show_bug.cgi?id=34106 ; https://bugs.llvm.org/show_bug.cgi?id=34106
; "ARMTargetLowering::isLegalAddressingMode can accept incorrect ; "ARMTargetLowering::isLegalAddressingMode can accept incorrect
; addressing modes for Thumb1 target" ; addressing modes for Thumb1 target"
▲ Show 20 Lines • Show All 113 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopStrengthReduce/ivchain.ll

; RUN: opt < %s -loop-reduce -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -loop-reduce -S | FileCheck %s
; RUN: opt -passes='require<scalar-evolution>,require<targetir>,loop(loop-reduce)' < %s -S | FileCheck %s ; RUN: opt -opaque-pointers=0 -passes='require<scalar-evolution>,require<targetir>,loop(loop-reduce)' < %s -S | FileCheck %s
; ;
; PR11782: bad cast to AddRecExpr. ; PR11782: bad cast to AddRecExpr.
; A sign extend feeds an IVUser and cannot be hoisted into the AddRec. ; A sign extend feeds an IVUser and cannot be hoisted into the AddRec.
; CollectIVChains should bailout on this case. ; CollectIVChains should bailout on this case.
; Provide legal integer types. ; Provide legal integer types.
target datalayout = "n8:16:32:64" target datalayout = "n8:16:32:64"
Show All 38 Lines

llvm/test/Transforms/LoopStrengthReduce/missing-phi-operand-update.ll

; PR41445: This test checks the case when LSR split critical edge ; PR41445: This test checks the case when LSR split critical edge
; and phi node has other pending fixup operands ; and phi node has other pending fixup operands
; RUN: opt -S -loop-reduce < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -S -loop-reduce < %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"
; We have %indvars.iv.lcssa phi node where 4 input operands ; We have %indvars.iv.lcssa phi node where 4 input operands
; need to be rewritten: %tmp1, %tmp2, %tmp3, %tmp4. ; need to be rewritten: %tmp1, %tmp2, %tmp3, %tmp4.
; When we try to rewrite %tmp1, we first split the critical edge. ; When we try to rewrite %tmp1, we first split the critical edge.
; All the other PHI inputs besides %tmp1 go to a new phi node. ; All the other PHI inputs besides %tmp1 go to a new phi node.
▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopStrengthReduce/nonintegral.ll

; RUN: opt -S -loop-reduce < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -S -loop-reduce < %s | FileCheck %s
; Address Space 10 is non-integral. The optimizer is not allowed to use ; Address Space 10 is non-integral. The optimizer is not allowed to use
; ptrtoint/inttoptr instructions. Make sure that this doesn't happen ; ptrtoint/inttoptr instructions. Make sure that this doesn't happen
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128-ni:10:11:12" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128-ni:10:11:12"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @japi1__unsafe_getindex_65028(i64 addrspace(10)* %arg) { define void @japi1__unsafe_getindex_65028(i64 addrspace(10)* %arg) {
; CHECK-NOT: inttoptr ; CHECK-NOT: inttoptr
Show All 36 Lines

llvm/test/Transforms/LoopStrengthReduce/post-inc-icmpzero.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -loop-reduce -S < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -loop-reduce -S < %s | FileCheck %s
; PR9939 ; PR9939
; LSR should properly handle the post-inc offset when folding the ; LSR should properly handle the post-inc offset when folding the
; non-IV operand of an icmp into the IV. ; non-IV operand of an icmp into the IV.
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32: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"
%struct.Vector2 = type { i16*, [64 x i16], i32 } %struct.Vector2 = type { i16*, [64 x i16], i32 }
▲ Show 20 Lines • Show All 142 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopStrengthReduce/post-increment-insertion.ll

; 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 -loop-reduce -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -loop-reduce -S | FileCheck %s
; REQUIRES: x86-registered-target ; REQUIRES: x86-registered-target
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"
; FIXME: iv.next is supposed to be inserted in the backedge. ; FIXME: iv.next is supposed to be inserted in the backedge.
define i32 @test_01(i32* %p, i64 %len, i32 %x) { define i32 @test_01(i32* %p, i64 %len, i32 %x) {
; CHECK-LABEL: @test_01( ; CHECK-LABEL: @test_01(
▲ Show 20 Lines • Show All 254 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopStrengthReduce/preserve-gep-loop-variant.ll

; RUN: opt < %s -loop-reduce -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -loop-reduce -S | FileCheck %s
; CHECK-NOT: {{inttoptr|ptrtoint}} ; CHECK-NOT: {{inttoptr|ptrtoint}}
; CHECK: scevgep ; CHECK: scevgep
; CHECK-NOT: {{inttoptr|ptrtoint}} ; CHECK-NOT: {{inttoptr|ptrtoint}}
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-n32:64" 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-n32:64"
; Indvars shouldn't need inttoptr/ptrtoint to expand an address here. ; Indvars shouldn't need inttoptr/ptrtoint to expand an address here.
define void @foo(i8* %p) nounwind { define void @foo(i8* %p) nounwind {
Show All 33 Lines

llvm/test/Transforms/LoopStrengthReduce/shl.ll

; RUN: opt < %s -loop-reduce -gvn -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -loop-reduce -gvn -S | FileCheck %s
target datalayout = "e-i64:64-v16:16-v32:32-n16:32:64" target datalayout = "e-i64:64-v16:16-v32:32-n16:32:64"
define void @_Z3fooPfll(float* nocapture readonly %input, i64 %n, i64 %s) { define void @_Z3fooPfll(float* nocapture readonly %input, i64 %n, i64 %s) {
; CHECK-LABEL: @_Z3fooPfll( ; CHECK-LABEL: @_Z3fooPfll(
entry: entry:
%mul = shl nsw i64 %s, 2 %mul = shl nsw i64 %s, 2
; CHECK: %mul = shl i64 %s, 2 ; CHECK: %mul = shl i64 %s, 2
Show All 29 Lines

llvm/test/Transforms/LoopStrengthReduce/uglygep-address-space.ll

; RUN: opt < %s -loop-reduce -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -loop-reduce -S | FileCheck %s
; LSR shouldn't consider %t8 to be an interesting user of %t6, and it ; LSR shouldn't consider %t8 to be an interesting user of %t6, and it
; should be able to form pretty GEPs. ; should be able to form pretty GEPs.
target datalayout = "e-p:64:64:64-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32: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-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
; Copy of uglygep with a different address space ; Copy of uglygep with a different address space
; This tests expandAddToGEP uses the right smaller integer type for ; This tests expandAddToGEP uses the right smaller integer type for
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopStrengthReduce/uglygep.ll

; RUN: opt < %s -loop-reduce -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -loop-reduce -S | FileCheck %s
; LSR shouldn't consider %t8 to be an interesting user of %t6, and it ; LSR shouldn't consider %t8 to be an interesting user of %t6, and it
; should be able to form pretty GEPs. ; should be able to form pretty GEPs.
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32: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 void @test(i8* %ptr.i8, float** %ptr.float) { define void @test(i8* %ptr.i8, float** %ptr.float) {
; CHECK-LABEL: define void @test( ; CHECK-LABEL: define void @test(
▲ Show 20 Lines • Show All 113 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopVectorize/AArch64/deterministic-type-shrinkage.ll

; RUN: opt -S < %s -passes=loop-vectorize,instcombine 2>&1 | FileCheck %s ; RUN: opt -opaque-pointers=0 -S < %s -passes=loop-vectorize,instcombine 2>&1 | FileCheck %s
target datalayout = "e-m:e-i64:64-i128:128-n32:64-S128" target datalayout = "e-m:e-i64:64-i128:128-n32:64-S128"
target triple = "aarch64" target triple = "aarch64"
;; See https://llvm.org/bugs/show_bug.cgi?id=25490 ;; See https://llvm.org/bugs/show_bug.cgi?id=25490
;; Due to the data structures used, the LLVM IR was not determinisic. ;; Due to the data structures used, the LLVM IR was not determinisic.
;; This test comes from the PR. ;; This test comes from the PR.
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopVectorize/AArch64/extractvalue-no-scalarization-required.ll

; REQUIRES: asserts ; REQUIRES: asserts
; RUN: opt -passes=loop-vectorize -mtriple=arm64-apple-ios %s -S -debug -disable-output 2>&1 | FileCheck --check-prefix=CM %s ; RUN: opt -opaque-pointers=0 -passes=loop-vectorize -mtriple=arm64-apple-ios %s -S -debug -disable-output 2>&1 | FileCheck --check-prefix=CM %s
; RUN: opt -passes=loop-vectorize -force-vector-width=2 -force-vector-interleave=1 %s -S | FileCheck --check-prefix=FORCED %s ; RUN: opt -opaque-pointers=0 -passes=loop-vectorize -force-vector-width=2 -force-vector-interleave=1 %s -S | FileCheck --check-prefix=FORCED %s
; Test case from PR41294. ; Test case from PR41294.
; Check scalar cost for extractvalue. The constant and loop invariant operands are free, ; Check scalar cost for extractvalue. The constant and loop invariant operands are free,
; leaving cost 3 for scalarizing the result + 2 for executing the op with VF 2. ; leaving cost 3 for scalarizing the result + 2 for executing the op with VF 2.
; CM: LV: Found uniform instruction: %a = extractvalue { i64, i64 } %sv, 0 ; CM: LV: Found uniform instruction: %a = extractvalue { i64, i64 } %sv, 0
; CM: LV: Found uniform instruction: %b = extractvalue { i64, i64 } %sv, 1 ; CM: LV: Found uniform instruction: %b = extractvalue { i64, i64 } %sv, 1
▲ Show 20 Lines • Show All 93 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopVectorize/AArch64/scalable-strict-fadd.ll

; RUN: opt < %s -passes=loop-vectorize -mtriple aarch64-unknown-linux-gnu -mattr=+sve -prefer-predicate-over-epilogue=scalar-epilogue \ ; RUN: opt -opaque-pointers=0 < %s -passes=loop-vectorize -mtriple aarch64-unknown-linux-gnu -mattr=+sve -prefer-predicate-over-epilogue=scalar-epilogue \
; RUN: -force-ordered-reductions=false -hints-allow-reordering=false -S | FileCheck %s --check-prefix=CHECK-NOT-VECTORIZED ; RUN: -force-ordered-reductions=false -hints-allow-reordering=false -S | FileCheck %s --check-prefix=CHECK-NOT-VECTORIZED
; RUN: opt < %s -passes=loop-vectorize -mtriple aarch64-unknown-linux-gnu -mattr=+sve -prefer-predicate-over-epilogue=scalar-epilogue \ ; RUN: opt -opaque-pointers=0 < %s -passes=loop-vectorize -mtriple aarch64-unknown-linux-gnu -mattr=+sve -prefer-predicate-over-epilogue=scalar-epilogue \
; RUN: -force-ordered-reductions=false -hints-allow-reordering=true -S | FileCheck %s --check-prefix=CHECK-UNORDERED ; RUN: -force-ordered-reductions=false -hints-allow-reordering=true -S | FileCheck %s --check-prefix=CHECK-UNORDERED
; RUN: opt < %s -passes=loop-vectorize -mtriple aarch64-unknown-linux-gnu -mattr=+sve -prefer-predicate-over-epilogue=scalar-epilogue \ ; RUN: opt -opaque-pointers=0 < %s -passes=loop-vectorize -mtriple aarch64-unknown-linux-gnu -mattr=+sve -prefer-predicate-over-epilogue=scalar-epilogue \
; RUN: -force-ordered-reductions=true -hints-allow-reordering=false -S | FileCheck %s --check-prefix=CHECK-ORDERED ; RUN: -force-ordered-reductions=true -hints-allow-reordering=false -S | FileCheck %s --check-prefix=CHECK-ORDERED
; RUN: opt < %s -passes=loop-vectorize -mtriple aarch64-unknown-linux-gnu -mattr=+sve -prefer-predicate-over-epilogue=scalar-epilogue \ ; RUN: opt -opaque-pointers=0 < %s -passes=loop-vectorize -mtriple aarch64-unknown-linux-gnu -mattr=+sve -prefer-predicate-over-epilogue=scalar-epilogue \
; RUN: -force-ordered-reductions=true -hints-allow-reordering=true -S | FileCheck %s --check-prefix=CHECK-UNORDERED ; RUN: -force-ordered-reductions=true -hints-allow-reordering=true -S | FileCheck %s --check-prefix=CHECK-UNORDERED
; RUN: opt < %s -passes=loop-vectorize -mtriple aarch64-unknown-linux-gnu -mattr=+sve -prefer-predicate-over-epilogue=scalar-epilogue \ ; RUN: opt -opaque-pointers=0 < %s -passes=loop-vectorize -mtriple aarch64-unknown-linux-gnu -mattr=+sve -prefer-predicate-over-epilogue=scalar-epilogue \
; RUN: -hints-allow-reordering=false -S | FileCheck %s --check-prefix=CHECK-ORDERED ; RUN: -hints-allow-reordering=false -S | FileCheck %s --check-prefix=CHECK-ORDERED
; RUN: opt < %s -passes=loop-vectorize -mtriple aarch64-unknown-linux-gnu -mattr=+sve -prefer-predicate-over-epilogue=predicate-else-scalar-epilogue \ ; RUN: opt -opaque-pointers=0 < %s -passes=loop-vectorize -mtriple aarch64-unknown-linux-gnu -mattr=+sve -prefer-predicate-over-epilogue=predicate-else-scalar-epilogue \
; RUN: -hints-allow-reordering=false -S | FileCheck %s --check-prefix=CHECK-ORDERED-TF ; RUN: -hints-allow-reordering=false -S | FileCheck %s --check-prefix=CHECK-ORDERED-TF
define float @fadd_strict(float* noalias nocapture readonly %a, i64 %n) #0 { define float @fadd_strict(float* noalias nocapture readonly %a, i64 %n) #0 {
; CHECK-ORDERED-LABEL: @fadd_strict ; CHECK-ORDERED-LABEL: @fadd_strict
; CHECK-ORDERED: vector.body: ; CHECK-ORDERED: vector.body:
; CHECK-ORDERED: %[[VEC_PHI:.*]] = phi float [ 0.000000e+00, %vector.ph ], [ %[[RDX:.*]], %vector.body ] ; CHECK-ORDERED: %[[VEC_PHI:.*]] = phi float [ 0.000000e+00, %vector.ph ], [ %[[RDX:.*]], %vector.body ]
; CHECK-ORDERED: %[[LOAD:.*]] = load <vscale x 8 x float>, <vscale x 8 x float>* ; CHECK-ORDERED: %[[LOAD:.*]] = load <vscale x 8 x float>, <vscale x 8 x float>*
; CHECK-ORDERED: %[[RDX]] = call float @llvm.vector.reduce.fadd.nxv8f32(float %[[VEC_PHI]], <vscale x 8 x float> %[[LOAD]]) ; CHECK-ORDERED: %[[RDX]] = call float @llvm.vector.reduce.fadd.nxv8f32(float %[[VEC_PHI]], <vscale x 8 x float> %[[LOAD]])
▲ Show 20 Lines • Show All 717 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopVectorize/AArch64/strict-fadd.ll

; RUN: opt < %s -passes=loop-vectorize -mtriple aarch64-unknown-linux-gnu -force-ordered-reductions=false -hints-allow-reordering=false -S 2>%t | FileCheck %s --check-prefix=CHECK-NOT-VECTORIZED ; RUN: opt -opaque-pointers=0 < %s -passes=loop-vectorize -mtriple aarch64-unknown-linux-gnu -force-ordered-reductions=false -hints-allow-reordering=false -S 2>%t | FileCheck %s --check-prefix=CHECK-NOT-VECTORIZED
; RUN: opt < %s -passes=loop-vectorize -mtriple aarch64-unknown-linux-gnu -force-ordered-reductions=false -hints-allow-reordering=true -S 2>%t | FileCheck %s --check-prefix=CHECK-UNORDERED ; RUN: opt -opaque-pointers=0 < %s -passes=loop-vectorize -mtriple aarch64-unknown-linux-gnu -force-ordered-reductions=false -hints-allow-reordering=true -S 2>%t | FileCheck %s --check-prefix=CHECK-UNORDERED
; RUN: opt < %s -passes=loop-vectorize -mtriple aarch64-unknown-linux-gnu -force-ordered-reductions=true -hints-allow-reordering=false -S 2>%t | FileCheck %s --check-prefix=CHECK-ORDERED ; RUN: opt -opaque-pointers=0 < %s -passes=loop-vectorize -mtriple aarch64-unknown-linux-gnu -force-ordered-reductions=true -hints-allow-reordering=false -S 2>%t | FileCheck %s --check-prefix=CHECK-ORDERED
; RUN: opt < %s -passes=loop-vectorize -mtriple aarch64-unknown-linux-gnu -force-ordered-reductions=true -hints-allow-reordering=true -S 2>%t | FileCheck %s --check-prefix=CHECK-UNORDERED ; RUN: opt -opaque-pointers=0 < %s -passes=loop-vectorize -mtriple aarch64-unknown-linux-gnu -force-ordered-reductions=true -hints-allow-reordering=true -S 2>%t | FileCheck %s --check-prefix=CHECK-UNORDERED
; RUN: opt < %s -passes=loop-vectorize -mtriple aarch64-unknown-linux-gnu -hints-allow-reordering=false -S 2>%t | FileCheck %s --check-prefix=CHECK-ORDERED ; RUN: opt -opaque-pointers=0 < %s -passes=loop-vectorize -mtriple aarch64-unknown-linux-gnu -hints-allow-reordering=false -S 2>%t | FileCheck %s --check-prefix=CHECK-ORDERED
define float @fadd_strict(float* noalias nocapture readonly %a, i64 %n) { define float @fadd_strict(float* noalias nocapture readonly %a, i64 %n) {
; CHECK-ORDERED-LABEL: @fadd_strict ; CHECK-ORDERED-LABEL: @fadd_strict
; CHECK-ORDERED: vector.body: ; CHECK-ORDERED: vector.body:
; CHECK-ORDERED: %[[VEC_PHI:.*]] = phi float [ 0.000000e+00, %vector.ph ], [ %[[RDX:.*]], %vector.body ] ; CHECK-ORDERED: %[[VEC_PHI:.*]] = phi float [ 0.000000e+00, %vector.ph ], [ %[[RDX:.*]], %vector.body ]
; CHECK-ORDERED: %[[LOAD:.*]] = load <8 x float>, <8 x float>* ; CHECK-ORDERED: %[[LOAD:.*]] = load <8 x float>, <8 x float>*
; CHECK-ORDERED: %[[RDX]] = call float @llvm.vector.reduce.fadd.v8f32(float %[[VEC_PHI]], <8 x float> %[[LOAD]]) ; CHECK-ORDERED: %[[RDX]] = call float @llvm.vector.reduce.fadd.v8f32(float %[[VEC_PHI]], <8 x float> %[[LOAD]])
; CHECK-ORDERED: for.end ; CHECK-ORDERED: for.end
▲ Show 20 Lines • Show All 1,416 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopVectorize/AArch64/sve-extract-last-veclane.ll

; RUN: opt -passes=loop-vectorize,dce,instcombine -mtriple aarch64-linux-gnu -S < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -passes=loop-vectorize,dce,instcombine -mtriple aarch64-linux-gnu -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"
target triple = "aarch64-unknown-linux-gnu" target triple = "aarch64-unknown-linux-gnu"
define void @inv_store_last_lane(i32* noalias nocapture %a, i32* noalias nocapture %inv, i32* noalias nocapture readonly %b, i64 %n) #0 { define void @inv_store_last_lane(i32* noalias nocapture %a, i32* noalias nocapture %inv, i32* noalias nocapture readonly %b, i64 %n) #0 {
; CHECK-LABEL: @inv_store_last_lane ; CHECK-LABEL: @inv_store_last_lane
; CHECK: vector.body: ; CHECK: vector.body:
; CHECK: store <vscale x 4 x i32> %[[VEC_VAL:.*]], < ; CHECK: store <vscale x 4 x i32> %[[VEC_VAL:.*]], <
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopVectorize/AArch64/sve-inductions-unusual-types.ll

; REQUIRES: asserts ; REQUIRES: asserts
; RUN: opt -passes=loop-vectorize -S < %s -debug -prefer-predicate-over-epilogue=scalar-epilogue 2>%t | FileCheck %s ; RUN: opt -opaque-pointers=0 -passes=loop-vectorize -S < %s -debug -prefer-predicate-over-epilogue=scalar-epilogue 2>%t | FileCheck %s
; RUN: cat %t | FileCheck %s --check-prefix=DEBUG ; RUN: cat %t | FileCheck %s --check-prefix=DEBUG
target triple = "aarch64-unknown-linux-gnu" target triple = "aarch64-unknown-linux-gnu"
; DEBUG: Found an estimated cost of Invalid for VF vscale x 1 For instruction: %indvars.iv1294 = phi i7 [ %indvars.iv.next1295, %for.body ], [ 0, %entry ] ; DEBUG: Found an estimated cost of Invalid for VF vscale x 1 For instruction: %indvars.iv1294 = phi i7 [ %indvars.iv.next1295, %for.body ], [ 0, %entry ]
; DEBUG: Found an estimated cost of Invalid for VF vscale x 1 For instruction: %addi7 = add i7 %indvars.iv1294, 0 ; DEBUG: Found an estimated cost of Invalid for VF vscale x 1 For instruction: %addi7 = add i7 %indvars.iv1294, 0
; DEBUG: Found an estimated cost of Invalid for VF vscale x 1 For instruction: %indvars.iv.next1295 = add i7 %indvars.iv1294, 1 ; DEBUG: Found an estimated cost of Invalid for VF vscale x 1 For instruction: %indvars.iv.next1295 = add i7 %indvars.iv1294, 1
▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopVectorize/AArch64/sve-tail-folding-option.ll

; RUN: opt < %s -passes=loop-vectorize -sve-tail-folding=disabled -S | FileCheck %s -check-prefix=CHECK-NOTF ; RUN: opt -opaque-pointers=0 < %s -passes=loop-vectorize -sve-tail-folding=disabled -S | FileCheck %s -check-prefix=CHECK-NOTF
; RUN: opt < %s -passes=loop-vectorize -sve-tail-folding=default -S | FileCheck %s -check-prefix=CHECK-NOTF ; RUN: opt -opaque-pointers=0 < %s -passes=loop-vectorize -sve-tail-folding=default -S | FileCheck %s -check-prefix=CHECK-NOTF
; RUN: opt < %s -passes=loop-vectorize -sve-tail-folding=all -S | FileCheck %s -check-prefix=CHECK-TF ; RUN: opt -opaque-pointers=0 < %s -passes=loop-vectorize -sve-tail-folding=all -S | FileCheck %s -check-prefix=CHECK-TF
; RUN: opt < %s -passes=loop-vectorize -sve-tail-folding=disabled+simple+reductions+recurrences -S | FileCheck %s -check-prefix=CHECK-TF ; RUN: opt -opaque-pointers=0 < %s -passes=loop-vectorize -sve-tail-folding=disabled+simple+reductions+recurrences -S | FileCheck %s -check-prefix=CHECK-TF
; RUN: opt < %s -passes=loop-vectorize -sve-tail-folding=all+noreductions -S | FileCheck %s -check-prefix=CHECK-TF-NORED ; RUN: opt -opaque-pointers=0 < %s -passes=loop-vectorize -sve-tail-folding=all+noreductions -S | FileCheck %s -check-prefix=CHECK-TF-NORED
; RUN: opt < %s -passes=loop-vectorize -sve-tail-folding=all+norecurrences -S | FileCheck %s -check-prefix=CHECK-TF-NOREC ; RUN: opt -opaque-pointers=0 < %s -passes=loop-vectorize -sve-tail-folding=all+norecurrences -S | FileCheck %s -check-prefix=CHECK-TF-NOREC
; RUN: opt < %s -passes=loop-vectorize -sve-tail-folding=reductions -S | FileCheck %s -check-prefix=CHECK-TF-ONLYRED ; RUN: opt -opaque-pointers=0 < %s -passes=loop-vectorize -sve-tail-folding=reductions -S | FileCheck %s -check-prefix=CHECK-TF-ONLYRED
target triple = "aarch64-unknown-linux-gnu" target triple = "aarch64-unknown-linux-gnu"
define void @simple_memset(i32 %val, i32* %ptr, i64 %n) #0 { define void @simple_memset(i32 %val, i32* %ptr, i64 %n) #0 {
; CHECK-NOTF-LABEL: @simple_memset( ; CHECK-NOTF-LABEL: @simple_memset(
; CHECK-NOTF: vector.ph: ; CHECK-NOTF: vector.ph:
; CHECK-NOTF: %[[INSERT:.*]] = insertelement <vscale x 4 x i32> poison, i32 %val, i64 0 ; CHECK-NOTF: %[[INSERT:.*]] = insertelement <vscale x 4 x i32> poison, i32 %val, i64 0
; CHECK-NOTF: %[[SPLAT:.*]] = shufflevector <vscale x 4 x i32> %[[INSERT]], <vscale x 4 x i32> poison, <vscale x 4 x i32> zeroinitializer ; CHECK-NOTF: %[[SPLAT:.*]] = shufflevector <vscale x 4 x i32> %[[INSERT]], <vscale x 4 x i32> poison, <vscale x 4 x i32> zeroinitializer
▲ Show 20 Lines • Show All 260 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopVectorize/AArch64/sve-tail-folding-optsize.ll

; RUN: opt -passes=loop-vectorize -S < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -passes=loop-vectorize -S < %s | FileCheck %s
target triple = "aarch64-unknown-linux-gnu" target triple = "aarch64-unknown-linux-gnu"
define void @trip1024_i64(i64* noalias nocapture noundef %dst, i64* noalias nocapture noundef readonly %src) #0 { define void @trip1024_i64(i64* noalias nocapture noundef %dst, i64* noalias nocapture noundef readonly %src) #0 {
; CHECK-LABEL: @trip1024_i64( ; CHECK-LABEL: @trip1024_i64(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP0:%.*]] = call i64 @llvm.vscale.i64() ; CHECK-NEXT: [[TMP0:%.*]] = call i64 @llvm.vscale.i64()
; CHECK-NEXT: [[TMP1:%.*]] = mul i64 [[TMP0]], 2 ; CHECK-NEXT: [[TMP1:%.*]] = mul i64 [[TMP0]], 2
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopVectorize/AArch64/sve-tail-folding-reductions.ll

; RUN: opt -S -hints-allow-reordering=false -passes=loop-vectorize -prefer-predicate-over-epilogue=predicate-else-scalar-epilogue \ ; RUN: opt -opaque-pointers=0 -S -hints-allow-reordering=false -passes=loop-vectorize -prefer-predicate-over-epilogue=predicate-else-scalar-epilogue \
; RUN: < %s | FileCheck %s --check-prefix=CHECK ; RUN: < %s | FileCheck %s --check-prefix=CHECK
; RUN: opt -S -hints-allow-reordering=false -passes=loop-vectorize -prefer-predicate-over-epilogue=predicate-else-scalar-epilogue \ ; RUN: opt -opaque-pointers=0 -S -hints-allow-reordering=false -passes=loop-vectorize -prefer-predicate-over-epilogue=predicate-else-scalar-epilogue \
; RUN: -prefer-inloop-reductions < %s | FileCheck %s --check-prefix=CHECK-IN-LOOP ; RUN: -prefer-inloop-reductions < %s | FileCheck %s --check-prefix=CHECK-IN-LOOP
target triple = "aarch64-unknown-linux-gnu" target triple = "aarch64-unknown-linux-gnu"
define i32 @add_reduction_i32(i32* %ptr, i64 %n) #0 { define i32 @add_reduction_i32(i32* %ptr, i64 %n) #0 {
; CHECK-LABEL: @add_reduction_i32( ; CHECK-LABEL: @add_reduction_i32(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[UMAX:%.*]] = call i64 @llvm.umax.i64(i64 [[N:%.*]], i64 1) ; CHECK-NEXT: [[UMAX:%.*]] = call i64 @llvm.umax.i64(i64 [[N:%.*]], i64 1)
▲ Show 20 Lines • Show All 324 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopVectorize/AArch64/sve-tail-folding-unroll.ll

; RUN: opt -S -passes=loop-vectorize -prefer-predicate-over-epilogue=predicate-else-scalar-epilogue -force-vector-interleave=4 -force-vector-width=4 < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -S -passes=loop-vectorize -prefer-predicate-over-epilogue=predicate-else-scalar-epilogue -force-vector-interleave=4 -force-vector-width=4 < %s | FileCheck %s
target triple = "aarch64-unknown-linux-gnu" target triple = "aarch64-unknown-linux-gnu"
define void @simple_memset(i32 %val, i32* %ptr, i64 %n) #0 { define void @simple_memset(i32 %val, i32* %ptr, i64 %n) #0 {
; CHECK-LABEL: @simple_memset( ; CHECK-LABEL: @simple_memset(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[UMAX:%.*]] = call i64 @llvm.umax.i64(i64 [[N:%.*]], i64 1) ; CHECK-NEXT: [[UMAX:%.*]] = call i64 @llvm.umax.i64(i64 [[N:%.*]], i64 1)
▲ Show 20 Lines • Show All 287 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopVectorize/AArch64/sve-widen-gep.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 -passes=loop-vectorize -S -mtriple=aarch64 -mattr=+sve -debug-only=loop-vectorize \ ; RUN: opt -opaque-pointers=0 -passes=loop-vectorize -S -mtriple=aarch64 -mattr=+sve -debug-only=loop-vectorize \
; RUN: -prefer-predicate-over-epilogue=scalar-epilogue < %s 2>&1 | FileCheck %s ; RUN: -prefer-predicate-over-epilogue=scalar-epilogue < %s 2>&1 | FileCheck %s
target triple = "aarch64-unknown-linux-gnu" target triple = "aarch64-unknown-linux-gnu"
; CHECK-LABEL: LV: Checking a loop in 'pointer_induction_used_as_vector' ; CHECK-LABEL: LV: Checking a loop in 'pointer_induction_used_as_vector'
; CHECK-NOT: LV: Found {{.*}} scalar instruction: %ptr.iv.2.next = getelementptr inbounds i8, i8* %ptr.iv.2, i64 1 ; CHECK-NOT: LV: Found {{.*}} scalar instruction: %ptr.iv.2.next = getelementptr inbounds i8, i8* %ptr.iv.2, i64 1
; ;
; CHECK: VPlan 'Initial VPlan for VF={vscale x 2},UF>=1' { ; CHECK: VPlan 'Initial VPlan for VF={vscale x 2},UF>=1' {
▲ Show 20 Lines • Show All 211 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopVectorize/AArch64/sve-widen-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 -mtriple aarch64-linux-gnu -mattr=+sve -passes=loop-vectorize,dce,instcombine -S \ ; RUN: opt -opaque-pointers=0 -mtriple aarch64-linux-gnu -mattr=+sve -passes=loop-vectorize,dce,instcombine -S \
; RUN: -prefer-predicate-over-epilogue=scalar-epilogue < %s | FileCheck %s ; RUN: -prefer-predicate-over-epilogue=scalar-epilogue < %s | FileCheck %s
; Ensure that we can vectorize loops such as: ; Ensure that we can vectorize loops such as:
; int *ptr = c; ; int *ptr = c;
; for (long long i = 0; i < n; i++) { ; for (long long i = 0; i < n; i++) {
; int X1 = *ptr++; ; int X1 = *ptr++;
; int X2 = *ptr++; ; int X2 = *ptr++;
; a[i] = X1 + 1; ; a[i] = X1 + 1;
▲ Show 20 Lines • Show All 397 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopVectorize/AArch64/tail-fold-uniform-memops.ll

; RUN: opt -passes=loop-vectorize -scalable-vectorization=off -force-vector-width=4 -prefer-predicate-over-epilogue=predicate-dont-vectorize -S < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -passes=loop-vectorize -scalable-vectorization=off -force-vector-width=4 -prefer-predicate-over-epilogue=predicate-dont-vectorize -S < %s | FileCheck %s
; NOTE: These tests aren't really target-specific, but it's convenient to target AArch64 ; NOTE: These tests aren't really target-specific, but it's convenient to target AArch64
; so that TTI.isLegalMaskedLoad can return true. ; so that TTI.isLegalMaskedLoad can return true.
target triple = "aarch64-linux-gnu" target triple = "aarch64-linux-gnu"
; The original loop had an unconditional uniform load. Let's make sure ; The original loop had an unconditional uniform load. Let's make sure
; we don't artificially create new predicated blocks for the load. ; we don't artificially create new predicated blocks for the load.
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopVectorize/AArch64/vector-reverse.ll

; Test VLA for reverse with fixed size vector ; Test VLA for reverse with fixed size vector
; This is the loop in c++ being vectorize in this file with ; This is the loop in c++ being vectorize in this file with
; shuffle reverse ; shuffle reverse
; #pragma clang loop vectorize_width(8, fixed) ; #pragma clang loop vectorize_width(8, fixed)
; for (int i = N-1; i >= 0; --i) ; for (int i = N-1; i >= 0; --i)
; a[i] = b[i] + 1.0; ; a[i] = b[i] + 1.0;
; RUN: opt -passes=loop-vectorize,dce -mtriple aarch64-linux-gnu -S \ ; RUN: opt -opaque-pointers=0 -passes=loop-vectorize,dce -mtriple aarch64-linux-gnu -S \
; RUN: -prefer-predicate-over-epilogue=scalar-epilogue < %s | FileCheck %s ; RUN: -prefer-predicate-over-epilogue=scalar-epilogue < %s | FileCheck %s
define void @vector_reverse_f64(i64 %N, double* %a, double* %b) #0 { define void @vector_reverse_f64(i64 %N, double* %a, double* %b) #0 {
; CHECK-LABEL: vector_reverse_f64 ; CHECK-LABEL: vector_reverse_f64
; CHECK-LABEL: vector.body ; CHECK-LABEL: vector.body
; CHECK: %[[GEP:.*]] = getelementptr inbounds double, double* %{{.*}}, i32 0 ; CHECK: %[[GEP:.*]] = getelementptr inbounds double, double* %{{.*}}, i32 0
; CHECK-NEXT: %[[GEP1:.*]] = getelementptr inbounds double, double* %[[GEP]], i32 -7 ; CHECK-NEXT: %[[GEP1:.*]] = getelementptr inbounds double, double* %[[GEP]], i32 -7
; CHECK-NEXT: %[[CAST:.*]] = bitcast double* %[[GEP1]] to <8 x double>* ; CHECK-NEXT: %[[CAST:.*]] = bitcast double* %[[GEP1]] to <8 x double>*
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopVectorize/ARM/tail-folding-counting-down.ll

; RUN: opt < %s -passes=loop-vectorize -S | FileCheck %s --check-prefixes=COMMON,DEFAULT ; RUN: opt -opaque-pointers=0 < %s -passes=loop-vectorize -S | FileCheck %s --check-prefixes=COMMON,DEFAULT
; RUN: opt < %s -passes=loop-vectorize -tail-predication=enabled -prefer-predicate-over-epilogue=predicate-dont-vectorize -S | FileCheck %s --check-prefixes=COMMON,CHECK-TF,CHECK-PREFER ; RUN: opt -opaque-pointers=0 < %s -passes=loop-vectorize -tail-predication=enabled -prefer-predicate-over-epilogue=predicate-dont-vectorize -S | FileCheck %s --check-prefixes=COMMON,CHECK-TF,CHECK-PREFER
; RUN: opt < %s -passes=loop-vectorize -tail-predication=enabled -prefer-predicate-over-epilogue=predicate-else-scalar-epilogue -S | FileCheck %s --check-prefixes=COMMON,CHECK-TF,CHECK-PREFER ; RUN: opt -opaque-pointers=0 < %s -passes=loop-vectorize -tail-predication=enabled -prefer-predicate-over-epilogue=predicate-else-scalar-epilogue -S | FileCheck %s --check-prefixes=COMMON,CHECK-TF,CHECK-PREFER
; RUN: opt < %s -passes=loop-vectorize -tail-predication=enabled -S | FileCheck %s --check-prefixes=COMMON,CHECK-TF,CHECK-ENABLE-TP ; RUN: opt -opaque-pointers=0 < %s -passes=loop-vectorize -tail-predication=enabled -S | FileCheck %s --check-prefixes=COMMON,CHECK-TF,CHECK-ENABLE-TP
target datalayout = "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64" target datalayout = "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64"
target triple = "thumbv8.1m.main-arm-unknown-eabihf" target triple = "thumbv8.1m.main-arm-unknown-eabihf"
; This IR corresponds to this type of C-code: ; This IR corresponds to this type of C-code:
; ;
; void f(char *a, char *b, char *c, int N) { ; void f(char *a, char *b, char *c, int N) {
; while (N-- > 0) ; while (N-- > 0)
▲ Show 20 Lines • Show All 426 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopVectorize/ARM/tail-folding-reduces-vf.ll

; RUN: opt < %s -mattr=+mve,+mve.fp -passes=loop-vectorize -tail-predication=disabled -S | FileCheck %s --check-prefixes=DEFAULT ; RUN: opt -opaque-pointers=0 < %s -mattr=+mve,+mve.fp -passes=loop-vectorize -tail-predication=disabled -S | FileCheck %s --check-prefixes=DEFAULT
; RUN: opt < %s -mattr=+mve,+mve.fp -passes=loop-vectorize -prefer-predicate-over-epilogue=predicate-else-scalar-epilogue -S | FileCheck %s --check-prefixes=TAILPRED ; RUN: opt -opaque-pointers=0 < %s -mattr=+mve,+mve.fp -passes=loop-vectorize -prefer-predicate-over-epilogue=predicate-else-scalar-epilogue -S | FileCheck %s --check-prefixes=TAILPRED
target datalayout = "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64" target datalayout = "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64"
target triple = "thumbv8.1m.main-arm-none-eabi" target triple = "thumbv8.1m.main-arm-none-eabi"
; When TP is disabled, this test can vectorize with a VF of 16. ; When TP is disabled, this test can vectorize with a VF of 16.
; When TP is enabled, this test should vectorize with a VF of 8. ; When TP is enabled, this test should vectorize with a VF of 8.
; ;
; DEFAULT: load <16 x i8>, <16 x i8>* ; DEFAULT: load <16 x i8>, <16 x i8>*
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopVectorize/PowerPC/optimal-epilog-vectorization.ll

; RUN: opt < %s -passes='loop-vectorize' -enable-epilogue-vectorization -epilogue-vectorization-force-VF=2 -S | FileCheck %s --check-prefix VF-TWO-CHECK ; RUN: opt -opaque-pointers=0 < %s -passes='loop-vectorize' -enable-epilogue-vectorization -epilogue-vectorization-force-VF=2 -S | FileCheck %s --check-prefix VF-TWO-CHECK
; RUN: opt < %s -passes='loop-vectorize' -enable-epilogue-vectorization -epilogue-vectorization-force-VF=4 -S | FileCheck %s --check-prefix VF-FOUR-CHECK ; RUN: opt -opaque-pointers=0 < %s -passes='loop-vectorize' -enable-epilogue-vectorization -epilogue-vectorization-force-VF=4 -S | FileCheck %s --check-prefix VF-FOUR-CHECK
target datalayout = "e-m:e-i64:64-n32:64" target datalayout = "e-m:e-i64:64-n32:64"
target triple = "powerpc64le-unknown-linux-gnu" target triple = "powerpc64le-unknown-linux-gnu"
; Function Attrs: nounwind ; Function Attrs: nounwind
define dso_local void @f1(float* noalias %aa, float* noalias %bb, float* noalias %cc, i32 signext %N) #0 { define dso_local void @f1(float* noalias %aa, float* noalias %bb, float* noalias %cc, i32 signext %N) #0 {
; VF-TWO-CHECK-LABEL: @f1( ; VF-TWO-CHECK-LABEL: @f1(
; VF-TWO-CHECK-NEXT: entry: ; VF-TWO-CHECK-NEXT: entry:
▲ Show 20 Lines • Show All 1,006 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopVectorize/RISCV/select-cmp-reduction.ll

; RUN: opt -passes=loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -S \ ; RUN: opt -opaque-pointers=0 -passes=loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -S \
; RUN: < %s | FileCheck %s ; RUN: < %s | FileCheck %s
; RUN: opt -passes=loop-vectorize -force-vector-interleave=1 -force-vector-width=4 \ ; RUN: opt -opaque-pointers=0 -passes=loop-vectorize -force-vector-interleave=1 -force-vector-width=4 \
; RUN: -scalable-vectorization=on -S < %s | FileCheck %s -check-prefix=SCALABLE ; RUN: -scalable-vectorization=on -S < %s | FileCheck %s -check-prefix=SCALABLE
target triple = "riscv64" target triple = "riscv64"
define i32 @select_icmp(i32 %x, i32 %y, i32* nocapture readonly %c, i64 %n) #0 { define i32 @select_icmp(i32 %x, i32 %y, i32* nocapture readonly %c, i64 %n) #0 {
; CHECK-LABEL: @select_icmp ; CHECK-LABEL: @select_icmp
; CHECK: vector.ph: ; CHECK: vector.ph:
; CHECK-NEXT: [[N_MOD_VF:%.*]] = urem i64 %n, 4 ; CHECK-NEXT: [[N_MOD_VF:%.*]] = urem i64 %n, 4
▲ Show 20 Lines • Show All 489 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopVectorize/SystemZ/load-scalarization-cost-0.ll

; RUN: opt -mtriple=s390x-unknown-linux -mcpu=z13 -passes=loop-vectorize \ ; RUN: opt -opaque-pointers=0 -mtriple=s390x-unknown-linux -mcpu=z13 -passes=loop-vectorize \
; RUN: -force-vector-width=2 -debug-only=loop-vectorize \ ; RUN: -force-vector-width=2 -debug-only=loop-vectorize \
; RUN: -disable-output < %s 2>&1 | FileCheck %s ; RUN: -disable-output < %s 2>&1 | FileCheck %s
; REQUIRES: asserts ; REQUIRES: asserts
; ;
; Check that a scalarized load does not get operands scalarization costs added. ; Check that a scalarized load does not get operands scalarization costs added.
define void @fun(i64* %data, i64 %n, i64 %s, double* %Src) { define void @fun(i64* %data, i64 %n, i64 %s, double* %Src) {
entry: entry:
Show All 18 Lines

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

; REQUIRES: asserts ; REQUIRES: asserts
; RUN: opt < %s -aa-pipeline=basic-aa -passes=loop-vectorize,instcombine -S -debug-only=loop-vectorize -disable-output -print-after=instcombine 2>&1 | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -aa-pipeline=basic-aa -passes=loop-vectorize,instcombine -S -debug-only=loop-vectorize -disable-output -print-after=instcombine 2>&1 | FileCheck %s
; RUN: opt < %s -passes=loop-vectorize -force-vector-width=2 -S | FileCheck %s -check-prefix=FORCE ; RUN: opt -opaque-pointers=0 < %s -passes=loop-vectorize -force-vector-width=2 -S | FileCheck %s -check-prefix=FORCE
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: PR31671 ; CHECK-LABEL: PR31671
; ;
; Check a pointer in which one of its uses is consecutive-like and another of ; Check a pointer in which one of its uses is consecutive-like and another of
; its uses is non-consecutive-like. In the test case below, %tmp3 is the ; its uses is non-consecutive-like. In the test case below, %tmp3 is the
▲ Show 20 Lines • Show All 122 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopVectorize/X86/drop-poison-generating-flags.ll

; RUN: opt %s -passes=loop-vectorize -force-vector-width=4 -force-vector-interleave=1 -S | FileCheck %s ; RUN: opt -opaque-pointers=0 %s -passes=loop-vectorize -force-vector-width=4 -force-vector-interleave=1 -S | FileCheck %s
; Make sure that integer poison-generating flags (i.e., nuw/nsw, exact and inbounds) ; Make sure that integer poison-generating flags (i.e., nuw/nsw, exact and inbounds)
; are dropped from instructions in blocks that need predication and are linearized ; are dropped from instructions in blocks that need predication and are linearized
; and masked after vectorization. We only drop flags from scalar instructions that ; and masked after vectorization. We only drop flags from scalar instructions that
; contribute to the address computation of a masked vector load/store. After ; contribute to the address computation of a masked vector load/store. After
; linearizing the control flow and removing their guarding condition, these ; linearizing the control flow and removing their guarding condition, these
; instructions could generate a poison value which would be used as base address of ; instructions could generate a poison value which would be used as base address of
; the masked vector load/store (see PR52111). For gather/scatter cases, ; the masked vector load/store (see PR52111). For gather/scatter cases,
▲ Show 20 Lines • Show All 407 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopVectorize/X86/pointer-runtime-checks-unprofitable.ll

; RUN: opt -passes="loop-vectorize" -mtriple=x86_64-unknown-linux -S -debug %s 2>&1 | FileCheck %s ; RUN: opt -opaque-pointers=0 -passes="loop-vectorize" -mtriple=x86_64-unknown-linux -S -debug %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-unknown-linux" target triple = "x86_64-unknown-linux"
declare double @llvm.pow.f64(double, double) declare double @llvm.pow.f64(double, double)
▲ Show 20 Lines • Show All 95 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopVectorize/X86/pr51366-sunk-instruction-used-outside-of-loop.ll

; RUN: opt -passes=loop-vectorize -mtriple=x86_64-unknown-linux -force-vector-width=2 -force-vector-interleave=1 -S %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -passes=loop-vectorize -mtriple=x86_64-unknown-linux -force-vector-width=2 -force-vector-interleave=1 -S %s | FileCheck %s
define i32* @test(i32* noalias %src, i32* noalias %dst) { define i32* @test(i32* noalias %src, i32* noalias %dst) {
; CHECK-LABEL: @test( ; CHECK-LABEL: @test(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK: vector.body: ; CHECK: vector.body:
; CHECK-NEXT: [[INDEX:%.*]] = phi i64 [ 0, %vector.ph ], [ [[INDEX_NEXT:%.*]], [[PRED_LOAD_CONTINUE2:%.*]] ] ; CHECK-NEXT: [[INDEX:%.*]] = phi i64 [ 0, %vector.ph ], [ [[INDEX_NEXT:%.*]], [[PRED_LOAD_CONTINUE2:%.*]] ]
; CHECK-NEXT: [[VEC_IND:%.*]] = phi <2 x i64> [ <i64 0, i64 1>, %vector.ph ], [ [[VEC_IND_NEXT:%.*]], [[PRED_LOAD_CONTINUE2]] ] ; CHECK-NEXT: [[VEC_IND:%.*]] = phi <2 x i64> [ <i64 0, i64 1>, %vector.ph ], [ [[VEC_IND_NEXT:%.*]], [[PRED_LOAD_CONTINUE2]] ]
; CHECK-NEXT: [[TMP0:%.*]] = add i64 [[INDEX]], 0 ; CHECK-NEXT: [[TMP0:%.*]] = add i64 [[INDEX]], 0
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 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 -passes=loop-vectorize,dce,instcombine -force-vector-interleave=1 -force-vector-width=4 -loop-vectorize-with-block-frequency -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes=loop-vectorize,dce,instcombine -force-vector-interleave=1 -force-vector-width=4 -loop-vectorize-with-block-frequency -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/consec_no_gep.ll

;RUN: opt < %s -passes=loop-vectorize,instcombine -force-vector-width=4 -force-vector-interleave=1 -S | FileCheck %s ;RUN: opt -opaque-pointers=0 < %s -passes=loop-vectorize,instcombine -force-vector-width=4 -force-vector-interleave=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"
;; Check consecutive memory access without preceding GEP instruction ;; Check consecutive memory access without preceding GEP instruction
; for (int i=0; i<len; i++) { ; for (int i=0; i<len; i++) {
; *to++ = *from++; ; *to++ = *from++;
; } ; }
Show All 33 Lines

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

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

llvm/test/Transforms/LoopVectorize/induction_plus.ll

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

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

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

llvm/test/Transforms/LoopVectorize/iv_outside_user.ll

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

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

; RUN: opt < %s -passes=loop-vectorize,dce,instcombine -force-vector-interleave=1 -force-vector-width=4 -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes=loop-vectorize,dce,instcombine -force-vector-interleave=1 -force-vector-width=4 -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/no_outside_user.ll

; RUN: opt -S -passes=loop-vectorize -force-vector-interleave=1 -force-vector-width=2 < %s 2>&1 | FileCheck %s ; RUN: opt -opaque-pointers=0 -S -passes=loop-vectorize -force-vector-interleave=1 -force-vector-width=2 < %s 2>&1 | FileCheck %s
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32-n8:16:32-S128" target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32-n8:16:32-S128"
@f = common global i32 0, align 4 @f = common global i32 0, align 4
@.str = private unnamed_addr constant [4 x i8] c"%d\0A\00", align 1 @.str = private unnamed_addr constant [4 x i8] c"%d\0A\00", align 1
@c = common global i32 0, align 4 @c = common global i32 0, align 4
@a = common global i32 0, align 4 @a = common global i32 0, align 4
@b = common global i32 0, align 4 @b = common global i32 0, align 4
▲ Show 20 Lines • Show All 405 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopVectorize/pr35773.ll

; RUN: opt -S -passes=loop-vectorize -force-vector-width=4 -force-vector-interleave=1 < %s 2>&1 | FileCheck %s ; RUN: opt -opaque-pointers=0 -S -passes=loop-vectorize -force-vector-width=4 -force-vector-interleave=1 < %s 2>&1 | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
@b = common local_unnamed_addr global i8 0, align 1 @b = common local_unnamed_addr global i8 0, align 1
define void @doit1(i32* %ptr) { define void @doit1(i32* %ptr) {
; CHECK-LABEL: @doit1( ; CHECK-LABEL: @doit1(
; CHECK: vector.body: ; CHECK: vector.body:
; CHECK-NEXT: [[MAIN_IV:%.*]] = phi i32 [ 0, [[VECTOR_PH:%.*]] ], [ [[MAIN_IV_NEXT:%.*]], [[VECTOR_BODY:%.*]] ] ; CHECK-NEXT: [[MAIN_IV:%.*]] = phi i32 [ 0, [[VECTOR_PH:%.*]] ], [ [[MAIN_IV_NEXT:%.*]], [[VECTOR_BODY:%.*]] ]
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopVectorize/pr39417-optsize-scevchecks.ll

; RUN: opt -S -passes=loop-vectorize -force-vector-width=4 -force-vector-interleave=1 < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -S -passes=loop-vectorize -force-vector-width=4 -force-vector-interleave=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"
; PR39417 ; PR39417
; Check that the need for overflow check prevents vectorizing a loop with tiny ; Check that the need for overflow check prevents vectorizing a loop with tiny
; trip count (which implies opt for size). ; trip count (which implies opt -opaque-pointers=0 for size).
; CHECK-LABEL: @func_34 ; CHECK-LABEL: @func_34
; CHECK-NOT: vector.scevcheck ; CHECK-NOT: vector.scevcheck
; CHECK-NOT: vector.body: ; CHECK-NOT: vector.body:
; CHECK-LABEL: bb67: ; CHECK-LABEL: bb67:
define void @func_34() { define void @func_34() {
bb1: bb1:
br label %bb67 br label %bb67
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopVectorize/pr59319-loop-access-info-invalidation.ll

; 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=loop-distribute,loop-vectorize -enable-loop-distribute -force-vector-width=4 -force-vector-interleave=1 -S \ ; RUN: opt -opaque-pointers=0 -passes=loop-distribute,loop-vectorize -enable-loop-distribute -force-vector-width=4 -force-vector-interleave=1 -S \
; RUN: %s | FileCheck %s ; RUN: %s | FileCheck %s
; This test is to assure LoopAccessInfo invalidation after LoopVectorize ; This test is to assure LoopAccessInfo invalidation after LoopVectorize
; modifies the IR. ; modifies the IR.
define void @reduced(i32* %0, i32* %1, i64 %iv, i32* %2, i64 %iv76, i64 %iv93) { define void @reduced(i32* %0, i32* %1, i64 %iv, i32* %2, i64 %iv76, i64 %iv93) {
; CHECK-LABEL: @reduced( ; CHECK-LABEL: @reduced(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP3:%.*]] = bitcast i32* [[TMP1:%.*]] to i8* ; CHECK-NEXT: [[TMP3:%.*]] = bitcast i32* [[TMP1:%.*]] to i8*
▲ Show 20 Lines • Show All 158 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopVectorize/reduction-odd-interleave-counts.ll

; RUN: opt %s -passes=loop-vectorize -force-vector-interleave=3 -force-vector-width=4 -S | FileCheck --check-prefix=UF3 %s ; RUN: opt -opaque-pointers=0 %s -passes=loop-vectorize -force-vector-interleave=3 -force-vector-width=4 -S | FileCheck --check-prefix=UF3 %s
; RUN: opt %s -passes=loop-vectorize -force-vector-interleave=5 -force-vector-width=4 -S | FileCheck --check-prefix=UF5 %s ; RUN: opt -opaque-pointers=0 %s -passes=loop-vectorize -force-vector-interleave=5 -force-vector-width=4 -S | FileCheck --check-prefix=UF5 %s
define i32 @reduction_sum(i64 %n, i32* noalias nocapture %A) { define i32 @reduction_sum(i64 %n, i32* noalias nocapture %A) {
; UF3-LABEL: vector.body: ; UF3-LABEL: vector.body:
; UF3-NEXT: [[IV:%.+]] = phi i64 [ 0, %vector.ph ], [ [[IV_NEXT:%.+]], %vector.body ] ; UF3-NEXT: [[IV:%.+]] = phi i64 [ 0, %vector.ph ], [ [[IV_NEXT:%.+]], %vector.body ]
; UF3-NEXT: [[SUM0:%.+]] = phi <4 x i32> [ zeroinitializer, %vector.ph ], [ [[SUM0_NEXT:%.+]], %vector.body ] ; UF3-NEXT: [[SUM0:%.+]] = phi <4 x i32> [ zeroinitializer, %vector.ph ], [ [[SUM0_NEXT:%.+]], %vector.body ]
; UF3-NEXT: [[SUM1:%.+]] = phi <4 x i32> [ zeroinitializer, %vector.ph ], [ [[SUM1_NEXT:%.+]], %vector.body ] ; UF3-NEXT: [[SUM1:%.+]] = phi <4 x i32> [ zeroinitializer, %vector.ph ], [ [[SUM1_NEXT:%.+]], %vector.body ]
; UF3-NEXT: [[SUM2:%.+]] = phi <4 x i32> [ zeroinitializer, %vector.ph ], [ [[SUM2_NEXT:%.+]], %vector.body ] ; UF3-NEXT: [[SUM2:%.+]] = phi <4 x i32> [ zeroinitializer, %vector.ph ], [ [[SUM2_NEXT:%.+]], %vector.body ]
; UF3-NEXT: [[IV0:%.+]] = add i64 [[IV]], 0 ; UF3-NEXT: [[IV0:%.+]] = add i64 [[IV]], 0
▲ Show 20 Lines • Show All 93 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopVectorize/reduction-with-invariant-store.ll

; RUN: opt < %s -passes="loop-vectorize" -force-vector-interleave=1 -force-vector-width=4 -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes="loop-vectorize" -force-vector-interleave=1 -force-vector-width=4 -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; This test checks that we can vectorize loop with reduction variable ; This test checks that we can vectorize loop with reduction variable
; stored in an invariant address. ; stored in an invariant address.
; ;
; int sum = 0; ; int sum = 0;
; for(i=0..N) { ; for(i=0..N) {
▲ Show 20 Lines • Show All 553 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopVectorize/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 < %s -aa-pipeline=basic-aa -passes=loop-vectorize,dce,instcombine -force-vector-interleave=1 -force-vector-width=4 -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -aa-pipeline=basic-aa -passes=loop-vectorize,dce,instcombine -force-vector-interleave=1 -force-vector-width=4 -S | FileCheck %s
; RUN: opt < %s -aa-pipeline= -passes=loop-vectorize -S -pass-remarks-analysis='loop-vectorize' 2>&1 | FileCheck %s -check-prefix=FORCED_OPTSIZE ; RUN: opt -opaque-pointers=0 < %s -aa-pipeline= -passes=loop-vectorize -S -pass-remarks-analysis='loop-vectorize' 2>&1 | FileCheck %s -check-prefix=FORCED_OPTSIZE
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; Make sure we vectorize this loop: ; Make sure we vectorize this loop:
; int foo(float *a, float *b, int n) { ; int foo(float *a, float *b, int n) {
; for (int i=0; i<n; ++i) ; for (int i=0; i<n; ++i)
; a[i] = b[i] * 3; ; a[i] = b[i] * 3;
; } ; }
▲ Show 20 Lines • Show All 387 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopVectorize/scalable-lifetime.ll

; RUN: opt -S -scalable-vectorization=on -force-target-supports-scalable-vectors=true -passes=loop-vectorize -force-vector-width=2 -force-vector-interleave=1 < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -S -scalable-vectorization=on -force-target-supports-scalable-vectors=true -passes=loop-vectorize -force-vector-width=2 -force-vector-interleave=1 < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; Make sure we can vectorize loops which contain lifetime markers. ; Make sure we can vectorize loops which contain lifetime markers.
define void @test(i32 *%d) { define void @test(i32 *%d) {
; CHECK-LABEL: @test( ; CHECK-LABEL: @test(
; CHECK: entry: ; CHECK: entry:
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopVectorize/scalar_after_vectorization.ll

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

llvm/test/Transforms/LoopVectorize/scalarized-bitcast.ll

; REQUIRES: asserts ; REQUIRES: asserts
; RUN: opt -passes=loop-vectorize -force-vector-width=2 -debug-only=loop-vectorize -S -o - < %s 2>&1 | FileCheck %s ; RUN: opt -opaque-pointers=0 -passes=loop-vectorize -force-vector-width=2 -debug-only=loop-vectorize -S -o - < %s 2>&1 | FileCheck %s
%struct.foo = type { i32, i64 } %struct.foo = type { i32, i64 }
; CHECK: LV: Found an estimated cost of 0 for VF 2 For instruction: %0 = bitcast i64* %b to i32* ; CHECK: LV: Found an estimated cost of 0 for VF 2 For instruction: %0 = bitcast i64* %b to i32*
; The bitcast below will be scalarized due to the predication in the loop. Bitcasts ; The bitcast below will be scalarized due to the predication in the loop. Bitcasts
; between pointer types should be treated as free, despite the scalarization. ; between pointer types should be treated as free, despite the scalarization.
define void @foo(%struct.foo* noalias nocapture %in, i32* noalias nocapture readnone %out, i64 %n) { define void @foo(%struct.foo* noalias nocapture %in, i32* noalias nocapture readnone %out, i64 %n) {
Show All 30 Lines

llvm/test/Transforms/LoopVectorize/uniform-blend.ll

; RUN: opt -passes=loop-vectorize -force-vector-width=4 -S %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -passes=loop-vectorize -force-vector-width=4 -S %s | FileCheck %s
@dst = external global [32 x i16], align 1 @dst = external global [32 x i16], align 1
define void @blend_uniform_iv_trunc(i1 %c) { define void @blend_uniform_iv_trunc(i1 %c) {
; CHECK-LABEL: @blend_uniform_iv_trunc( ; CHECK-LABEL: @blend_uniform_iv_trunc(
; CHECK: vector.ph: ; CHECK: vector.ph:
; CHECK-NEXT: [[MASK0:%.*]] = insertelement <4 x i1> poison, i1 %c, i64 0 ; CHECK-NEXT: [[MASK0:%.*]] = insertelement <4 x i1> poison, i1 %c, i64 0
; CHECK-NEXT: [[MASK1:%.*]] = shufflevector <4 x i1> [[MASK0]], <4 x i1> poison, <4 x i32> zeroinitializer ; CHECK-NEXT: [[MASK1:%.*]] = shufflevector <4 x i1> [[MASK0]], <4 x i1> poison, <4 x i32> zeroinitializer
▲ Show 20 Lines • Show All 146 Lines • Show Last 20 Lines

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

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

llvm/test/Transforms/LoopVectorize/vector-intrinsic-call-cost.ll

; RUN: opt -S -passes=loop-vectorize -force-vector-width=4 %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -S -passes=loop-vectorize -force-vector-width=4 %s | FileCheck %s
; CHECK-LABEL: @test_fshl ; CHECK-LABEL: @test_fshl
; CHECK-LABEL: vector.body: ; CHECK-LABEL: vector.body:
; CHECK-NEXT: [[IDX:%.+]] = phi i32 [ 0, %vector.ph ], [ %index.next, %vector.body ] ; CHECK-NEXT: [[IDX:%.+]] = phi i32 [ 0, %vector.ph ], [ %index.next, %vector.body ]
; CHECK-NEXT: [[IDX0:%.+]] = add i32 %index, 0 ; CHECK-NEXT: [[IDX0:%.+]] = add i32 %index, 0
; CHECK-NEXT: [[FSHL:%.+]] = call <4 x i16> @llvm.fshl.v4i16(<4 x i16> undef, <4 x i16> undef, <4 x i16> <i16 15, i16 15, i16 15, i16 15>) ; CHECK-NEXT: [[FSHL:%.+]] = call <4 x i16> @llvm.fshl.v4i16(<4 x i16> undef, <4 x i16> undef, <4 x i16> <i16 15, i16 15, i16 15, i16 15>)
; CHECK-NEXT: [[GEP0:%.+]] = getelementptr inbounds i16, i16* %dst, i32 [[IDX0]] ; CHECK-NEXT: [[GEP0:%.+]] = getelementptr inbounds i16, i16* %dst, i32 [[IDX0]]
; CHECK-NEXT: [[GEP1:%.+]] = getelementptr inbounds i16, i16* [[GEP0]], i32 0 ; CHECK-NEXT: [[GEP1:%.+]] = getelementptr inbounds i16, i16* [[GEP0]], i32 0
Show All 24 Lines

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

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

llvm/test/Transforms/LoopVersioning/add-phi-update-users.ll

; RUN: opt < %s -passes=loop-versioning -S -o - | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes=loop-versioning -S -o - | FileCheck %s
; This test case used to end like this: ; This test case used to end like this:
; ;
; Instruction does not dominate all uses! ; Instruction does not dominate all uses!
; %t2 = load i16, i16* @b, align 1, !tbaa !2, !alias.scope !6 ; %t2 = load i16, i16* @b, align 1, !tbaa !2, !alias.scope !6
; %tobool = icmp eq i16 %t2, 0 ; %tobool = icmp eq i16 %t2, 0
; LLVM ERROR: Broken function found, compilation aborted! ; LLVM ERROR: Broken function found, compilation aborted!
; ;
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopVersioning/basic.ll

; RUN: opt -passes=loop-versioning -S < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -passes=loop-versioning -S < %s | FileCheck %s
; RUN: opt -aa-pipeline=basic-aa -passes=loop-versioning -S < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -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:
br label %for.body br label %for.body
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

llvm/test/Transforms/LoopVersioning/bound-check-partially-known.ll

; RUN: opt -aa-pipeline=basic-aa -passes=loop-versioning -S %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -aa-pipeline=basic-aa -passes=loop-versioning -S %s | FileCheck %s
%struct.foo = type { [32000 x double], [32000 x double] } %struct.foo = type { [32000 x double], [32000 x double] }
@global = external global %struct.foo, align 32 @global = external global %struct.foo, align 32
define void @bound_check_partially_known_1(i32 %N) { define void @bound_check_partially_known_1(i32 %N) {
; CHECK-LABEL: @bound_check_partially_known_1( ; CHECK-LABEL: @bound_check_partially_known_1(
; CHECK-NEXT: loop.lver.check: ; CHECK-NEXT: loop.lver.check:
Show All 36 Lines

llvm/test/Transforms/LoopVersioning/lcssa.ll

; RUN: opt -passes=loop-versioning -S < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -passes=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/wrapping-pointer-versioning.ll

; 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=loop-versioning -S < %s | FileCheck %s -check-prefix=LV ; RUN: opt -opaque-pointers=0 -passes=loop-versioning -S < %s | FileCheck %s -check-prefix=LV
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"
; For this loop: ; For this loop:
; unsigned index = 0; ; unsigned index = 0;
; for (int i = 0; i < n; i++) { ; for (int i = 0; i < n; i++) {
; A[2 * index] = A[2 * index] + B[i]; ; A[2 * index] = A[2 * index] + B[i];
; index++; ; index++;
▲ Show 20 Lines • Show All 535 Lines • Show Last 20 Lines

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

; RUN: opt < %s -passes=newgvn -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes=newgvn -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/NewGVN/no_speculative_loads_with_asan.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -O3 -S %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -O3 -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"
declare noalias i8* @_Znam(i64) #1 declare noalias i8* @_Znam(i64) #1
define i32 @TestNoAsan() { define i32 @TestNoAsan() {
; CHECK-LABEL: @TestNoAsan( ; CHECK-LABEL: @TestNoAsan(
; CHECK-NEXT: ret i32 0 ; CHECK-NEXT: ret i32 0
; ;
%1 = tail call noalias i8* @_Znam(i64 2) %1 = tail call noalias i8* @_Znam(i64 2)
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

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

; RUN: opt -passes=newgvn -S < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -passes=newgvn -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/NewGVN/pr31613.ll

; 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 -passes=newgvn -enable-store-refinement -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes=newgvn -enable-store-refinement -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"
;; Both of these tests are tests of phi nodes that end up all equivalent to each other ;; Both of these tests are tests of phi nodes that end up all equivalent to each other
;; Without proper leader ordering, we will end up cycling the leader between all of them and never converge. ;; Without proper leader ordering, we will end up cycling the leader between all of them and never converge.
define void @foo() { define void @foo() {
; CHECK-LABEL: @foo( ; CHECK-LABEL: @foo(
; CHECK-NEXT: bb: ; CHECK-NEXT: bb:
▲ Show 20 Lines • Show All 125 Lines • Show Last 20 Lines

llvm/test/Transforms/NewGVN/refine-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 -passes=newgvn -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes=newgvn -S | FileCheck %s
;; Now that we do store refinement, we have to verify that we add fake uses ;; Now that we do store refinement, we have to verify that we add fake uses
;; when we skip existing stores. ;; when we skip existing stores.
;; We also are testing that various variations that cause stores to move classes ;; We also are testing that various variations that cause stores to move classes
;; have the right class movement happen ;; have the right class movement happen
;; All of these tests result in verification failures if it does not. ;; All of these tests result in verification failures if it does not.
source_filename = "bugpoint-output-daef094.bc" source_filename = "bugpoint-output-daef094.bc"
target triple = "x86_64-apple-darwin16.5.0" target triple = "x86_64-apple-darwin16.5.0"
▲ Show 20 Lines • Show All 177 Lines • Show Last 20 Lines

llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-14.ll

; 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 -passes=rewrite-statepoints-for-gc < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -S -passes=rewrite-statepoints-for-gc < %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"
declare void @foo() gc "statepoint-example" declare void @foo() gc "statepoint-example"
; FIXME: In this test case %b6.base, which is inserted by RS4GC, is identical ; FIXME: In this test case %b6.base, which is inserted by RS4GC, is identical
; to %b6. ; to %b6.
▲ Show 20 Lines • Show All 275 Lines • Show Last 20 Lines

llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-3.ll

; 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 -passes=rewrite-statepoints-for-gc -S 2>&1 | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes=rewrite-statepoints-for-gc -S 2>&1 | FileCheck %s
; derived %next.i64 base %base_obj ; derived %next.i64 base %base_obj
define void @test(i64 addrspace(1)* %base_obj) gc "statepoint-example" { define void @test(i64 addrspace(1)* %base_obj) gc "statepoint-example" {
; CHECK-LABEL: @test( ; CHECK-LABEL: @test(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[OBJ:%.*]] = getelementptr i64, i64 addrspace(1)* [[BASE_OBJ:%.*]], i32 1 ; CHECK-NEXT: [[OBJ:%.*]] = getelementptr i64, i64 addrspace(1)* [[BASE_OBJ:%.*]], i32 1
; CHECK-NEXT: br label [[LOOP:%.*]] ; CHECK-NEXT: br label [[LOOP:%.*]]
Show All 27 Lines

llvm/test/Transforms/RewriteStatepointsForGC/invokes.ll

; RUN: opt < %s -S -passes=rewrite-statepoints-for-gc | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -S -passes=rewrite-statepoints-for-gc | FileCheck %s
declare i64 addrspace(1)* @some_call(i64 addrspace(1)*) declare i64 addrspace(1)* @some_call(i64 addrspace(1)*)
declare i32 @personality_function() declare i32 @personality_function()
define i64 addrspace(1)* @test_basic(i64 addrspace(1)* %obj, i64 addrspace(1)* %obj1) gc "statepoint-example" personality i32 ()* @personality_function { define i64 addrspace(1)* @test_basic(i64 addrspace(1)* %obj, i64 addrspace(1)* %obj1) gc "statepoint-example" personality i32 ()* @personality_function {
; CHECK-LABEL: entry: ; CHECK-LABEL: entry:
entry: entry:
; CHECK: invoke ; CHECK: invoke
▲ Show 20 Lines • Show All 128 Lines • Show Last 20 Lines

llvm/test/Transforms/RewriteStatepointsForGC/liveness-basics.ll

; A collection of liveness test cases to ensure we're reporting the ; A collection of liveness test cases to ensure we're reporting the
; correct live values at statepoints ; correct live values at statepoints
; RUN: opt -passes=rewrite-statepoints-for-gc -spp-rematerialization-threshold=0 -S < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -passes=rewrite-statepoints-for-gc -spp-rematerialization-threshold=0 -S < %s | FileCheck %s
; Tests to make sure we consider %obj live in both the taken and untaken ; Tests to make sure we consider %obj live in both the taken and untaken
; predeccessor of merge. ; predeccessor of merge.
define i64 addrspace(1)* @test1(i1 %cmp, i64 addrspace(1)* %obj) gc "statepoint-example" { define i64 addrspace(1)* @test1(i1 %cmp, i64 addrspace(1)* %obj) gc "statepoint-example" {
; CHECK-LABEL: @test1 ; CHECK-LABEL: @test1
entry: entry:
br i1 %cmp, label %taken, label %untaken br i1 %cmp, label %taken, label %untaken
▲ Show 20 Lines • Show All 154 Lines • Show Last 20 Lines

llvm/test/Transforms/RewriteStatepointsForGC/preprocess.ll

; RUN: opt -passes=rewrite-statepoints-for-gc -S < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -passes=rewrite-statepoints-for-gc -S < %s | FileCheck %s
; Test to make sure we destroy LCSSA's single entry phi nodes before ; Test to make sure we destroy LCSSA's single entry phi nodes before
; running liveness ; running liveness
declare void @consume(...) "gc-leaf-function" declare void @consume(...) "gc-leaf-function"
define void @test6(i64 addrspace(1)* %obj) gc "statepoint-example" { define void @test6(i64 addrspace(1)* %obj) gc "statepoint-example" {
; CHECK-LABEL: @test6 ; CHECK-LABEL: @test6
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

llvm/test/Transforms/RewriteStatepointsForGC/relocate-invoke-result.ll

;; RUN: opt -passes=rewrite-statepoints-for-gc,verify -S < %s | FileCheck %s ;; RUN: opt -opaque-pointers=0 -passes=rewrite-statepoints-for-gc,verify -S < %s | FileCheck %s
;; This test is to verify that RewriteStatepointsForGC correctly relocates values ;; This test is to verify that RewriteStatepointsForGC correctly relocates values
;; defined by invoke instruction results. ;; defined by invoke instruction results.
declare i64* addrspace(1)* @non_gc_call() "gc-leaf-function" declare i64* addrspace(1)* @non_gc_call() "gc-leaf-function"
declare void @gc_call() declare void @gc_call()
declare i32* @fake_personality_function() declare i32* @fake_personality_function()
Show All 22 Lines

llvm/test/Transforms/RewriteStatepointsForGC/relocation.ll

; RUN: opt < %s -passes=rewrite-statepoints-for-gc -spp-rematerialization-threshold=0 -S | FileCheck %s ; RUN: opt -opaque-pointers=0 < %s -passes=rewrite-statepoints-for-gc -spp-rematerialization-threshold=0 -S | FileCheck %s
declare void @foo() declare void @foo()
declare void @use(...) "gc-leaf-function" declare void @use(...) "gc-leaf-function"
define i64 addrspace(1)* @test1(i64 addrspace(1)* %obj, i64 addrspace(1)* %obj2, i1 %condition) gc "statepoint-example" { define i64 addrspace(1)* @test1(i64 addrspace(1)* %obj, i64 addrspace(1)* %obj2, i1 %condition) gc "statepoint-example" {
; CHECK-LABEL: @test1 ; CHECK-LABEL: @test1
▲ Show 20 Lines • Show All 276 Lines • Show Last 20 Lines

mlir/test/Target/LLVMIR/Import/basic.ll

; RUN: mlir-translate -import-llvm %s | FileCheck %s ; RUN: mlir-translate -opaque-pointers=0 -import-llvm %s | FileCheck %s
; RUN: mlir-translate -import-llvm -mlir-print-debuginfo %s | FileCheck %s --check-prefix=CHECK-DBG ; RUN: mlir-translate -opaque-pointers=0 -import-llvm -mlir-print-debuginfo %s | FileCheck %s --check-prefix=CHECK-DBG
; CHECK-DBG: #[[MODULELOC:.+]] = loc({{.*}}basic.ll{{.*}}:0:0) ; CHECK-DBG: #[[MODULELOC:.+]] = loc({{.*}}basic.ll{{.*}}:0:0)
@global = external global double, align 8 @global = external global double, align 8
; CHECK: llvm.func @fe(i32) -> f32 ; CHECK: llvm.func @fe(i32) -> f32
declare float @fe(i32) declare float @fe(i32)
▲ Show 20 Lines • Show All 129 Lines • Show Last 20 Lines

mlir/test/Target/LLVMIR/Import/constant.ll

; RUN: mlir-translate -import-llvm -split-input-file %s | FileCheck %s ; RUN: mlir-translate -opaque-pointers=0 -import-llvm -split-input-file %s | FileCheck %s
; CHECK-LABEL: @int_constants ; CHECK-LABEL: @int_constants
define void @int_constants(i16 %arg0, i32 %arg1, i1 %arg2) { define void @int_constants(i16 %arg0, i32 %arg1, i1 %arg2) {
; CHECK: %[[C0:.+]] = llvm.mlir.constant(42 : i16) : i16 ; CHECK: %[[C0:.+]] = llvm.mlir.constant(42 : i16) : i16
; CHECK: %[[C1:.+]] = llvm.mlir.constant(7 : i32) : i32 ; CHECK: %[[C1:.+]] = llvm.mlir.constant(7 : i32) : i32
; CHECK: %[[C2:.+]] = llvm.mlir.constant(true) : i1 ; CHECK: %[[C2:.+]] = llvm.mlir.constant(true) : i1
; CHECK: llvm.add %[[C0]], %{{.*}} : i16 ; CHECK: llvm.add %[[C0]], %{{.*}} : i16
▲ Show 20 Lines • Show All 219 Lines • Show Last 20 Lines

mlir/test/Target/LLVMIR/Import/incorrect-constant-caching.ll

; RUN: mlir-translate --import-llvm %s | FileCheck %s ; RUN: mlir-translate -opaque-pointers=0 --import-llvm %s | FileCheck %s
; Testing the fix for issue where llvm.getelementptr translated from the second ; Testing the fix for issue where llvm.getelementptr translated from the second
; ConstantExpr-GEP tried to use llvm.constant(0: i32)-s that were below itself, ; ConstantExpr-GEP tried to use llvm.constant(0: i32)-s that were below itself,
; because it's reusing the cached ConstantInt-type zero value translated earlier. ; because it's reusing the cached ConstantInt-type zero value translated earlier.
; This test is primarily used to make sure an verification is passed. Thus, we ; This test is primarily used to make sure an verification is passed. Thus, we
; only wrote minimum level of checks. ; only wrote minimum level of checks.
Show All 21 Lines

mlir/test/Target/LLVMIR/Import/incorrect-constexpr-inst-caching.ll

; RUN: mlir-translate --import-llvm %s | FileCheck %s ; RUN: mlir-translate -opaque-pointers=0 --import-llvm %s | FileCheck %s
; REQUIRES: asserts ; REQUIRES: asserts
; This test is primarily used to make sure an assertion is not triggered. ; This test is primarily used to make sure an assertion is not triggered.
; Thus, we only wrote minimum level of checks. ; Thus, we only wrote minimum level of checks.
%my_struct = type {i32, i8*} %my_struct = type {i32, i8*}
; CHECK: llvm.mlir.constant(8 : i32) : i32 ; CHECK: llvm.mlir.constant(8 : i32) : i32
; CHECK: llvm.mlir.addressof @str0 : !llvm.ptr<array<5 x i8>> ; CHECK: llvm.mlir.addressof @str0 : !llvm.ptr<array<5 x i8>>
Show All 21 Lines

mlir/test/Target/LLVMIR/Import/incorrect-scalable-vector-check.ll

; RUN: mlir-translate --import-llvm %s | FileCheck %s ; RUN: mlir-translate -opaque-pointers=0 --import-llvm %s | FileCheck %s
; CHECK: llvm.func @shufflevector_crash ; CHECK: llvm.func @shufflevector_crash
define void @shufflevector_crash(<2 x i32*> %arg0) { define void @shufflevector_crash(<2 x i32*> %arg0) {
; CHECK: llvm.shufflevector %{{.+}}, %{{.+}} [1, 0] : !llvm.vec<2 x ptr<i32>> ; CHECK: llvm.shufflevector %{{.+}}, %{{.+}} [1, 0] : !llvm.vec<2 x ptr<i32>>
%1 = shufflevector <2 x i32*> %arg0, <2 x i32*> undef, <2 x i32> <i32 1, i32 0> %1 = shufflevector <2 x i32*> %arg0, <2 x i32*> undef, <2 x i32> <i32 1, i32 0>
ret void ret void
} }

mlir/test/Target/LLVMIR/Import/intrinsic.ll

; RUN: mlir-translate -import-llvm %s | FileCheck %s ; RUN: mlir-translate -opaque-pointers=0 -import-llvm %s | FileCheck %s
; CHECK-LABEL: llvm.func @fmuladd_test ; CHECK-LABEL: llvm.func @fmuladd_test
define void @fmuladd_test(float %0, float %1, <8 x float> %2, i8* %3) { define void @fmuladd_test(float %0, float %1, <8 x float> %2, i8* %3) {
; CHECK: llvm.intr.fmuladd(%{{.*}}, %{{.*}}, %{{.*}}) : (f32, f32, f32) -> f32 ; CHECK: llvm.intr.fmuladd(%{{.*}}, %{{.*}}, %{{.*}}) : (f32, f32, f32) -> f32
%5 = call float @llvm.fmuladd.f32(float %0, float %1, float %0) %5 = call float @llvm.fmuladd.f32(float %0, float %1, float %0)
; CHECK: llvm.intr.fmuladd(%{{.*}}, %{{.*}}, %{{.*}}) : (vector<8xf32>, vector<8xf32>, vector<8xf32>) -> vector<8xf32> ; CHECK: llvm.intr.fmuladd(%{{.*}}, %{{.*}}, %{{.*}}) : (vector<8xf32>, vector<8xf32>, vector<8xf32>) -> vector<8xf32>
%6 = call <8 x float> @llvm.fmuladd.v8f32(<8 x float> %2, <8 x float> %2, <8 x float> %2) %6 = call <8 x float> @llvm.fmuladd.v8f32(<8 x float> %2, <8 x float> %2, <8 x float> %2)
; CHECK: llvm.intr.fma(%{{.*}}, %{{.*}}, %{{.*}}) : (f32, f32, f32) -> f32 ; CHECK: llvm.intr.fma(%{{.*}}, %{{.*}}, %{{.*}}) : (f32, f32, f32) -> f32
▲ Show 20 Lines • Show All 786 Lines • Show Last 20 Lines

mlir/test/Target/LLVMIR/Import/zeroinitializer.ll

; RUN: mlir-translate --import-llvm %s | FileCheck %s ; RUN: mlir-translate -opaque-pointers=0 --import-llvm %s | FileCheck %s
%Domain = type { %Domain**, %Domain* } %Domain = type { %Domain**, %Domain* }
; CHECK: llvm.mlir.global external @D() ; CHECK: llvm.mlir.global external @D()
; CHECK-SAME: !llvm.struct<"Domain", (ptr<ptr<struct<"Domain">>>, ptr<struct<"Domain">>)> ; CHECK-SAME: !llvm.struct<"Domain", (ptr<ptr<struct<"Domain">>>, ptr<struct<"Domain">>)>
; CHECK: %[[E0:.+]] = llvm.mlir.null : !llvm.ptr<ptr<struct<"Domain", (ptr<ptr<struct<"Domain">>>, ptr<struct<"Domain">>)>>> ; CHECK: %[[E0:.+]] = llvm.mlir.null : !llvm.ptr<ptr<struct<"Domain", (ptr<ptr<struct<"Domain">>>, ptr<struct<"Domain">>)>>>
; CHECK: %[[E1:.+]] = llvm.mlir.null : !llvm.ptr<struct<"Domain", (ptr<ptr<struct<"Domain">>>, ptr<struct<"Domain">>)>> ; CHECK: %[[E1:.+]] = llvm.mlir.null : !llvm.ptr<struct<"Domain", (ptr<ptr<struct<"Domain">>>, ptr<struct<"Domain">>)>>
; CHECK: %[[ROOT:.+]] = llvm.mlir.undef : !llvm.struct<"Domain", (ptr<ptr<struct<"Domain">>>, ptr<struct<"Domain">>)> ; CHECK: %[[ROOT:.+]] = llvm.mlir.undef : !llvm.struct<"Domain", (ptr<ptr<struct<"Domain">>>, ptr<struct<"Domain">>)>
; CHECK: %[[CHAIN:.+]] = llvm.insertvalue %[[E0]], %[[ROOT]][0] ; CHECK: %[[CHAIN:.+]] = llvm.insertvalue %[[E0]], %[[ROOT]][0]
; CHECK: %[[RES:.+]] = llvm.insertvalue %[[E1]], %[[CHAIN]][1] ; CHECK: %[[RES:.+]] = llvm.insertvalue %[[E1]], %[[CHAIN]][1]
; CHECK: llvm.return %[[RES]] ; CHECK: llvm.return %[[RES]]
@D = global %Domain zeroinitializer @D = global %Domain zeroinitializer

polly/test/CodeGen/LoopParallelMD/single_loop_param_parallel.ll

; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s -check-prefix=SEQUENTIAL ; RUN: opt -opaque-pointers=0 %loadPolly -polly-codegen -S < %s | FileCheck %s -check-prefix=SEQUENTIAL
; RUN: opt %loadPolly -polly-codegen -polly-ast-detect-parallel -S < %s | FileCheck %s -check-prefix=PARALLEL ; RUN: opt -opaque-pointers=0 %loadPolly -polly-codegen -polly-ast-detect-parallel -S < %s | FileCheck %s -check-prefix=PARALLEL
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32: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"
; This is a trivially parallel loop. We just use it to ensure that we actually ; This is a trivially parallel loop. We just use it to ensure that we actually
; emit the right information. ; emit the right information.
; ;
; for (i = 0; i < n; i++) ; for (i = 0; i < n; i++)
; A[i] = 1; ; A[i] = 1;
; ;
▲ Show 20 Lines • Show All 85 Lines • Show Last 20 Lines

polly/test/CodeGen/MemAccess/codegen_address_space.ll

;RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-codegen -instnamer < %s -S | FileCheck %s ;RUN: opt -opaque-pointers=0 %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-codegen -instnamer < %s -S | FileCheck %s
;int A[100]; ;int A[100];
; ;
;int codegen_simple () { ;int codegen_simple () {
; for (int i = 0; i < 12; i++) ; for (int i = 0; i < 12; i++)
; A[13] = A[i] + A[i-1]; ; A[13] = A[i] + A[i-1];
; ;
; return 0; ; return 0;
Show All 35 Lines

polly/test/CodeGen/MemAccess/codegen_constant_offset.ll

;RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-codegen -instnamer < %s -S | FileCheck %s ;RUN: opt -opaque-pointers=0 %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-codegen -instnamer < %s -S | FileCheck %s
;int A[100]; ;int A[100];
; ;
;int codegen_constant_offset() { ;int codegen_constant_offset() {
; for (int i = 0; i < 12; i++) ; for (int i = 0; i < 12; i++)
; A[13] = A[i] + A[i-1]; ; A[13] = A[i] + A[i-1];
; ;
; return 0; ; return 0;
Show All 33 Lines

polly/test/CodeGen/MemAccess/codegen_simple.ll

;RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-codegen -instnamer < %s -S | FileCheck %s ;RUN: opt -opaque-pointers=0 %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-codegen -instnamer < %s -S | FileCheck %s
;int A[100]; ;int A[100];
; ;
;int codegen_simple () { ;int codegen_simple () {
; for (int i = 0; i < 12; i++) ; for (int i = 0; i < 12; i++)
; A[13] = A[i] + A[i-1]; ; A[13] = A[i] + A[i-1];
; ;
; return 0; ; return 0;
Show All 33 Lines

polly/test/CodeGen/MemAccess/codegen_simple_float.ll

;RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-codegen -instnamer < %s -S | FileCheck %s ;RUN: opt -opaque-pointers=0 %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-codegen -instnamer < %s -S | FileCheck %s
; ;
;float A[100]; ;float A[100];
; ;
;int codegen_simple () { ;int codegen_simple () {
; for (int i = 0; i < 12; i++) ; for (int i = 0; i < 12; i++)
; A[13] = A[i] + A[i-1]; ; A[13] = A[i] + A[i-1];
; ;
; return 0; ; return 0;
Show All 32 Lines

polly/test/CodeGen/MemAccess/codegen_simple_md.ll

;RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed+withconst -polly-codegen < %s -S | FileCheck -check-prefix=WITHCONST %s ;RUN: opt -opaque-pointers=0 %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed+withconst -polly-codegen < %s -S | FileCheck -check-prefix=WITHCONST %s
;RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed+withoutconst -polly-codegen < %s -S | FileCheck -check-prefix=WITHOUTCONST %s ;RUN: opt -opaque-pointers=0 %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed+withoutconst -polly-codegen < %s -S | FileCheck -check-prefix=WITHOUTCONST %s
;int A[1040]; ;int A[1040];
; ;
;int codegen_simple_md() { ;int codegen_simple_md() {
; for (int i = 0; i < 32; ++i) ; for (int i = 0; i < 32; ++i)
; for (int j = 0; j < 32; ++j) ; for (int j = 0; j < 32; ++j)
; A[32*i+j] = 100; ; A[32*i+j] = 100;
; ;
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

polly/test/CodeGen/MemAccess/codegen_simple_md_float.ll

;RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed+withconst -polly-codegen < %s -S | FileCheck -check-prefix=WITHCONST %s ;RUN: opt -opaque-pointers=0 %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed+withconst -polly-codegen < %s -S | FileCheck -check-prefix=WITHCONST %s
;RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed+withoutconst -polly-codegen < %s -S | FileCheck -check-prefix=WITHOUTCONST %s ;RUN: opt -opaque-pointers=0 %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed+withoutconst -polly-codegen < %s -S | FileCheck -check-prefix=WITHOUTCONST %s
; ;
;float A[1040]; ;float A[1040];
; ;
;int codegen_simple_md() { ;int codegen_simple_md() {
; for (int i = 0; i < 32; ++i) ; for (int i = 0; i < 32; ++i)
; for (int j = 0; j < 32; ++j) ; for (int j = 0; j < 32; ++j)
; A[32*i+j] = 100; ; A[32*i+j] = 100;
;} ;}
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

polly/test/CodeGen/MemAccess/create_arrays.ll

; RUN: opt %loadPolly -polly-print-scops -polly-print-import-jscop -polly-import-jscop-postfix=transformed -disable-output < %s 2>&1 | FileCheck %s ; RUN: opt -opaque-pointers=0 %loadPolly -polly-print-scops -polly-print-import-jscop -polly-import-jscop-postfix=transformed -disable-output < %s 2>&1 | FileCheck %s
; RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-codegen -S < %s 2>&1 | FileCheck %s --check-prefix=CODEGEN ; RUN: opt -opaque-pointers=0 %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-codegen -S < %s 2>&1 | FileCheck %s --check-prefix=CODEGEN
; ;
; for (i = 0; i < _PB_NI; i++) ; for (i = 0; i < _PB_NI; i++)
; for (j = 0; j < _PB_NJ; j++) ; for (j = 0; j < _PB_NJ; j++)
; for (k = 0; k < _PB_NK; ++k) ; for (k = 0; k < _PB_NK; ++k)
; B[i][j] = beta * A[i][k]; ; B[i][j] = beta * A[i][k];
; ;
; ;
; CHECK: Arrays { ; CHECK: Arrays {
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

polly/test/CodeGen/MemAccess/create_arrays_heap.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-print-scops -polly-print-import-jscop -polly-import-jscop-postfix=transformed -disable-output < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 %loadPolly -polly-stmt-granularity=bb -polly-print-scops -polly-print-import-jscop -polly-import-jscop-postfix=transformed -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-codegen -S < %s | FileCheck %s --check-prefix=CODEGEN ; RUN: opt -opaque-pointers=0 %loadPolly -polly-stmt-granularity=bb -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-codegen -S < %s | FileCheck %s --check-prefix=CODEGEN
; ;
; #define Ni 1056 ; #define Ni 1056
; #define Nj 1056 ; #define Nj 1056
; #define Nk 1024 ; #define Nk 1024
; ;
; void create_arrays_heap(double beta, double A[Ni][Nk], double B[Ni][Nj]) { ; void create_arrays_heap(double beta, double A[Ni][Nk], double B[Ni][Nj]) {
; int i,j,k; ; int i,j,k;
; ;
▲ Show 20 Lines • Show All 103 Lines • Show Last 20 Lines

polly/test/CodeGen/MemAccess/different_types.ll

; RUN: opt %loadPolly -polly-import-jscop \ ; RUN: opt -opaque-pointers=0 %loadPolly -polly-import-jscop \
; RUN: \ ; RUN: \
; RUN: -polly-codegen -S < %s | FileCheck %s ; RUN: -polly-codegen -S < %s | FileCheck %s
; ;
; void foo(float A[], float B[]) { ; void foo(float A[], float B[]) {
; for (long i = 0; i < 100; i++) ; for (long i = 0; i < 100; i++)
; *(int *)(&A[i]) = *(int *)(&B[i]); ; *(int *)(&A[i]) = *(int *)(&B[i]);
; for (long i = 0; i < 100; i++) ; for (long i = 0; i < 100; i++)
; A[i] += 10; ; A[i] += 10;
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

polly/test/CodeGen/MemAccess/generate-all.ll

; RUN: opt %loadPolly -polly-codegen -polly-codegen-generate-expressions=false \ ; RUN: opt -opaque-pointers=0 %loadPolly -polly-codegen -polly-codegen-generate-expressions=false \
; RUN: -S < %s | FileCheck %s -check-prefix=SCEV ; RUN: -S < %s | FileCheck %s -check-prefix=SCEV
; RUN: opt %loadPolly -polly-codegen -polly-codegen-generate-expressions=true \ ; RUN: opt -opaque-pointers=0 %loadPolly -polly-codegen -polly-codegen-generate-expressions=true \
; RUN: -S < %s | FileCheck %s -check-prefix=ASTEXPR ; RUN: -S < %s | FileCheck %s -check-prefix=ASTEXPR
; ;
; void foo(float A[]) { ; void foo(float A[]) {
; for (long i = 0; i < 100; i++) ; for (long i = 0; i < 100; i++)
; A[i % 4] += 10; ; A[i % 4] += 10;
; } ; }
; SCEV: polly.stmt.bb2: ; preds = %polly.loop_header ; SCEV: polly.stmt.bb2: ; preds = %polly.loop_header
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

polly/test/CodeGen/MemAccess/invariant_base_ptr.ll

; RUN: opt %loadPolly -polly-import-jscop \ ; RUN: opt -opaque-pointers=0 %loadPolly -polly-import-jscop \
; RUN: -polly-codegen -polly-invariant-load-hoisting -S \ ; RUN: -polly-codegen -polly-invariant-load-hoisting -S \
; RUN: 2>&1 < %s | FileCheck %s ; RUN: 2>&1 < %s | FileCheck %s
; Setting new access functions where the base pointer of the array that is newly ; Setting new access functions where the base pointer of the array that is newly
; accessed is only loaded within the scop itself caused incorrect code to be ; accessed is only loaded within the scop itself caused incorrect code to be
; generated when invariant load hoisting is disabled. This test case checks ; generated when invariant load hoisting is disabled. This test case checks
; that in case invariant load hoisting is enabled, we generate correct code. ; that in case invariant load hoisting is enabled, we generate correct code.
Show All 32 Lines

polly/test/CodeGen/MemAccess/map_scalar_access.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-import-jscop-postfix=transformed -polly-print-import-jscop -disable-output < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 %loadPolly -polly-stmt-granularity=bb -polly-import-jscop-postfix=transformed -polly-print-import-jscop -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-import-jscop-postfix=transformed -polly-import-jscop -polly-codegen -S < %s | FileCheck %s --check-prefix=CODEGEN ; RUN: opt -opaque-pointers=0 %loadPolly -polly-stmt-granularity=bb -polly-import-jscop-postfix=transformed -polly-import-jscop -polly-codegen -S < %s | FileCheck %s --check-prefix=CODEGEN
define void @map_scalar_access(double* noalias nonnull %A) { define void @map_scalar_access(double* noalias nonnull %A) {
entry: entry:
br label %outer.for br label %outer.for
outer.for: outer.for:
%j = phi i32 [0, %entry], [%j.inc, %outer.inc] %j = phi i32 [0, %entry], [%j.inc, %outer.inc]
%j.cmp = icmp slt i32 %j, 1 %j.cmp = icmp slt i32 %j, 1
▲ Show 20 Lines • Show All 139 Lines • Show Last 20 Lines

polly/test/CodeGen/MemAccess/multiple_types.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-import-jscop \ ; RUN: opt -opaque-pointers=0 %loadPolly -polly-stmt-granularity=bb -polly-import-jscop \
; RUN: -polly-allow-differing-element-types \ ; RUN: -polly-allow-differing-element-types \
; RUN: -polly-codegen -S < %s | FileCheck %s ; RUN: -polly-codegen -S < %s | FileCheck %s
; ;
; // Check that accessing one array with different types works. ; // Check that accessing one array with different types works.
; void multiple_types(char *Short, char *Float, char *Double) { ; void multiple_types(char *Short, char *Float, char *Double) {
; for (long i = 0; i < 100; i++) { ; for (long i = 0; i < 100; i++) {
; Short[i] = *(short *)&Short[2 * i]; ; Short[i] = *(short *)&Short[2 * i];
; Float[i] = *(float *)&Float[4 * i]; ; Float[i] = *(float *)&Float[4 * i];
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

polly/test/CodeGen/MemAccess/simple_stride_test.ll

; RUN: opt %loadPolly -basic-aa -polly-import-jscop -polly-codegen -polly-vectorizer=polly -S < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 %loadPolly -basic-aa -polly-import-jscop -polly-codegen -polly-vectorizer=polly -S < %s | FileCheck %s
; ;
; Check that we use the correct __new__ strides: ; Check that we use the correct __new__ strides:
; stride zero for B ; stride zero for B
; stride one for A ; stride one for A
; ;
; CHECK: %polly.access.B = getelementptr i32, i32* %B, i64 0 ; CHECK: %polly.access.B = getelementptr i32, i32* %B, i64 0
; CHECK: %[[BC:[._a-zA-Z0-9]*]] = bitcast i32* %polly.access.B to <1 x i32>* ; CHECK: %[[BC:[._a-zA-Z0-9]*]] = bitcast i32* %polly.access.B to <1 x i32>*
; CHECK: %[[LD:[._a-zA-Z0-9]*]] = load <1 x i32>, <1 x i32>* %[[BC]], align 8 ; CHECK: %[[LD:[._a-zA-Z0-9]*]] = load <1 x i32>, <1 x i32>* %[[BC]], align 8
Show All 38 Lines

polly/test/CodeGen/OpenMP/alias-metadata.ll

; RUN: opt %loadPolly -polly-codegen -polly-parallel -S < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 %loadPolly -polly-codegen -polly-parallel -S < %s | FileCheck %s
; ;
; void foo(float *A, float *B) { ; void foo(float *A, float *B) {
; for (long i = 0; i < 1000; i++) ; for (long i = 0; i < 1000; i++)
; for (long j = 0; j < 1000; j++) ; for (long j = 0; j < 1000; j++)
; A[i] = B[i]; ; A[i] = B[i];
; } ; }
; ;
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"
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

polly/test/CodeGen/OpenMP/loop-body-references-outer-values.ll

; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-print-ast -disable-output < %s | FileCheck %s -check-prefix=AST ; RUN: opt -opaque-pointers=0 %loadPolly -polly-parallel -polly-parallel-force -polly-print-ast -disable-output < %s | FileCheck %s -check-prefix=AST
; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-codegen -S < %s | FileCheck %s -check-prefix=IR ; RUN: opt -opaque-pointers=0 %loadPolly -polly-parallel -polly-parallel-force -polly-codegen -S < %s | FileCheck %s -check-prefix=IR
; Make sure we correctly forward the reference to 'A' to the OpenMP subfunction. ; Make sure we correctly forward the reference to 'A' to the OpenMP subfunction.
; ;
; void loop_references_outer_ids(float *A) { ; void loop_references_outer_ids(float *A) {
; for (long i = 0; i < 100; i++) ; for (long i = 0; i < 100; i++)
; A[i] = i; ; A[i] = i;
; } ; }
Show All 35 Lines

polly/test/CodeGen/OpenMP/loop-bounds-reference-outer-ids.ll

; RUN: opt %loadPolly -polly-parallel -polly-print-ast -disable-output < %s | FileCheck %s -check-prefix=AST ; RUN: opt -opaque-pointers=0 %loadPolly -polly-parallel -polly-print-ast -disable-output < %s | FileCheck %s -check-prefix=AST
; RUN: opt %loadPolly -polly-parallel -polly-codegen -S < %s | FileCheck %s -check-prefix=IR ; RUN: opt -opaque-pointers=0 %loadPolly -polly-parallel -polly-codegen -S < %s | FileCheck %s -check-prefix=IR
; ;
; float A[100]; ; float A[100];
; ;
; void loop_references_outer_ids(long n) { ; void loop_references_outer_ids(long n) {
; for (long i = 0; i < 100; i++) ; for (long i = 0; i < 100; i++)
; for (long j = 0; j < 100; j++) ; for (long j = 0; j < 100; j++)
; for (long k = 0; k < n + i; k++) ; for (long k = 0; k < n + i; k++)
; A[j] += i + j + k; ; A[j] += i + j + k;
▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

polly/test/CodeGen/OpenMP/mapped-phi-access.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-parallel -polly-delicm -polly-codegen -S < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 %loadPolly -polly-stmt-granularity=bb -polly-parallel -polly-delicm -polly-codegen -S < %s | FileCheck %s
; ;
; Verify that -polly-parallel can handle mapped scalar MemoryAccesses. ; Verify that -polly-parallel can handle mapped scalar MemoryAccesses.
; ;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
define void @main() local_unnamed_addr #0 { define void @main() local_unnamed_addr #0 {
entry: entry:
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

polly/test/CodeGen/OpenMP/new_multidim_access.ll

; RUN: opt %loadPolly -polly-print-import-jscop \ ; RUN: opt -opaque-pointers=0 %loadPolly -polly-print-import-jscop \
; RUN: -disable-output < %s | FileCheck %s ; RUN: -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-import-jscop \ ; RUN: opt -opaque-pointers=0 %loadPolly -polly-import-jscop \
; RUN: -polly-codegen -S < %s \ ; RUN: -polly-codegen -S < %s \
; RUN: -polly-parallel \ ; RUN: -polly-parallel \
; RUN: | FileCheck %s -check-prefix=IR ; RUN: | FileCheck %s -check-prefix=IR
; void new_multidim_access(long n, long m, float A[][m]) { ; void new_multidim_access(long n, long m, float A[][m]) {
; for (long i = 0; i < n; i++) ; for (long i = 0; i < n; i++)
; for (long j = 0; j < 100; j++) ; for (long j = 0; j < 100; j++)
; A[i][2 * j] += i + j; ; A[i][2 * j] += i + j;
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

polly/test/CodeGen/OpenMP/recomputed-srem.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-codegen -polly-parallel \ ; RUN: opt -opaque-pointers=0 %loadPolly -polly-stmt-granularity=bb -polly-codegen -polly-parallel \
; RUN: -polly-parallel-force -S < %s | FileCheck %s ; RUN: -polly-parallel-force -S < %s | FileCheck %s
; ;
; Test to verify that we pass %rem96 to the parallel subfunction. ; Test to verify that we pass %rem96 to the parallel subfunction.
; ;
; CHECK: %[[R:[0-9]*]] = getelementptr inbounds { i32, i32, i64, float*, float*, i32 }, { i32, i32, i64, float*, float*, i32 }* %polly.par.userContext1, i32 0, i32 5 ; CHECK: %[[R:[0-9]*]] = getelementptr inbounds { i32, i32, i64, float*, float*, i32 }, { i32, i32, i64, float*, float*, i32 }* %polly.par.userContext1, i32 0, i32 5
; CHECK-NEXT: %polly.subfunc.arg.rem96 = load i32, i32* %[[R]] ; CHECK-NEXT: %polly.subfunc.arg.rem96 = load i32, i32* %[[R]]
; ;
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"
Show All 35 Lines

polly/test/CodeGen/OpenMP/single_loop.ll

; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-print-ast -disable-output < %s | FileCheck %s -check-prefix=AST ; RUN: opt -opaque-pointers=0 %loadPolly -polly-parallel -polly-parallel-force -polly-print-ast -disable-output < %s | FileCheck %s -check-prefix=AST
; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-codegen -S -verify-dom-info < %s | FileCheck %s -check-prefix=IR ; RUN: opt -opaque-pointers=0 %loadPolly -polly-parallel -polly-parallel-force -polly-codegen -S -verify-dom-info < %s | FileCheck %s -check-prefix=IR
; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-import-jscop -polly-print-ast -disable-output < %s | FileCheck %s -check-prefix=AST-STRIDE4 ; RUN: opt -opaque-pointers=0 %loadPolly -polly-parallel -polly-parallel-force -polly-import-jscop -polly-print-ast -disable-output < %s | FileCheck %s -check-prefix=AST-STRIDE4
; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-import-jscop -polly-codegen -S < %s | FileCheck %s -check-prefix=IR-STRIDE4 ; RUN: opt -opaque-pointers=0 %loadPolly -polly-parallel -polly-parallel-force -polly-import-jscop -polly-codegen -S < %s | FileCheck %s -check-prefix=IR-STRIDE4
; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-codegen -polly-omp-backend=LLVM -polly-scheduling=static -polly-scheduling-chunksize=43 -S -verify-dom-info < %s | FileCheck %s -check-prefix=LIBOMP-IR-STATIC-CHUNKED ; RUN: opt -opaque-pointers=0 %loadPolly -polly-parallel -polly-parallel-force -polly-codegen -polly-omp-backend=LLVM -polly-scheduling=static -polly-scheduling-chunksize=43 -S -verify-dom-info < %s | FileCheck %s -check-prefix=LIBOMP-IR-STATIC-CHUNKED
; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-codegen -polly-omp-backend=LLVM -polly-scheduling=static -S -verify-dom-info < %s | FileCheck %s -check-prefix=LIBOMP-IR-STATIC ; RUN: opt -opaque-pointers=0 %loadPolly -polly-parallel -polly-parallel-force -polly-codegen -polly-omp-backend=LLVM -polly-scheduling=static -S -verify-dom-info < %s | FileCheck %s -check-prefix=LIBOMP-IR-STATIC
; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-codegen -polly-omp-backend=LLVM -polly-scheduling=dynamic -S -verify-dom-info < %s | FileCheck %s -check-prefix=LIBOMP-IR-DYNAMIC ; RUN: opt -opaque-pointers=0 %loadPolly -polly-parallel -polly-parallel-force -polly-codegen -polly-omp-backend=LLVM -polly-scheduling=dynamic -S -verify-dom-info < %s | FileCheck %s -check-prefix=LIBOMP-IR-DYNAMIC
; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-codegen -polly-omp-backend=LLVM -polly-scheduling=dynamic -polly-scheduling-chunksize=4 -S -verify-dom-info < %s | FileCheck %s -check-prefix=LIBOMP-IR-DYNAMIC-FOUR ; RUN: opt -opaque-pointers=0 %loadPolly -polly-parallel -polly-parallel-force -polly-codegen -polly-omp-backend=LLVM -polly-scheduling=dynamic -polly-scheduling-chunksize=4 -S -verify-dom-info < %s | FileCheck %s -check-prefix=LIBOMP-IR-DYNAMIC-FOUR
; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-import-jscop -polly-codegen -polly-omp-backend=LLVM -S < %s | FileCheck %s -check-prefix=LIBOMP-IR-STRIDE4 ; RUN: opt -opaque-pointers=0 %loadPolly -polly-parallel -polly-parallel-force -polly-import-jscop -polly-codegen -polly-omp-backend=LLVM -S < %s | FileCheck %s -check-prefix=LIBOMP-IR-STRIDE4
; This extensive test case tests the creation of the full set of OpenMP calls ; This extensive test case tests the creation of the full set of OpenMP calls
; as well as the subfunction creation using a trivial loop as example. ; as well as the subfunction creation using a trivial loop as example.
; ;
; #define N 1024 ; #define N 1024
; float A[N]; ; float A[N];
; ;
; void single_parallel_loop(void) { ; void single_parallel_loop(void) {
▲ Show 20 Lines • Show All 224 Lines • Show Last 20 Lines

polly/test/CodeGen/RuntimeDebugBuilder/combine_different_values.ll

; RUN: opt %loadPolly -polly-codegen -S \ ; RUN: opt -opaque-pointers=0 %loadPolly -polly-codegen -S \
; RUN: -polly-codegen-add-debug-printing \ ; RUN: -polly-codegen-add-debug-printing \
; RUN: -polly-ignore-aliasing < %s | FileCheck %s ; RUN: -polly-ignore-aliasing < %s | FileCheck %s
; #define N 10 ; #define N 10
; void foo(float A[restrict], double B[restrict], char C[restrict], ; void foo(float A[restrict], double B[restrict], char C[restrict],
; int D[restrict], long E[restrict]) { ; int D[restrict], long E[restrict]) {
; for (long i = 0; i < N; i++) ; for (long i = 0; i < N; i++)
; A[i] += B[i] + C[i] + D[i] + E[i]; ; A[i] += B[i] + C[i] + D[i] + E[i];
▲ Show 20 Lines • Show All 170 Lines • Show Last 20 Lines

polly/test/CodeGen/aliasing_different_base_and_access_type.ll

; RUN: opt %loadPolly -S -polly-codegen < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 %loadPolly -S -polly-codegen < %s | FileCheck %s
; ;
; We have to cast %B to "short *" before we create RTCs. ; We have to cast %B to "short *" before we create RTCs.
; ;
; CHECK: %polly.access.cast.B = bitcast i32* %B to i16* ; CHECK: %polly.access.cast.B = bitcast i32* %B to i16*
; CHECK-NEXT: %polly.access.B = getelementptr i16, i16* %polly.access.cast.B, i64 1024 ; CHECK-NEXT: %polly.access.B = getelementptr i16, i16* %polly.access.cast.B, i64 1024
; ;
; We should never access %B as an i32 pointer: ; We should never access %B as an i32 pointer:
; ;
Show All 34 Lines

polly/test/CodeGen/aliasing_different_pointer_types.ll

; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 %loadPolly -polly-codegen -S < %s | FileCheck %s
; ;
; Check that we cast the different pointer types correctly before we compare ; Check that we cast the different pointer types correctly before we compare
; them in the RTC's. We use i8* as max pointer type. ; them in the RTC's. We use i8* as max pointer type.
; ;
; CHECK: polly.split_new_and_old: ; CHECK: polly.split_new_and_old:
; CHECK: %polly.access.B = getelementptr float*, float** %B, i64 1024 ; CHECK: %polly.access.B = getelementptr float*, float** %B, i64 1024
; CHECK: %polly.access.A = getelementptr double*, double** %A, i64 0 ; CHECK: %polly.access.A = getelementptr double*, double** %A, i64 0
; CHECK: %[[paBb:[._a-zA-Z0-9]]] = ptrtoint float** %polly.access.B to i64 ; CHECK: %[[paBb:[._a-zA-Z0-9]]] = ptrtoint float** %polly.access.B to i64
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

polly/test/CodeGen/aliasing_parametric_simple_1.ll

; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 %loadPolly -polly-codegen -S < %s | FileCheck %s
; ;
; void jd(int *A, int *B, int c) { ; void jd(int *A, int *B, int c) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; A[i] = B[c]; ; A[i] = B[c];
; } ; }
; ;
; CHECK: %[[Cext:[._a-zA-Z0-9]*]] = sext i32 %c to i64 ; CHECK: %[[Cext:[._a-zA-Z0-9]*]] = sext i32 %c to i64
; CHECK: %[[Cp1:[._a-zA-Z0-9]*]] = call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %[[Cext]], i64 1) ; CHECK: %[[Cp1:[._a-zA-Z0-9]*]] = call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %[[Cext]], i64 1)
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

polly/test/CodeGen/aliasing_parametric_simple_2.ll

; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 %loadPolly -polly-codegen -S < %s | FileCheck %s
; ;
; void jd(int *A, int *B, int c) { ; void jd(int *A, int *B, int c) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; A[i] = B[c - 10] + B[5]; ; A[i] = B[c - 10] + B[5];
; } ; }
; ;
; CHECK: %[[Ctx:[._a-zA-Z0-9]*]] = and i1 true ; CHECK: %[[Ctx:[._a-zA-Z0-9]*]] = and i1 true
; CHECK-NEXT: %[[M0:[._a-zA-Z0-9]*]] = sext i32 %c to i64 ; CHECK-NEXT: %[[M0:[._a-zA-Z0-9]*]] = sext i32 %c to i64
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

polly/test/CodeGen/annotated_alias_scopes.ll

; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s --check-prefix=SCOPES ; RUN: opt -opaque-pointers=0 %loadPolly -polly-codegen -S < %s | FileCheck %s --check-prefix=SCOPES
; ;
; Check that we create alias scopes that indicate the accesses to A, B and C cannot alias in any way. ; Check that we create alias scopes that indicate the accesses to A, B and C cannot alias in any way.
; ;
; SCOPES-LABEL: polly.stmt.for.body: ; SCOPES-LABEL: polly.stmt.for.body:
; SCOPES: %[[BIdx:[._a-zA-Z0-9]*]] = getelementptr{{.*}} i32* %B, i64 %polly.indvar ; SCOPES: %[[BIdx:[._a-zA-Z0-9]*]] = getelementptr{{.*}} i32* %B, i64 %polly.indvar
; SCOPES: load i32, i32* %[[BIdx]], align 4, !alias.scope !0, !noalias !3 ; SCOPES: load i32, i32* %[[BIdx]], align 4, !alias.scope !0, !noalias !3
; SCOPES: %[[CIdx:[._a-zA-Z0-9]*]] = getelementptr{{.*}} float* %C, i64 %polly.indvar ; SCOPES: %[[CIdx:[._a-zA-Z0-9]*]] = getelementptr{{.*}} float* %C, i64 %polly.indvar
; SCOPES: load float, float* %[[CIdx]], align 4, !alias.scope !6, !noalias !7 ; SCOPES: load float, float* %[[CIdx]], align 4, !alias.scope !6, !noalias !7
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

polly/test/CodeGen/getNumberOfIterations.ll

; RUN: opt %loadPolly -polly-vectorizer=polly -polly-codegen \ ; RUN: opt -opaque-pointers=0 %loadPolly -polly-vectorizer=polly -polly-codegen \
; RUN: < %s -S | FileCheck %s ; RUN: < %s -S | FileCheck %s
; #pragma known-parallel ; #pragma known-parallel
; for (int c0 = 0; c0 <= min(15, N - 1); c0 += 1) ; for (int c0 = 0; c0 <= min(15, N - 1); c0 += 1)
; Stmt_if_then(c0); ; Stmt_if_then(c0);
; CHECK: polly.stmt.if.then: ; preds = %polly.loop_header ; CHECK: polly.stmt.if.then: ; preds = %polly.loop_header
; CHECK: %p_conv = sitofp i64 %polly.indvar to float ; CHECK: %p_conv = sitofp i64 %polly.indvar to float
Show All 30 Lines

polly/test/CodeGen/invariant_load.ll

; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -S < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -S < %s | FileCheck %s
; ;
; CHECK-LABEL: polly.preload.begin: ; CHECK-LABEL: polly.preload.begin:
; CHECK-NEXT: %polly.access.B = getelementptr i32, i32* %B, i64 0 ; CHECK-NEXT: %polly.access.B = getelementptr i32, i32* %B, i64 0
; CHECK-NEXT: %polly.access.B.load = load i32, i32* %polly.access.B ; CHECK-NEXT: %polly.access.B.load = load i32, i32* %polly.access.B
; ;
; CHECK-LABEL: polly.stmt.bb2: ; CHECK-LABEL: polly.stmt.bb2:
; CHECK-NEXT: %scevgep = getelementptr i32, i32* %A, i64 %polly.indvar ; CHECK-NEXT: %scevgep = getelementptr i32, i32* %A, i64 %polly.indvar
; CHECK-NEXT: store i32 %polly.access.B.load, i32* %scevgep, align 4 ; CHECK-NEXT: store i32 %polly.access.B.load, i32* %scevgep, align 4
Show All 30 Lines

polly/test/CodeGen/invariant_load_address_space.ll

; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -S < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -S < %s | FileCheck %s
; ;
; CHECK-LABEL: polly.preload.begin: ; CHECK-LABEL: polly.preload.begin:
; CHECK-NEXT: %polly.access.B = getelementptr i32, i32 addrspace(1)* %B, i64 0 ; CHECK-NEXT: %polly.access.B = getelementptr i32, i32 addrspace(1)* %B, i64 0
; CHECK-NOT: addrspacecast ; CHECK-NOT: addrspacecast
; CHECK-NEXT: %polly.access.B.load = load i32, i32 addrspace(1)* %polly.access.B ; CHECK-NEXT: %polly.access.B.load = load i32, i32 addrspace(1)* %polly.access.B
; ;
; CHECK-LABEL: polly.stmt.bb2: ; CHECK-LABEL: polly.stmt.bb2:
; CHECK-NEXT: %scevgep = getelementptr i32, i32* %A, i64 %polly.indvar ; CHECK-NEXT: %scevgep = getelementptr i32, i32* %A, i64 %polly.indvar
Show All 31 Lines

polly/test/CodeGen/invariant_load_base_pointer.ll

; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -polly-ignore-aliasing -polly-process-unprofitable -S < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -polly-ignore-aliasing -polly-process-unprofitable -S < %s | FileCheck %s
; ;
; CHECK-LABEL: polly.preload.begin: ; CHECK-LABEL: polly.preload.begin:
; CHECK-NEXT: %polly.access.BPLoc = getelementptr i32*, i32** %BPLoc, i64 0 ; CHECK-NEXT: %polly.access.BPLoc = getelementptr i32*, i32** %BPLoc, i64 0
; CHECK-NEXT: %polly.access.BPLoc.load = load i32*, i32** %polly.access.BPLoc ; CHECK-NEXT: %polly.access.BPLoc.load = load i32*, i32** %polly.access.BPLoc
; ;
; CHECK-LABEL: polly.stmt.bb2: ; CHECK-LABEL: polly.stmt.bb2:
; CHECK-NEXT: %scevgep = getelementptr i32, i32* %polly.access.BPLoc.load, i64 %polly.indvar ; CHECK-NEXT: %scevgep = getelementptr i32, i32* %polly.access.BPLoc.load, i64 %polly.indvar
; ;
Show All 29 Lines

polly/test/CodeGen/invariant_load_base_pointer_conditional.ll

; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -polly-ignore-aliasing -polly-process-unprofitable -S < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -polly-ignore-aliasing -polly-process-unprofitable -S < %s | FileCheck %s
; ;
; CHECK-LABEL: polly.preload.begin: ; CHECK-LABEL: polly.preload.begin:
; CHECK-NEXT: %0 = sext i32 %N to i64 ; CHECK-NEXT: %0 = sext i32 %N to i64
; CHECK-NEXT: %1 = icmp sge i64 %0, 514 ; CHECK-NEXT: %1 = icmp sge i64 %0, 514
; CHECK-NEXT: %polly.preload.cond.result = and i1 %1, true ; CHECK-NEXT: %polly.preload.cond.result = and i1 %1, true
; CHECK-NEXT: br label %polly.preload.cond ; CHECK-NEXT: br label %polly.preload.cond
; ;
; CHECK-LABEL: polly.preload.cond: ; CHECK-LABEL: polly.preload.cond:
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

polly/test/CodeGen/invariant_load_base_pointer_conditional_2.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -polly-print-scops -disable-output < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 %loadPolly -polly-invariant-load-hoisting=true -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -S -polly-codegen -polly-invariant-load-hoisting=true < %s | FileCheck %s --check-prefix=IR ; RUN: opt -opaque-pointers=0 %loadPolly -S -polly-codegen -polly-invariant-load-hoisting=true < %s | FileCheck %s --check-prefix=IR
; RUN: opt %loadPolly -S -polly-codegen -polly-invariant-load-hoisting=true --polly-overflow-tracking=always < %s | FileCheck %s --check-prefix=IRA ; RUN: opt -opaque-pointers=0 %loadPolly -S -polly-codegen -polly-invariant-load-hoisting=true --polly-overflow-tracking=always < %s | FileCheck %s --check-prefix=IRA
; ;
; As (p + q) can overflow we have to check that we load from ; As (p + q) can overflow we have to check that we load from
; I[p + q] only if it does not. ; I[p + q] only if it does not.
; ;
; CHECK: Invariant Accesses: { ; CHECK: Invariant Accesses: {
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [N, p, q] -> { Stmt_for_body[i0] -> MemRef_I[p + q] }; ; CHECK-NEXT: [N, p, q] -> { Stmt_for_body[i0] -> MemRef_I[p + q] };
; CHECK-NEXT: Execution Context: [N, p, q] -> { : N > 0 and -2147483648 - p <= q <= 2147483647 - p } ; CHECK-NEXT: Execution Context: [N, p, q] -> { : N > 0 and -2147483648 - p <= q <= 2147483647 - p }
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

polly/test/CodeGen/invariant_load_canonicalize_array_baseptrs.ll

; RUN: opt %loadPolly -polly-codegen -S < %s \ ; RUN: opt -opaque-pointers=0 %loadPolly -polly-codegen -S < %s \
; RUN: -polly-invariant-load-hoisting \ ; RUN: -polly-invariant-load-hoisting \
; RUN: | FileCheck %s ; RUN: | FileCheck %s
; CHECK: %polly.access.A = getelementptr float*, float** %A, i64 0 ; CHECK: %polly.access.A = getelementptr float*, float** %A, i64 0
; CHECK: %polly.access.A.load = load float*, float** %polly.access.A ; CHECK: %polly.access.A.load = load float*, float** %polly.access.A
; CHECK: store float 4.200000e+01, float* %polly.access.A.load ; CHECK: store float 4.200000e+01, float* %polly.access.A.load
; CHECK: store float 4.800000e+01, float* %polly.access.A.load ; CHECK: store float 4.800000e+01, float* %polly.access.A.load
Show All 27 Lines

polly/test/CodeGen/invariant_load_condition.ll

; RUN: opt %loadPolly -polly-process-unprofitable -polly-codegen -polly-invariant-load-hoisting=true -S < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 %loadPolly -polly-process-unprofitable -polly-codegen -polly-invariant-load-hoisting=true -S < %s | FileCheck %s
; ;
; CHECK-LABEL: polly.preload.begin: ; CHECK-LABEL: polly.preload.begin:
; CHECK-NEXT: %polly.access.C = getelementptr i32, i32* %C, i64 0 ; CHECK-NEXT: %polly.access.C = getelementptr i32, i32* %C, i64 0
; CHECK-NEXT: %polly.access.C.load = load i32, i32* %polly.access.C ; CHECK-NEXT: %polly.access.C.load = load i32, i32* %polly.access.C
; CHECK-NOT: %polly.access.C.load = load i32, i32* %polly.access.C ; CHECK-NOT: %polly.access.C.load = load i32, i32* %polly.access.C
; ;
; CHECK-LABEL: polly.cond: ; CHECK-LABEL: polly.cond:
; CHECK-NEXT: %[[R0:[0-9]*]] = sext i32 %polly.access.C.load to i64 ; CHECK-NEXT: %[[R0:[0-9]*]] = sext i32 %polly.access.C.load to i64
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

polly/test/CodeGen/invariant_load_escaping.ll

; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -S < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -S < %s | FileCheck %s
; ;
; int f(int *A, int *B) { ; int f(int *A, int *B) {
; // Possible aliasing between A and B but if not then *B would be ; // Possible aliasing between A and B but if not then *B would be
; // invariant. We assume this and hoist *B but need to use a merged ; // invariant. We assume this and hoist *B but need to use a merged
; // version in the return. ; // version in the return.
; int i = 0; ; int i = 0;
; int x = 0; ; int x = 0;
; ;
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

polly/test/CodeGen/invariant_load_hoist_alignment.ll

; RUN: opt %loadPolly -basic-aa -polly-codegen -polly-vectorizer=polly -S \ ; RUN: opt -opaque-pointers=0 %loadPolly -basic-aa -polly-codegen -polly-vectorizer=polly -S \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %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"
@A = common global [1024 x i32] zeroinitializer, align 16 @A = common global [1024 x i32] zeroinitializer, align 16
@B = common global [1024 x i32] zeroinitializer, align 16 @B = common global [1024 x i32] zeroinitializer, align 16
declare i32 @foo(i32) readnone declare i32 @foo(i32) readnone
Show All 22 Lines

polly/test/CodeGen/invariant_load_ptr_ptr_noalias.ll

; RUN: opt %loadPolly -polly-process-unprofitable -polly-codegen -polly-invariant-load-hoisting=true -polly-ignore-aliasing -S < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 %loadPolly -polly-process-unprofitable -polly-codegen -polly-invariant-load-hoisting=true -polly-ignore-aliasing -S < %s | FileCheck %s
; ;
; CHECK-LABEL: polly.preload.begin: ; CHECK-LABEL: polly.preload.begin:
; CHECK: %polly.access.A = getelementptr i32**, i32*** %A, i64 42 ; CHECK: %polly.access.A = getelementptr i32**, i32*** %A, i64 42
; CHECK: %polly.access.A.load = load i32**, i32*** %polly.access.A ; CHECK: %polly.access.A.load = load i32**, i32*** %polly.access.A
; CHECK: %polly.access.polly.access.A.load = getelementptr i32*, i32** %polly.access.A.load, i64 32 ; CHECK: %polly.access.polly.access.A.load = getelementptr i32*, i32** %polly.access.A.load, i64 32
; CHECK: %polly.access.polly.access.A.load.load = load i32*, i32** %polly.access.polly.access.A.load ; CHECK: %polly.access.polly.access.A.load.load = load i32*, i32** %polly.access.polly.access.A.load
; ;
; CHECK: polly.stmt.bb2: ; CHECK: polly.stmt.bb2:
Show All 35 Lines

polly/test/CodeGen/invariant_load_scalar_dep.ll

; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -polly-ignore-aliasing -polly-process-unprofitable -S < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -polly-ignore-aliasing -polly-process-unprofitable -S < %s | FileCheck %s
; ;
; CHECK-LABEL: polly.preload.begin: ; CHECK-LABEL: polly.preload.begin:
; CHECK: %polly.access.B = getelementptr i32, i32* %B, i64 0 ; CHECK: %polly.access.B = getelementptr i32, i32* %B, i64 0
; CHECK: %polly.access.B.load = load i32, i32* %polly.access.B ; CHECK: %polly.access.B.load = load i32, i32* %polly.access.B
; ;
; CHECK-LABEL: polly.stmt.bb2.split: ; CHECK-LABEL: polly.stmt.bb2.split:
; CHECK: %scevgep = getelementptr i32, i32* %A, i64 %polly.indvar ; CHECK: %scevgep = getelementptr i32, i32* %A, i64 %polly.indvar
; CHECK: store i32 %polly.access.B.load, i32* %scevgep, align 4 ; CHECK: store i32 %polly.access.B.load, i32* %scevgep, align 4
Show All 35 Lines

polly/test/CodeGen/load_subset_with_context.ll

; RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-codegen -S < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-codegen -S < %s | FileCheck %s
; ;
; A load must provide a value for every statement instance. ; A load must provide a value for every statement instance.
; Statement instances not in the SCoP's context are irrelevant. ; Statement instances not in the SCoP's context are irrelevant.
; ;
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"
@ATH = external dso_local unnamed_addr constant [88 x float], align 16 @ATH = external dso_local unnamed_addr constant [88 x float], align 16
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

polly/test/CodeGen/loop_with_condition_nested.ll

; RUN: opt %loadPolly -basic-aa -polly-print-ast -disable-output < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 %loadPolly -basic-aa -polly-print-ast -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -basic-aa -polly-codegen < %s | opt -passes='print<loops>' -disable-output 2>&1 | FileCheck %s -check-prefix=LOOPS ; RUN: opt -opaque-pointers=0 %loadPolly -basic-aa -polly-codegen < %s | opt -opaque-pointers=0 -passes='print<loops>' -disable-output 2>&1 | FileCheck %s -check-prefix=LOOPS
;#include <string.h> ;#include <string.h>
;#define N 1024 ;#define N 1024
;int A[N]; ;int A[N];
;int B[N]; ;int B[N];
; ;
;void loop_with_condition() { ;void loop_with_condition() {
▲ Show 20 Lines • Show All 205 Lines • Show Last 20 Lines

polly/test/CodeGen/multiple-types-invariant-load.ll

; RUN: opt %loadPolly -polly-allow-differing-element-types -polly-codegen -S \ ; RUN: opt -opaque-pointers=0 %loadPolly -polly-allow-differing-element-types -polly-codegen -S \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s
; CHECK: %polly.access.cast.global.load = bitcast %struct.hoge* %global.load to i32* ; CHECK: %polly.access.cast.global.load = bitcast %struct.hoge* %global.load to i32*
; CHECK: %polly.access.global.load = getelementptr i32, i32* %polly.access.cast.global.load, i64 0 ; CHECK: %polly.access.global.load = getelementptr i32, i32* %polly.access.cast.global.load, i64 0
; CHECK: %polly.access.global.load.load = load i32, i32* %polly.access.global.load ; CHECK: %polly.access.global.load.load = load i32, i32* %polly.access.global.load
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 All 27 Lines

polly/test/CodeGen/no-overflow-tracking.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -polly-print-scops -disable-output < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 %loadPolly -polly-invariant-load-hoisting=true -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -polly-overflow-tracking=never -polly-codegen -S < %s | FileCheck %s --check-prefix=IR ; RUN: opt -opaque-pointers=0 %loadPolly -polly-invariant-load-hoisting=true -polly-overflow-tracking=never -polly-codegen -S < %s | FileCheck %s --check-prefix=IR
; ;
; As (p + q) can overflow we have to check that we load from ; As (p + q) can overflow we have to check that we load from
; I[p + q] only if it does not. ; I[p + q] only if it does not.
; ;
; CHECK: Invariant Accesses: { ; CHECK: Invariant Accesses: {
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [N, p, q] -> { Stmt_for_body[i0] -> MemRef_I[p + q] }; ; CHECK-NEXT: [N, p, q] -> { Stmt_for_body[i0] -> MemRef_I[p + q] };
; CHECK-NEXT: Execution Context: [N, p, q] -> { : N > 0 and -2147483648 - p <= q <= 2147483647 - p } ; CHECK-NEXT: Execution Context: [N, p, q] -> { : N > 0 and -2147483648 - p <= q <= 2147483647 - p }
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

polly/test/CodeGen/non-affine-subregion-dominance-reuse.ll

; RUN: opt %loadPolly -polly-codegen -S -verify-dom-info \ ; RUN: opt -opaque-pointers=0 %loadPolly -polly-codegen -S -verify-dom-info \
; RUN: < %s | FileCheck %s ; RUN: < %s | FileCheck %s
; ;
; Check that we do not reuse the B[i-1] GEP created in block S again in ; Check that we do not reuse the B[i-1] GEP created in block S again in
; block Q. Hence, we create two GEPs for B[i-1]: ; block Q. Hence, we create two GEPs for B[i-1]:
; ;
; CHECK: %scevgep{{.}} = getelementptr i32, i32* %B, i64 -1 ; CHECK: %scevgep{{.}} = getelementptr i32, i32* %B, i64 -1
; CHECK: %scevgep{{.}} = getelementptr i32, i32* %B, i64 -1 ; CHECK: %scevgep{{.}} = getelementptr i32, i32* %B, i64 -1
; ;
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

polly/test/CodeGen/non-affine-switch.ll

; RUN: opt %loadPolly \ ; RUN: opt -opaque-pointers=0 %loadPolly \
; RUN: -S -polly-codegen < %s | FileCheck %s ; RUN: -S -polly-codegen < %s | FileCheck %s
; ;
; void f(int *A, int N) { ; void f(int *A, int N) {
; for (int i = 0; i < N; i++) ; for (int i = 0; i < N; i++)
; switch (A[i]) { ; switch (A[i]) {
; case 0: ; case 0:
; A[i] += 1; ; A[i] += 1;
; break; ; break;
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

polly/test/CodeGen/non-affine-synthesized-in-branch.ll

; RUN: opt %loadPolly -polly-process-unprofitable -polly-codegen -S < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 %loadPolly -polly-process-unprofitable -polly-codegen -S < %s | FileCheck %s
; ;
; llvm.org/PR25412 ; llvm.org/PR25412
; %synthgep caused %gep to be synthesized in subregion_if which was reused for ; %synthgep caused %gep to be synthesized in subregion_if which was reused for
; %retval in subregion_exit, even though it is not dominating subregion_exit. ; %retval in subregion_exit, even though it is not dominating subregion_exit.
; ;
; CHECK-LABEL: polly.stmt.polly.merge_new_and_old.exit: ; CHECK-LABEL: polly.stmt.polly.merge_new_and_old.exit:
; CHECK: %scevgep[[R1:[0-9]*]] = getelementptr %struct.hoge, %struct.hoge* %arg, i64 0, i32 2 ; CHECK: %scevgep[[R1:[0-9]*]] = getelementptr %struct.hoge, %struct.hoge* %arg, i64 0, i32 2
; CHECK: store double* %scevgep[[R1]], double** %gep.s2a ; CHECK: store double* %scevgep[[R1]], double** %gep.s2a
Show All 21 Lines

polly/test/CodeGen/non-affine-update.ll

; RUN: opt %loadPolly -polly-import-jscop \ ; RUN: opt -opaque-pointers=0 %loadPolly -polly-import-jscop \
; RUN: -polly-codegen -S < %s | FileCheck %s ; RUN: -polly-codegen -S < %s | FileCheck %s
; ;
; void non-affine-update(double A[], double C[], double B[]) { ; void non-affine-update(double A[], double C[], double B[]) {
; for (int i = 0; i < 10; i++) { ; for (int i = 0; i < 10; i++) {
; if (A[i] >= 6) ; if (A[i] >= 6)
; B[i] += 42; ; B[i] += 42;
; else ; else
; C[i] += 3; ; C[i] += 3;
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

polly/test/CodeGen/non_affine_float_compare.ll

; RUN: opt %loadPolly -polly-codegen \ ; RUN: opt -opaque-pointers=0 %loadPolly -polly-codegen \
; RUN: -polly-allow-nonaffine-branches -S -verify-dom-info \ ; RUN: -polly-allow-nonaffine-branches -S -verify-dom-info \
; RUN: < %s | FileCheck %s ; RUN: < %s | FileCheck %s
; ;
; void f(float *A) { ; void f(float *A) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; if (A[i] == A[i - 1]) ; if (A[i] == A[i - 1])
; A[i]++; ; A[i]++;
; A[i]++; ; A[i]++;
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

polly/test/CodeGen/partial_write_array.ll

; RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-codegen -S < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-codegen -S < %s | FileCheck %s
; ;
; Partial write of an array access. ; Partial write of an array access.
; ;
; for (int j = 0; j < n; j += 1) ; for (int j = 0; j < n; j += 1)
; A[0] = 42.0 ; A[0] = 42.0
; ;
define void @partial_write_array(i32 %n, double* noalias nonnull %A) { define void @partial_write_array(i32 %n, double* noalias nonnull %A) {
Show All 35 Lines

polly/test/CodeGen/partial_write_full_write_that_appears_partial.ll

; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 %loadPolly -polly-codegen -S < %s | FileCheck %s
; CHECK: polly.stmt.if.then81: ; preds = %polly.stmt.if.end75 ; CHECK: polly.stmt.if.then81: ; preds = %polly.stmt.if.end75
; CHECK-NEXT: %scevgep = getelementptr [2 x %S], [2 x %S]* %tmp, i64 0, i64 %.147 ; CHECK-NEXT: %scevgep = getelementptr [2 x %S], [2 x %S]* %tmp, i64 0, i64 %.147
; CHECK-NEXT: %scevgep1 = bitcast %S* %scevgep to float* ; CHECK-NEXT: %scevgep1 = bitcast %S* %scevgep to float*
; CHECK-NEXT: store float undef, float* %scevgep1, align 4, !alias.scope !0, !noalias !3 ; CHECK-NEXT: store float undef, float* %scevgep1, align 4, !alias.scope !0, !noalias !3
; CHECK-NEXT: br label %polly.stmt.if.end87.region_exiting ; CHECK-NEXT: br label %polly.stmt.if.end87.region_exiting
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"
Show All 25 Lines

polly/test/CodeGen/partial_write_impossible_restriction.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-codegen -S < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 %loadPolly -polly-stmt-granularity=bb -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-codegen -S < %s | FileCheck %s
; ;
; The isl scheduler isolates %cond.false into two instances. ; The isl scheduler isolates %cond.false into two instances.
; A partial write access in one of the instances was never executed, ; A partial write access in one of the instances was never executed,
; which caused problems when querying for its index expression, which ; which caused problems when querying for its index expression, which
; is not available in that case. ; is not available in that case.
; ;
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"
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

polly/test/CodeGen/partial_write_in_region.ll

; RUN: opt %loadPolly -polly-import-jscop \ ; RUN: opt -opaque-pointers=0 %loadPolly -polly-import-jscop \
; RUN: -polly-import-jscop-postfix=transformed -polly-codegen \ ; RUN: -polly-import-jscop-postfix=transformed -polly-codegen \
; RUN: -verify-dom-info \ ; RUN: -verify-dom-info \
; RUN: -S < %s | FileCheck %s ; RUN: -S < %s | FileCheck %s
; ;
; void foo(long A[], float B[], float C[]) { ; void foo(long A[], float B[], float C[]) {
; for (long i = 0; i < 1024; i++) { ; for (long i = 0; i < 1024; i++) {
; if (A[i]) { ; if (A[i]) {
; S: B[i]++; ; S: B[i]++;
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

polly/test/CodeGen/phi_conditional_simple_1.ll

; RUN: opt %loadPolly -polly-print-ast -disable-output < %s | FileCheck %s --check-prefix=AST ; RUN: opt -opaque-pointers=0 %loadPolly -polly-print-ast -disable-output < %s | FileCheck %s --check-prefix=AST
; RUN: opt %loadPolly -S -polly-codegen < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 %loadPolly -S -polly-codegen < %s | FileCheck %s
; ;
; void jd(int *A, int c) { ; void jd(int *A, int c) {
; for (int i = 0; i < 1024; i++) { ; for (int i = 0; i < 1024; i++) {
; if (c) ; if (c)
; A[i] = 1; ; A[i] = 1;
; else ; else
; A[i] = 2; ; A[i] = 2;
; } ; }
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

polly/test/CodeGen/phi_loop_carried_float.ll

; RUN: opt %loadPolly -S -polly-codegen < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 %loadPolly -S -polly-codegen < %s | FileCheck %s
; ;
; float f(float *A, int N) { ; float f(float *A, int N) {
; float tmp = 0; ; float tmp = 0;
; for (int i = 0; i < N; i++) ; for (int i = 0; i < N; i++)
; tmp += A[i]; ; tmp += A[i];
; } ; }
; ;
; CHECK: bb: ; CHECK: bb:
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

polly/test/CodeGen/phi_loop_carried_float_escape.ll

; RUN: opt %loadPolly -S \ ; RUN: opt -opaque-pointers=0 %loadPolly -S \
; RUN: -polly-analyze-read-only-scalars=false -polly-codegen < %s | FileCheck %s ; RUN: -polly-analyze-read-only-scalars=false -polly-codegen < %s | FileCheck %s
; RUN: opt %loadPolly -S \ ; RUN: opt -opaque-pointers=0 %loadPolly -S \
; RUN: -polly-analyze-read-only-scalars=true -polly-codegen < %s | FileCheck %s ; RUN: -polly-analyze-read-only-scalars=true -polly-codegen < %s | FileCheck %s
; ;
; float f(float *A, int N) { ; float f(float *A, int N) {
; float tmp = 0; ; float tmp = 0;
; for (int i = 0; i < N; i++) ; for (int i = 0; i < N; i++)
; tmp += A[i]; ; tmp += A[i];
; return tmp; ; return tmp;
; } ; }
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

polly/test/CodeGen/region-with-instructions.ll

; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 %loadPolly -polly-codegen -S < %s | FileCheck %s
; CHECK-LABEL: polly.stmt.bb48: ; CHECK-LABEL: polly.stmt.bb48:
; CHECK-NEXT: %scevgep = getelementptr i64, i64* %A, i64 %polly.indvar ; CHECK-NEXT: %scevgep = getelementptr i64, i64* %A, i64 %polly.indvar
; CHECK-NEXT: %tmp51_p_scalar_ = load i64, i64* %scevgep, ; CHECK-NEXT: %tmp51_p_scalar_ = load i64, i64* %scevgep,
; CHECK-NEXT: %p_tmp52 = and i64 %tmp51_p_scalar_, %tmp26 ; CHECK-NEXT: %p_tmp52 = and i64 %tmp51_p_scalar_, %tmp26
; CHECK-NEXT: %p_tmp53 = icmp eq i64 %p_tmp52, %tmp26 ; CHECK-NEXT: %p_tmp53 = icmp eq i64 %p_tmp52, %tmp26
; CHECK-NEXT: store i64 42, i64* %scevgep, align 8 ; CHECK-NEXT: store i64 42, i64* %scevgep, align 8
; CHECK-NEXT: br i1 %p_tmp53, label %polly.stmt.bb54, label %polly.stmt.bb56.exit ; CHECK-NEXT: br i1 %p_tmp53, label %polly.stmt.bb54, label %polly.stmt.bb56.exit
Show All 38 Lines

polly/test/CodeGen/scev-backedgetaken.ll

; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 %loadPolly -polly-codegen -S < %s | FileCheck %s
; ;
; llvm.org/PR48422 ; llvm.org/PR48422
; Use of ScalarEvolution in Codegen not possible because DominatorTree is not updated. ; Use of ScalarEvolution in Codegen not possible because DominatorTree is not updated.
; ;
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"
define dso_local void @func(i1 %b, i1 %p3, [14 x i32]* %d) local_unnamed_addr { define dso_local void @func(i1 %b, i1 %p3, [14 x i32]* %d) local_unnamed_addr {
entry: entry:
Show All 40 Lines

polly/test/CodeGen/scev_expansion_in_nonaffine.ll

; RUN: opt %loadPolly -polly-codegen -S \ ; RUN: opt -opaque-pointers=0 %loadPolly -polly-codegen -S \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s
; bugpoint-reduced testcase of MiBench/consumer-lame/quantize-pvt.c from the ; bugpoint-reduced testcase of MiBench/consumer-lame/quantize-pvt.c from the
; test-suite. ; test-suite.
; It features a SCEV that is used in two BasicBlock within a non-affine ; It features a SCEV that is used in two BasicBlock within a non-affine
; subregion where none of the blocks dominate the other. We check that the SCEV ; subregion where none of the blocks dominate the other. We check that the SCEV
; is expanded independently for both BasicBlocks instead of just once for the ; is expanded independently for both BasicBlocks instead of just once for the
; whole subregion. ; whole subregion.
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

polly/test/CodeGen/scev_looking_through_bitcasts.ll

; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 %loadPolly -polly-codegen -S < %s | FileCheck %s
; ;
; Scalar write of bitcasted value. Instead of writing %b of type ; Scalar write of bitcasted value. Instead of writing %b of type
; %structty, the SCEV expression looks through the bitcast such that ; %structty, the SCEV expression looks through the bitcast such that
; SCEVExpander returns %add.ptr81.i of type i8* to be the new value ; SCEVExpander returns %add.ptr81.i of type i8* to be the new value
; of %b. ; of %b.
; ;
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"
Show All 30 Lines

polly/test/CodeGen/simple_vec_call.ll

; RUN: opt %loadPolly -basic-aa -polly-codegen -polly-vectorizer=polly -S \ ; RUN: opt -opaque-pointers=0 %loadPolly -basic-aa -polly-codegen -polly-vectorizer=polly -S \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %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"
@A = common global [1024 x float] zeroinitializer, align 16 @A = common global [1024 x float] zeroinitializer, align 16
@B = common global [1024 x float] zeroinitializer, align 16 @B = common global [1024 x float] zeroinitializer, align 16
declare float @foo(float) readnone declare float @foo(float) readnone
Show All 28 Lines

polly/test/CodeGen/simple_vec_call_2.ll

; RUN: opt %loadPolly -basic-aa -polly-codegen -polly-vectorizer=polly -dce \ ; RUN: opt -opaque-pointers=0 %loadPolly -basic-aa -polly-codegen -polly-vectorizer=polly -dce \
; RUN: -polly-invariant-load-hoisting=true -S < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true -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"
@A = common global [1024 x float] zeroinitializer, align 16 @A = common global [1024 x float] zeroinitializer, align 16
@B = common global [1024 x float**] zeroinitializer, align 16 @B = common global [1024 x float**] zeroinitializer, align 16
declare float** @foo(float) readnone declare float** @foo(float) readnone
Show All 28 Lines

polly/test/CodeGen/simple_vec_cast.ll

; RUN: opt %loadPolly -basic-aa -polly-codegen -polly-vectorizer=polly \ ; RUN: opt -opaque-pointers=0 %loadPolly -basic-aa -polly-codegen -polly-vectorizer=polly \
; RUN: -polly-invariant-load-hoisting=true -dce -S < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true -dce -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"
@A = common global [1024 x float] zeroinitializer, align 16 @A = common global [1024 x float] zeroinitializer, align 16
@B = common global [1024 x double] zeroinitializer, align 16 @B = common global [1024 x double] zeroinitializer, align 16
define void @simple_vec_const() nounwind { define void @simple_vec_const() nounwind {
bb: bb:
Show All 29 Lines

polly/test/CodeGen/simple_vec_const.ll

; RUN: opt %loadPolly -basic-aa -polly-codegen -polly-vectorizer=polly -S \ ; RUN: opt -opaque-pointers=0 %loadPolly -basic-aa -polly-codegen -polly-vectorizer=polly -S \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s
;#define N 1024 ;#define N 1024
;float A[N]; ;float A[N];
;float B[N]; ;float B[N];
; ;
;void simple_vec_const(void) { ;void simple_vec_const(void) {
; int i; ; int i;
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

polly/test/CodeGen/simple_vec_ptr_ptr_ty.ll

; RUN: opt %loadPolly -basic-aa -polly-codegen -polly-vectorizer=polly -S \ ; RUN: opt -opaque-pointers=0 %loadPolly -basic-aa -polly-codegen -polly-vectorizer=polly -S \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %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"
@A = common global [1024 x float**] zeroinitializer, align 16 @A = common global [1024 x float**] zeroinitializer, align 16
@B = common global [1024 x float**] zeroinitializer, align 16 @B = common global [1024 x float**] zeroinitializer, align 16
declare float @foo(float) readnone declare float @foo(float) readnone
Show All 22 Lines

polly/test/CodeGen/simple_vec_stride_one.ll

; RUN: opt %loadPolly -polly-codegen -polly-vectorizer=polly \ ; RUN: opt -opaque-pointers=0 %loadPolly -polly-codegen -polly-vectorizer=polly \
; RUN: < %s -S | FileCheck %s ; RUN: < %s -S | FileCheck %s
; CHECK: store <4 x double> %val.s2a_p_splat, <4 x double>* %vector_ptr ; CHECK: store <4 x double> %val.s2a_p_splat, <4 x double>* %vector_ptr
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 @update_access_functions(i64 %arg, double* %A, double* %B) { define void @update_access_functions(i64 %arg, double* %A, double* %B) {
bb3: bb3:
br label %loop1 br label %loop1
Show All 28 Lines

polly/test/CodeGen/single_loop_param_less_equal.ll

; RUN: opt %loadPolly -polly-print-ast -disable-output < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 %loadPolly -polly-print-ast -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s -check-prefix=CODEGEN ; RUN: opt -opaque-pointers=0 %loadPolly -polly-codegen -S < %s | FileCheck %s -check-prefix=CODEGEN
; RUN: opt %loadPolly -polly-codegen < %s | opt -passes='print<loops>' -disable-output 2>&1 | FileCheck %s -check-prefix=LOOPS ; RUN: opt -opaque-pointers=0 %loadPolly -polly-codegen < %s | opt -opaque-pointers=0 -passes='print<loops>' -disable-output 2>&1 | FileCheck %s -check-prefix=LOOPS
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32: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"
@A = common global [1024 x i32] zeroinitializer @A = common global [1024 x i32] zeroinitializer
define void @bar(i64 %n) { define void @bar(i64 %n) {
start: start:
%n_plus_one = add i64 %n, 1 %n_plus_one = add i64 %n, 1
fence seq_cst fence seq_cst
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

polly/test/CodeGen/single_loop_param_less_than.ll

; RUN: opt %loadPolly -polly-print-ast -disable-output < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 %loadPolly -polly-print-ast -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s -check-prefix=CODEGEN ; RUN: opt -opaque-pointers=0 %loadPolly -polly-codegen -S < %s | FileCheck %s -check-prefix=CODEGEN
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32: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"
@A = common global [1024 x i32] zeroinitializer @A = common global [1024 x i32] zeroinitializer
define void @bar(i64 %n) { define void @bar(i64 %n) {
start: start:
fence seq_cst fence seq_cst
br label %loop.header br label %loop.header
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

polly/test/CodeGen/stmt_split_no_dependence.ll

; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 %loadPolly -polly-codegen -S < %s | FileCheck %s
; ;
; CHECK: store i32 %8, i32* %scevgep, align 4, !alias.scope !1, !noalias !4 ; CHECK: store i32 %8, i32* %scevgep, align 4, !alias.scope !1, !noalias !4
; CHECK: store i32 %9, i32* %scevgep4, align 4, !alias.scope !4, !noalias !1 ; CHECK: store i32 %9, i32* %scevgep4, align 4, !alias.scope !4, !noalias !1
; ;
; void func(int *A, int *B){ ; void func(int *A, int *B){
; for (int i = 0; i < 1024; i+=1) { ; for (int i = 0; i < 1024; i+=1) {
; Stmt: ; Stmt:
; A[i] = i; ; A[i] = i;
Show All 35 Lines

polly/test/CodeGen/stride_detection.ll

; RUN: opt %loadPolly -polly-opt-isl -polly-vectorizer=polly -polly-codegen < %s -S | FileCheck %s ; RUN: opt -opaque-pointers=0 %loadPolly -polly-opt-isl -polly-vectorizer=polly -polly-codegen < %s -S | FileCheck %s
; #pragma known-parallel ; #pragma known-parallel
; for (int c0 = 0; c0 <= 31; c0 += 1) ; for (int c0 = 0; c0 <= 31; c0 += 1)
; for (int c1 = 0; c1 <= floord(nk - 1, 32); c1 += 1) ; for (int c1 = 0; c1 <= floord(nk - 1, 32); c1 += 1)
; for (int c2 = 0; c2 <= 7; c2 += 1) ; for (int c2 = 0; c2 <= 7; c2 += 1)
; for (int c3 = 0; c3 <= min(31, nk - 32 * c1 - 1); c3 += 1) ; for (int c3 = 0; c3 <= min(31, nk - 32 * c1 - 1); c3 += 1)
; #pragma simd ; #pragma simd
; for (int c4 = 0; c4 <= 3; c4 += 1) ; for (int c4 = 0; c4 <= 3; c4 += 1)
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

polly/test/CodeGen/switch-in-non-affine-region.ll

; RUN: opt %loadPolly \ ; RUN: opt -opaque-pointers=0 %loadPolly \
; RUN: -S -polly-codegen < %s | FileCheck %s ; RUN: -S -polly-codegen < %s | FileCheck %s
; ;
; void f(int *A, int N) { ; void f(int *A, int N) {
; for (int i = 0; i < N; i++) ; for (int i = 0; i < N; i++)
; if (A[i]) ; if (A[i])
; switch (i % 4) { ; switch (i % 4) {
; case 0: ; case 0:
; A[i] += 1; ; A[i] += 1;
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

polly/test/GPGPU/cuda-managed-memory-simple.ll

; RUN: opt %loadPolly -S -polly-process-unprofitable -polly-acc-mincompute=0 -polly-codegen-ppcg -polly-acc-codegen-managed-memory < %s | \ ; RUN: opt -opaque-pointers=0 %loadPolly -S -polly-process-unprofitable -polly-acc-mincompute=0 -polly-codegen-ppcg -polly-acc-codegen-managed-memory < %s | \
; RUN: FileCheck %s ; RUN: FileCheck %s
; REQUIRES: pollyacc ; REQUIRES: pollyacc
; ;
; #include <cuda_runtime.h> ; #include <cuda_runtime.h>
; ;
; static const int N = 45; ; static const int N = 45;
▲ Show 20 Lines • Show All 109 Lines • Show Last 20 Lines

polly/test/GPGPU/host-control-flow.ll

; RUN: opt %loadPolly -polly-codegen-ppcg -disable-output \ ; RUN: opt -opaque-pointers=0 %loadPolly -polly-codegen-ppcg -disable-output \
; RUN: -polly-acc-dump-code < %s | FileCheck %s -check-prefix=CODE ; RUN: -polly-acc-dump-code < %s | FileCheck %s -check-prefix=CODE
; RUN: opt %loadPolly -polly-codegen-ppcg -disable-output \ ; RUN: opt -opaque-pointers=0 %loadPolly -polly-codegen-ppcg -disable-output \
; RUN: -polly-acc-dump-kernel-ir < %s | FileCheck %s -check-prefix=KERNEL-IR ; RUN: -polly-acc-dump-kernel-ir < %s | FileCheck %s -check-prefix=KERNEL-IR
; RUN: opt %loadPolly -polly-codegen-ppcg \ ; RUN: opt -opaque-pointers=0 %loadPolly -polly-codegen-ppcg \
; RUN: -S < %s | FileCheck %s -check-prefix=IR ; RUN: -S < %s | FileCheck %s -check-prefix=IR
; void foo(float A[2][100]) { ; void foo(float A[2][100]) {
; for (long t = 0; t < 100; t++) ; for (long t = 0; t < 100; t++)
; for (long i = 1; i < 99; i++) ; for (long i = 1; i < 99; i++)
; A[(t + 1) % 2][i] += A[t % 2][i - 1] + A[t % 2][i] + A[t % 2][i + 1]; ; A[(t + 1) % 2][i] += A[t % 2][i - 1] + A[t % 2][i] + A[t % 2][i + 1];
; } ; }
; REQUIRES: pollyacc ; REQUIRES: pollyacc
▲ Show 20 Lines • Show All 161 Lines • Show Last 20 Lines

polly/test/GPGPU/intrinsic-copied-into-kernel.ll

; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s --check-prefix=SCOP ; RUN: opt -opaque-pointers=0 %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s --check-prefix=SCOP
; RUN: opt %loadPolly -polly-codegen-ppcg -polly-acc-dump-kernel-ir -disable-output < %s | FileCheck %s --check-prefix=KERNEL-IR ; RUN: opt -opaque-pointers=0 %loadPolly -polly-codegen-ppcg -polly-acc-dump-kernel-ir -disable-output < %s | FileCheck %s --check-prefix=KERNEL-IR
; RUN: opt %loadPolly -S -polly-codegen-ppcg < %s | FileCheck %s --check-prefix=HOST-IR ; RUN: opt -opaque-pointers=0 %loadPolly -S -polly-codegen-ppcg < %s | FileCheck %s --check-prefix=HOST-IR
; Test that we do recognise and codegen a kernel that has intrinsics. ; Test that we do recognise and codegen a kernel that has intrinsics.
; REQUIRES: pollyacc ; REQUIRES: pollyacc
; Check that we model the kernel as a scop. ; Check that we model the kernel as a scop.
; SCOP: Function: f ; SCOP: Function: f
; SCOP-NEXT: Region: %entry.split---%for.end ; SCOP-NEXT: Region: %entry.split---%for.end
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

polly/test/GPGPU/invariant-load-hoisting-of-array.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting -polly-print-scops -disable-output < %s | FileCheck %s -check-prefix=SCOP ; RUN: opt -opaque-pointers=0 %loadPolly -polly-invariant-load-hoisting -polly-print-scops -disable-output < %s | FileCheck %s -check-prefix=SCOP
; RUN: opt %loadPolly -S -polly-codegen-ppcg \ ; RUN: opt -opaque-pointers=0 %loadPolly -S -polly-codegen-ppcg \
; RUN: -polly-invariant-load-hoisting < %s | FileCheck %s -check-prefix=HOST-IR ; RUN: -polly-invariant-load-hoisting < %s | FileCheck %s -check-prefix=HOST-IR
; REQUIRES: pollyacc ; REQUIRES: pollyacc
; Entry: Contains (%loaded.ptr.preload.s2a = alloca double*) which is ; Entry: Contains (%loaded.ptr.preload.s2a = alloca double*) which is
; | invariant load hoisted `%loaded.ptr` ; | invariant load hoisted `%loaded.ptr`
; v ; v
; Run-time check --(failure branch)--> { old code - contains `%loaded.ptr` } ; Run-time check --(failure branch)--> { old code - contains `%loaded.ptr` }
▲ Show 20 Lines • Show All 90 Lines • Show Last 20 Lines

polly/test/GPGPU/kernel-params-only-some-arrays.ll

; RUN: opt %loadPolly -polly-codegen-ppcg -polly-acc-dump-kernel-ir \ ; RUN: opt -opaque-pointers=0 %loadPolly -polly-codegen-ppcg -polly-acc-dump-kernel-ir \
; RUN: -disable-output < %s | \ ; RUN: -disable-output < %s | \
; RUN: FileCheck -check-prefix=KERNEL %s ; RUN: FileCheck -check-prefix=KERNEL %s
; RUN: opt %loadPolly -polly-codegen-ppcg \ ; RUN: opt -opaque-pointers=0 %loadPolly -polly-codegen-ppcg \
; RUN: -S < %s | \ ; RUN: -S < %s | \
; RUN: FileCheck -check-prefix=IR %s ; RUN: FileCheck -check-prefix=IR %s
; REQUIRES: pollyacc ; REQUIRES: pollyacc
; ;
; void kernel_params_only_some_arrays(float A[], float B[]) { ; void kernel_params_only_some_arrays(float A[], float B[]) {
; for (long i = 0; i < 32; i++) ; for (long i = 0; i < 32; i++)
; A[i] += 42; ; A[i] += 42;
▲ Show 20 Lines • Show All 93 Lines • Show Last 20 Lines

polly/test/GPGPU/phi-nodes-in-kernel.ll

; RUN: opt %loadPolly -polly-codegen-ppcg -polly-acc-dump-code \ ; RUN: opt -opaque-pointers=0 %loadPolly -polly-codegen-ppcg -polly-acc-dump-code \
; RUN: -disable-output < %s | \ ; RUN: -disable-output < %s | \
; RUN: FileCheck -check-prefix=CODE %s ; RUN: FileCheck -check-prefix=CODE %s
; RUN: opt %loadPolly -polly-codegen-ppcg -S < %s | \ ; RUN: opt -opaque-pointers=0 %loadPolly -polly-codegen-ppcg -S < %s | \
; RUN: FileCheck %s -check-prefix=IR ; RUN: FileCheck %s -check-prefix=IR
; RUN: opt %loadPolly -polly-codegen-ppcg -polly-acc-dump-kernel-ir \ ; RUN: opt -opaque-pointers=0 %loadPolly -polly-codegen-ppcg -polly-acc-dump-kernel-ir \
; RUN: -disable-output < %s | \ ; RUN: -disable-output < %s | \
; RUN: FileCheck %s -check-prefix=KERNEL-IR ; RUN: FileCheck %s -check-prefix=KERNEL-IR
; REQUIRES: pollyacc ; REQUIRES: pollyacc
; Approximate C source: ; Approximate C source:
; void kernel_dynprog(int c[50]) { ; void kernel_dynprog(int c[50]) {
; int iter = 0; ; int iter = 0;
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

polly/test/GPGPU/private-memory.ll

; RUN: opt %loadPolly -polly-codegen-ppcg -polly-acc-dump-code \ ; RUN: opt -opaque-pointers=0 %loadPolly -polly-codegen-ppcg -polly-acc-dump-code \
; RUN: -polly-acc-use-private \ ; RUN: -polly-acc-use-private \
; RUN: -disable-output < %s | \ ; RUN: -disable-output < %s | \
; RUN: FileCheck -check-prefix=CODE %s ; RUN: FileCheck -check-prefix=CODE %s
; RUN: opt %loadPolly -polly-codegen-ppcg \ ; RUN: opt -opaque-pointers=0 %loadPolly -polly-codegen-ppcg \
; RUN: -polly-acc-use-private \ ; RUN: -polly-acc-use-private \
; RUN: -disable-output -polly-acc-dump-kernel-ir < %s | \ ; RUN: -disable-output -polly-acc-dump-kernel-ir < %s | \
; RUN: FileCheck -check-prefix=KERNEL %s ; RUN: FileCheck -check-prefix=KERNEL %s
; REQUIRES: pollyacc ; REQUIRES: pollyacc
; void add(float *A) { ; void add(float *A) {
; for (long i = 0; i < 32; i++) ; for (long i = 0; i < 32; i++)
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

polly/test/GPGPU/shared-memory-two-dimensional.ll

; RUN: opt %loadPolly -polly-codegen-ppcg -polly-acc-dump-code \ ; RUN: opt -opaque-pointers=0 %loadPolly -polly-codegen-ppcg -polly-acc-dump-code \
; RUN: -polly-acc-use-shared \ ; RUN: -polly-acc-use-shared \
; RUN: -disable-output < %s | \ ; RUN: -disable-output < %s | \
; RUN: FileCheck -check-prefix=CODE %s ; RUN: FileCheck -check-prefix=CODE %s
; RUN: opt %loadPolly -polly-codegen-ppcg \ ; RUN: opt -opaque-pointers=0 %loadPolly -polly-codegen-ppcg \
; RUN: -polly-acc-use-shared \ ; RUN: -polly-acc-use-shared \
; RUN: -disable-output -polly-acc-dump-kernel-ir < %s | \ ; RUN: -disable-output -polly-acc-dump-kernel-ir < %s | \
; RUN: FileCheck -check-prefix=KERNEL %s ; RUN: FileCheck -check-prefix=KERNEL %s
; REQUIRES: pollyacc ; REQUIRES: pollyacc
; void foo(float A[], float b[][8]) { ; void foo(float A[], float b[][8]) {
; for (long i = 0; i < 32; i++) ; for (long i = 0; i < 32; i++)
▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

polly/test/GPGPU/shared-memory.ll

; RUN: opt %loadPolly -polly-codegen-ppcg -polly-acc-dump-code \ ; RUN: opt -opaque-pointers=0 %loadPolly -polly-codegen-ppcg -polly-acc-dump-code \
; RUN: -polly-acc-use-shared \ ; RUN: -polly-acc-use-shared \
; RUN: -disable-output < %s | \ ; RUN: -disable-output < %s | \
; RUN: FileCheck -check-prefix=CODE %s ; RUN: FileCheck -check-prefix=CODE %s
; RUN: opt %loadPolly -polly-codegen-ppcg \ ; RUN: opt -opaque-pointers=0 %loadPolly -polly-codegen-ppcg \
; RUN: -polly-acc-use-shared \ ; RUN: -polly-acc-use-shared \
; RUN: -disable-output -polly-acc-dump-kernel-ir < %s | \ ; RUN: -disable-output -polly-acc-dump-kernel-ir < %s | \
; RUN: FileCheck -check-prefix=KERNEL %s ; RUN: FileCheck -check-prefix=KERNEL %s
; REQUIRES: pollyacc ; REQUIRES: pollyacc
; void add(float *A) { ; void add(float *A) {
; for (long i = 0; i < 32; i++) ; for (long i = 0; i < 32; i++)
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

polly/test/GPGPU/spir-codegen.ll

; RUN: opt %loadPolly -polly-codegen-ppcg \ ; RUN: opt -opaque-pointers=0 %loadPolly -polly-codegen-ppcg \
; RUN: -polly-gpu-arch=spir32 \ ; RUN: -polly-gpu-arch=spir32 \
; RUN: -polly-acc-dump-kernel-ir -polly-process-unprofitable -disable-output -enable-new-pm=0 < %s | \ ; RUN: -polly-acc-dump-kernel-ir -polly-process-unprofitable -disable-output -enable-new-pm=0 < %s | \
; RUN: FileCheck %s ; RUN: FileCheck %s
; REQUIRES: pollyacc ; REQUIRES: pollyacc
; CHECK: target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-i128:128:128-f32:32:32-f64:64:64-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64-v96:128:128-v128:128:128-v192:256:256-v256:256:256-v512:512:512-v1024:1024:1024" ; CHECK: target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-i128:128:128-f32:32:32-f64:64:64-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64-v96:128:128-v128:128:128-v192:256:256-v256:256:256-v512:512:512-v1024:1024:1024"
; CHECK-NEXT: target triple = "spir-unknown-unknown" ; CHECK-NEXT: target triple = "spir-unknown-unknown"
▲ Show 20 Lines • Show All 109 Lines • Show Last 20 Lines

polly/test/ScopDetect/base_pointer_load_setNewAccessRelation.ll

; RUN: opt %loadPolly -polly-ignore-aliasing -polly-invariant-load-hoisting=true -polly-scops -polly-print-import-jscop -polly-codegen -disable-output < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 %loadPolly -polly-ignore-aliasing -polly-invariant-load-hoisting=true -polly-scops -polly-print-import-jscop -polly-codegen -disable-output < %s | FileCheck %s
; ;
; This violated an assertion in setNewAccessRelation that assumed base pointers ; This violated an assertion in setNewAccessRelation that assumed base pointers
; to be load-hoisted. Without this assertion, it codegen would generate invalid ; to be load-hoisted. Without this assertion, it codegen would generate invalid
; code. ; code.
; ;
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-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"
define void @base_pointer_load_is_inst_inside_invariant_1(i64 %n, float** %A) { define void @base_pointer_load_is_inst_inside_invariant_1(i64 %n, float** %A) {
Show All 33 Lines

polly/test/ScopInfo/int2ptr_ptr2int.ll

; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -S -polly-codegen < %s | FileCheck %s --check-prefix=IR ; RUN: opt -opaque-pointers=0 %loadPolly -S -polly-codegen < %s | FileCheck %s --check-prefix=IR
; ;
; void f(long *A, long *ptr, long val) { ; void f(long *A, long *ptr, long val) {
; for (long i = 0; i < 100; i++) { ; for (long i = 0; i < 100; i++) {
; long ptrV = ((long)(ptr + 1)) + 1; ; long ptrV = ((long)(ptr + 1)) + 1;
; long valP = (long)(((long *)(val + 1)) + 1); ; long valP = (long)(((long *)(val + 1)) + 1);
; A[ptrV] += A[valP]; ; A[ptrV] += A[valP];
; } ; }
; } ; }
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

polly/test/ScopInfo/int2ptr_ptr2int_2.ll

; RUN: opt %loadPolly -polly-print-scops \ ; RUN: opt -opaque-pointers=0 %loadPolly -polly-print-scops \
; RUN: -polly-invariant-load-hoisting=true -disable-output < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -S -polly-codegen \ ; RUN: opt -opaque-pointers=0 %loadPolly -S -polly-codegen \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s --check-prefix=IR ; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s --check-prefix=IR
; ;
; void f(long *A, long *B, long *ptr, long val) { ; void f(long *A, long *B, long *ptr, long val) {
; for (long i = 0; i < 100; i++) { ; for (long i = 0; i < 100; i++) {
; long ptrV = ((long)(ptr + 1)) + 1; ; long ptrV = ((long)(ptr + 1)) + 1;
; long valP = (long)(((long *)(val + 1)) + 1); ; long valP = (long)(((long *)(val + 1)) + 1);
; A[ptrV] += B[valP]; ; A[ptrV] += B[valP];
; } ; }
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

polly/test/ScopInfo/invariant_load_access_classes_different_base_type.ll

; RUN: opt %loadPolly -polly-print-scops -polly-invariant-load-hoisting=true -disable-output < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 %loadPolly -polly-print-scops -polly-invariant-load-hoisting=true -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -S < %s | FileCheck %s --check-prefix=CODEGEN ; RUN: opt -opaque-pointers=0 %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -S < %s | FileCheck %s --check-prefix=CODEGEN
; ;
; struct { ; struct {
; int a; ; int a;
; float b; ; float b;
; } S; ; } S;
; ;
; void f(int *A) { ; void f(int *A) {
; for (int i = 0; i < 1000; i++) ; for (int i = 0; i < 1000; i++)
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

polly/test/ScopInfo/invariant_load_access_classes_different_base_type_escaping.ll

; RUN: opt %loadPolly -polly-print-scops -polly-invariant-load-hoisting=true -disable-output < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 %loadPolly -polly-print-scops -polly-invariant-load-hoisting=true -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -S < %s | FileCheck %s --check-prefix=CODEGEN ; RUN: opt -opaque-pointers=0 %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -S < %s | FileCheck %s --check-prefix=CODEGEN
; ;
; struct { ; struct {
; int a; ; int a;
; float b; ; float b;
; } S; ; } S;
; ;
; float f(int *A) { ; float f(int *A) {
; int x; ; int x;
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

polly/test/ScopInfo/invariant_load_zext_parameter.ll

; RUN: opt %loadPolly -polly-print-scops -polly-invariant-load-hoisting=true -disable-output < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 %loadPolly -polly-print-scops -polly-invariant-load-hoisting=true -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -S < %s | FileCheck %s --check-prefix=CODEGEN ; RUN: opt -opaque-pointers=0 %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -S < %s | FileCheck %s --check-prefix=CODEGEN
; ;
; void f(int *I0, int *I1, int *V) { ; void f(int *I0, int *I1, int *V) {
; for (int i = 0; i < 1000; i++) { ; for (int i = 0; i < 1000; i++) {
; if ((long)(*I0) == 0) ; if ((long)(*I0) == 0)
; V[i] += *I1; ; V[i] += *I1;
; } ; }
; } ; }
; ;
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

polly/test/ScopInfo/memcpy.ll

; RUN: opt %loadPolly -basic-aa -polly-allow-differing-element-types -polly-print-scops -disable-output < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 %loadPolly -basic-aa -polly-allow-differing-element-types -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -S -basic-aa -polly-allow-differing-element-types -polly-codegen < %s | FileCheck --check-prefix=IR %s ; RUN: opt -opaque-pointers=0 %loadPolly -S -basic-aa -polly-allow-differing-element-types -polly-codegen < %s | FileCheck --check-prefix=IR %s
; ;
; CHECK: Arrays { ; CHECK: Arrays {
; CHECK-NEXT: i8 MemRef_A[*]; // Element size 1 ; CHECK-NEXT: i8 MemRef_A[*]; // Element size 1
; CHECK-NEXT: i8 MemRef_B[*]; // Element size 1 ; CHECK-NEXT: i8 MemRef_B[*]; // Element size 1
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK: Statements { ; CHECK: Statements {
; CHECK-NEXT: Stmt_for_body3 ; CHECK-NEXT: Stmt_for_body3
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

polly/test/ScopInfo/memmove.ll

; RUN: opt %loadPolly -basic-aa -polly-allow-differing-element-types -polly-print-scops -disable-output < %s | FileCheck %s ; RUN: opt -opaque-pointers=0 %loadPolly -basic-aa -polly-allow-differing-element-types -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -S -basic-aa -polly-allow-differing-element-types -polly-codegen < %s | FileCheck --check-prefix=IR %s ; RUN: opt -opaque-pointers=0 %loadPolly -S -basic-aa -polly-allow-differing-element-types -polly-codegen < %s | FileCheck --check-prefix=IR %s
; ;
; CHECK: Arrays { ; CHECK: Arrays {
; CHECK-NEXT: i8 MemRef_A[*]; // Element size 1 ; CHECK-NEXT: i8 MemRef_A[*]; // Element size 1
; CHECK-NEXT: i8 MemRef_B[*]; // Element size 1 ; CHECK-NEXT: i8 MemRef_B[*]; // Element size 1
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK: Statements { ; CHECK: Statements {
; CHECK-NEXT: Stmt_for_body3 ; CHECK-NEXT: Stmt_for_body3
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines