This is an archive of the discontinued LLVM Phabricator instance.

Differential D145355

[AggressiveInstCombine] Pre-Commit test for D144445 (NFC)
ClosedPublic

Authored by khei4 on Mar 5 2023, 11:03 PM.

Details

Reviewers
None
Commits
rGc7a3284de305: [AggressiveInstCombine] Pre-Commit test for D144445 (NFC)
Summary

precommit test for D144445

  • change planned to apply on InstSimplify to AggressiveInstCombine
  • residues of test changes moved to llvm/test/Transforms/InstSimplify/load.ll

Diff Detail

Event Timeline

khei4 created this revision.Mar 5 2023, 11:03 PM
Herald added a project: Restricted Project. · View Herald TranscriptMar 5 2023, 11:03 PM
khei4 requested review of this revision.Mar 5 2023, 11:03 PM
Herald added a project: Restricted Project. · View Herald TranscriptMar 5 2023, 11:03 PM
Herald added a subscriber: llvm-commits. · View Herald Transcript
Harbormaster completed remote builds in B217499: Diff 502526.Mar 5 2023, 11:03 PM
khei4 mentioned this in D144445: [AggressiveInstCombine] folding load for constant global patterened arrays and structs by alignment.Mar 5 2023, 11:14 PM
khei4 updated this revision to Diff 502530.Mar 5 2023, 11:23 PM

revert fixed tests

Harbormaster completed remote builds in B217504: Diff 502530.Mar 5 2023, 11:24 PM
khei4 updated this revision to Diff 502531.Mar 5 2023, 11:24 PM
khei4 added a child revision: D144445: [AggressiveInstCombine] folding load for constant global patterened arrays and structs by alignment.

fix wrong diff

khei4 edited the summary of this revision. (Show Details)Mar 5 2023, 11:28 PM
Harbormaster completed remote builds in B217505: Diff 502531.Mar 6 2023, 1:27 AM
khei4 retitled this revision from [AggressiveInstCombine] Pre-Commit test for D144445 to [AggressiveInstCombine] Pre-Commit test for D144445 (NFC).Mar 8 2023, 10:22 PM
khei4 updated this revision to Diff 503629.Mar 8 2023, 10:33 PM
This comment was removed by khei4.
khei4 updated this revision to Diff 503631.Mar 8 2023, 10:34 PM

add ptr array tests, const offset tests

Harbormaster completed remote builds in B218300: Diff 503631.Mar 8 2023, 11:47 PM
khei4 updated this revision to Diff 503697.Mar 9 2023, 1:43 AM

tweak

Harbormaster completed remote builds in B218341: Diff 503697.Mar 9 2023, 3:03 AM
khei4 updated this revision to Diff 505365.Mar 14 2023, 10:26 PM

fix wrong load for pointer array

Harbormaster completed remote builds in B219547: Diff 505365.Mar 14 2023, 11:52 PM
khei4 updated this revision to Diff 506514.Mar 20 2023, 3:00 AM

add test cases

  • volatile load
  • ptrmasked pointer load
  • not inbounds load
Harbormaster completed remote builds in B220390: Diff 506514.Mar 20 2023, 3:53 AM
khei4 updated this revision to Diff 507299.Mar 22 2023, 3:27 AM

add

  • TODO comments with expected results
  • (un)successful non-inbounds cases
khei4 mentioned this in D146622: [AggressiveInstCombine] folding load for constant global patterened arrays and structs by GEP indices.Mar 22 2023, 3:56 AM
khei4 added a child revision: D146622: [AggressiveInstCombine] folding load for constant global patterened arrays and structs by GEP indices.Mar 22 2023, 3:59 AM
Harbormaster completed remote builds in B220974: Diff 507299.Mar 22 2023, 5:21 AM
This revision was not accepted when it landed; it landed in state Needs Review.Mar 23 2023, 7:31 AM
This revision was landed with ongoing or failed builds.
Closed by commit rGc7a3284de305: [AggressiveInstCombine] Pre-Commit test for D144445 (NFC) (authored by khei4). · Explain Why
This revision was automatically updated to reflect the committed changes.
khei4 added a commit: rGc7a3284de305: [AggressiveInstCombine] Pre-Commit test for D144445 (NFC).

Revision Contents

PathSize
llvm/
test/
Transforms/
AggressiveInstCombine/
163 lines
InstSimplify/
20 lines

