This is an archive of the discontinued LLVM Phabricator instance.

Differential D90371

[DSE] Improve partial overlap detection
ClosedPublic

Authored by ebrevnov on Oct 29 2020, 1:48 AM.

Details

Reviewers
fhahn
junbuml
hfinkel
asbirlea
Commits
rG3d31adaec443: [DSE] Improve partial overlap detection
Summary

Currently isOverwrite returns OW_MaybePartial even for accesss known not to overlap. This is not a big problem for legacy implementation (since isPartialOverwrite follows isOverwrite and clarifies the result). Contrary SSA based version does a lot of work to later find out that accesses don't overlap. Besides negative impact on compile time we quickly reach MemorySSAPartialStoreLimit and miss optimization opportunities.

Note: In fact, I think it would be cleaner implementation if isOverwrite returned fully clarified result in the first place whithout need to call isPartialOverwrite. This can be done as a follow up. What do you think?

Diff Detail

Event Timeline

ebrevnov created this revision.Oct 29 2020, 1:48 AM
Herald added a project: Restricted Project. · View Herald TranscriptOct 29 2020, 1:48 AM
Herald added subscribers: llvm-commits, asbirlea, george.burgess.iv, hiraditya. · View Herald Transcript
ebrevnov requested review of this revision.Oct 29 2020, 1:48 AM
ebrevnov edited the summary of this revision. (Show Details)Oct 29 2020, 1:52 AM
ebrevnov added reviewers: fhahn, junbuml, hfinkel.
ebrevnov mentioned this in D90095: [DSE] Enable MSSA DSE to optimize across PHIs.Oct 29 2020, 2:08 AM
Harbormaster completed remote builds in B76873: Diff 301534.Oct 29 2020, 2:27 AM
fhahn accepted this revision.Oct 29 2020, 5:01 AM

The initial split was quite crude and only re-used the existing utilities for partial store handling. Thanks for improving this! I am sure there's further potential for improvements.

LGTM!

