This is an archive of the discontinued LLVM Phabricator instance.

Differential D104962

Disable ReplaceLDS pass, patch up tests to match
ClosedPublic

Authored by JonChesterfield on Jun 25 2021, 5:22 PM.

Details

Reviewers
hsmhsm
Commits
rG50ad3478bdd3: Disable ReplaceLDS pass, patch up tests to match
Summary

Most tests passed with an extra argument to explicitly enable the pass.
One does not, deleted it as part of this change. I can't see why the codegen
would be different between default on and default off but switched on. It
can be retrieved from the project history.

This would be a revert, but git revert was not clean. Disabling the pass
and leaving it in tree is less likely to cause breakage elsewhere than
patching up the git revert conflicts on unfamiliar code. It'll be landed
without review, as @hsmhsm is believed unavailable at present.

Diff Detail

Event Timeline

JonChesterfield created this revision.Jun 25 2021, 5:22 PM
Herald added subscribers: foad, nikic, kerbowa and 4 others. · View Herald TranscriptJun 25 2021, 5:22 PM
JonChesterfield requested review of this revision.Jun 25 2021, 5:22 PM
Herald added a project: Restricted Project. · View Herald TranscriptJun 25 2021, 5:22 PM
Herald added a subscriber: llvm-commits. · View Herald Transcript
JonChesterfield mentioned this in D103225: [AMDGPU] Replace non-kernel function uses of LDS globals by pointers..Jun 25 2021, 5:24 PM
JonChesterfield edited the summary of this revision. (Show Details)Jun 25 2021, 5:35 PM
This revision was not accepted when it landed; it landed in state Needs Review.Jun 25 2021, 5:36 PM
This revision was landed with ongoing or failed builds.
Closed by commit rG50ad3478bdd3: Disable ReplaceLDS pass, patch up tests to match (authored by JonChesterfield). · Explain Why
This revision was automatically updated to reflect the committed changes.
JonChesterfield added a commit: rG50ad3478bdd3: Disable ReplaceLDS pass, patch up tests to match.
Harbormaster completed remote builds in B111097: Diff 354634.Jun 25 2021, 5:54 PM
hsmhsm mentioned this in D107329: [AMDGPU] Ignore call graph node which does not have function info..Aug 3 2021, 7:08 AM
hsmhsm added a reverting change: D109062: Revert "Disable ReplaceLDS pass, patch up tests to match".Sep 1 2021, 7:23 AM
hsmhsm mentioned this in D109062: Revert "Disable ReplaceLDS pass, patch up tests to match".Sep 1 2021, 7:43 AM
hsmhsm added a reverting change: rG5ae6804d179e: Revert "Disable ReplaceLDS pass, patch up tests to match".Sep 1 2021, 8:50 AM
JonChesterfield mentioned this in D147586: [amdgpu][nfc] Remove dead code associated with LDS lowering.Apr 4 2023, 5:14 PM
JonChesterfield mentioned this in rG3c76e5f0c868: [amdgpu][nfc] Remove dead code associated with LDS lowering.Apr 5 2023, 2:24 PM

Revision Contents

Diff 354637

llvm/lib/Target/AMDGPU/AMDGPUTargetMachine.cpp

Show First 20 Lines • Show All 194 Lines • ▼ Show 20 Lines
static cl::opt<bool> EnableStructurizerWorkarounds( static cl::opt<bool> EnableStructurizerWorkarounds(
"amdgpu-enable-structurizer-workarounds", "amdgpu-enable-structurizer-workarounds",
cl::desc("Enable workarounds for the StructurizeCFG pass"), cl::init(true), cl::desc("Enable workarounds for the StructurizeCFG pass"), cl::init(true),
cl::Hidden); cl::Hidden);
static cl::opt<bool> EnableLDSReplaceWithPointer( static cl::opt<bool> EnableLDSReplaceWithPointer(
"amdgpu-enable-lds-replace-with-pointer", "amdgpu-enable-lds-replace-with-pointer",
cl::desc("Enable LDS replace with pointer pass"), cl::init(true), cl::desc("Enable LDS replace with pointer pass"), cl::init(false),
cl::Hidden); cl::Hidden);
static cl::opt<bool, true> EnableLowerModuleLDS( static cl::opt<bool, true> EnableLowerModuleLDS(
"amdgpu-enable-lower-module-lds", cl::desc("Enable lower module lds pass"), "amdgpu-enable-lower-module-lds", cl::desc("Enable lower module lds pass"),
cl::location(AMDGPUTargetMachine::EnableLowerModuleLDS), cl::init(true), cl::location(AMDGPUTargetMachine::EnableLowerModuleLDS), cl::init(true),
cl::Hidden); cl::Hidden);
extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeAMDGPUTarget() { extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeAMDGPUTarget() {
▲ Show 20 Lines • Show All 1,213 Lines • Show Last 20 Lines

llvm/test/CodeGen/AMDGPU/llc-pipeline.ll

Show All 36 Lines
; GCN-O0-NEXT: Expand Atomic instructions ; GCN-O0-NEXT: Expand Atomic instructions
; GCN-O0-NEXT: AMDGPU Lower Intrinsics ; GCN-O0-NEXT: AMDGPU Lower Intrinsics
; GCN-O0-NEXT: AMDGPU Inline All Functions ; GCN-O0-NEXT: AMDGPU Inline All Functions
; GCN-O0-NEXT: CallGraph Construction ; GCN-O0-NEXT: CallGraph Construction
; GCN-O0-NEXT: Call Graph SCC Pass Manager ; GCN-O0-NEXT: Call Graph SCC Pass Manager
; GCN-O0-NEXT: Inliner for always_inline functions ; GCN-O0-NEXT: Inliner for always_inline functions
; GCN-O0-NEXT: A No-Op Barrier Pass ; GCN-O0-NEXT: A No-Op Barrier Pass
; GCN-O0-NEXT: Lower OpenCL enqueued blocks ; GCN-O0-NEXT: Lower OpenCL enqueued blocks
; GCN-O0-NEXT: Replace within non-kernel function use of LDS with pointer
; GCN-O0-NEXT: Lower uses of LDS variables from non-kernel functions ; GCN-O0-NEXT: Lower uses of LDS variables from non-kernel functions
; GCN-O0-NEXT: FunctionPass Manager ; GCN-O0-NEXT: FunctionPass Manager
; GCN-O0-NEXT: Dominator Tree Construction ; GCN-O0-NEXT: Dominator Tree Construction
; GCN-O0-NEXT: Post-Dominator Tree Construction ; GCN-O0-NEXT: Post-Dominator Tree Construction
; GCN-O0-NEXT: Natural Loop Information ; GCN-O0-NEXT: Natural Loop Information
; GCN-O0-NEXT: Legacy Divergence Analysis ; GCN-O0-NEXT: Legacy Divergence Analysis
; GCN-O0-NEXT: AMDGPU IR optimizations ; GCN-O0-NEXT: AMDGPU IR optimizations
; GCN-O0-NEXT: Lower Garbage Collection Instructions ; GCN-O0-NEXT: Lower Garbage Collection Instructions
▲ Show 20 Lines • Show All 134 Lines • ▼ Show 20 Lines
; GCN-O1-NEXT: Expand Atomic instructions ; GCN-O1-NEXT: Expand Atomic instructions
; GCN-O1-NEXT: AMDGPU Lower Intrinsics ; GCN-O1-NEXT: AMDGPU Lower Intrinsics
; GCN-O1-NEXT: AMDGPU Inline All Functions ; GCN-O1-NEXT: AMDGPU Inline All Functions
; GCN-O1-NEXT: CallGraph Construction ; GCN-O1-NEXT: CallGraph Construction
; GCN-O1-NEXT: Call Graph SCC Pass Manager ; GCN-O1-NEXT: Call Graph SCC Pass Manager
; GCN-O1-NEXT: Inliner for always_inline functions ; GCN-O1-NEXT: Inliner for always_inline functions
; GCN-O1-NEXT: A No-Op Barrier Pass ; GCN-O1-NEXT: A No-Op Barrier Pass
; GCN-O1-NEXT: Lower OpenCL enqueued blocks ; GCN-O1-NEXT: Lower OpenCL enqueued blocks
; GCN-O1-NEXT: Replace within non-kernel function use of LDS with pointer
; GCN-O1-NEXT: Lower uses of LDS variables from non-kernel functions ; GCN-O1-NEXT: Lower uses of LDS variables from non-kernel functions
; GCN-O1-NEXT: FunctionPass Manager ; GCN-O1-NEXT: FunctionPass Manager
; GCN-O1-NEXT: Infer address spaces ; GCN-O1-NEXT: Infer address spaces
; GCN-O1-NEXT: AMDGPU Promote Alloca ; GCN-O1-NEXT: AMDGPU Promote Alloca
; GCN-O1-NEXT: Dominator Tree Construction ; GCN-O1-NEXT: Dominator Tree Construction
; GCN-O1-NEXT: SROA ; GCN-O1-NEXT: SROA
; GCN-O1-NEXT: Post-Dominator Tree Construction ; GCN-O1-NEXT: Post-Dominator Tree Construction
; GCN-O1-NEXT: Natural Loop Information ; GCN-O1-NEXT: Natural Loop Information
▲ Show 20 Lines • Show All 232 Lines • ▼ Show 20 Lines
; GCN-O1-OPTS-NEXT: Expand Atomic instructions ; GCN-O1-OPTS-NEXT: Expand Atomic instructions
; GCN-O1-OPTS-NEXT: AMDGPU Lower Intrinsics ; GCN-O1-OPTS-NEXT: AMDGPU Lower Intrinsics
; GCN-O1-OPTS-NEXT: AMDGPU Inline All Functions ; GCN-O1-OPTS-NEXT: AMDGPU Inline All Functions
; GCN-O1-OPTS-NEXT: CallGraph Construction ; GCN-O1-OPTS-NEXT: CallGraph Construction
; GCN-O1-OPTS-NEXT: Call Graph SCC Pass Manager ; GCN-O1-OPTS-NEXT: Call Graph SCC Pass Manager
; GCN-O1-OPTS-NEXT: Inliner for always_inline functions ; GCN-O1-OPTS-NEXT: Inliner for always_inline functions
; GCN-O1-OPTS-NEXT: A No-Op Barrier Pass ; GCN-O1-OPTS-NEXT: A No-Op Barrier Pass
; GCN-O1-OPTS-NEXT: Lower OpenCL enqueued blocks ; GCN-O1-OPTS-NEXT: Lower OpenCL enqueued blocks
; GCN-O1-OPTS-NEXT: Replace within non-kernel function use of LDS with pointer
; GCN-O1-OPTS-NEXT: Lower uses of LDS variables from non-kernel functions ; GCN-O1-OPTS-NEXT: Lower uses of LDS variables from non-kernel functions
; GCN-O1-OPTS-NEXT: FunctionPass Manager ; GCN-O1-OPTS-NEXT: FunctionPass Manager
; GCN-O1-OPTS-NEXT: Infer address spaces ; GCN-O1-OPTS-NEXT: Infer address spaces
; GCN-O1-OPTS-NEXT: AMDGPU Promote Alloca ; GCN-O1-OPTS-NEXT: AMDGPU Promote Alloca
; GCN-O1-OPTS-NEXT: Dominator Tree Construction ; GCN-O1-OPTS-NEXT: Dominator Tree Construction
; GCN-O1-OPTS-NEXT: SROA ; GCN-O1-OPTS-NEXT: SROA
; GCN-O1-OPTS-NEXT: Basic Alias Analysis (stateless AA impl) ; GCN-O1-OPTS-NEXT: Basic Alias Analysis (stateless AA impl)
; GCN-O1-OPTS-NEXT: Function Alias Analysis Results ; GCN-O1-OPTS-NEXT: Function Alias Analysis Results
▲ Show 20 Lines • Show All 264 Lines • ▼ Show 20 Lines
; GCN-O2-NEXT: Expand Atomic instructions ; GCN-O2-NEXT: Expand Atomic instructions
; GCN-O2-NEXT: AMDGPU Lower Intrinsics ; GCN-O2-NEXT: AMDGPU Lower Intrinsics
; GCN-O2-NEXT: AMDGPU Inline All Functions ; GCN-O2-NEXT: AMDGPU Inline All Functions
; GCN-O2-NEXT: CallGraph Construction ; GCN-O2-NEXT: CallGraph Construction
; GCN-O2-NEXT: Call Graph SCC Pass Manager ; GCN-O2-NEXT: Call Graph SCC Pass Manager
; GCN-O2-NEXT: Inliner for always_inline functions ; GCN-O2-NEXT: Inliner for always_inline functions
; GCN-O2-NEXT: A No-Op Barrier Pass ; GCN-O2-NEXT: A No-Op Barrier Pass
; GCN-O2-NEXT: Lower OpenCL enqueued blocks ; GCN-O2-NEXT: Lower OpenCL enqueued blocks
; GCN-O2-NEXT: Replace within non-kernel function use of LDS with pointer
; GCN-O2-NEXT: Lower uses of LDS variables from non-kernel functions ; GCN-O2-NEXT: Lower uses of LDS variables from non-kernel functions
; GCN-O2-NEXT: FunctionPass Manager ; GCN-O2-NEXT: FunctionPass Manager
; GCN-O2-NEXT: Infer address spaces ; GCN-O2-NEXT: Infer address spaces
; GCN-O2-NEXT: AMDGPU Promote Alloca ; GCN-O2-NEXT: AMDGPU Promote Alloca
; GCN-O2-NEXT: Dominator Tree Construction ; GCN-O2-NEXT: Dominator Tree Construction
; GCN-O2-NEXT: SROA ; GCN-O2-NEXT: SROA
; GCN-O2-NEXT: Basic Alias Analysis (stateless AA impl) ; GCN-O2-NEXT: Basic Alias Analysis (stateless AA impl)
; GCN-O2-NEXT: Function Alias Analysis Results ; GCN-O2-NEXT: Function Alias Analysis Results
▲ Show 20 Lines • Show All 265 Lines • ▼ Show 20 Lines
; GCN-O3-NEXT: Expand Atomic instructions ; GCN-O3-NEXT: Expand Atomic instructions
; GCN-O3-NEXT: AMDGPU Lower Intrinsics ; GCN-O3-NEXT: AMDGPU Lower Intrinsics
; GCN-O3-NEXT: AMDGPU Inline All Functions ; GCN-O3-NEXT: AMDGPU Inline All Functions
; GCN-O3-NEXT: CallGraph Construction ; GCN-O3-NEXT: CallGraph Construction
; GCN-O3-NEXT: Call Graph SCC Pass Manager ; GCN-O3-NEXT: Call Graph SCC Pass Manager
; GCN-O3-NEXT: Inliner for always_inline functions ; GCN-O3-NEXT: Inliner for always_inline functions
; GCN-O3-NEXT: A No-Op Barrier Pass ; GCN-O3-NEXT: A No-Op Barrier Pass
; GCN-O3-NEXT: Lower OpenCL enqueued blocks ; GCN-O3-NEXT: Lower OpenCL enqueued blocks
; GCN-O3-NEXT: Replace within non-kernel function use of LDS with pointer
; GCN-O3-NEXT: Lower uses of LDS variables from non-kernel functions ; GCN-O3-NEXT: Lower uses of LDS variables from non-kernel functions
; GCN-O3-NEXT: FunctionPass Manager ; GCN-O3-NEXT: FunctionPass Manager
; GCN-O3-NEXT: Infer address spaces ; GCN-O3-NEXT: Infer address spaces
; GCN-O3-NEXT: AMDGPU Promote Alloca ; GCN-O3-NEXT: AMDGPU Promote Alloca
; GCN-O3-NEXT: Dominator Tree Construction ; GCN-O3-NEXT: Dominator Tree Construction
; GCN-O3-NEXT: SROA ; GCN-O3-NEXT: SROA
; GCN-O3-NEXT: Basic Alias Analysis (stateless AA impl) ; GCN-O3-NEXT: Basic Alias Analysis (stateless AA impl)
; GCN-O3-NEXT: Function Alias Analysis Results ; GCN-O3-NEXT: Function Alias Analysis Results
▲ Show 20 Lines • Show All 259 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 < %s | FileCheck %s ; RUN: opt -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 < %s | FileCheck %s ; RUN: opt -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-ignore-global-scope-use.ll

; RUN: opt -S -mtriple=amdgcn-- -amdgpu-replace-lds-use-with-pointer < %s | FileCheck %s ; RUN: opt -S -mtriple=amdgcn-- -amdgpu-replace-lds-use-with-pointer -amdgpu-enable-lds-replace-with-pointer=true < %s | FileCheck %s
; DESCRIPTION: ; DESCRIPTION:
; ;
; None of lds are pointer-replaced since they are all used in global scope in one or the other way. ; None of lds are pointer-replaced since they are all used in global scope in one or the other way.
; ;
; CHECK: @lds = internal addrspace(3) global [4 x i32] undef, align 4 ; CHECK: @lds = internal addrspace(3) global [4 x i32] undef, align 4
; CHECK: @lds.1 = addrspace(3) global i16 undef, align 2 ; CHECK: @lds.1 = addrspace(3) global i16 undef, align 2
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

llvm/test/CodeGen/AMDGPU/replace-lds-by-ptr-ignore-inline-asm-call.ll

; RUN: opt -S -mtriple=amdgcn-- -amdgpu-replace-lds-use-with-pointer < %s | FileCheck %s ; RUN: opt -S -mtriple=amdgcn-- -amdgpu-replace-lds-use-with-pointer -amdgpu-enable-lds-replace-with-pointer=true < %s | FileCheck %s
; DESCRIPTION: ; DESCRIPTION:
; ;
; We do not know what to do with inline asm call, we ignore it, hence pointer replacement for ; We do not know what to do with inline asm call, we ignore it, hence pointer replacement for
; @used_only_within_func does not take place. ; @used_only_within_func does not take place.
; ;
; CHECK: @used_only_within_func = addrspace(3) global [4 x i32] undef, align 4 ; CHECK: @used_only_within_func = addrspace(3) global [4 x i32] undef, align 4
Show All 21 Lines

llvm/test/CodeGen/AMDGPU/replace-lds-by-ptr-ignore-kernel-only-used-lds.ll

; RUN: opt -S -mtriple=amdgcn-- -amdgpu-replace-lds-use-with-pointer < %s | FileCheck %s ; RUN: opt -S -mtriple=amdgcn-- -amdgpu-replace-lds-use-with-pointer -amdgpu-enable-lds-replace-with-pointer=true < %s | FileCheck %s
; DESCRIPTION ; ; DESCRIPTION ;
; ;
; LDS global @used_only_within_kern is used only within kernel @k0, hence pointer replacement ; LDS global @used_only_within_kern is used only within kernel @k0, hence pointer replacement
; does not take place for @used_only_within_kern. ; does not take place for @used_only_within_kern.
; ;
; CHECK: @used_only_within_kern = addrspace(3) global [4 x i32] undef, align 4 ; CHECK: @used_only_within_kern = addrspace(3) global [4 x i32] undef, align 4
Show All 16 Lines

llvm/test/CodeGen/AMDGPU/replace-lds-by-ptr-ignore-not-reachable-lds.ll

; RUN: opt -S -mtriple=amdgcn-- -amdgpu-replace-lds-use-with-pointer < %s | FileCheck %s ; RUN: opt -S -mtriple=amdgcn-- -amdgpu-replace-lds-use-with-pointer -amdgpu-enable-lds-replace-with-pointer=true < %s | FileCheck %s
; DESCRIPTION ; ; DESCRIPTION ;
; ;
; LDS global @not-reachable-lds is used within non-kernel function @f0, but @f0 is *not* ; LDS global @not-reachable-lds is used within non-kernel function @f0, but @f0 is *not*
; reachable from kernel @k, hence pointer replacement does not take place. ; reachable from kernel @k, hence pointer replacement does not take place.
; ;
; CHECK: @not-reachable-lds = internal addrspace(3) global [4 x i32] undef, align 4 ; CHECK: @not-reachable-lds = internal addrspace(3) global [4 x i32] undef, align 4
Show All 19 Lines

llvm/test/CodeGen/AMDGPU/replace-lds-by-ptr-ignore-small-lds.ll

; RUN: opt -S -mtriple=amdgcn-- -amdgpu-replace-lds-use-with-pointer < %s | FileCheck %s ; RUN: opt -S -mtriple=amdgcn-- -amdgpu-replace-lds-use-with-pointer -amdgpu-enable-lds-replace-with-pointer=true < %s | FileCheck %s
; DESCRIPTION ; ; DESCRIPTION ;
; ;
; LDS global @small_lds is used within non-kernel function @f0, and @f0 is reachable ; LDS global @small_lds is used within non-kernel function @f0, and @f0 is reachable
; from kernel @k0, but since @small_lds too small for pointer replacement, pointer ; from kernel @k0, but since @small_lds too small for pointer replacement, pointer
; replacement does not take place. ; replacement does not take place.
; ;
Show All 22 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 < %s | FileCheck %s ; RUN: opt -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 < %s | FileCheck %s ; RUN: opt -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 < %s | FileCheck %s ; RUN: opt -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-lds-offsets.ll

  • This file was deleted.
; RUN: opt -S -mtriple=amdgcn-- -amdgpu-replace-lds-use-with-pointer < %s | FileCheck --check-prefix=POINTER-REPLACE %s
; RUN: opt -S -mtriple=amdgcn-- -amdgpu-replace-lds-use-with-pointer -amdgpu-lower-module-lds < %s | FileCheck --check-prefix=LOWER_LDS %s
; RUN: llc -mtriple=amdgcn-- -mcpu=gfx900 < %s | FileCheck --check-prefix=GCN %s
;
; DESCRIPTION:
;
; 1. There are three lds defined - @lds.1, @lds.2 and @lds.3, which are of types i32, i64, and [2 x i64].
; @lds.3 is aliased to to @alias.to.lds.3
; 2. @lds.1 is used in function @f1, and @lds.2 is used in function @f2, @alias.to.lds.3 is used in kernel @k1.
; 3. Pointer-replacement pass replaces @lds.1 and @lds.2 by pointers @lds.1.ptr and @lds.2.ptr respectively.
; However it does not touch @lds.3 since it is used in global scope (aliased).
;
; 4. LDS-lowering pass sees use of @lds.1.ptr in function @f1, use of @lds.2.ptr in function @f2, and use of
; @lds.3 (via alias @alias.to.lds.3) in kernel @k1. Hence it module lowers these lds into struct instance
; @llvm.amdgcn.module.lds.
;
; The struct member order is - [lds.3, lds.1.ptr, lds.2.ptr]. Since @llvm.amdgcn.module.lds itself is allocated
; on address 0, lds.3 is allocated on address 0, lds.1.ptr is allocated on address 16, and lds.2.ptr is allocated
; on address 18.
;
; Again LDS-lowering pass sees use of @lds.1 and @lds.2 in kernel. Hence it kernel lowers these lds into struct
; instance @llvm.amdgcn.kernel.k1.lds.
;
; The struct member order is - [@lds.2, @lds.1]. By now, already (16 + 2 + 2) 20 byte of memory allocated, @lds.2
; is allocated on address 24 since it needs to be allocated on 8 byte boundary, and @lds.1 is allocated on address
; 32.
;
; 5. Hence the final GCN ISA looks as below:
;
; Within kernel @k1:
; address 24 is stored in address 18.
; address 32 is stored in address 16
;
; Within function @f1:
; address 32 is loaded from address 16
;
; Within function @f2:
; address 24 is loaded from address 18
;
; POINTER-REPLACE: @lds.1 = addrspace(3) global i32 undef, align 4
; POINTER-REPLACE: @lds.2 = addrspace(3) global i64 undef, align 8
; POINTER-REPLACE: @lds.3 = addrspace(3) global [2 x i64] undef, align 16
; POINTER-REPLACE: @lds.1.ptr = internal unnamed_addr addrspace(3) global i16 undef, align 2
; POINTER-REPLACE: @lds.2.ptr = internal unnamed_addr addrspace(3) global i16 undef, align 2
; POINTER-REPLACE: @alias.to.lds.3 = alias [2 x i64], [2 x i64] addrspace(3)* @lds.3
; LOWER_LDS-NOT: @lds.1
; LOWER_LDS-NOT: @lds.2
; LOWER_LDS-NOT: @lds.3
; LOWER_LDS: %llvm.amdgcn.module.lds.t = type { [2 x i64], i16, i16 }
; LOWER_LDS: %llvm.amdgcn.kernel.k1.lds.t = type { i64, i32 }
; LOWER_LDS: @llvm.amdgcn.module.lds = internal addrspace(3) global %llvm.amdgcn.module.lds.t undef, align 16
; LOWER_LDS: @llvm.compiler.used = appending global [1 x i8*] [i8* addrspacecast (i8 addrspace(3)* bitcast (%llvm.amdgcn.module.lds.t addrspace(3)* @llvm.amdgcn.module.lds to i8 addrspace(3)*) to i8*)], section "llvm.metadata"
; LOWER_LDS: @llvm.amdgcn.kernel.k1.lds = internal addrspace(3) global %llvm.amdgcn.kernel.k1.lds.t undef, align 8
; LOWER_LDS: @alias.to.lds.3 = alias [2 x i64], getelementptr inbounds (%llvm.amdgcn.module.lds.t, %llvm.amdgcn.module.lds.t addrspace(3)* @llvm.amdgcn.module.lds, i32 0, i32 0)
@lds.1 = addrspace(3) global i32 undef, align 4
@lds.2 = addrspace(3) global i64 undef, align 8
@lds.3 = addrspace(3) global [2 x i64] undef, align 16
@alias.to.lds.3 = alias [2 x i64], [2 x i64] addrspace(3)* @lds.3
; POINTER-REPLACE-LABEL: @f1
; POINTER-REPLACE: %1 = load i16, i16 addrspace(3)* @lds.1.ptr, align 2
; POINTER-REPLACE: %2 = getelementptr i8, i8 addrspace(3)* null, i16 %1
; POINTER-REPLACE: %3 = bitcast i8 addrspace(3)* %2 to i32 addrspace(3)*
; POINTER-REPLACE: store i32 7, i32 addrspace(3)* %3, align 4
; POINTER-REPLACE: ret void
; LOWER_LDS-LABEL: @f1
; LOWER_LDS: %1 = load i16, i16 addrspace(3)* getelementptr inbounds (%llvm.amdgcn.module.lds.t, %llvm.amdgcn.module.lds.t addrspace(3)* @llvm.amdgcn.module.lds, i32 0, i32 1), align 16
; LOWER_LDS: %2 = getelementptr i8, i8 addrspace(3)* null, i16 %1
; LOWER_LDS: %3 = bitcast i8 addrspace(3)* %2 to i32 addrspace(3)*
; LOWER_LDS: store i32 7, i32 addrspace(3)* %3, align 4
; LOWER_LDS: ret void
; GCN-LABEL: f1:
; GCN: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0)
; GCN: v_mov_b32_e32 v0, 0
; GCN: ds_read_i16 v0, v0 offset:16
; GCN: v_mov_b32_e32 v1, 7
; GCN: s_waitcnt lgkmcnt(0)
; GCN: ds_write_b32 v0, v1
; GCN: s_waitcnt lgkmcnt(0)
; GCN: s_setpc_b64 s[30:31]
define void @f1() {
store i32 7, i32 addrspace(3)* @lds.1
ret void
}
; POINTER-REPLACE-LABEL: @f2
; POINTER-REPLACE: %1 = load i16, i16 addrspace(3)* @lds.2.ptr, align 2
; POINTER-REPLACE: %2 = getelementptr i8, i8 addrspace(3)* null, i16 %1
; POINTER-REPLACE: %3 = bitcast i8 addrspace(3)* %2 to i64 addrspace(3)*
; POINTER-REPLACE: store i64 15, i64 addrspace(3)* %3, align 4
; POINTER-REPLACE: ret void
; LOWER_LDS-LABEL: @f2
; LOWER_LDS: %1 = load i16, i16 addrspace(3)* getelementptr inbounds (%llvm.amdgcn.module.lds.t, %llvm.amdgcn.module.lds.t addrspace(3)* @llvm.amdgcn.module.lds, i32 0, i32 2), align 2
; LOWER_LDS: %2 = getelementptr i8, i8 addrspace(3)* null, i16 %1
; LOWER_LDS: %3 = bitcast i8 addrspace(3)* %2 to i64 addrspace(3)*
; LOWER_LDS: store i64 15, i64 addrspace(3)* %3, align 4
; LOWER_LDS: ret void
; GCN-LABEL: f2:
; GCN: s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0)
; GCN: v_mov_b32_e32 v1, 0
; GCN: ds_read_i16 v2, v1 offset:18
; GCN: v_mov_b32_e32 v0, 15
; GCN: s_waitcnt lgkmcnt(0)
; GCN: ds_write_b64 v2, v[0:1]
; GCN: s_waitcnt lgkmcnt(0)
; GCN: s_setpc_b64 s[30:31]
define void @f2() {
store i64 15, i64 addrspace(3)* @lds.2
ret void
}
; POINTER-REPLACE-LABEL: @k1
; POINTER-REPLACE: %1 = call i32 @llvm.amdgcn.mbcnt.lo(i32 -1, i32 0)
; POINTER-REPLACE: %2 = icmp eq i32 %1, 0
; POINTER-REPLACE: br i1 %2, label %3, label %4
;
; POINTER-REPLACE-LABEL: 3:
; POINTER-REPLACE: store i16 ptrtoint (i64 addrspace(3)* @lds.2 to i16), i16 addrspace(3)* @lds.2.ptr, align 2
; POINTER-REPLACE: store i16 ptrtoint (i32 addrspace(3)* @lds.1 to i16), i16 addrspace(3)* @lds.1.ptr, align 2
; POINTER-REPLACE: br label %4
;
; POINTER-REPLACE-LABEL: 4:
; POINTER-REPLACE: call void @llvm.amdgcn.wave.barrier()
; POINTER-REPLACE: %bc = bitcast [2 x i64] addrspace(3)* @alias.to.lds.3 to i8 addrspace(3)*
; POINTER-REPLACE: store i8 3, i8 addrspace(3)* %bc, align 2
; POINTER-REPLACE: call void @f1()
; POINTER-REPLACE: call void @f2()
; POINTER-REPLACE: ret void
; LOWER_LDS-LABEL: @k1
; LOWER_LDS: call void @llvm.donothing() [ "ExplicitUse"(%llvm.amdgcn.module.lds.t addrspace(3)* @llvm.amdgcn.module.lds) ]
; LOWER_LDS: %1 = call i32 @llvm.amdgcn.mbcnt.lo(i32 -1, i32 0)
; LOWER_LDS: %2 = icmp eq i32 %1, 0
; LOWER_LDS: br i1 %2, label %3, label %6
;
; LOWER_LDS-LABEL: 3:
; LOWER_LDS: %4 = ptrtoint i64 addrspace(3)* getelementptr inbounds (%llvm.amdgcn.kernel.k1.lds.t, %llvm.amdgcn.kernel.k1.lds.t addrspace(3)* @llvm.amdgcn.kernel.k1.lds, i32 0, i32 0) to i16
; LOWER_LDS: store i16 %4, i16 addrspace(3)* getelementptr inbounds (%llvm.amdgcn.module.lds.t, %llvm.amdgcn.module.lds.t addrspace(3)* @llvm.amdgcn.module.lds, i32 0, i32 2), align 2
; LOWER_LDS: %5 = ptrtoint i32 addrspace(3)* getelementptr inbounds (%llvm.amdgcn.kernel.k1.lds.t, %llvm.amdgcn.kernel.k1.lds.t addrspace(3)* @llvm.amdgcn.kernel.k1.lds, i32 0, i32 1) to i16
; LOWER_LDS: store i16 %5, i16 addrspace(3)* getelementptr inbounds (%llvm.amdgcn.module.lds.t, %llvm.amdgcn.module.lds.t addrspace(3)* @llvm.amdgcn.module.lds, i32 0, i32 1), align 16
; LOWER_LDS: br label %6
;
; LOWER_LDS-LABEL: 6:
; LOWER_LDS: call void @llvm.amdgcn.wave.barrier()
; LOWER_LDS: %bc = bitcast [2 x i64] addrspace(3)* @alias.to.lds.3 to i8 addrspace(3)*
; LOWER_LDS: store i8 3, i8 addrspace(3)* %bc, align 2
; LOWER_LDS: call void @f1()
; LOWER_LDS: call void @f2()
; LOWER_LDS: ret void
; GCN-LABEL: k1:
; GCN: s_mov_b32 s8, SCRATCH_RSRC_DWORD0
; GCN: s_mov_b32 s9, SCRATCH_RSRC_DWORD1
; GCN: s_mov_b32 s10, -1
; GCN: s_mov_b32 s11, 0xe00000
; GCN: s_add_u32 s8, s8, s1
; GCN: v_mbcnt_lo_u32_b32 v0, -1, 0
; GCN: s_addc_u32 s9, s9, 0
; GCN: v_cmp_eq_u32_e32 vcc, 0, v0
; GCN: s_mov_b32 s32, 0
; GCN: s_and_saveexec_b64 s[0:1], vcc
; GCN: s_cbranch_execz BB2_2
; GCN: v_mov_b32_e32 v0, 0
; GCN: v_mov_b32_e32 v1, 0x180020
; GCN: ds_write_b32 v0, v1 offset:16
; GCN-LABEL: BB2_2:
; GCN: s_or_b64 exec, exec, s[0:1]
; GCN: s_getpc_b64 s[0:1]
; GCN: s_add_u32 s0, s0, f1@gotpcrel32@lo+4
; GCN: s_addc_u32 s1, s1, f1@gotpcrel32@hi+12
; GCN: s_load_dwordx2 s[4:5], s[0:1], 0x0
; GCN: s_mov_b64 s[0:1], s[8:9]
; GCN: s_mov_b64 s[2:3], s[10:11]
; GCN: v_mov_b32_e32 v0, alias.to.lds.3@abs32@lo
; GCN: v_mov_b32_e32 v1, 3
; ; wave barrier
; GCN: ds_write_b8 v0, v1
; GCN: s_waitcnt lgkmcnt(0)
; GCN: s_swappc_b64 s[30:31], s[4:5]
; GCN: s_getpc_b64 s[0:1]
; GCN: s_add_u32 s0, s0, f2@gotpcrel32@lo+4
; GCN: s_addc_u32 s1, s1, f2@gotpcrel32@hi+12
; GCN: s_load_dwordx2 s[4:5], s[0:1], 0x0
; GCN: s_mov_b64 s[0:1], s[8:9]
; GCN: s_mov_b64 s[2:3], s[10:11]
; GCN: s_waitcnt lgkmcnt(0)
; GCN: s_swappc_b64 s[30:31], s[4:5]
; GCN: s_endpgm
define amdgpu_kernel void @k1() {
%bc = bitcast [2 x i64] addrspace(3)* @alias.to.lds.3 to i8 addrspace(3)*
store i8 3, i8 addrspace(3)* %bc, align 2
call void @f1()
call void @f2()
ret void
}

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

; RUN: opt -S -mtriple=amdgcn-- -amdgpu-replace-lds-use-with-pointer < %s | FileCheck %s ; RUN: opt -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 < %s | FileCheck %s ; RUN: opt -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-const-expr1.ll

; RUN: opt -S -mtriple=amdgcn-- -amdgpu-replace-lds-use-with-pointer < %s | FileCheck %s ; RUN: opt -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, as an operand of nested constant expression, and this non-kernel function is ; function, as an operand of nested constant expression, and this non-kernel function is
; reachable from kernel. Hence nested constant expression should to be converted into a ; reachable from kernel. Hence nested constant expression should to be converted into a
; series of instructons and pointer replacement should take place. ; series of instructons and pointer replacement should take place.
; ;
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

llvm/test/CodeGen/AMDGPU/replace-lds-by-ptr-use-within-const-expr2.ll

; RUN: opt -S -mtriple=amdgcn-- -amdgpu-replace-lds-use-with-pointer < %s | FileCheck %s ; RUN: opt -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, as an operand of nested constant expression, and this non-kernel function is ; function, as an operand of nested constant expression, and this non-kernel function is
; reachable from kernel. Hence nested constant expression should to be converted into a ; reachable from kernel. Hence nested constant expression should to be converted into a
; series of instructons and pointer replacement should take place. But, important note ; series of instructons and pointer replacement should take place. But, important note
; is - only constant expression operands which uses lds should be converted into ; is - only constant expression operands which uses lds should be converted into
; instructions, other constant expression operands which do not use lds should be left ; instructions, other constant expression operands which do not use lds should be left
▲ Show 20 Lines • Show All 49 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 < %s | FileCheck %s ; RUN: opt -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/AMDGPU/replace-lds-by-ptr-indirect-call-selected_functions.ll