Diff 506514

llvm/test/Transforms/AggressiveInstCombine/patterned-load.ll

  • This file was added.
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -passes=aggressive-instcombine -S -data-layout="e" | FileCheck %s --check-prefixes=CHECK,LE
; RUN: opt < %s -passes=aggressive-instcombine -S -data-layout="E" | FileCheck %s --check-prefixes=CHECK,BE
@constarray1 = internal constant [8 x i8] c"\01\00\01\00\01\00\01\00", align 4
@constarray2 = internal constant [8 x i8] c"\FF\FF\01\00\01\00\01\00", align 4
@g = internal constant i32 42
@constptrarray = internal constant [4 x ptr] [ptr @g, ptr @g, ptr @g, ptr @g], align 4
@constpackedstruct = internal constant <{[8 x i8]}> <{[8 x i8] c"\01\00\01\00\01\00\01\00"}>, align 4
@conststruct = internal constant {i16, [8 x i8]} {i16 1, [8 x i8] c"\01\00\01\00\01\00\01\00"}, align 4
define i8 @gep_load_i8_align2(i64 %idx){
; CHECK-LABEL: @gep_load_i8_align2(
; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds i8, ptr @constarray1, i64 [[IDX:%.*]]
; CHECK-NEXT: [[TMP2:%.*]] = load i8, ptr [[TMP1]], align 2
; CHECK-NEXT: ret i8 [[TMP2]]
;
%1 = getelementptr inbounds i8, ptr @constarray1, i64 %idx
%2 = load i8, ptr %1, align 2
ret i8 %2
}
; can't be folded because access with i8 strides is not patterned.
define i8 @gep_load_i8_align1(i64 %idx){
; CHECK-LABEL: @gep_load_i8_align1(
; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds i8, ptr @constarray1, i64 [[IDX:%.*]]
; CHECK-NEXT: [[TMP2:%.*]] = load i8, ptr [[TMP1]], align 1
; CHECK-NEXT: ret i8 [[TMP2]]
;
%1 = getelementptr inbounds i8, ptr @constarray1, i64 %idx
%2 = load i8, ptr %1, align 1
ret i8 %2
}
; can't be folded because volatile load cannot assure same results.
define i8 @gep_load_i8_align2_volatile(i64 %idx){
; CHECK-LABEL: @gep_load_i8_align2_volatile(
; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds i8, ptr @constarray1, i64 [[IDX:%.*]]
; CHECK-NEXT: [[TMP2:%.*]] = load volatile i8, ptr [[TMP1]], align 2
; CHECK-NEXT: ret i8 [[TMP2]]
;
%1 = getelementptr inbounds i8, ptr @constarray1, i64 %idx
%2 = load volatile i8, ptr %1, align 2
ret i8 %2
}
declare ptr @llvm.ptrmask.p0.i64(ptr , i64)
; can't be folded because ptrmask can change ptr, while preserving provenance
define i8 @gep_load_i8_align2_ptrmasked(i64 %idx, i64 %mask){
; CHECK-LABEL: @gep_load_i8_align2_ptrmasked(
; CHECK-NEXT: [[TMP1:%.*]] = call ptr @llvm.ptrmask.p0.i64(ptr @constarray1, i64 [[MASK:%.*]])
; CHECK-NEXT: [[TMP2:%.*]] = getelementptr inbounds i8, ptr [[TMP1]], i64 [[IDX:%.*]]
; CHECK-NEXT: [[TMP3:%.*]] = load i8, ptr [[TMP2]], align 2
; CHECK-NEXT: ret i8 [[TMP3]]
;
%1 = call ptr @llvm.ptrmask.p0.i64(ptr @constarray1, i64 %mask)
%2 = getelementptr inbounds i8, ptr %1, i64 %idx
%3 = load i8, ptr %2, align 2
ret i8 %3
}
; can't be folded because gep is not inbounds
define i8 @gep_load_i8_align2_not_inbounds(i64 %idx, i64 %mask){
; CHECK-LABEL: @gep_load_i8_align2_not_inbounds(
; CHECK-NEXT: [[TMP1:%.*]] = getelementptr i8, ptr @constarray1, i64 [[IDX:%.*]]
; CHECK-NEXT: [[TMP2:%.*]] = load i8, ptr [[TMP1]], align 2
; CHECK-NEXT: ret i8 [[TMP2]]
;
%1 = getelementptr i8, ptr @constarray1, i64 %idx
%2 = load i8, ptr %1, align 2
ret i8 %2
}
define i32 @gep_i16_load_i32_align1(i64 %idx){
; CHECK-LABEL: @gep_i16_load_i32_align1(
; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds i16, ptr @constarray1, i64 [[IDX:%.*]]
; CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[TMP1]], align 1
; CHECK-NEXT: ret i32 [[TMP2]]
;
%1 = getelementptr inbounds i16, ptr @constarray1, i64 %idx
%2 = load i32, ptr %1, align 1
ret i32 %2
}
define i32 @gep_i32_load_i32_align8(i64 %idx){
; CHECK-LABEL: @gep_i32_load_i32_align8(
; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds i32, ptr @constarray1, i64 [[IDX:%.*]]
; CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[TMP1]], align 8
; CHECK-NEXT: ret i32 [[TMP2]]
;
%1 = getelementptr inbounds i32, ptr @constarray1, i64 %idx
%2 = load i32, ptr %1, align 8
ret i32 %2
}
define i32 @gep_i32_load_i32_with_const_offset(i64 %idx){
; CHECK-LABEL: @gep_i32_load_i32_with_const_offset(
; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds i16, ptr @constarray2, i64 1
; CHECK-NEXT: [[TMP2:%.*]] = getelementptr inbounds i32, ptr [[TMP1]], i64 [[IDX:%.*]]
; CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[TMP2]], align 4
; CHECK-NEXT: ret i32 [[TMP3]]
;
%1 = getelementptr inbounds i16, ptr @constarray2, i64 1
%2 = getelementptr inbounds i32, ptr %1, i64 %idx
%3 = load i32, ptr %2, align 4
ret i32 %3
}
define i32 @gep_i32_load_i32_const_ptr_array(i64 %idx){
; CHECK-LABEL: @gep_i32_load_i32_const_ptr_array(
; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds ptr, ptr @constptrarray, i64 [[IDX:%.*]]
; CHECK-NEXT: [[TMP2:%.*]] = load ptr, ptr [[TMP1]], align 4
; CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[TMP2]], align 4
; CHECK-NEXT: ret i32 [[TMP3]]
;
%1 = getelementptr inbounds ptr, ptr @constptrarray, i64 %idx
%2 = load ptr, ptr %1, align 4
%3 = load i32, ptr %2, align 4
ret i32 %3
}
define i32 @gep_i32_load_i32_align4_packedstruct(i64 %idx){
; CHECK-LABEL: @gep_i32_load_i32_align4_packedstruct(
; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds i32, ptr @constpackedstruct, i64 [[IDX:%.*]]
; CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[TMP1]], align 4
; CHECK-NEXT: ret i32 [[TMP2]]
;
%1 = getelementptr inbounds i32, ptr @constpackedstruct, i64 %idx
%2 = load i32, ptr %1, align 4
ret i32 %2
}
; can't be folded
define i32 @gep_i8_load_i32_align1_packedstruct(i64 %idx){
; CHECK-LABEL: @gep_i8_load_i32_align1_packedstruct(
; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds i8, ptr @constpackedstruct, i64 [[IDX:%.*]]
; CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[TMP1]], align 1
; CHECK-NEXT: ret i32 [[TMP2]]
;
%1 = getelementptr inbounds i8, ptr @constpackedstruct, i64 %idx
%2 = load i32, ptr %1, align 1
ret i32 %2
}
define i32 @gep_i32_load_i32_align4_struct_with_const_offset(i64 %idx){
; CHECK-LABEL: @gep_i32_load_i32_align4_struct_with_const_offset(
; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds i16, ptr @conststruct, i64 1
; CHECK-NEXT: [[TMP2:%.*]] = getelementptr inbounds i32, ptr [[TMP1]], i64 [[IDX:%.*]]
; CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[TMP2]], align 4
; CHECK-NEXT: ret i32 [[TMP3]]
;
%1 = getelementptr inbounds i16, ptr @conststruct, i64 1
%2 = getelementptr inbounds i32, ptr %1, i64 %idx
%3 = load i32, ptr %2, align 4
ret i32 %3
}
;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
; BE: {{.*}}
; LE: {{.*}}

llvm/test/Transforms/InstSimplify/load-patterned-aggregates.ll

  • This file was deleted.
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32-n8:16:32"
@constzeroarray = internal constant [4 x i32] zeroinitializer
@constarray = internal constant [8 x i8] c"\01\00\01\00\01\00\01\00", align 4
@conststruct = internal constant <{[8 x i8]}> <{[8 x i8] c"\01\00\01\00\01\00\01\00"}>, align 4
define i32 @load_gep_const_zero_array(i64 %idx) {
; CHECK-LABEL: @load_gep_const_zero_array(
; CHECK-NEXT: ret i32 0
;
%gep = getelementptr inbounds [4 x i32], ptr @constzeroarray, i64 0, i64 %idx
%load = load i32, ptr %gep
ret i32 %load
}
define i8 @load_i8_multi_gep_const_zero_array(i64 %idx1, i64 %idx2) {
; CHECK-LABEL: @load_i8_multi_gep_const_zero_array(
; CHECK-NEXT: ret i8 0
;
%gep1 = getelementptr inbounds i8, ptr @constzeroarray, i64 %idx1
%gep = getelementptr inbounds i8, ptr %gep1, i64 %idx2
%load = load i8, ptr %gep
ret i8 %load
}
define i32 @load_gep_const_patterned_array(i64 %idx) {
; CHECK-LABEL: @load_gep_const_patterned_array(
; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds [4 x i32], ptr @constarray, i64 0, i64 [[IDX:%.*]]
; CHECK-NEXT: [[LOAD:%.*]] = load i32, ptr [[GEP]], align 4
; CHECK-NEXT: ret i32 [[LOAD]]
;
%gep = getelementptr inbounds [4 x i32], ptr @constarray, i64 0, i64 %idx
%load = load i32, ptr %gep
ret i32 %load
}
define i8 @load_i8_multi_gep_const_array(i64 %idx1, i64 %idx2) {
; CHECK-LABEL: @load_i8_multi_gep_const_array(
; CHECK-NEXT: [[GEP1:%.*]] = getelementptr inbounds i8, ptr @constarray, i64 [[IDX1:%.*]]
; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds i8, ptr [[GEP1]], i64 [[IDX2:%.*]]
; CHECK-NEXT: [[LOAD:%.*]] = load i8, ptr [[GEP]], align 1
; CHECK-NEXT: ret i8 [[LOAD]]
;
%gep1 = getelementptr inbounds i8, ptr @constarray, i64 %idx1
%gep = getelementptr inbounds i8, ptr %gep1, i64 %idx2
%load = load i8, ptr %gep
ret i8 %load
}
; TODO: this should be ret i8 1
define i8 @gep_load_i8_align2(i64 %idx){
; CHECK-LABEL: @gep_load_i8_align2(
; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds i8, ptr @constarray, i64 [[IDX:%.*]]
; CHECK-NEXT: [[TMP2:%.*]] = load i8, ptr [[TMP1]], align 2
; CHECK-NEXT: ret i8 [[TMP2]]
;
%1 = getelementptr inbounds i8, ptr @constarray, i64 %idx
%2 = load i8, ptr %1, align 2
ret i8 %2
}
; can't be folded
define i8 @gep_load_i8_align1(i64 %idx){
; CHECK-LABEL: @gep_load_i8_align1(
; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds i8, ptr @constarray, i64 [[IDX:%.*]]
; CHECK-NEXT: [[TMP2:%.*]] = load i8, ptr [[TMP1]], align 1
; CHECK-NEXT: ret i8 [[TMP2]]
;
%1 = getelementptr inbounds i8, ptr @constarray, i64 %idx
%2 = load i8, ptr %1, align 1
ret i8 %2
}
; TODO: this should be ret i8 65537 on the case for little endian
define i32 @gep_i32_load_i32_align4(i64 %idx){
; CHECK-LABEL: @gep_i32_load_i32_align4(
; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds i32, ptr @constarray, i64 [[IDX:%.*]]
; CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[TMP1]], align 4
; CHECK-NEXT: ret i32 [[TMP2]]
;
%1 = getelementptr inbounds i32, ptr @constarray, i64 %idx
%2 = load i32, ptr %1, align 4
ret i32 %2
}
; TODO: this should be ret i8 65537 on the case for little endian
define i32 @gep_i32_load_i32_align4_struct(i64 %idx){
; CHECK-LABEL: @gep_i32_load_i32_align4_struct(
; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds i32, ptr @conststruct, i64 [[IDX:%.*]]
; CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[TMP1]], align 4
; CHECK-NEXT: ret i32 [[TMP2]]
;
%1 = getelementptr inbounds i32, ptr @conststruct, i64 %idx
%2 = load i32, ptr %1, align 4
ret i32 %2
}
; can't be folded
define i32 @gep_i8_load_i32_align1(i64 %idx){
; CHECK-LABEL: @gep_i8_load_i32_align1(
; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds i8, ptr @constarray, i64 [[IDX:%.*]]
; CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[TMP1]], align 1
; CHECK-NEXT: ret i32 [[TMP2]]
;
%1 = getelementptr inbounds i8, ptr @constarray, i64 %idx
%2 = load i32, ptr %1, align 1
ret i32 %2
}
; can't be folded
define i32 @gep_i8_load_i32_align1_struct(i64 %idx){
; CHECK-LABEL: @gep_i8_load_i32_align1_struct(
; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds i8, ptr @conststruct, i64 [[IDX:%.*]]
; CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[TMP1]], align 1
; CHECK-NEXT: ret i32 [[TMP2]]
;
%1 = getelementptr inbounds i8, ptr @conststruct, i64 %idx
%2 = load i32, ptr %1, align 1
ret i32 %2
}
; TODO: This could be folded but need to see GEP source types
define i32 @gep_i16_load_i32_align1(i64 %idx){
; CHECK-LABEL: @gep_i16_load_i32_align1(
; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds i16, ptr @constarray, i64 [[IDX:%.*]]
; CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[TMP1]], align 1
; CHECK-NEXT: ret i32 [[TMP2]]
;
%1 = getelementptr inbounds i16, ptr @constarray, i64 %idx
%2 = load i32, ptr %1, align 1
ret i32 %2
}

llvm/test/Transforms/InstSimplify/load.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -passes=instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
@zeroinit = constant {} zeroinitializer @zeroinit = constant {} zeroinitializer
@poison = constant {} poison @poison = constant {} poison
@constzeroarray = internal constant [4 x i32] zeroinitializer
define i32 @crash_on_zeroinit() { define i32 @crash_on_zeroinit() {
; CHECK-LABEL: @crash_on_zeroinit( ; CHECK-LABEL: @crash_on_zeroinit(
; CHECK-NEXT: ret i32 poison ; CHECK-NEXT: ret i32 poison
; ;
%load = load i32, ptr @zeroinit %load = load i32, ptr @zeroinit
ret i32 %load ret i32 %load
} }
Show All 21 Lines
; This does an out of bounds load from the global constant ; This does an out of bounds load from the global constant
define <3 x float> @load_vec3() { define <3 x float> @load_vec3() {
; CHECK-LABEL: @load_vec3( ; CHECK-LABEL: @load_vec3(
; CHECK-NEXT: ret <3 x float> poison ; CHECK-NEXT: ret <3 x float> poison
; ;
%1 = load <3 x float>, ptr getelementptr inbounds (<3 x float>, ptr @constvec, i64 1) %1 = load <3 x float>, ptr getelementptr inbounds (<3 x float>, ptr @constvec, i64 1)
ret <3 x float> %1 ret <3 x float> %1
} }
define i32 @load_gep_const_zero_array(i64 %idx) {
; CHECK-LABEL: @load_gep_const_zero_array(
; CHECK-NEXT: ret i32 0
;
%gep = getelementptr inbounds [4 x i32], ptr @constzeroarray, i64 0, i64 %idx
%load = load i32, ptr %gep
ret i32 %load
}
define i8 @load_i8_multi_gep_const_zero_array(i64 %idx1, i64 %idx2) {
; CHECK-LABEL: @load_i8_multi_gep_const_zero_array(
; CHECK-NEXT: ret i8 0
;
%gep1 = getelementptr inbounds i8, ptr @constzeroarray, i64 %idx1
%gep = getelementptr inbounds i8, ptr %gep1, i64 %idx2
%load = load i8, ptr %gep
ret i8 %load
}
llvm/test/Transforms/AggressiveInstCombine/patterned-load.ll