This is an archive of the discontinued LLVM Phabricator instance.

Differential D144476

[GlobalOpt] Extend logic in SRA heuristic to skip stores of initializer.
ClosedPublic

Authored by fhahn on Feb 21 2023, 5:23 AM.

Details

Reviewers
aeubanks
nikic
kubamracek
Commits
rG226778e1b2d1: [GlobalOpt] Extend logic in SRA heuristic to skip stores of initializer.
Summary

If all stores only store the initializer value of a global, consider it
as not stored in the heuristic. GlobalOpt will remove such stores later
on.

Depends on D129857.

Diff Detail

Event Timeline

fhahn created this revision.Feb 21 2023, 5:23 AM
Herald added a project: Restricted Project. · View Herald TranscriptFeb 21 2023, 5:23 AM
Herald added subscribers: ormris, StephenFan, hiraditya. · View Herald Transcript
fhahn requested review of this revision.Feb 21 2023, 5:23 AM
Herald added a project: Restricted Project. · View Herald TranscriptFeb 21 2023, 5:23 AM
Harbormaster completed remote builds in B214984: Diff 499122.Feb 21 2023, 5:24 AM
fhahn added a child revision: D144477: [GlobalOpt] Handle stored-once in collectSRATypes (WIP)..Feb 21 2023, 5:31 AM
fhahn mentioned this in D129857: [GlobalOpt] Ignore only loaded / only stored global parts in global SRA heuristic.Feb 21 2023, 5:35 AM
fhahn updated this revision to Diff 501813.Mar 2 2023, 2:29 AM

Rebase and ping :)

nikic added inline comments.Mar 2 2023, 2:56 AM
llvm/lib/Transforms/IPO/GlobalOpt.cpp
400

Rebase over https://github.com/llvm/llvm-project/commit/0ecef88cb167dbd19023a932e7abac09059c3e4e?

408

Shouldn't we be comparing with the initializer at the specific offset?

Harbormaster completed remote builds in B216938: Diff 501813.Mar 2 2023, 3:49 AM
fhahn mentioned this in rGf3fad132e346: [GlobalOpt] Add tests that only stores initializer, split test file..Mar 6 2023, 1:51 AM
fhahn mentioned this in rG148f083681f8: [GlobalOpt] Add SRA test with constant expr GEPs without inbounds..Mar 6 2023, 3:03 AM
fhahn updated this revision to Diff 502568.Mar 6 2023, 3:09 AM

Update to use ConstantFoldLoadFromConst to check the initializer value in the specifi field.

fhahn updated this revision to Diff 502570.Mar 6 2023, 3:11 AM

Rebase on top of 0ecef88.

fhahn marked 2 inline comments as done.Mar 6 2023, 3:11 AM
fhahn added inline comments.
llvm/lib/Transforms/IPO/GlobalOpt.cpp
400

Done!

408

Yeah, I updated the code to use ConstantFoldLoadFromConst

nikic added inline comments.Mar 6 2023, 3:53 AM
llvm/lib/Transforms/IPO/GlobalOpt.cpp
408

Why can't this reuse the offset calculation from above?

Harbormaster completed remote builds in B217531: Diff 502570.Mar 6 2023, 4:12 AM
fhahn updated this revision to Diff 502584.Mar 6 2023, 4:23 AM
fhahn marked 2 inline comments as done.

Use existing offset directly.

fhahn marked an inline comment as done.Mar 6 2023, 4:27 AM
fhahn added inline comments.
llvm/lib/Transforms/IPO/GlobalOpt.cpp
408

Missed that, should be updated now, thanks!

Harbormaster completed remote builds in B217540: Diff 502584.Mar 6 2023, 5:29 AM
nikic accepted this revision.Mar 6 2023, 7:18 AM

LGTM, though I think it might be cleaner if we collected the initializer part during the construction of GlobalPart, rather than calculating it twice, here and during the SRA split.

This revision is now accepted and ready to land.Mar 6 2023, 7:18 AM
This revision was landed with ongoing or failed builds.Mar 7 2023, 2:08 AM
Closed by commit rG226778e1b2d1: [GlobalOpt] Extend logic in SRA heuristic to skip stores of initializer. (authored by fhahn). · Explain Why
This revision was automatically updated to reflect the committed changes.
fhahn marked an inline comment as done.
fhahn added a commit: rG226778e1b2d1: [GlobalOpt] Extend logic in SRA heuristic to skip stores of initializer..
fhahn mentioned this in D145490: [GlobalOpt] Collect initializer when building GlobalPart..Mar 7 2023, 5:11 AM
fhahn added a comment.Mar 7 2023, 5:12 AM
In D144476#4171586, @nikic wrote:

LGTM, though I think it might be cleaner if we collected the initializer part during the construction of GlobalPart, rather than calculating it twice, here and during the SRA split.

Posted D145490 as follow-up

fhahn mentioned this in rG84870c4abbac: [GlobalOpt] Collect initializer when building GlobalPart..Mar 19 2023, 1:54 PM

Revision Contents