This gives nice improvements in some cases and compile-time looks neutral to slightly positive (http://llvm-compile-time-tracker.com/compare.php?from=df63eedef64d715ce1f31843f7de9c11fe1e597f&to=e3bdfcf94a9eeae6e006d010464f0c1b3550577d&stat=instructions)

Same hash: 196 (filtered out)
Remaining: 41
Metric: dse.NumCompletePartials

Program                                        base   patch  diff
 test-suite...CI_Purple/SMG2000/smg2000.test     1.00  10.00 900.0%
 test-suite.../CINT2000/252.eon/252.eon.test    44.00 392.00 790.9%
 test-suite...rks/FreeBench/pifft/pifft.test     1.00   3.00 200.0%
 test-suite.../Benchmarks/Bullet/bullet.test    36.00  97.00 169.4%
 test-suite.../CINT2006/403.gcc/403.gcc.test     2.00   5.00 150.0%
 test-suite...tions/lambda-0.1.3/lambda.test     1.00   2.00 100.0%
 test-suite.../CINT2000/176.gcc/176.gcc.test     4.00   7.00 75.0%
 test-suite...3.xalancbmk/483.xalancbmk.test    19.00  26.00 36.8%
 test-suite...rks/tramp3d-v4/tramp3d-v4.test    37.00  50.00 35.1%
 test-suite...marks/7zip/7zip-benchmark.test    28.00  37.00 32.1%
 test-suite...yApps-C++/PENNANT/PENNANT.test     6.00   7.00 16.7%
 test-suite...006/447.dealII/447.dealII.test   405.00 423.00  4.4%
Same hash: 196 (filtered out)
Remaining: 41
Metric: dse.NumFastStores

Program                                        base    patch   diff
 test-suite...rks/FreeBench/pifft/pifft.test     1.00    3.00  200.0%
 test-suite...000/183.equake/183.equake.test     2.00    4.00  100.0%
 test-suite...langs-C/football/football.test     5.00    9.00  80.0%
 test-suite...lications/viterbi/viterbi.test     2.00    3.00  50.0%
 test-suite...hmarks/McCat/08-main/main.test    15.00   20.00  33.3%
 test-suite...arks/VersaBench/dbms/dbms.test     8.00   10.00  25.0%
 test-suite...ks/Prolangs-C++/city/city.test    24.00   27.00  12.5%
 test-suite.../CINT2000/175.vpr/175.vpr.test    11.00   12.00   9.1%
 test-suite...ce/Benchmarks/PAQ8p/paq8p.test    63.00   68.00   7.9%
 test-suite...arks/mafft/pairlocalalign.test    92.00   98.00   6.5%
 test-suite.../CINT2000/252.eon/252.eon.test   2405.00 2556.00  6.3%
 test-suite...CI_Purple/SMG2000/smg2000.test   153.00  162.00   5.9%
 test-suite.../Benchmarks/Bullet/bullet.test   1312.00 1357.00  3.4%
 test-suite.../CINT2000/176.gcc/176.gcc.test   587.00  603.00   2.7%
 test-suite...tions/lambda-0.1.3/lambda.test    44.00   45.00   2.3%
 test-suite...yApps-C++/PENNANT/PENNANT.test    46.00   47.00   2.2%
 test-suite...chmarks/MallocBench/gs/gs.test   113.00  115.00   1.8%
 test-suite...ications/JM/lencod/lencod.test   765.00  778.00   1.7%
 test-suite...rks/tramp3d-v4/tramp3d-v4.test   893.00  905.00   1.3%
 test-suite.../CINT2006/403.gcc/403.gcc.test   1204.00 1217.00  1.1%
 test-suite...marks/7zip/7zip-benchmark.test   2189.00 2209.00  0.9%
 test-suite...006/447.dealII/447.dealII.test   3013.00 3032.00  0.6%
 test-suite...3.xalancbmk/483.xalancbmk.test   1475.00 1482.00  0.5%
 test-suite...lications/ClamAV/clamscan.test   246.00  247.00   0.4%
 test-suite...006/453.povray/453.povray.test   1233.00 1237.00  0.3%
 test-suite...:: External/Povray/povray.test   1251.00 1255.00  0.3%

Note: In fact, I think it would be cleaner implementation if isOverwrite returned fully clarified result in the first place whithout need to call isPartialOverwrite. This can be done as a follow up. What do you think?

sounds good to me.

This revision is now accepted and ready to land.Oct 29 2020, 5:01 AM
fhahn added a reviewer: asbirlea.Oct 29 2020, 5:01 AM
asbirlea accepted this revision.Oct 29 2020, 4:37 PM

This LGTM.
I'd like to understand better what you mean by not calling partialOverwrite. If the functionality in that call would be included in the isOverwrite call, note that there are call-paths that would do more work than they do now, and I thought there was a previous refactoring done to avoid this.
I may be mis-understanding though, so feel free to send the additional changes and we can discuss on those.

ebrevnov added a comment.Oct 29 2020, 11:40 PM
In D90371#2363420, @asbirlea wrote:

This LGTM.
I'd like to understand better what you mean by not calling partialOverwrite. If the functionality in that call would be included in the isOverwrite call, note that there are call-paths that would do more work than they do now, and I thought there was a previous refactoring done to avoid this.

As of today isPartialOverwrite does two things. 1) Clarifies OW_MaybePartial returned by isOverwrite 2) Takes some actions if EnablePartialOverwriteTracking is true and accesses do overwrite. My suggestion to move part 1) into isOverwrite and keep second part inside isPartialOverwrite (and rename isPartialOverwrite).

I may be mis-understanding though, so feel free to send the additional changes and we can discuss on those.

This revision was landed with ongoing or failed builds.Oct 30 2020, 8:23 AM
Closed by commit rG3d31adaec443: [DSE] Improve partial overlap detection (authored by Evgeniy Brevnov <ybrevnov@azul.com>). · Explain Why
This revision was automatically updated to reflect the committed changes.
Evgeniy Brevnov <ybrevnov@azul.com> added a commit: rG3d31adaec443: [DSE] Improve partial overlap detection.

Revision Contents

PathSize
llvm/
lib/
Transforms/
Scalar/
50 lines
test/
Transforms/
DeadStoreElimination/
MSSA/
53 lines
70 lines

Diff 301906

llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp

Show First 20 Lines • Show All 495 Lines • ▼ Show 20 LinesisOverwrite(const Instruction *LaterI, const Instruction *EarlierI,
LaterOff = 0; LaterOff = 0;
const Value *BP1 = GetPointerBaseWithConstantOffset(P1, EarlierOff, DL); const Value *BP1 = GetPointerBaseWithConstantOffset(P1, EarlierOff, DL);
const Value *BP2 = GetPointerBaseWithConstantOffset(P2, LaterOff, DL); const Value *BP2 = GetPointerBaseWithConstantOffset(P2, LaterOff, DL);
// If the base pointers still differ, we have two completely different stores. // If the base pointers still differ, we have two completely different stores.
if (BP1 != BP2) if (BP1 != BP2)
return OW_Unknown; return OW_Unknown;
// The later store completely overlaps the earlier store if: // The later access completely overlaps the earlier store if and only if
// // both start and end of the earlier one is "inside" the later one:
// 1. Both start at the same offset and the later one's size is greater than // |<->|--earlier--|<->|
// or equal to the earlier one's, or // |-------later-------|
// // Accesses may overlap if and only if start of one of them is "inside"
// |--earlier--| // another one:
// |-- later --| // |<->|--earlier--|<----->|
// // |-------later-------|
// 2. The earlier store has an offset greater than the later offset, but which // OR
// still lies completely within the later store. // |----- earlier -----|
// // |<->|---later---|<----->|
// |--earlier--|
// |----- later ------|
// //
// We have to be careful here as *Off is signed while *.Size is unsigned. // We have to be careful here as *Off is signed while *.Size is unsigned.
if (EarlierOff >= LaterOff &&
LaterSize >= EarlierSize &&
uint64_t(EarlierOff - LaterOff) + EarlierSize <= LaterSize)
return OW_Complete;
// Later may overwrite earlier completely with other partial writes. // Check if the earlier access starts "not before" the later one.
if (EarlierOff >= LaterOff) {
// If the earlier access ends "not after" the later access then the earlier
// one is completely overwritten by the later one.
if (uint64_t(EarlierOff - LaterOff) + EarlierSize <= LaterSize)
return OW_Complete;
// If start of the earlier access is "before" end of the later access then
// accesses overlap.
else if ((uint64_t)(EarlierOff - LaterOff) < LaterSize)
return OW_MaybePartial;
}
// If start of the later access is "before" end of the earlier access then
// accesses overlap.
else if ((uint64_t)(LaterOff - EarlierOff) < EarlierSize) {
return OW_MaybePartial; return OW_MaybePartial;
} }
// Can reach here only if accesses are known not to overlap. There is no
// dedicated code to indicate no overlap so signal "unknown".
return OW_Unknown;
}
/// Return 'OW_Complete' if a store to the 'Later' location completely /// Return 'OW_Complete' if a store to the 'Later' location completely
/// overwrites a store to the 'Earlier' location, 'OW_End' if the end of the /// overwrites a store to the 'Earlier' location, 'OW_End' if the end of the
/// 'Earlier' location is completely overwritten by 'Later', 'OW_Begin' if the /// 'Earlier' location is completely overwritten by 'Later', 'OW_Begin' if the
/// beginning of the 'Earlier' location is overwritten by 'Later'. /// beginning of the 'Earlier' location is overwritten by 'Later'.
/// 'OW_PartialEarlierWithFullLater' means that an earlier (big) store was /// 'OW_PartialEarlierWithFullLater' means that an earlier (big) store was
/// overwritten by a latter (smaller) store which doesn't write outside the big /// overwritten by a latter (smaller) store which doesn't write outside the big
/// store's memory locations. Returns 'OW_Unknown' if nothing can be determined. /// store's memory locations. Returns 'OW_Unknown' if nothing can be determined.
/// NOTE: This function must only be called if both \p Later and \p Earlier /// NOTE: This function must only be called if both \p Later and \p Earlier
▲ Show 20 Lines • Show All 2,234 Lines • Show Last 20 Lines

llvm/test/Transforms/DeadStoreElimination/MSSA/combined-partial-overwrites.ll

; 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 -dse -enable-dse-partial-store-merging=false < %s | FileCheck --check-prefixes=CHECK,DEFAULT-LIMIT %s ; RUN: opt -S -dse -enable-dse-partial-store-merging=false < %s | FileCheck --check-prefixes=CHECK %s
; RUN: opt -S -dse -enable-dse-partial-store-merging=false -dse-memoryssa-partial-store-limit=10 < %s | FileCheck --check-prefixes=CHECK,LARGER-LIMIT %s
target datalayout = "E-m:e-i64:64-n32:64" target datalayout = "E-m:e-i64:64-n32:64"
target triple = "powerpc64le-unknown-linux" target triple = "powerpc64le-unknown-linux"
%"struct.std::complex" = type { { float, float } } %"struct.std::complex" = type { { float, float } }
define void @_Z4testSt7complexIfE(%"struct.std::complex"* noalias nocapture sret %agg.result, i64 %c.coerce) { define void @_Z4testSt7complexIfE(%"struct.std::complex"* noalias nocapture sret %agg.result, i64 %c.coerce) {
; CHECK-LABEL: @_Z4testSt7complexIfE( ; CHECK-LABEL: @_Z4testSt7complexIfE(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
▲ Show 20 Lines • Show All 196 Lines • ▼ Show 20 Lines
} }
declare void @llvm.memset.p0i8.i64(i8* nocapture, i8, i64, i1) declare void @llvm.memset.p0i8.i64(i8* nocapture, i8, i64, i1)
declare void @goFunc(%struct.foostruct*) declare void @goFunc(%struct.foostruct*)
declare i32 @fa(i8*, i8**, i32, i8, i8*) declare i32 @fa(i8*, i8**, i32, i8, i8*)
; We miss this case, because of an aggressive limit of partial overlap analysis. ; We miss this case, because of an aggressive limit of partial overlap analysis.
; With a larger partial store limit, we remove the memset. ; With a larger partial store limit, we remove the memset.
define void @test4() { define void @test4() {
; DEFAULT-LIMIT-LABEL: @test4( ; CHECK-LABEL: @test4(
; DEFAULT-LIMIT-NEXT: entry: ; CHECK-NEXT: entry:
; DEFAULT-LIMIT-NEXT: [[BANG:%.*]] = alloca [[STRUCT_FOOSTRUCT:%.*]], align 8 ; CHECK-NEXT: [[BANG:%.*]] = alloca [[STRUCT_FOOSTRUCT:%.*]], align 8
; DEFAULT-LIMIT-NEXT: [[V1:%.*]] = bitcast %struct.foostruct* [[BANG]] to i8* ; CHECK-NEXT: [[V2:%.*]] = getelementptr inbounds [[STRUCT_FOOSTRUCT]], %struct.foostruct* [[BANG]], i64 0, i32 0
; DEFAULT-LIMIT-NEXT: [[TMP0:%.*]] = getelementptr inbounds i8, i8* [[V1]], i64 32 ; CHECK-NEXT: store i32 (i8*, i8**, i32, i8, i8*)* @fa, i32 (i8*, i8**, i32, i8, i8*)** [[V2]], align 8
; DEFAULT-LIMIT-NEXT: call void @llvm.memset.p0i8.i64(i8* align 8 [[TMP0]], i8 0, i64 8, i1 false) ; CHECK-NEXT: [[V3:%.*]] = getelementptr inbounds [[STRUCT_FOOSTRUCT]], %struct.foostruct* [[BANG]], i64 0, i32 1
; DEFAULT-LIMIT-NEXT: [[V2:%.*]] = getelementptr inbounds [[STRUCT_FOOSTRUCT]], %struct.foostruct* [[BANG]], i64 0, i32 0 ; CHECK-NEXT: store i32 (i8*, i8**, i32, i8, i8*)* @fa, i32 (i8*, i8**, i32, i8, i8*)** [[V3]], align 8
; DEFAULT-LIMIT-NEXT: store i32 (i8*, i8**, i32, i8, i8*)* @fa, i32 (i8*, i8**, i32, i8, i8*)** [[V2]], align 8 ; CHECK-NEXT: [[V4:%.*]] = getelementptr inbounds [[STRUCT_FOOSTRUCT]], %struct.foostruct* [[BANG]], i64 0, i32 2
; DEFAULT-LIMIT-NEXT: [[V3:%.*]] = getelementptr inbounds [[STRUCT_FOOSTRUCT]], %struct.foostruct* [[BANG]], i64 0, i32 1 ; CHECK-NEXT: store i32 (i8*, i8**, i32, i8, i8*)* @fa, i32 (i8*, i8**, i32, i8, i8*)** [[V4]], align 8
; DEFAULT-LIMIT-NEXT: store i32 (i8*, i8**, i32, i8, i8*)* @fa, i32 (i8*, i8**, i32, i8, i8*)** [[V3]], align 8 ; CHECK-NEXT: [[V5:%.*]] = getelementptr inbounds [[STRUCT_FOOSTRUCT]], %struct.foostruct* [[BANG]], i64 0, i32 3
; DEFAULT-LIMIT-NEXT: [[V4:%.*]] = getelementptr inbounds [[STRUCT_FOOSTRUCT]], %struct.foostruct* [[BANG]], i64 0, i32 2 ; CHECK-NEXT: store i32 (i8*, i8**, i32, i8, i8*)* @fa, i32 (i8*, i8**, i32, i8, i8*)** [[V5]], align 8
; DEFAULT-LIMIT-NEXT: store i32 (i8*, i8**, i32, i8, i8*)* @fa, i32 (i8*, i8**, i32, i8, i8*)** [[V4]], align 8 ; CHECK-NEXT: [[V6:%.*]] = getelementptr inbounds [[STRUCT_FOOSTRUCT]], %struct.foostruct* [[BANG]], i64 0, i32 4
; DEFAULT-LIMIT-NEXT: [[V5:%.*]] = getelementptr inbounds [[STRUCT_FOOSTRUCT]], %struct.foostruct* [[BANG]], i64 0, i32 3 ; CHECK-NEXT: store void (i8*, i32, i32)* null, void (i8*, i32, i32)** [[V6]], align 8
; DEFAULT-LIMIT-NEXT: store i32 (i8*, i8**, i32, i8, i8*)* @fa, i32 (i8*, i8**, i32, i8, i8*)** [[V5]], align 8 ; CHECK-NEXT: call void @goFunc(%struct.foostruct* [[BANG]])
; DEFAULT-LIMIT-NEXT: [[V6:%.*]] = getelementptr inbounds [[STRUCT_FOOSTRUCT]], %struct.foostruct* [[BANG]], i64 0, i32 4 ; CHECK-NEXT: ret void
; DEFAULT-LIMIT-NEXT: store void (i8*, i32, i32)* null, void (i8*, i32, i32)** [[V6]], align 8
; DEFAULT-LIMIT-NEXT: call void @goFunc(%struct.foostruct* [[BANG]])
; DEFAULT-LIMIT-NEXT: ret void
;
; LARGER-LIMIT-LABEL: @test4(
; LARGER-LIMIT-NEXT: entry:
; LARGER-LIMIT-NEXT: [[BANG:%.*]] = alloca [[STRUCT_FOOSTRUCT:%.*]], align 8
; LARGER-LIMIT-NEXT: [[V2:%.*]] = getelementptr inbounds [[STRUCT_FOOSTRUCT]], %struct.foostruct* [[BANG]], i64 0, i32 0
; LARGER-LIMIT-NEXT: store i32 (i8*, i8**, i32, i8, i8*)* @fa, i32 (i8*, i8**, i32, i8, i8*)** [[V2]], align 8
; LARGER-LIMIT-NEXT: [[V3:%.*]] = getelementptr inbounds [[STRUCT_FOOSTRUCT]], %struct.foostruct* [[BANG]], i64 0, i32 1
; LARGER-LIMIT-NEXT: store i32 (i8*, i8**, i32, i8, i8*)* @fa, i32 (i8*, i8**, i32, i8, i8*)** [[V3]], align 8
; LARGER-LIMIT-NEXT: [[V4:%.*]] = getelementptr inbounds [[STRUCT_FOOSTRUCT]], %struct.foostruct* [[BANG]], i64 0, i32 2
; LARGER-LIMIT-NEXT: store i32 (i8*, i8**, i32, i8, i8*)* @fa, i32 (i8*, i8**, i32, i8, i8*)** [[V4]], align 8
; LARGER-LIMIT-NEXT: [[V5:%.*]] = getelementptr inbounds [[STRUCT_FOOSTRUCT]], %struct.foostruct* [[BANG]], i64 0, i32 3
; LARGER-LIMIT-NEXT: store i32 (i8*, i8**, i32, i8, i8*)* @fa, i32 (i8*, i8**, i32, i8, i8*)** [[V5]], align 8
; LARGER-LIMIT-NEXT: [[V6:%.*]] = getelementptr inbounds [[STRUCT_FOOSTRUCT]], %struct.foostruct* [[BANG]], i64 0, i32 4
; LARGER-LIMIT-NEXT: store void (i8*, i32, i32)* null, void (i8*, i32, i32)** [[V6]], align 8
; LARGER-LIMIT-NEXT: call void @goFunc(%struct.foostruct* [[BANG]])
; LARGER-LIMIT-NEXT: ret void
;
entry: entry:
%bang = alloca %struct.foostruct, align 8 %bang = alloca %struct.foostruct, align 8
%v1 = bitcast %struct.foostruct* %bang to i8* %v1 = bitcast %struct.foostruct* %bang to i8*
call void @llvm.memset.p0i8.i64(i8* align 8 %v1, i8 0, i64 40, i1 false) call void @llvm.memset.p0i8.i64(i8* align 8 %v1, i8 0, i64 40, i1 false)
%v2 = getelementptr inbounds %struct.foostruct, %struct.foostruct* %bang, i64 0, i32 0 %v2 = getelementptr inbounds %struct.foostruct, %struct.foostruct* %bang, i64 0, i32 0
store i32 (i8*, i8**, i32, i8, i8*)* @fa, i32 (i8*, i8**, i32, i8, i8*)** %v2, align 8 store i32 (i8*, i8**, i32, i8, i8*)* @fa, i32 (i8*, i8**, i32, i8, i8*)** %v2, align 8
%v3 = getelementptr inbounds %struct.foostruct, %struct.foostruct* %bang, i64 0, i32 1 %v3 = getelementptr inbounds %struct.foostruct, %struct.foostruct* %bang, i64 0, i32 1
▲ Show 20 Lines • Show All 105 Lines • Show Last 20 Lines

llvm/test/Transforms/DeadStoreElimination/MSSA/multiblock-overlap.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -dse %s -S | FileCheck --check-prefixes=CHECK,DEFAULT-LIMIT %s ; RUN: opt -dse %s -S | FileCheck --check-prefixes=CHECK %s
; RUN: opt -dse -dse-memoryssa-partial-store-limit=10 %s -S | FileCheck --check-prefixes=CHECK,LARGER-LIMIT %s
%struct.ham = type { [3 x double], [3 x double]} %struct.ham = type { [3 x double], [3 x double]}
declare void @may_throw() declare void @may_throw()
declare void @llvm.memset.p0i8.i64(i8* nocapture writeonly, i8, i64, i1 immarg) declare void @llvm.memset.p0i8.i64(i8* nocapture writeonly, i8, i64, i1 immarg)
; We miss this case, because of an aggressive limit of partial overlap analysis. ; We miss this case, because of an aggressive limit of partial overlap analysis.
; With a larger partial store limit, we remove the memset. ; With a larger partial store limit, we remove the memset.
define void @overlap1(%struct.ham* %arg, i1 %cond) { define void @overlap1(%struct.ham* %arg, i1 %cond) {
; DEFAULT-LIMIT-LABEL: @overlap1( ; CHECK-LABEL: @overlap1(
; DEFAULT-LIMIT-NEXT: bb: ; CHECK-NEXT: bb:
; DEFAULT-LIMIT-NEXT: [[TMP:%.*]] = getelementptr inbounds [[STRUCT_HAM:%.*]], %struct.ham* [[ARG:%.*]], i64 0, i32 0, i64 2 ; CHECK-NEXT: [[TMP:%.*]] = getelementptr inbounds [[STRUCT_HAM:%.*]], %struct.ham* [[ARG:%.*]], i64 0, i32 0, i64 2
; DEFAULT-LIMIT-NEXT: [[TMP1:%.*]] = getelementptr inbounds [[STRUCT_HAM]], %struct.ham* [[ARG]], i64 0, i32 0, i64 1 ; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds [[STRUCT_HAM]], %struct.ham* [[ARG]], i64 0, i32 0, i64 1
; DEFAULT-LIMIT-NEXT: [[TMP2:%.*]] = getelementptr inbounds [[STRUCT_HAM]], %struct.ham* [[ARG]], i64 0, i32 0, i64 0 ; CHECK-NEXT: [[TMP2:%.*]] = getelementptr inbounds [[STRUCT_HAM]], %struct.ham* [[ARG]], i64 0, i32 0, i64 0
; DEFAULT-LIMIT-NEXT: [[TMP3:%.*]] = getelementptr inbounds [[STRUCT_HAM]], %struct.ham* [[ARG]], i64 0, i32 1, i64 2 ; CHECK-NEXT: [[TMP3:%.*]] = getelementptr inbounds [[STRUCT_HAM]], %struct.ham* [[ARG]], i64 0, i32 1, i64 2
; DEFAULT-LIMIT-NEXT: [[TMP4:%.*]] = getelementptr inbounds [[STRUCT_HAM]], %struct.ham* [[ARG]], i64 0, i32 1, i64 1 ; CHECK-NEXT: [[TMP4:%.*]] = getelementptr inbounds [[STRUCT_HAM]], %struct.ham* [[ARG]], i64 0, i32 1, i64 1
; DEFAULT-LIMIT-NEXT: [[TMP5:%.*]] = getelementptr inbounds [[STRUCT_HAM]], %struct.ham* [[ARG]], i64 0, i32 1, i32 0 ; CHECK-NEXT: [[TMP5:%.*]] = getelementptr inbounds [[STRUCT_HAM]], %struct.ham* [[ARG]], i64 0, i32 1, i32 0
; DEFAULT-LIMIT-NEXT: [[TMP6:%.*]] = bitcast double* [[TMP2]] to i8* ; CHECK-NEXT: br i1 [[COND:%.*]], label [[BB7:%.*]], label [[BB8:%.*]]
; DEFAULT-LIMIT-NEXT: [[TMP0:%.*]] = getelementptr inbounds i8, i8* [[TMP6]], i64 32 ; CHECK: bb7:
; DEFAULT-LIMIT-NEXT: call void @llvm.memset.p0i8.i64(i8* nonnull align 8 dereferenceable(48) [[TMP0]], i8 0, i64 16, i1 false) ; CHECK-NEXT: br label [[BB9:%.*]]
; DEFAULT-LIMIT-NEXT: br i1 [[COND:%.*]], label [[BB7:%.*]], label [[BB8:%.*]] ; CHECK: bb8:
; DEFAULT-LIMIT: bb7: ; CHECK-NEXT: br label [[BB9]]
; DEFAULT-LIMIT-NEXT: br label [[BB9:%.*]] ; CHECK: bb9:
; DEFAULT-LIMIT: bb8: ; CHECK-NEXT: store double 1.000000e+00, double* [[TMP2]], align 8
; DEFAULT-LIMIT-NEXT: br label [[BB9]] ; CHECK-NEXT: store double 2.000000e+00, double* [[TMP1]], align 8
; DEFAULT-LIMIT: bb9: ; CHECK-NEXT: store double 3.000000e+00, double* [[TMP]], align 8
; DEFAULT-LIMIT-NEXT: store double 1.000000e+00, double* [[TMP2]], align 8 ; CHECK-NEXT: store double 4.000000e+00, double* [[TMP5]], align 8
; DEFAULT-LIMIT-NEXT: store double 2.000000e+00, double* [[TMP1]], align 8 ; CHECK-NEXT: store double 5.000000e+00, double* [[TMP4]], align 8
; DEFAULT-LIMIT-NEXT: store double 3.000000e+00, double* [[TMP]], align 8 ; CHECK-NEXT: store double 6.000000e+00, double* [[TMP3]], align 8
; DEFAULT-LIMIT-NEXT: store double 4.000000e+00, double* [[TMP5]], align 8 ; CHECK-NEXT: ret void
; DEFAULT-LIMIT-NEXT: store double 5.000000e+00, double* [[TMP4]], align 8
; DEFAULT-LIMIT-NEXT: store double 6.000000e+00, double* [[TMP3]], align 8
; DEFAULT-LIMIT-NEXT: ret void
;
; LARGER-LIMIT-LABEL: @overlap1(
; LARGER-LIMIT-NEXT: bb:
; LARGER-LIMIT-NEXT: [[TMP:%.*]] = getelementptr inbounds [[STRUCT_HAM:%.*]], %struct.ham* [[ARG:%.*]], i64 0, i32 0, i64 2
; LARGER-LIMIT-NEXT: [[TMP1:%.*]] = getelementptr inbounds [[STRUCT_HAM]], %struct.ham* [[ARG]], i64 0, i32 0, i64 1
; LARGER-LIMIT-NEXT: [[TMP2:%.*]] = getelementptr inbounds [[STRUCT_HAM]], %struct.ham* [[ARG]], i64 0, i32 0, i64 0
; LARGER-LIMIT-NEXT: [[TMP3:%.*]] = getelementptr inbounds [[STRUCT_HAM]], %struct.ham* [[ARG]], i64 0, i32 1, i64 2
; LARGER-LIMIT-NEXT: [[TMP4:%.*]] = getelementptr inbounds [[STRUCT_HAM]], %struct.ham* [[ARG]], i64 0, i32 1, i64 1
; LARGER-LIMIT-NEXT: [[TMP5:%.*]] = getelementptr inbounds [[STRUCT_HAM]], %struct.ham* [[ARG]], i64 0, i32 1, i32 0
; LARGER-LIMIT-NEXT: br i1 [[COND:%.*]], label [[BB7:%.*]], label [[BB8:%.*]]
; LARGER-LIMIT: bb7:
; LARGER-LIMIT-NEXT: br label [[BB9:%.*]]
; LARGER-LIMIT: bb8:
; LARGER-LIMIT-NEXT: br label [[BB9]]
; LARGER-LIMIT: bb9:
; LARGER-LIMIT-NEXT: store double 1.000000e+00, double* [[TMP2]], align 8
; LARGER-LIMIT-NEXT: store double 2.000000e+00, double* [[TMP1]], align 8
; LARGER-LIMIT-NEXT: store double 3.000000e+00, double* [[TMP]], align 8
; LARGER-LIMIT-NEXT: store double 4.000000e+00, double* [[TMP5]], align 8
; LARGER-LIMIT-NEXT: store double 5.000000e+00, double* [[TMP4]], align 8
; LARGER-LIMIT-NEXT: store double 6.000000e+00, double* [[TMP3]], align 8
; LARGER-LIMIT-NEXT: ret void
; ;
bb: bb:
%tmp = getelementptr inbounds %struct.ham, %struct.ham* %arg, i64 0, i32 0, i64 2 %tmp = getelementptr inbounds %struct.ham, %struct.ham* %arg, i64 0, i32 0, i64 2
%tmp1 = getelementptr inbounds %struct.ham, %struct.ham* %arg, i64 0, i32 0, i64 1 %tmp1 = getelementptr inbounds %struct.ham, %struct.ham* %arg, i64 0, i32 0, i64 1
%tmp2 = getelementptr inbounds %struct.ham, %struct.ham* %arg, i64 0, i32 0, i64 0 %tmp2 = getelementptr inbounds %struct.ham, %struct.ham* %arg, i64 0, i32 0, i64 0
%tmp3 = getelementptr inbounds %struct.ham, %struct.ham* %arg, i64 0,i32 1, i64 2 %tmp3 = getelementptr inbounds %struct.ham, %struct.ham* %arg, i64 0,i32 1, i64 2
%tmp4 = getelementptr inbounds %struct.ham, %struct.ham* %arg, i64 0, i32 1, i64 1 %tmp4 = getelementptr inbounds %struct.ham, %struct.ham* %arg, i64 0, i32 1, i64 1
%tmp5 = getelementptr inbounds %struct.ham, %struct.ham* %arg, i64 0, i32 1, i32 0 %tmp5 = getelementptr inbounds %struct.ham, %struct.ham* %arg, i64 0, i32 1, i32 0
▲ Show 20 Lines • Show All 103 Lines • Show Last 20 Lines