PathSize
llvm/
lib/
Transforms/
IPO/
19 lines
test/
Transforms/
GlobalOpt/
280 lines

Diff 502961

llvm/lib/Transforms/IPO/GlobalOpt.cpp

Show First 20 Lines • Show All 386 Lines • ▼ Show 20 Lines if (Value *Ptr = getLoadStorePointerOperand(V)) {
auto It = Parts.try_emplace(Offset.getZExtValue(), GlobalPart{Ty}).first; auto It = Parts.try_emplace(Offset.getZExtValue(), GlobalPart{Ty}).first;
if (Ty != It->second.Ty) if (Ty != It->second.Ty)
return false; return false;
// Scalable types not currently supported. // Scalable types not currently supported.
if (isa<ScalableVectorType>(Ty)) if (isa<ScalableVectorType>(Ty))
return false; return false;
auto IsStored = [GV, &DL, &Offset](Value *V) {
auto *SI = dyn_cast<StoreInst>(V);
if (!SI)
return false;
Constant *StoredConst = dyn_cast<Constant>(SI->getOperand(0));
nikicUnsubmitted
Done
ReplyInline Actions

Rebase over https://github.com/llvm/llvm-project/commit/0ecef88cb167dbd19023a932e7abac09059c3e4e?

nikic: Rebase over https://github.com/llvm/llvm-project/commit/0ecef88cb167dbd19023a932e7abac09059c3e4…
fhahnAuthorUnsubmitted
Done
ReplyInline Actions

Done!

fhahn: Done!
if (!StoredConst)
return true;
// Don't consider stores that only write the initializer value.
if (Constant *Result = ConstantFoldLoadFromConst(
GV->getInitializer(), StoredConst->getType(), Offset, DL))
return Result != StoredConst;
nikicUnsubmitted
Done
ReplyInline Actions

Shouldn't we be comparing with the initializer at the specific offset?

nikic: Shouldn't we be comparing with the initializer at the specific offset?
fhahnAuthorUnsubmitted
Done
ReplyInline Actions

Yeah, I updated the code to use ConstantFoldLoadFromConst

fhahn: Yeah, I updated the code to use ConstantFoldLoadFromConst
nikicUnsubmitted
Done
ReplyInline Actions

Why can't this reuse the offset calculation from above?

nikic: Why can't this reuse the offset calculation from above?
fhahnAuthorUnsubmitted
Done
ReplyInline Actions

Missed that, should be updated now, thanks!

fhahn: Missed that, should be updated now, thanks!
return true;
};
It->second.IsLoaded |= isa<LoadInst>(V); It->second.IsLoaded |= isa<LoadInst>(V);
It->second.IsStored |= isa<StoreInst>(V); It->second.IsStored |= IsStored(V);
continue; continue;
} }
// Ignore dead constant users. // Ignore dead constant users.
if (auto *C = dyn_cast<Constant>(V)) { if (auto *C = dyn_cast<Constant>(V)) {
if (!isSafeToDestroyConstant(C)) if (!isSafeToDestroyConstant(C))
return false; return false;
continue; continue;
▲ Show 20 Lines • Show All 2,108 Lines • Show Last 20 Lines

llvm/test/Transforms/GlobalOpt/sra-many-stores-initializers.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --check-globals
; RUN: opt -passes=globalopt -S %s | FileCheck %s ; RUN: opt -passes=globalopt -S %s | FileCheck %s
%struct.20ptr = type { ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr } %struct.20ptr = type { ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr }
@global.20ptr = internal global %struct.20ptr zeroinitializer @global.20ptr = internal global %struct.20ptr zeroinitializer
@c = global ptr null @c = global ptr null
;. ;.
; CHECK: @[[GLOBAL_20PTR:[a-zA-Z0-9_$"\\.-]+]] = internal unnamed_addr global [[STRUCT_20PTR:%.*]] zeroinitializer
; CHECK: @[[C:[a-zA-Z0-9_$"\\.-]+]] = global ptr null ; CHECK: @[[C:[a-zA-Z0-9_$"\\.-]+]] = global ptr null
; CHECK: @[[GLOBAL_20PTR_2:[a-zA-Z0-9_$"\\.-]+]] = internal unnamed_addr global [[STRUCT_20PTR:%.*]] { ptr null, ptr null, ptr null, ptr null, ptr null, ptr null, ptr null, ptr null, ptr null, ptr null, ptr null, ptr null, ptr null, ptr null, ptr null, ptr null, ptr null, ptr null, ptr null, ptr @c }
; CHECK: @[[GLOBAL_20PTR_3:[a-zA-Z0-9_$"\\.-]+]] = internal unnamed_addr global [[STRUCT_20PTR:%.*]] { ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr null, ptr null, ptr null, ptr @c } ; CHECK: @[[GLOBAL_20PTR_3:[a-zA-Z0-9_$"\\.-]+]] = internal unnamed_addr global [[STRUCT_20PTR:%.*]] { ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr null, ptr null, ptr null, ptr @c }
; CHECK: @[[GLOBAL_20PTR_4:[a-zA-Z0-9_$"\\.-]+]] = internal unnamed_addr global [[STRUCT_20PTR:%.*]] { ptr null, ptr null, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr null, ptr null, ptr null, ptr @c } ; CHECK: @[[GLOBAL_20PTR_4_16:[a-zA-Z0-9_$"\\.-]+]] = internal unnamed_addr global ptr null
;. ;.
define void @store_initializer() { define void @store_initializer() {
; CHECK-LABEL: @store_initializer( ; CHECK-LABEL: @store_initializer(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: store ptr null, ptr @global.20ptr, align 8 ; CHECK-NEXT: store volatile ptr null, ptr @c, align 8
; CHECK-NEXT: store ptr null, ptr getelementptr inbounds ([[STRUCT_20PTR:%.*]], ptr @global.20ptr, i64 0, i32 1), align 8 ; CHECK-NEXT: store volatile ptr null, ptr @c, align 8
; CHECK-NEXT: store ptr null, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr, i64 0, i32 2), align 8 ; CHECK-NEXT: store volatile ptr null, ptr @c, align 8
; CHECK-NEXT: store ptr null, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr, i64 0, i32 3), align 8 ; CHECK-NEXT: store volatile ptr null, ptr @c, align 8
; CHECK-NEXT: store ptr null, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr, i64 0, i32 4), align 8 ; CHECK-NEXT: store volatile ptr null, ptr @c, align 8
; CHECK-NEXT: store ptr null, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr, i64 0, i32 5), align 8 ; CHECK-NEXT: store volatile ptr null, ptr @c, align 8
; CHECK-NEXT: store ptr null, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr, i64 0, i32 6), align 8 ; CHECK-NEXT: store volatile ptr null, ptr @c, align 8
; CHECK-NEXT: store ptr null, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr, i64 0, i32 7), align 8 ; CHECK-NEXT: store volatile ptr null, ptr @c, align 8
; CHECK-NEXT: store ptr null, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr, i64 0, i32 8), align 8 ; CHECK-NEXT: store volatile ptr null, ptr @c, align 8
; CHECK-NEXT: store ptr null, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr, i64 0, i32 9), align 8 ; CHECK-NEXT: store volatile ptr null, ptr @c, align 8
; CHECK-NEXT: store ptr null, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr, i64 0, i32 10), align 8 ; CHECK-NEXT: store volatile ptr null, ptr @c, align 8
; CHECK-NEXT: store ptr null, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr, i64 0, i32 11), align 8 ; CHECK-NEXT: store volatile ptr null, ptr @c, align 8
; CHECK-NEXT: store ptr null, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr, i64 0, i32 12), align 8 ; CHECK-NEXT: store volatile ptr null, ptr @c, align 8
; CHECK-NEXT: store ptr null, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr, i64 0, i32 13), align 8 ; CHECK-NEXT: store volatile ptr null, ptr @c, align 8
; CHECK-NEXT: store ptr null, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr, i64 0, i32 14), align 8 ; CHECK-NEXT: store volatile ptr null, ptr @c, align 8
; CHECK-NEXT: store ptr null, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr, i64 0, i32 15), align 8 ; CHECK-NEXT: store volatile ptr null, ptr @c, align 8
; CHECK-NEXT: store ptr null, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr, i64 0, i32 16), align 8 ; CHECK-NEXT: store volatile ptr null, ptr @c, align 8
; CHECK-NEXT: [[L0:%.*]] = load ptr, ptr @global.20ptr, align 8
; CHECK-NEXT: store volatile ptr [[L0]], ptr @c, align 8
; CHECK-NEXT: [[L1:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr, i64 0, i32 1), align 8
; CHECK-NEXT: store volatile ptr [[L1]], ptr @c, align 8
; CHECK-NEXT: [[L2:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr, i64 0, i32 2), align 8
; CHECK-NEXT: store volatile ptr [[L2]], ptr @c, align 8
; CHECK-NEXT: [[L3:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr, i64 0, i32 3), align 8
; CHECK-NEXT: store volatile ptr [[L3]], ptr @c, align 8
; CHECK-NEXT: [[L4:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr, i64 0, i32 4), align 8
; CHECK-NEXT: store volatile ptr [[L4]], ptr @c, align 8
; CHECK-NEXT: [[L5:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr, i64 0, i32 5), align 8
; CHECK-NEXT: store volatile ptr [[L5]], ptr @c, align 8
; CHECK-NEXT: [[L6:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr, i64 0, i32 6), align 8
; CHECK-NEXT: store volatile ptr [[L6]], ptr @c, align 8
; CHECK-NEXT: [[L7:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr, i64 0, i32 7), align 8
; CHECK-NEXT: store volatile ptr [[L7]], ptr @c, align 8
; CHECK-NEXT: [[L8:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr, i64 0, i32 8), align 8
; CHECK-NEXT: store volatile ptr [[L8]], ptr @c, align 8
; CHECK-NEXT: [[L9:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr, i64 0, i32 9), align 8
; CHECK-NEXT: store volatile ptr [[L9]], ptr @c, align 8
; CHECK-NEXT: [[L10:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr, i64 0, i32 10), align 8
; CHECK-NEXT: store volatile ptr [[L10]], ptr @c, align 8
; CHECK-NEXT: [[L11:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr, i64 0, i32 11), align 8
; CHECK-NEXT: store volatile ptr [[L11]], ptr @c, align 8
; CHECK-NEXT: [[L12:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr, i64 0, i32 12), align 8
; CHECK-NEXT: store volatile ptr [[L12]], ptr @c, align 8
; CHECK-NEXT: [[L13:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr, i64 0, i32 13), align 8
; CHECK-NEXT: store volatile ptr [[L13]], ptr @c, align 8
; CHECK-NEXT: [[L14:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr, i64 0, i32 14), align 8
; CHECK-NEXT: store volatile ptr [[L14]], ptr @c, align 8
; CHECK-NEXT: [[L15:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr, i64 0, i32 15), align 8
; CHECK-NEXT: store volatile ptr [[L15]], ptr @c, align 8
; CHECK-NEXT: [[L16:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr, i64 0, i32 16), align 8
; CHECK-NEXT: store volatile ptr [[L16]], ptr @c, align 8
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
entry: entry:
store ptr null, ptr getelementptr inbounds (%struct.20ptr, ptr @global.20ptr, i64 0, i32 0), align 8 store ptr null, ptr getelementptr inbounds (%struct.20ptr, ptr @global.20ptr, i64 0, i32 0), align 8
store ptr null, ptr getelementptr inbounds (%struct.20ptr, ptr @global.20ptr, i64 0, i32 1), align 8 store ptr null, ptr getelementptr inbounds (%struct.20ptr, ptr @global.20ptr, i64 0, i32 1), align 8
store ptr null, ptr getelementptr inbounds (%struct.20ptr, ptr @global.20ptr, i64 0, i32 2), align 8 store ptr null, ptr getelementptr inbounds (%struct.20ptr, ptr @global.20ptr, i64 0, i32 2), align 8
store ptr null, ptr getelementptr inbounds (%struct.20ptr, ptr @global.20ptr, i64 0, i32 3), align 8 store ptr null, ptr getelementptr inbounds (%struct.20ptr, ptr @global.20ptr, i64 0, i32 3), align 8
store ptr null, ptr getelementptr inbounds (%struct.20ptr, ptr @global.20ptr, i64 0, i32 4), align 8 store ptr null, ptr getelementptr inbounds (%struct.20ptr, ptr @global.20ptr, i64 0, i32 4), align 8
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Lines
; Global with initializer where some elements in the initializer are not null. ; Global with initializer where some elements in the initializer are not null.
@global.20ptr.2 = internal global %struct.20ptr { ptr null, ptr null, ptr null, ptr null, ptr null, ptr null, ptr null, ptr null, ptr null, ptr null, ptr null, ptr null, ptr null, ptr null, ptr null, ptr null, ptr null, ptr null, ptr null, ptr @c } @global.20ptr.2 = internal global %struct.20ptr { ptr null, ptr null, ptr null, ptr null, ptr null, ptr null, ptr null, ptr null, ptr null, ptr null, ptr null, ptr null, ptr null, ptr null, ptr null, ptr null, ptr null, ptr null, ptr null, ptr @c }
define void @store_null_initializer_2() { define void @store_null_initializer_2() {
; CHECK-LABEL: @store_null_initializer_2( ; CHECK-LABEL: @store_null_initializer_2(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: store ptr null, ptr @global.20ptr.2, align 8 ; CHECK-NEXT: store volatile ptr null, ptr @c, align 8
; CHECK-NEXT: store ptr null, ptr getelementptr inbounds ([[STRUCT_20PTR:%.*]], ptr @global.20ptr.2, i64 0, i32 1), align 8 ; CHECK-NEXT: store volatile ptr null, ptr @c, align 8
; CHECK-NEXT: store ptr null, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.2, i64 0, i32 2), align 8 ; CHECK-NEXT: store volatile ptr null, ptr @c, align 8
; CHECK-NEXT: store ptr null, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.2, i64 0, i32 3), align 8 ; CHECK-NEXT: store volatile ptr null, ptr @c, align 8
; CHECK-NEXT: store ptr null, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.2, i64 0, i32 4), align 8 ; CHECK-NEXT: store volatile ptr null, ptr @c, align 8
; CHECK-NEXT: store ptr null, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.2, i64 0, i32 5), align 8 ; CHECK-NEXT: store volatile ptr null, ptr @c, align 8
; CHECK-NEXT: store ptr null, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.2, i64 0, i32 6), align 8 ; CHECK-NEXT: store volatile ptr null, ptr @c, align 8
; CHECK-NEXT: store ptr null, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.2, i64 0, i32 7), align 8 ; CHECK-NEXT: store volatile ptr null, ptr @c, align 8
; CHECK-NEXT: store ptr null, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.2, i64 0, i32 8), align 8 ; CHECK-NEXT: store volatile ptr null, ptr @c, align 8
; CHECK-NEXT: store ptr null, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.2, i64 0, i32 9), align 8 ; CHECK-NEXT: store volatile ptr null, ptr @c, align 8
; CHECK-NEXT: store ptr null, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.2, i64 0, i32 10), align 8 ; CHECK-NEXT: store volatile ptr null, ptr @c, align 8
; CHECK-NEXT: store ptr null, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.2, i64 0, i32 11), align 8 ; CHECK-NEXT: store volatile ptr null, ptr @c, align 8
; CHECK-NEXT: store ptr null, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.2, i64 0, i32 12), align 8 ; CHECK-NEXT: store volatile ptr null, ptr @c, align 8
; CHECK-NEXT: store ptr null, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.2, i64 0, i32 13), align 8 ; CHECK-NEXT: store volatile ptr null, ptr @c, align 8
; CHECK-NEXT: store ptr null, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.2, i64 0, i32 14), align 8 ; CHECK-NEXT: store volatile ptr null, ptr @c, align 8
; CHECK-NEXT: store ptr null, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.2, i64 0, i32 15), align 8 ; CHECK-NEXT: store volatile ptr null, ptr @c, align 8
; CHECK-NEXT: store ptr null, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.2, i64 0, i32 16), align 8 ; CHECK-NEXT: store volatile ptr null, ptr @c, align 8
; CHECK-NEXT: store ptr null, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.2, i64 0, i32 19), align 8 ; CHECK-NEXT: store volatile ptr null, ptr @c, align 8
; CHECK-NEXT: [[L0:%.*]] = load ptr, ptr @global.20ptr.2, align 8
; CHECK-NEXT: store volatile ptr [[L0]], ptr @c, align 8
; CHECK-NEXT: [[L1:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.2, i64 0, i32 1), align 8
; CHECK-NEXT: store volatile ptr [[L1]], ptr @c, align 8
; CHECK-NEXT: [[L2:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.2, i64 0, i32 2), align 8
; CHECK-NEXT: store volatile ptr [[L2]], ptr @c, align 8
; CHECK-NEXT: [[L3:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.2, i64 0, i32 3), align 8
; CHECK-NEXT: store volatile ptr [[L3]], ptr @c, align 8
; CHECK-NEXT: [[L4:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.2, i64 0, i32 4), align 8
; CHECK-NEXT: store volatile ptr [[L4]], ptr @c, align 8
; CHECK-NEXT: [[L5:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.2, i64 0, i32 5), align 8
; CHECK-NEXT: store volatile ptr [[L5]], ptr @c, align 8
; CHECK-NEXT: [[L6:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.2, i64 0, i32 6), align 8
; CHECK-NEXT: store volatile ptr [[L6]], ptr @c, align 8
; CHECK-NEXT: [[L7:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.2, i64 0, i32 7), align 8
; CHECK-NEXT: store volatile ptr [[L7]], ptr @c, align 8
; CHECK-NEXT: [[L8:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.2, i64 0, i32 8), align 8
; CHECK-NEXT: store volatile ptr [[L8]], ptr @c, align 8
; CHECK-NEXT: [[L9:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.2, i64 0, i32 9), align 8
; CHECK-NEXT: store volatile ptr [[L9]], ptr @c, align 8
; CHECK-NEXT: [[L10:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.2, i64 0, i32 10), align 8
; CHECK-NEXT: store volatile ptr [[L10]], ptr @c, align 8
; CHECK-NEXT: [[L11:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.2, i64 0, i32 11), align 8
; CHECK-NEXT: store volatile ptr [[L11]], ptr @c, align 8
; CHECK-NEXT: [[L12:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.2, i64 0, i32 12), align 8
; CHECK-NEXT: store volatile ptr [[L12]], ptr @c, align 8
; CHECK-NEXT: [[L13:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.2, i64 0, i32 13), align 8
; CHECK-NEXT: store volatile ptr [[L13]], ptr @c, align 8
; CHECK-NEXT: [[L14:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.2, i64 0, i32 14), align 8
; CHECK-NEXT: store volatile ptr [[L14]], ptr @c, align 8
; CHECK-NEXT: [[L15:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.2, i64 0, i32 15), align 8
; CHECK-NEXT: store volatile ptr [[L15]], ptr @c, align 8
; CHECK-NEXT: [[L16:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.2, i64 0, i32 16), align 8
; CHECK-NEXT: store volatile ptr [[L16]], ptr @c, align 8
; CHECK-NEXT: [[L19:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.2, i64 0, i32 19), align 8
; CHECK-NEXT: store volatile ptr [[L19]], ptr @c, align 8
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
entry: entry:
store ptr null, ptr getelementptr inbounds (%struct.20ptr, ptr @global.20ptr.2, i64 0, i32 0), align 8 store ptr null, ptr getelementptr inbounds (%struct.20ptr, ptr @global.20ptr.2, i64 0, i32 0), align 8
store ptr null, ptr getelementptr inbounds (%struct.20ptr, ptr @global.20ptr.2, i64 0, i32 1), align 8 store ptr null, ptr getelementptr inbounds (%struct.20ptr, ptr @global.20ptr.2, i64 0, i32 1), align 8
store ptr null, ptr getelementptr inbounds (%struct.20ptr, ptr @global.20ptr.2, i64 0, i32 2), align 8 store ptr null, ptr getelementptr inbounds (%struct.20ptr, ptr @global.20ptr.2, i64 0, i32 2), align 8
store ptr null, ptr getelementptr inbounds (%struct.20ptr, ptr @global.20ptr.2, i64 0, i32 3), align 8 store ptr null, ptr getelementptr inbounds (%struct.20ptr, ptr @global.20ptr.2, i64 0, i32 3), align 8
store ptr null, ptr getelementptr inbounds (%struct.20ptr, ptr @global.20ptr.2, i64 0, i32 4), align 8 store ptr null, ptr getelementptr inbounds (%struct.20ptr, ptr @global.20ptr.2, i64 0, i32 4), align 8
▲ Show 20 Lines • Show All 176 Lines • ▼ Show 20 Lines
@global.20ptr.4 = internal global %struct.20ptr { ptr null, ptr null, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr null, ptr null, ptr null, ptr @c } @global.20ptr.4 = internal global %struct.20ptr { ptr null, ptr null, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr @c, ptr null, ptr null, ptr null, ptr @c }
; Stores writing a different value than the initializer. ; Stores writing a different value than the initializer.
define void @store_mixed_initializer() { define void @store_mixed_initializer() {
; CHECK-LABEL: @store_mixed_initializer( ; CHECK-LABEL: @store_mixed_initializer(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: store ptr null, ptr @global.20ptr.4, align 8 ; CHECK-NEXT: store ptr @c, ptr @global.20ptr.4.16, align 8
; CHECK-NEXT: store ptr null, ptr getelementptr inbounds ([[STRUCT_20PTR:%.*]], ptr @global.20ptr.4, i64 0, i32 1), align 8 ; CHECK-NEXT: store volatile ptr null, ptr @c, align 8
; CHECK-NEXT: store ptr @c, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 2), align 8 ; CHECK-NEXT: store volatile ptr null, ptr @c, align 8
; CHECK-NEXT: store ptr @c, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 3), align 8 ; CHECK-NEXT: store volatile ptr @c, ptr @c, align 8
; CHECK-NEXT: store ptr @c, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 4), align 8 ; CHECK-NEXT: store volatile ptr @c, ptr @c, align 8
; CHECK-NEXT: store ptr @c, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 5), align 8 ; CHECK-NEXT: store volatile ptr @c, ptr @c, align 8
; CHECK-NEXT: store ptr @c, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 6), align 8 ; CHECK-NEXT: store volatile ptr @c, ptr @c, align 8
; CHECK-NEXT: store ptr @c, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 7), align 8 ; CHECK-NEXT: store volatile ptr @c, ptr @c, align 8
; CHECK-NEXT: store ptr @c, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 8), align 8 ; CHECK-NEXT: store volatile ptr @c, ptr @c, align 8
; CHECK-NEXT: store ptr @c, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 9), align 8 ; CHECK-NEXT: store volatile ptr @c, ptr @c, align 8
; CHECK-NEXT: store ptr @c, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 10), align 8 ; CHECK-NEXT: store volatile ptr @c, ptr @c, align 8
; CHECK-NEXT: store ptr @c, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 11), align 8 ; CHECK-NEXT: store volatile ptr @c, ptr @c, align 8
; CHECK-NEXT: store ptr @c, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 12), align 8 ; CHECK-NEXT: store volatile ptr @c, ptr @c, align 8
; CHECK-NEXT: store ptr @c, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 13), align 8 ; CHECK-NEXT: store volatile ptr @c, ptr @c, align 8
; CHECK-NEXT: store ptr @c, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 14), align 8 ; CHECK-NEXT: store volatile ptr @c, ptr @c, align 8
; CHECK-NEXT: store ptr @c, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 15), align 8 ; CHECK-NEXT: store volatile ptr @c, ptr @c, align 8
; CHECK-NEXT: store ptr @c, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 16), align 8 ; CHECK-NEXT: store volatile ptr @c, ptr @c, align 8
; CHECK-NEXT: [[L0:%.*]] = load ptr, ptr @global.20ptr.4, align 8 ; CHECK-NEXT: [[L16:%.*]] = load ptr, ptr @global.20ptr.4.16, align 8
; CHECK-NEXT: store volatile ptr [[L0]], ptr @c, align 8
; CHECK-NEXT: [[L1:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 1), align 8
; CHECK-NEXT: store volatile ptr [[L1]], ptr @c, align 8
; CHECK-NEXT: [[L2:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 2), align 8
; CHECK-NEXT: store volatile ptr [[L2]], ptr @c, align 8
; CHECK-NEXT: [[L3:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 3), align 8
; CHECK-NEXT: store volatile ptr [[L3]], ptr @c, align 8
; CHECK-NEXT: [[L4:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 4), align 8
; CHECK-NEXT: store volatile ptr [[L4]], ptr @c, align 8
; CHECK-NEXT: [[L5:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 5), align 8
; CHECK-NEXT: store volatile ptr [[L5]], ptr @c, align 8
; CHECK-NEXT: [[L6:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 6), align 8
; CHECK-NEXT: store volatile ptr [[L6]], ptr @c, align 8
; CHECK-NEXT: [[L7:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 7), align 8
; CHECK-NEXT: store volatile ptr [[L7]], ptr @c, align 8
; CHECK-NEXT: [[L8:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 8), align 8
; CHECK-NEXT: store volatile ptr [[L8]], ptr @c, align 8
; CHECK-NEXT: [[L9:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 9), align 8
; CHECK-NEXT: store volatile ptr [[L9]], ptr @c, align 8
; CHECK-NEXT: [[L10:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 10), align 8
; CHECK-NEXT: store volatile ptr [[L10]], ptr @c, align 8
; CHECK-NEXT: [[L11:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 11), align 8
; CHECK-NEXT: store volatile ptr [[L11]], ptr @c, align 8
; CHECK-NEXT: [[L12:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 12), align 8
; CHECK-NEXT: store volatile ptr [[L12]], ptr @c, align 8
; CHECK-NEXT: [[L13:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 13), align 8
; CHECK-NEXT: store volatile ptr [[L13]], ptr @c, align 8
; CHECK-NEXT: [[L14:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 14), align 8
; CHECK-NEXT: store volatile ptr [[L14]], ptr @c, align 8
; CHECK-NEXT: [[L15:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 15), align 8
; CHECK-NEXT: store volatile ptr [[L15]], ptr @c, align 8
; CHECK-NEXT: [[L16:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 16), align 8
; CHECK-NEXT: store volatile ptr [[L16]], ptr @c, align 8 ; CHECK-NEXT: store volatile ptr [[L16]], ptr @c, align 8
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
entry: entry:
store ptr null, ptr getelementptr inbounds (%struct.20ptr, ptr @global.20ptr.4, i64 0, i32 0), align 8 store ptr null, ptr getelementptr inbounds (%struct.20ptr, ptr @global.20ptr.4, i64 0, i32 0), align 8
store ptr null, ptr getelementptr inbounds (%struct.20ptr, ptr @global.20ptr.4, i64 0, i32 1), align 8 store ptr null, ptr getelementptr inbounds (%struct.20ptr, ptr @global.20ptr.4, i64 0, i32 1), align 8
store ptr @c, ptr getelementptr inbounds (%struct.20ptr, ptr @global.20ptr.4, i64 0, i32 2), align 8 store ptr @c, ptr getelementptr inbounds (%struct.20ptr, ptr @global.20ptr.4, i64 0, i32 2), align 8
store ptr @c, ptr getelementptr inbounds (%struct.20ptr, ptr @global.20ptr.4, i64 0, i32 3), align 8 store ptr @c, ptr getelementptr inbounds (%struct.20ptr, ptr @global.20ptr.4, i64 0, i32 3), align 8
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Linesentry:
ret void ret void
} }
; Same as @store_mixed_initializer, but the GEP constant expressions are not ; Same as @store_mixed_initializer, but the GEP constant expressions are not
; inbounds. ; inbounds.
define void @store_mixed_initializer_geps_without_inbounds() { define void @store_mixed_initializer_geps_without_inbounds() {
; CHECK-LABEL: @store_mixed_initializer_geps_without_inbounds( ; CHECK-LABEL: @store_mixed_initializer_geps_without_inbounds(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: store ptr null, ptr @global.20ptr.4, align 8 ; CHECK-NEXT: store ptr @c, ptr @global.20ptr.4.16, align 8
; CHECK-NEXT: store ptr null, ptr getelementptr inbounds ([[STRUCT_20PTR:%.*]], ptr @global.20ptr.4, i64 0, i32 1), align 8 ; CHECK-NEXT: store volatile ptr null, ptr @c, align 8
; CHECK-NEXT: store ptr @c, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 2), align 8 ; CHECK-NEXT: store volatile ptr null, ptr @c, align 8
; CHECK-NEXT: store ptr @c, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 3), align 8 ; CHECK-NEXT: store volatile ptr @c, ptr @c, align 8
; CHECK-NEXT: store ptr @c, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 4), align 8 ; CHECK-NEXT: store volatile ptr @c, ptr @c, align 8
; CHECK-NEXT: store ptr @c, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 5), align 8 ; CHECK-NEXT: store volatile ptr @c, ptr @c, align 8
; CHECK-NEXT: store ptr @c, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 6), align 8 ; CHECK-NEXT: store volatile ptr @c, ptr @c, align 8
; CHECK-NEXT: store ptr @c, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 7), align 8 ; CHECK-NEXT: store volatile ptr @c, ptr @c, align 8
; CHECK-NEXT: store ptr @c, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 8), align 8 ; CHECK-NEXT: store volatile ptr @c, ptr @c, align 8
; CHECK-NEXT: store ptr @c, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 9), align 8 ; CHECK-NEXT: store volatile ptr @c, ptr @c, align 8
; CHECK-NEXT: store ptr @c, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 10), align 8 ; CHECK-NEXT: store volatile ptr @c, ptr @c, align 8
; CHECK-NEXT: store ptr @c, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 11), align 8 ; CHECK-NEXT: store volatile ptr @c, ptr @c, align 8
; CHECK-NEXT: store ptr @c, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 12), align 8 ; CHECK-NEXT: store volatile ptr @c, ptr @c, align 8
; CHECK-NEXT: store ptr @c, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 13), align 8 ; CHECK-NEXT: store volatile ptr @c, ptr @c, align 8
; CHECK-NEXT: store ptr @c, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 14), align 8 ; CHECK-NEXT: store volatile ptr @c, ptr @c, align 8
; CHECK-NEXT: store ptr @c, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 15), align 8 ; CHECK-NEXT: store volatile ptr @c, ptr @c, align 8
; CHECK-NEXT: store ptr @c, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 16), align 8 ; CHECK-NEXT: store volatile ptr @c, ptr @c, align 8
; CHECK-NEXT: [[L0:%.*]] = load ptr, ptr @global.20ptr.4, align 8 ; CHECK-NEXT: [[L16:%.*]] = load ptr, ptr @global.20ptr.4.16, align 8
; CHECK-NEXT: store volatile ptr [[L0]], ptr @c, align 8
; CHECK-NEXT: [[L1:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 1), align 8
; CHECK-NEXT: store volatile ptr [[L1]], ptr @c, align 8
; CHECK-NEXT: [[L2:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 2), align 8
; CHECK-NEXT: store volatile ptr [[L2]], ptr @c, align 8
; CHECK-NEXT: [[L3:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 3), align 8
; CHECK-NEXT: store volatile ptr [[L3]], ptr @c, align 8
; CHECK-NEXT: [[L4:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 4), align 8
; CHECK-NEXT: store volatile ptr [[L4]], ptr @c, align 8
; CHECK-NEXT: [[L5:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 5), align 8
; CHECK-NEXT: store volatile ptr [[L5]], ptr @c, align 8
; CHECK-NEXT: [[L6:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 6), align 8
; CHECK-NEXT: store volatile ptr [[L6]], ptr @c, align 8
; CHECK-NEXT: [[L7:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 7), align 8
; CHECK-NEXT: store volatile ptr [[L7]], ptr @c, align 8
; CHECK-NEXT: [[L8:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 8), align 8
; CHECK-NEXT: store volatile ptr [[L8]], ptr @c, align 8
; CHECK-NEXT: [[L9:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 9), align 8
; CHECK-NEXT: store volatile ptr [[L9]], ptr @c, align 8
; CHECK-NEXT: [[L10:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 10), align 8
; CHECK-NEXT: store volatile ptr [[L10]], ptr @c, align 8
; CHECK-NEXT: [[L11:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 11), align 8
; CHECK-NEXT: store volatile ptr [[L11]], ptr @c, align 8
; CHECK-NEXT: [[L12:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 12), align 8
; CHECK-NEXT: store volatile ptr [[L12]], ptr @c, align 8
; CHECK-NEXT: [[L13:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 13), align 8
; CHECK-NEXT: store volatile ptr [[L13]], ptr @c, align 8
; CHECK-NEXT: [[L14:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 14), align 8
; CHECK-NEXT: store volatile ptr [[L14]], ptr @c, align 8
; CHECK-NEXT: [[L15:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 15), align 8
; CHECK-NEXT: store volatile ptr [[L15]], ptr @c, align 8
; CHECK-NEXT: [[L16:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_20PTR]], ptr @global.20ptr.4, i64 0, i32 16), align 8
; CHECK-NEXT: store volatile ptr [[L16]], ptr @c, align 8 ; CHECK-NEXT: store volatile ptr [[L16]], ptr @c, align 8
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
entry: entry:
store ptr null, ptr getelementptr (%struct.20ptr, ptr @global.20ptr.4, i64 0, i32 0), align 8 store ptr null, ptr getelementptr (%struct.20ptr, ptr @global.20ptr.4, i64 0, i32 0), align 8
store ptr null, ptr getelementptr (%struct.20ptr, ptr @global.20ptr.4, i64 0, i32 1), align 8 store ptr null, ptr getelementptr (%struct.20ptr, ptr @global.20ptr.4, i64 0, i32 1), align 8
store ptr @c, ptr getelementptr (%struct.20ptr, ptr @global.20ptr.4, i64 0, i32 2), align 8 store ptr @c, ptr getelementptr (%struct.20ptr, ptr @global.20ptr.4, i64 0, i32 2), align 8
store ptr @c, ptr getelementptr (%struct.20ptr, ptr @global.20ptr.4, i64 0, i32 3), align 8 store ptr @c, ptr getelementptr (%struct.20ptr, ptr @global.20ptr.4, i64 0, i32 3), align 8
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines