2399 lines · plain
1; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 52; RUN: opt < %s -data-layout="e-p:32:32:32-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-n8:16:32" -passes=gvn,dce -enable-split-backedge-in-load-pre -S | FileCheck %s --check-prefixes=CHECK,LE,LE-MEMDEP3; RUN: opt < %s -data-layout="e-p:32:32:32-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-n8:16:32" -passes='gvn<memoryssa>',dce -enable-split-backedge-in-load-pre -S | FileCheck %s --check-prefixes=CHECK,LE,LE-MEMSSA4; RUN: opt < %s -data-layout="E-p:32:32:32-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-n32" -passes=gvn,dce -enable-split-backedge-in-load-pre -S | FileCheck %s --check-prefixes=CHECK,BE,BE-MEMDEP5; RUN: opt < %s -data-layout="E-p:32:32:32-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-n32" -passes='gvn<memoryssa>',dce -enable-split-backedge-in-load-pre -S | FileCheck %s --check-prefixes=CHECK,BE,BE-MEMSSA6 7;; Trivial RLE test.8define i32 @test0(i32 %V, ptr %P) {9; LE-MEMDEP-LABEL: define i32 @test0(10; LE-MEMDEP-SAME: i32 [[V:%.*]], ptr [[P:%.*]]) {11; LE-MEMDEP-NEXT: store i32 [[V]], ptr [[P]], align 412; LE-MEMDEP-NEXT: ret i32 [[V]]13;14; LE-MEMSSA-LABEL: define i32 @test0(15; LE-MEMSSA-SAME: i32 [[V:%.*]], ptr [[P:%.*]]) {16; LE-MEMSSA-NEXT: store i32 [[V]], ptr [[P]], align 417; LE-MEMSSA-NEXT: [[A:%.*]] = load i32, ptr [[P]], align 418; LE-MEMSSA-NEXT: ret i32 [[A]]19;20; BE-MEMDEP-LABEL: define i32 @test0(21; BE-MEMDEP-SAME: i32 [[V:%.*]], ptr [[P:%.*]]) {22; BE-MEMDEP-NEXT: store i32 [[V]], ptr [[P]], align 423; BE-MEMDEP-NEXT: ret i32 [[V]]24;25; BE-MEMSSA-LABEL: define i32 @test0(26; BE-MEMSSA-SAME: i32 [[V:%.*]], ptr [[P:%.*]]) {27; BE-MEMSSA-NEXT: store i32 [[V]], ptr [[P]], align 428; BE-MEMSSA-NEXT: [[A:%.*]] = load i32, ptr [[P]], align 429; BE-MEMSSA-NEXT: ret i32 [[A]]30;31 store i32 %V, ptr %P32 33 %A = load i32, ptr %P34 ret i32 %A35}36 37 38;;===----------------------------------------------------------------------===;;39;; Tests for crashers40;;===----------------------------------------------------------------------===;;41 42;; PR501643define i8 @crash0({i32, i32} %A, ptr %P) {44; CHECK-LABEL: define i8 @crash0(45; CHECK-SAME: { i32, i32 } [[A:%.*]], ptr [[P:%.*]]) {46; CHECK-NEXT: store { i32, i32 } [[A]], ptr [[P]], align 447; CHECK-NEXT: [[Y:%.*]] = load i8, ptr [[P]], align 148; CHECK-NEXT: ret i8 [[Y]]49;50 store {i32, i32} %A, ptr %P51 %Y = load i8, ptr %P52 ret i8 %Y53}54 55;; No PR filed, crashed in CaptureTracker.56declare void @helper()57define void @crash1() {58; CHECK-LABEL: define void @crash1() {59; CHECK-NEXT: tail call void @llvm.memcpy.p0.p0.i64(ptr undef, ptr undef, i64 undef, i1 false) #[[ATTR3:[0-9]+]]60; CHECK-NEXT: ret void61;62 tail call void @llvm.memcpy.p0.p0.i64(ptr undef, ptr undef, i64 undef, i1 false) nounwind63 %ttmp = load i8, ptr @helper64 %x = icmp eq i8 %ttmp, 1565 ret void66}67 68 69;;===----------------------------------------------------------------------===;;70;; Store -> Load and Load -> Load forwarding where src and dst are different71;; types, but where the base pointer is a must alias.72;;===----------------------------------------------------------------------===;;73 74;; i32 -> f32 forwarding.75define float @coerce_mustalias1(i32 %V, ptr %P) {76; LE-MEMDEP-LABEL: define float @coerce_mustalias1(77; LE-MEMDEP-SAME: i32 [[V:%.*]], ptr [[P:%.*]]) {78; LE-MEMDEP-NEXT: store i32 [[V]], ptr [[P]], align 479; LE-MEMDEP-NEXT: [[TMP1:%.*]] = bitcast i32 [[V]] to float80; LE-MEMDEP-NEXT: ret float [[TMP1]]81;82; LE-MEMSSA-LABEL: define float @coerce_mustalias1(83; LE-MEMSSA-SAME: i32 [[V:%.*]], ptr [[P:%.*]]) {84; LE-MEMSSA-NEXT: store i32 [[V]], ptr [[P]], align 485; LE-MEMSSA-NEXT: [[A:%.*]] = load float, ptr [[P]], align 486; LE-MEMSSA-NEXT: ret float [[A]]87;88; BE-MEMDEP-LABEL: define float @coerce_mustalias1(89; BE-MEMDEP-SAME: i32 [[V:%.*]], ptr [[P:%.*]]) {90; BE-MEMDEP-NEXT: store i32 [[V]], ptr [[P]], align 491; BE-MEMDEP-NEXT: [[TMP1:%.*]] = bitcast i32 [[V]] to float92; BE-MEMDEP-NEXT: ret float [[TMP1]]93;94; BE-MEMSSA-LABEL: define float @coerce_mustalias1(95; BE-MEMSSA-SAME: i32 [[V:%.*]], ptr [[P:%.*]]) {96; BE-MEMSSA-NEXT: store i32 [[V]], ptr [[P]], align 497; BE-MEMSSA-NEXT: [[A:%.*]] = load float, ptr [[P]], align 498; BE-MEMSSA-NEXT: ret float [[A]]99;100 store i32 %V, ptr %P101 102 103 %A = load float, ptr %P104 ret float %A105}106 107;; ptr -> float forwarding.108define float @coerce_mustalias2(ptr %V, ptr %P) {109; LE-MEMDEP-LABEL: define float @coerce_mustalias2(110; LE-MEMDEP-SAME: ptr [[V:%.*]], ptr [[P:%.*]]) {111; LE-MEMDEP-NEXT: store ptr [[V]], ptr [[P]], align 4112; LE-MEMDEP-NEXT: [[TMP1:%.*]] = ptrtoint ptr [[V]] to i32113; LE-MEMDEP-NEXT: [[TMP2:%.*]] = bitcast i32 [[TMP1]] to float114; LE-MEMDEP-NEXT: ret float [[TMP2]]115;116; LE-MEMSSA-LABEL: define float @coerce_mustalias2(117; LE-MEMSSA-SAME: ptr [[V:%.*]], ptr [[P:%.*]]) {118; LE-MEMSSA-NEXT: store ptr [[V]], ptr [[P]], align 4119; LE-MEMSSA-NEXT: [[A:%.*]] = load float, ptr [[P]], align 4120; LE-MEMSSA-NEXT: ret float [[A]]121;122; BE-MEMDEP-LABEL: define float @coerce_mustalias2(123; BE-MEMDEP-SAME: ptr [[V:%.*]], ptr [[P:%.*]]) {124; BE-MEMDEP-NEXT: store ptr [[V]], ptr [[P]], align 4125; BE-MEMDEP-NEXT: [[TMP1:%.*]] = ptrtoint ptr [[V]] to i32126; BE-MEMDEP-NEXT: [[TMP2:%.*]] = bitcast i32 [[TMP1]] to float127; BE-MEMDEP-NEXT: ret float [[TMP2]]128;129; BE-MEMSSA-LABEL: define float @coerce_mustalias2(130; BE-MEMSSA-SAME: ptr [[V:%.*]], ptr [[P:%.*]]) {131; BE-MEMSSA-NEXT: store ptr [[V]], ptr [[P]], align 4132; BE-MEMSSA-NEXT: [[A:%.*]] = load float, ptr [[P]], align 4133; BE-MEMSSA-NEXT: ret float [[A]]134;135 store ptr %V, ptr %P136 137 138 %A = load float, ptr %P139 ret float %A140}141 142;; float -> ptr forwarding.143define ptr @coerce_mustalias3(float %V, ptr %P) {144; LE-MEMDEP-LABEL: define ptr @coerce_mustalias3(145; LE-MEMDEP-SAME: float [[V:%.*]], ptr [[P:%.*]]) {146; LE-MEMDEP-NEXT: store float [[V]], ptr [[P]], align 4147; LE-MEMDEP-NEXT: [[TMP1:%.*]] = bitcast float [[V]] to i32148; LE-MEMDEP-NEXT: [[TMP2:%.*]] = inttoptr i32 [[TMP1]] to ptr149; LE-MEMDEP-NEXT: ret ptr [[TMP2]]150;151; LE-MEMSSA-LABEL: define ptr @coerce_mustalias3(152; LE-MEMSSA-SAME: float [[V:%.*]], ptr [[P:%.*]]) {153; LE-MEMSSA-NEXT: store float [[V]], ptr [[P]], align 4154; LE-MEMSSA-NEXT: [[A:%.*]] = load ptr, ptr [[P]], align 4155; LE-MEMSSA-NEXT: ret ptr [[A]]156;157; BE-MEMDEP-LABEL: define ptr @coerce_mustalias3(158; BE-MEMDEP-SAME: float [[V:%.*]], ptr [[P:%.*]]) {159; BE-MEMDEP-NEXT: store float [[V]], ptr [[P]], align 4160; BE-MEMDEP-NEXT: [[TMP1:%.*]] = bitcast float [[V]] to i32161; BE-MEMDEP-NEXT: [[TMP2:%.*]] = inttoptr i32 [[TMP1]] to ptr162; BE-MEMDEP-NEXT: ret ptr [[TMP2]]163;164; BE-MEMSSA-LABEL: define ptr @coerce_mustalias3(165; BE-MEMSSA-SAME: float [[V:%.*]], ptr [[P:%.*]]) {166; BE-MEMSSA-NEXT: store float [[V]], ptr [[P]], align 4167; BE-MEMSSA-NEXT: [[A:%.*]] = load ptr, ptr [[P]], align 4168; BE-MEMSSA-NEXT: ret ptr [[A]]169;170 store float %V, ptr %P171 172 173 %A = load ptr, ptr %P174 ret ptr %A175}176 177;; i32 -> f32 load forwarding.178define float @coerce_mustalias4(ptr %P, i1 %cond) {179; LE-MEMDEP-LABEL: define float @coerce_mustalias4(180; LE-MEMDEP-SAME: ptr [[P:%.*]], i1 [[COND:%.*]]) {181; LE-MEMDEP-NEXT: [[A:%.*]] = load i32, ptr [[P]], align 4182; LE-MEMDEP-NEXT: [[TMP1:%.*]] = bitcast i32 [[A]] to float183; LE-MEMDEP-NEXT: br i1 [[COND]], label %[[T:.*]], label %[[F:.*]]184; LE-MEMDEP: [[T]]:185; LE-MEMDEP-NEXT: ret float [[TMP1]]186; LE-MEMDEP: [[F]]:187; LE-MEMDEP-NEXT: ret float [[TMP1]]188;189; LE-MEMSSA-LABEL: define float @coerce_mustalias4(190; LE-MEMSSA-SAME: ptr [[P:%.*]], i1 [[COND:%.*]]) {191; LE-MEMSSA-NEXT: [[A:%.*]] = load i32, ptr [[P]], align 4192; LE-MEMSSA-NEXT: [[B:%.*]] = load float, ptr [[P]], align 4193; LE-MEMSSA-NEXT: br i1 [[COND]], label %[[T:.*]], label %[[F:.*]]194; LE-MEMSSA: [[T]]:195; LE-MEMSSA-NEXT: ret float [[B]]196; LE-MEMSSA: [[F]]:197; LE-MEMSSA-NEXT: [[X:%.*]] = bitcast i32 [[A]] to float198; LE-MEMSSA-NEXT: ret float [[X]]199;200; BE-MEMDEP-LABEL: define float @coerce_mustalias4(201; BE-MEMDEP-SAME: ptr [[P:%.*]], i1 [[COND:%.*]]) {202; BE-MEMDEP-NEXT: [[A:%.*]] = load i32, ptr [[P]], align 4203; BE-MEMDEP-NEXT: [[TMP1:%.*]] = bitcast i32 [[A]] to float204; BE-MEMDEP-NEXT: br i1 [[COND]], label %[[T:.*]], label %[[F:.*]]205; BE-MEMDEP: [[T]]:206; BE-MEMDEP-NEXT: ret float [[TMP1]]207; BE-MEMDEP: [[F]]:208; BE-MEMDEP-NEXT: ret float [[TMP1]]209;210; BE-MEMSSA-LABEL: define float @coerce_mustalias4(211; BE-MEMSSA-SAME: ptr [[P:%.*]], i1 [[COND:%.*]]) {212; BE-MEMSSA-NEXT: [[A:%.*]] = load i32, ptr [[P]], align 4213; BE-MEMSSA-NEXT: [[B:%.*]] = load float, ptr [[P]], align 4214; BE-MEMSSA-NEXT: br i1 [[COND]], label %[[T:.*]], label %[[F:.*]]215; BE-MEMSSA: [[T]]:216; BE-MEMSSA-NEXT: ret float [[B]]217; BE-MEMSSA: [[F]]:218; BE-MEMSSA-NEXT: [[X:%.*]] = bitcast i32 [[A]] to float219; BE-MEMSSA-NEXT: ret float [[X]]220;221 %A = load i32, ptr %P222 223 %B = load float, ptr %P224 br i1 %cond, label %T, label %F225T:226 ret float %B227 228F:229 %X = bitcast i32 %A to float230 ret float %X231 232}233 234;; i32 -> i8 forwarding235define i8 @coerce_mustalias5(i32 %V, ptr %P) {236; LE-MEMDEP-LABEL: define i8 @coerce_mustalias5(237; LE-MEMDEP-SAME: i32 [[V:%.*]], ptr [[P:%.*]]) {238; LE-MEMDEP-NEXT: store i32 [[V]], ptr [[P]], align 4239; LE-MEMDEP-NEXT: [[TMP1:%.*]] = trunc i32 [[V]] to i8240; LE-MEMDEP-NEXT: ret i8 [[TMP1]]241;242; LE-MEMSSA-LABEL: define i8 @coerce_mustalias5(243; LE-MEMSSA-SAME: i32 [[V:%.*]], ptr [[P:%.*]]) {244; LE-MEMSSA-NEXT: store i32 [[V]], ptr [[P]], align 4245; LE-MEMSSA-NEXT: [[A:%.*]] = load i8, ptr [[P]], align 1246; LE-MEMSSA-NEXT: ret i8 [[A]]247;248; BE-MEMDEP-LABEL: define i8 @coerce_mustalias5(249; BE-MEMDEP-SAME: i32 [[V:%.*]], ptr [[P:%.*]]) {250; BE-MEMDEP-NEXT: store i32 [[V]], ptr [[P]], align 4251; BE-MEMDEP-NEXT: [[TMP1:%.*]] = lshr i32 [[V]], 24252; BE-MEMDEP-NEXT: [[TMP2:%.*]] = trunc i32 [[TMP1]] to i8253; BE-MEMDEP-NEXT: ret i8 [[TMP2]]254;255; BE-MEMSSA-LABEL: define i8 @coerce_mustalias5(256; BE-MEMSSA-SAME: i32 [[V:%.*]], ptr [[P:%.*]]) {257; BE-MEMSSA-NEXT: store i32 [[V]], ptr [[P]], align 4258; BE-MEMSSA-NEXT: [[A:%.*]] = load i8, ptr [[P]], align 1259; BE-MEMSSA-NEXT: ret i8 [[A]]260;261 store i32 %V, ptr %P262 263 264 %A = load i8, ptr %P265 ret i8 %A266}267 268;; i64 -> float forwarding269define float @coerce_mustalias6(i64 %V, ptr %P) {270; LE-MEMDEP-LABEL: define float @coerce_mustalias6(271; LE-MEMDEP-SAME: i64 [[V:%.*]], ptr [[P:%.*]]) {272; LE-MEMDEP-NEXT: store i64 [[V]], ptr [[P]], align 4273; LE-MEMDEP-NEXT: [[TMP1:%.*]] = trunc i64 [[V]] to i32274; LE-MEMDEP-NEXT: [[TMP2:%.*]] = bitcast i32 [[TMP1]] to float275; LE-MEMDEP-NEXT: ret float [[TMP2]]276;277; LE-MEMSSA-LABEL: define float @coerce_mustalias6(278; LE-MEMSSA-SAME: i64 [[V:%.*]], ptr [[P:%.*]]) {279; LE-MEMSSA-NEXT: store i64 [[V]], ptr [[P]], align 4280; LE-MEMSSA-NEXT: [[A:%.*]] = load float, ptr [[P]], align 4281; LE-MEMSSA-NEXT: ret float [[A]]282;283; BE-MEMDEP-LABEL: define float @coerce_mustalias6(284; BE-MEMDEP-SAME: i64 [[V:%.*]], ptr [[P:%.*]]) {285; BE-MEMDEP-NEXT: store i64 [[V]], ptr [[P]], align 4286; BE-MEMDEP-NEXT: [[TMP1:%.*]] = lshr i64 [[V]], 32287; BE-MEMDEP-NEXT: [[TMP2:%.*]] = trunc i64 [[TMP1]] to i32288; BE-MEMDEP-NEXT: [[TMP3:%.*]] = bitcast i32 [[TMP2]] to float289; BE-MEMDEP-NEXT: ret float [[TMP3]]290;291; BE-MEMSSA-LABEL: define float @coerce_mustalias6(292; BE-MEMSSA-SAME: i64 [[V:%.*]], ptr [[P:%.*]]) {293; BE-MEMSSA-NEXT: store i64 [[V]], ptr [[P]], align 4294; BE-MEMSSA-NEXT: [[A:%.*]] = load float, ptr [[P]], align 4295; BE-MEMSSA-NEXT: ret float [[A]]296;297 store i64 %V, ptr %P298 299 300 %A = load float, ptr %P301 ret float %A302}303 304;; i64 -> ptr (32-bit) forwarding305define ptr @coerce_mustalias7(i64 %V, ptr %P) {306; LE-MEMDEP-LABEL: define ptr @coerce_mustalias7(307; LE-MEMDEP-SAME: i64 [[V:%.*]], ptr [[P:%.*]]) {308; LE-MEMDEP-NEXT: store i64 [[V]], ptr [[P]], align 4309; LE-MEMDEP-NEXT: [[TMP1:%.*]] = trunc i64 [[V]] to i32310; LE-MEMDEP-NEXT: [[TMP2:%.*]] = inttoptr i32 [[TMP1]] to ptr311; LE-MEMDEP-NEXT: ret ptr [[TMP2]]312;313; LE-MEMSSA-LABEL: define ptr @coerce_mustalias7(314; LE-MEMSSA-SAME: i64 [[V:%.*]], ptr [[P:%.*]]) {315; LE-MEMSSA-NEXT: store i64 [[V]], ptr [[P]], align 4316; LE-MEMSSA-NEXT: [[A:%.*]] = load ptr, ptr [[P]], align 4317; LE-MEMSSA-NEXT: ret ptr [[A]]318;319; BE-MEMDEP-LABEL: define ptr @coerce_mustalias7(320; BE-MEMDEP-SAME: i64 [[V:%.*]], ptr [[P:%.*]]) {321; BE-MEMDEP-NEXT: store i64 [[V]], ptr [[P]], align 4322; BE-MEMDEP-NEXT: [[TMP1:%.*]] = lshr i64 [[V]], 32323; BE-MEMDEP-NEXT: [[TMP2:%.*]] = trunc i64 [[TMP1]] to i32324; BE-MEMDEP-NEXT: [[TMP3:%.*]] = inttoptr i32 [[TMP2]] to ptr325; BE-MEMDEP-NEXT: ret ptr [[TMP3]]326;327; BE-MEMSSA-LABEL: define ptr @coerce_mustalias7(328; BE-MEMSSA-SAME: i64 [[V:%.*]], ptr [[P:%.*]]) {329; BE-MEMSSA-NEXT: store i64 [[V]], ptr [[P]], align 4330; BE-MEMSSA-NEXT: [[A:%.*]] = load ptr, ptr [[P]], align 4331; BE-MEMSSA-NEXT: ret ptr [[A]]332;333 store i64 %V, ptr %P334 335 336 %A = load ptr, ptr %P337 ret ptr %A338}339 340; memset -> i16 forwarding.341define signext i16 @memset_to_i16_local(ptr %A) nounwind ssp {342; LE-MEMDEP-LABEL: define signext i16 @memset_to_i16_local(343; LE-MEMDEP-SAME: ptr [[A:%.*]]) #[[ATTR0:[0-9]+]] {344; LE-MEMDEP-NEXT: [[ENTRY:.*:]]345; LE-MEMDEP-NEXT: tail call void @llvm.memset.p0.i64(ptr [[A]], i8 1, i64 200, i1 false)346; LE-MEMDEP-NEXT: ret i16 257347;348; LE-MEMSSA-LABEL: define signext i16 @memset_to_i16_local(349; LE-MEMSSA-SAME: ptr [[A:%.*]]) #[[ATTR0:[0-9]+]] {350; LE-MEMSSA-NEXT: [[ENTRY:.*:]]351; LE-MEMSSA-NEXT: tail call void @llvm.memset.p0.i64(ptr [[A]], i8 1, i64 200, i1 false)352; LE-MEMSSA-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i16, ptr [[A]], i64 42353; LE-MEMSSA-NEXT: [[TTMP2:%.*]] = load i16, ptr [[ARRAYIDX]], align 2354; LE-MEMSSA-NEXT: ret i16 [[TTMP2]]355;356; BE-MEMDEP-LABEL: define signext i16 @memset_to_i16_local(357; BE-MEMDEP-SAME: ptr [[A:%.*]]) #[[ATTR0:[0-9]+]] {358; BE-MEMDEP-NEXT: [[ENTRY:.*:]]359; BE-MEMDEP-NEXT: tail call void @llvm.memset.p0.i64(ptr [[A]], i8 1, i64 200, i1 false)360; BE-MEMDEP-NEXT: ret i16 257361;362; BE-MEMSSA-LABEL: define signext i16 @memset_to_i16_local(363; BE-MEMSSA-SAME: ptr [[A:%.*]]) #[[ATTR0:[0-9]+]] {364; BE-MEMSSA-NEXT: [[ENTRY:.*:]]365; BE-MEMSSA-NEXT: tail call void @llvm.memset.p0.i64(ptr [[A]], i8 1, i64 200, i1 false)366; BE-MEMSSA-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i16, ptr [[A]], i64 42367; BE-MEMSSA-NEXT: [[TTMP2:%.*]] = load i16, ptr [[ARRAYIDX]], align 2368; BE-MEMSSA-NEXT: ret i16 [[TTMP2]]369;370entry:371 tail call void @llvm.memset.p0.i64(ptr %A, i8 1, i64 200, i1 false)372 %arrayidx = getelementptr inbounds i16, ptr %A, i64 42373 %ttmp2 = load i16, ptr %arrayidx374 ret i16 %ttmp2375}376 377; memset -> float forwarding.378define float @memset_to_float_local(ptr %A, i8 %Val) nounwind ssp {379; LE-MEMDEP-LABEL: define float @memset_to_float_local(380; LE-MEMDEP-SAME: ptr [[A:%.*]], i8 [[VAL:%.*]]) #[[ATTR0]] {381; LE-MEMDEP-NEXT: [[ENTRY:.*:]]382; LE-MEMDEP-NEXT: tail call void @llvm.memset.p0.i64(ptr [[A]], i8 [[VAL]], i64 400, i1 false)383; LE-MEMDEP-NEXT: [[TMP0:%.*]] = zext i8 [[VAL]] to i32384; LE-MEMDEP-NEXT: [[TMP1:%.*]] = shl i32 [[TMP0]], 8385; LE-MEMDEP-NEXT: [[TMP2:%.*]] = or i32 [[TMP0]], [[TMP1]]386; LE-MEMDEP-NEXT: [[TMP3:%.*]] = shl i32 [[TMP2]], 16387; LE-MEMDEP-NEXT: [[TMP4:%.*]] = or i32 [[TMP2]], [[TMP3]]388; LE-MEMDEP-NEXT: [[TMP5:%.*]] = bitcast i32 [[TMP4]] to float389; LE-MEMDEP-NEXT: ret float [[TMP5]]390;391; LE-MEMSSA-LABEL: define float @memset_to_float_local(392; LE-MEMSSA-SAME: ptr [[A:%.*]], i8 [[VAL:%.*]]) #[[ATTR0]] {393; LE-MEMSSA-NEXT: [[ENTRY:.*:]]394; LE-MEMSSA-NEXT: tail call void @llvm.memset.p0.i64(ptr [[A]], i8 [[VAL]], i64 400, i1 false)395; LE-MEMSSA-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds float, ptr [[A]], i64 42396; LE-MEMSSA-NEXT: [[TTMP2:%.*]] = load float, ptr [[ARRAYIDX]], align 4397; LE-MEMSSA-NEXT: ret float [[TTMP2]]398;399; BE-MEMDEP-LABEL: define float @memset_to_float_local(400; BE-MEMDEP-SAME: ptr [[A:%.*]], i8 [[VAL:%.*]]) #[[ATTR0]] {401; BE-MEMDEP-NEXT: [[ENTRY:.*:]]402; BE-MEMDEP-NEXT: tail call void @llvm.memset.p0.i64(ptr [[A]], i8 [[VAL]], i64 400, i1 false)403; BE-MEMDEP-NEXT: [[TMP0:%.*]] = zext i8 [[VAL]] to i32404; BE-MEMDEP-NEXT: [[TMP1:%.*]] = shl i32 [[TMP0]], 8405; BE-MEMDEP-NEXT: [[TMP2:%.*]] = or i32 [[TMP0]], [[TMP1]]406; BE-MEMDEP-NEXT: [[TMP3:%.*]] = shl i32 [[TMP2]], 16407; BE-MEMDEP-NEXT: [[TMP4:%.*]] = or i32 [[TMP2]], [[TMP3]]408; BE-MEMDEP-NEXT: [[TMP5:%.*]] = bitcast i32 [[TMP4]] to float409; BE-MEMDEP-NEXT: ret float [[TMP5]]410;411; BE-MEMSSA-LABEL: define float @memset_to_float_local(412; BE-MEMSSA-SAME: ptr [[A:%.*]], i8 [[VAL:%.*]]) #[[ATTR0]] {413; BE-MEMSSA-NEXT: [[ENTRY:.*:]]414; BE-MEMSSA-NEXT: tail call void @llvm.memset.p0.i64(ptr [[A]], i8 [[VAL]], i64 400, i1 false)415; BE-MEMSSA-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds float, ptr [[A]], i64 42416; BE-MEMSSA-NEXT: [[TTMP2:%.*]] = load float, ptr [[ARRAYIDX]], align 4417; BE-MEMSSA-NEXT: ret float [[TTMP2]]418;419entry:420 tail call void @llvm.memset.p0.i64(ptr %A, i8 %Val, i64 400, i1 false)421 %arrayidx = getelementptr inbounds float, ptr %A, i64 42 ; <ptr> [#uses=1]422 %ttmp2 = load float, ptr %arrayidx ; <float> [#uses=1]423 ret float %ttmp2424}425 426;; non-local memset -> i16 load forwarding.427define i16 @memset_to_i16_nonlocal0(ptr %P, i1 %cond) {428; LE-MEMDEP-LABEL: define i16 @memset_to_i16_nonlocal0(429; LE-MEMDEP-SAME: ptr [[P:%.*]], i1 [[COND:%.*]]) {430; LE-MEMDEP-NEXT: br i1 [[COND]], label %[[T:.*]], label %[[F:.*]]431; LE-MEMDEP: [[T]]:432; LE-MEMDEP-NEXT: tail call void @llvm.memset.p0.i64(ptr [[P]], i8 1, i64 400, i1 false)433; LE-MEMDEP-NEXT: br label %[[CONT:.*]]434; LE-MEMDEP: [[F]]:435; LE-MEMDEP-NEXT: tail call void @llvm.memset.p0.i64(ptr [[P]], i8 2, i64 400, i1 false)436; LE-MEMDEP-NEXT: br label %[[CONT]]437; LE-MEMDEP: [[CONT]]:438; LE-MEMDEP-NEXT: [[A:%.*]] = phi i16 [ 514, %[[F]] ], [ 257, %[[T]] ]439; LE-MEMDEP-NEXT: ret i16 [[A]]440;441; LE-MEMSSA-LABEL: define i16 @memset_to_i16_nonlocal0(442; LE-MEMSSA-SAME: ptr [[P:%.*]], i1 [[COND:%.*]]) {443; LE-MEMSSA-NEXT: br i1 [[COND]], label %[[T:.*]], label %[[F:.*]]444; LE-MEMSSA: [[T]]:445; LE-MEMSSA-NEXT: tail call void @llvm.memset.p0.i64(ptr [[P]], i8 1, i64 400, i1 false)446; LE-MEMSSA-NEXT: br label %[[CONT:.*]]447; LE-MEMSSA: [[F]]:448; LE-MEMSSA-NEXT: tail call void @llvm.memset.p0.i64(ptr [[P]], i8 2, i64 400, i1 false)449; LE-MEMSSA-NEXT: br label %[[CONT]]450; LE-MEMSSA: [[CONT]]:451; LE-MEMSSA-NEXT: [[P2:%.*]] = getelementptr i16, ptr [[P]], i32 4452; LE-MEMSSA-NEXT: [[A:%.*]] = load i16, ptr [[P2]], align 2453; LE-MEMSSA-NEXT: ret i16 [[A]]454;455; BE-MEMDEP-LABEL: define i16 @memset_to_i16_nonlocal0(456; BE-MEMDEP-SAME: ptr [[P:%.*]], i1 [[COND:%.*]]) {457; BE-MEMDEP-NEXT: br i1 [[COND]], label %[[T:.*]], label %[[F:.*]]458; BE-MEMDEP: [[T]]:459; BE-MEMDEP-NEXT: tail call void @llvm.memset.p0.i64(ptr [[P]], i8 1, i64 400, i1 false)460; BE-MEMDEP-NEXT: br label %[[CONT:.*]]461; BE-MEMDEP: [[F]]:462; BE-MEMDEP-NEXT: tail call void @llvm.memset.p0.i64(ptr [[P]], i8 2, i64 400, i1 false)463; BE-MEMDEP-NEXT: br label %[[CONT]]464; BE-MEMDEP: [[CONT]]:465; BE-MEMDEP-NEXT: [[A:%.*]] = phi i16 [ 514, %[[F]] ], [ 257, %[[T]] ]466; BE-MEMDEP-NEXT: ret i16 [[A]]467;468; BE-MEMSSA-LABEL: define i16 @memset_to_i16_nonlocal0(469; BE-MEMSSA-SAME: ptr [[P:%.*]], i1 [[COND:%.*]]) {470; BE-MEMSSA-NEXT: br i1 [[COND]], label %[[T:.*]], label %[[F:.*]]471; BE-MEMSSA: [[T]]:472; BE-MEMSSA-NEXT: tail call void @llvm.memset.p0.i64(ptr [[P]], i8 1, i64 400, i1 false)473; BE-MEMSSA-NEXT: br label %[[CONT:.*]]474; BE-MEMSSA: [[F]]:475; BE-MEMSSA-NEXT: tail call void @llvm.memset.p0.i64(ptr [[P]], i8 2, i64 400, i1 false)476; BE-MEMSSA-NEXT: br label %[[CONT]]477; BE-MEMSSA: [[CONT]]:478; BE-MEMSSA-NEXT: [[P2:%.*]] = getelementptr i16, ptr [[P]], i32 4479; BE-MEMSSA-NEXT: [[A:%.*]] = load i16, ptr [[P2]], align 2480; BE-MEMSSA-NEXT: ret i16 [[A]]481;482 br i1 %cond, label %T, label %F483T:484 tail call void @llvm.memset.p0.i64(ptr %P, i8 1, i64 400, i1 false)485 br label %Cont486 487F:488 tail call void @llvm.memset.p0.i64(ptr %P, i8 2, i64 400, i1 false)489 br label %Cont490 491Cont:492 %P2 = getelementptr i16, ptr %P, i32 4493 %A = load i16, ptr %P2494 ret i16 %A495 496}497 498@GCst = constant {i32, float, i32 } { i32 42, float 14., i32 97 }499@GCst_as1 = addrspace(1) constant {i32, float, i32 } { i32 42, float 14., i32 97 }500 501; memset -> float forwarding.502define float @memcpy_to_float_local(ptr %A) nounwind ssp {503; LE-MEMDEP-LABEL: define float @memcpy_to_float_local(504; LE-MEMDEP-SAME: ptr [[A:%.*]]) #[[ATTR0]] {505; LE-MEMDEP-NEXT: [[ENTRY:.*:]]506; LE-MEMDEP-NEXT: tail call void @llvm.memcpy.p0.p0.i64(ptr [[A]], ptr @GCst, i64 12, i1 false)507; LE-MEMDEP-NEXT: ret float 1.400000e+01508;509; LE-MEMSSA-LABEL: define float @memcpy_to_float_local(510; LE-MEMSSA-SAME: ptr [[A:%.*]]) #[[ATTR0]] {511; LE-MEMSSA-NEXT: [[ENTRY:.*:]]512; LE-MEMSSA-NEXT: tail call void @llvm.memcpy.p0.p0.i64(ptr [[A]], ptr @GCst, i64 12, i1 false)513; LE-MEMSSA-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds float, ptr [[A]], i64 1514; LE-MEMSSA-NEXT: [[TTMP2:%.*]] = load float, ptr [[ARRAYIDX]], align 4515; LE-MEMSSA-NEXT: ret float [[TTMP2]]516;517; BE-MEMDEP-LABEL: define float @memcpy_to_float_local(518; BE-MEMDEP-SAME: ptr [[A:%.*]]) #[[ATTR0]] {519; BE-MEMDEP-NEXT: [[ENTRY:.*:]]520; BE-MEMDEP-NEXT: tail call void @llvm.memcpy.p0.p0.i64(ptr [[A]], ptr @GCst, i64 12, i1 false)521; BE-MEMDEP-NEXT: ret float 1.400000e+01522;523; BE-MEMSSA-LABEL: define float @memcpy_to_float_local(524; BE-MEMSSA-SAME: ptr [[A:%.*]]) #[[ATTR0]] {525; BE-MEMSSA-NEXT: [[ENTRY:.*:]]526; BE-MEMSSA-NEXT: tail call void @llvm.memcpy.p0.p0.i64(ptr [[A]], ptr @GCst, i64 12, i1 false)527; BE-MEMSSA-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds float, ptr [[A]], i64 1528; BE-MEMSSA-NEXT: [[TTMP2:%.*]] = load float, ptr [[ARRAYIDX]], align 4529; BE-MEMSSA-NEXT: ret float [[TTMP2]]530;531entry:532 tail call void @llvm.memcpy.p0.p0.i64(ptr %A, ptr @GCst, i64 12, i1 false)533 %arrayidx = getelementptr inbounds float, ptr %A, i64 1 ; <ptr> [#uses=1]534 %ttmp2 = load float, ptr %arrayidx ; <float> [#uses=1]535 ret float %ttmp2536}537 538; memcpy from address space 1539define float @memcpy_to_float_local_as1(ptr %A) nounwind ssp {540; LE-MEMDEP-LABEL: define float @memcpy_to_float_local_as1(541; LE-MEMDEP-SAME: ptr [[A:%.*]]) #[[ATTR0]] {542; LE-MEMDEP-NEXT: [[ENTRY:.*:]]543; LE-MEMDEP-NEXT: tail call void @llvm.memcpy.p0.p1.i64(ptr [[A]], ptr addrspace(1) @GCst_as1, i64 12, i1 false)544; LE-MEMDEP-NEXT: ret float 1.400000e+01545;546; LE-MEMSSA-LABEL: define float @memcpy_to_float_local_as1(547; LE-MEMSSA-SAME: ptr [[A:%.*]]) #[[ATTR0]] {548; LE-MEMSSA-NEXT: [[ENTRY:.*:]]549; LE-MEMSSA-NEXT: tail call void @llvm.memcpy.p0.p1.i64(ptr [[A]], ptr addrspace(1) @GCst_as1, i64 12, i1 false)550; LE-MEMSSA-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds float, ptr [[A]], i64 1551; LE-MEMSSA-NEXT: [[TTMP2:%.*]] = load float, ptr [[ARRAYIDX]], align 4552; LE-MEMSSA-NEXT: ret float [[TTMP2]]553;554; BE-MEMDEP-LABEL: define float @memcpy_to_float_local_as1(555; BE-MEMDEP-SAME: ptr [[A:%.*]]) #[[ATTR0]] {556; BE-MEMDEP-NEXT: [[ENTRY:.*:]]557; BE-MEMDEP-NEXT: tail call void @llvm.memcpy.p0.p1.i64(ptr [[A]], ptr addrspace(1) @GCst_as1, i64 12, i1 false)558; BE-MEMDEP-NEXT: ret float 1.400000e+01559;560; BE-MEMSSA-LABEL: define float @memcpy_to_float_local_as1(561; BE-MEMSSA-SAME: ptr [[A:%.*]]) #[[ATTR0]] {562; BE-MEMSSA-NEXT: [[ENTRY:.*:]]563; BE-MEMSSA-NEXT: tail call void @llvm.memcpy.p0.p1.i64(ptr [[A]], ptr addrspace(1) @GCst_as1, i64 12, i1 false)564; BE-MEMSSA-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds float, ptr [[A]], i64 1565; BE-MEMSSA-NEXT: [[TTMP2:%.*]] = load float, ptr [[ARRAYIDX]], align 4566; BE-MEMSSA-NEXT: ret float [[TTMP2]]567;568entry:569 tail call void @llvm.memcpy.p0.p1.i64(ptr %A, ptr addrspace(1) @GCst_as1, i64 12, i1 false)570 %arrayidx = getelementptr inbounds float, ptr %A, i64 1 ; <ptr> [#uses=1]571 %ttmp2 = load float, ptr %arrayidx ; <float> [#uses=1]572 ret float %ttmp2573}574 575;; non-local i32/float -> i8 load forwarding.576define i8 @coerce_mustalias_nonlocal0(ptr %P, i1 %cond) {577; LE-MEMDEP-LABEL: define i8 @coerce_mustalias_nonlocal0(578; LE-MEMDEP-SAME: ptr [[P:%.*]], i1 [[COND:%.*]]) {579; LE-MEMDEP-NEXT: br i1 [[COND]], label %[[T:.*]], label %[[F:.*]]580; LE-MEMDEP: [[T]]:581; LE-MEMDEP-NEXT: store i32 42, ptr [[P]], align 4582; LE-MEMDEP-NEXT: br label %[[CONT:.*]]583; LE-MEMDEP: [[F]]:584; LE-MEMDEP-NEXT: store float 1.000000e+00, ptr [[P]], align 4585; LE-MEMDEP-NEXT: br label %[[CONT]]586; LE-MEMDEP: [[CONT]]:587; LE-MEMDEP-NEXT: [[A:%.*]] = phi i8 [ 0, %[[F]] ], [ 42, %[[T]] ]588; LE-MEMDEP-NEXT: ret i8 [[A]]589;590; LE-MEMSSA-LABEL: define i8 @coerce_mustalias_nonlocal0(591; LE-MEMSSA-SAME: ptr [[P:%.*]], i1 [[COND:%.*]]) {592; LE-MEMSSA-NEXT: br i1 [[COND]], label %[[T:.*]], label %[[F:.*]]593; LE-MEMSSA: [[T]]:594; LE-MEMSSA-NEXT: store i32 42, ptr [[P]], align 4595; LE-MEMSSA-NEXT: br label %[[CONT:.*]]596; LE-MEMSSA: [[F]]:597; LE-MEMSSA-NEXT: store float 1.000000e+00, ptr [[P]], align 4598; LE-MEMSSA-NEXT: br label %[[CONT]]599; LE-MEMSSA: [[CONT]]:600; LE-MEMSSA-NEXT: [[A:%.*]] = load i8, ptr [[P]], align 1601; LE-MEMSSA-NEXT: ret i8 [[A]]602;603; BE-MEMDEP-LABEL: define i8 @coerce_mustalias_nonlocal0(604; BE-MEMDEP-SAME: ptr [[P:%.*]], i1 [[COND:%.*]]) {605; BE-MEMDEP-NEXT: br i1 [[COND]], label %[[T:.*]], label %[[F:.*]]606; BE-MEMDEP: [[T]]:607; BE-MEMDEP-NEXT: store i32 42, ptr [[P]], align 4608; BE-MEMDEP-NEXT: br label %[[CONT:.*]]609; BE-MEMDEP: [[F]]:610; BE-MEMDEP-NEXT: store float 1.000000e+00, ptr [[P]], align 4611; BE-MEMDEP-NEXT: br label %[[CONT]]612; BE-MEMDEP: [[CONT]]:613; BE-MEMDEP-NEXT: [[A:%.*]] = phi i8 [ 63, %[[F]] ], [ 0, %[[T]] ]614; BE-MEMDEP-NEXT: ret i8 [[A]]615;616; BE-MEMSSA-LABEL: define i8 @coerce_mustalias_nonlocal0(617; BE-MEMSSA-SAME: ptr [[P:%.*]], i1 [[COND:%.*]]) {618; BE-MEMSSA-NEXT: br i1 [[COND]], label %[[T:.*]], label %[[F:.*]]619; BE-MEMSSA: [[T]]:620; BE-MEMSSA-NEXT: store i32 42, ptr [[P]], align 4621; BE-MEMSSA-NEXT: br label %[[CONT:.*]]622; BE-MEMSSA: [[F]]:623; BE-MEMSSA-NEXT: store float 1.000000e+00, ptr [[P]], align 4624; BE-MEMSSA-NEXT: br label %[[CONT]]625; BE-MEMSSA: [[CONT]]:626; BE-MEMSSA-NEXT: [[A:%.*]] = load i8, ptr [[P]], align 1627; BE-MEMSSA-NEXT: ret i8 [[A]]628;629 br i1 %cond, label %T, label %F630T:631 store i32 42, ptr %P632 br label %Cont633 634F:635 store float 1.0, ptr %P636 br label %Cont637 638Cont:639 %A = load i8, ptr %P640 ret i8 %A641 642}643 644 645;; non-local i32/float -> i8 load forwarding. This also tests that the "P3"646;; bitcast equivalence can be properly phi translated.647define i8 @coerce_mustalias_nonlocal1(ptr %P, i1 %cond) {648; LE-MEMDEP-LABEL: define i8 @coerce_mustalias_nonlocal1(649; LE-MEMDEP-SAME: ptr [[P:%.*]], i1 [[COND:%.*]]) {650; LE-MEMDEP-NEXT: br i1 [[COND]], label %[[T:.*]], label %[[F:.*]]651; LE-MEMDEP: [[T]]:652; LE-MEMDEP-NEXT: store i32 42, ptr [[P]], align 4653; LE-MEMDEP-NEXT: br label %[[CONT:.*]]654; LE-MEMDEP: [[F]]:655; LE-MEMDEP-NEXT: store float 1.000000e+00, ptr [[P]], align 4656; LE-MEMDEP-NEXT: br label %[[CONT]]657; LE-MEMDEP: [[CONT]]:658; LE-MEMDEP-NEXT: [[A:%.*]] = phi i8 [ 0, %[[F]] ], [ 42, %[[T]] ]659; LE-MEMDEP-NEXT: ret i8 [[A]]660;661; LE-MEMSSA-LABEL: define i8 @coerce_mustalias_nonlocal1(662; LE-MEMSSA-SAME: ptr [[P:%.*]], i1 [[COND:%.*]]) {663; LE-MEMSSA-NEXT: br i1 [[COND]], label %[[T:.*]], label %[[F:.*]]664; LE-MEMSSA: [[T]]:665; LE-MEMSSA-NEXT: store i32 42, ptr [[P]], align 4666; LE-MEMSSA-NEXT: br label %[[CONT:.*]]667; LE-MEMSSA: [[F]]:668; LE-MEMSSA-NEXT: store float 1.000000e+00, ptr [[P]], align 4669; LE-MEMSSA-NEXT: br label %[[CONT]]670; LE-MEMSSA: [[CONT]]:671; LE-MEMSSA-NEXT: [[A:%.*]] = load i8, ptr [[P]], align 1672; LE-MEMSSA-NEXT: ret i8 [[A]]673;674; BE-MEMDEP-LABEL: define i8 @coerce_mustalias_nonlocal1(675; BE-MEMDEP-SAME: ptr [[P:%.*]], i1 [[COND:%.*]]) {676; BE-MEMDEP-NEXT: br i1 [[COND]], label %[[T:.*]], label %[[F:.*]]677; BE-MEMDEP: [[T]]:678; BE-MEMDEP-NEXT: store i32 42, ptr [[P]], align 4679; BE-MEMDEP-NEXT: br label %[[CONT:.*]]680; BE-MEMDEP: [[F]]:681; BE-MEMDEP-NEXT: store float 1.000000e+00, ptr [[P]], align 4682; BE-MEMDEP-NEXT: br label %[[CONT]]683; BE-MEMDEP: [[CONT]]:684; BE-MEMDEP-NEXT: [[A:%.*]] = phi i8 [ 63, %[[F]] ], [ 0, %[[T]] ]685; BE-MEMDEP-NEXT: ret i8 [[A]]686;687; BE-MEMSSA-LABEL: define i8 @coerce_mustalias_nonlocal1(688; BE-MEMSSA-SAME: ptr [[P:%.*]], i1 [[COND:%.*]]) {689; BE-MEMSSA-NEXT: br i1 [[COND]], label %[[T:.*]], label %[[F:.*]]690; BE-MEMSSA: [[T]]:691; BE-MEMSSA-NEXT: store i32 42, ptr [[P]], align 4692; BE-MEMSSA-NEXT: br label %[[CONT:.*]]693; BE-MEMSSA: [[F]]:694; BE-MEMSSA-NEXT: store float 1.000000e+00, ptr [[P]], align 4695; BE-MEMSSA-NEXT: br label %[[CONT]]696; BE-MEMSSA: [[CONT]]:697; BE-MEMSSA-NEXT: [[A:%.*]] = load i8, ptr [[P]], align 1698; BE-MEMSSA-NEXT: ret i8 [[A]]699;700 br i1 %cond, label %T, label %F701T:702 store i32 42, ptr %P703 br label %Cont704 705F:706 store float 1.0, ptr %P707 br label %Cont708 709Cont:710 %A = load i8, ptr %P711 ret i8 %A712 713}714 715 716;; non-local i32 -> i8 partial redundancy load forwarding.717define i8 @coerce_mustalias_pre0(ptr %P, i1 %cond) {718; LE-MEMDEP-LABEL: define i8 @coerce_mustalias_pre0(719; LE-MEMDEP-SAME: ptr [[P:%.*]], i1 [[COND:%.*]]) {720; LE-MEMDEP-NEXT: br i1 [[COND]], label %[[T:.*]], label %[[F:.*]]721; LE-MEMDEP: [[T]]:722; LE-MEMDEP-NEXT: store i32 42, ptr [[P]], align 4723; LE-MEMDEP-NEXT: br label %[[CONT:.*]]724; LE-MEMDEP: [[F]]:725; LE-MEMDEP-NEXT: [[A_PRE:%.*]] = load i8, ptr [[P]], align 1726; LE-MEMDEP-NEXT: br label %[[CONT]]727; LE-MEMDEP: [[CONT]]:728; LE-MEMDEP-NEXT: [[A:%.*]] = phi i8 [ [[A_PRE]], %[[F]] ], [ 42, %[[T]] ]729; LE-MEMDEP-NEXT: ret i8 [[A]]730;731; LE-MEMSSA-LABEL: define i8 @coerce_mustalias_pre0(732; LE-MEMSSA-SAME: ptr [[P:%.*]], i1 [[COND:%.*]]) {733; LE-MEMSSA-NEXT: br i1 [[COND]], label %[[T:.*]], label %[[F:.*]]734; LE-MEMSSA: [[T]]:735; LE-MEMSSA-NEXT: store i32 42, ptr [[P]], align 4736; LE-MEMSSA-NEXT: br label %[[CONT:.*]]737; LE-MEMSSA: [[F]]:738; LE-MEMSSA-NEXT: br label %[[CONT]]739; LE-MEMSSA: [[CONT]]:740; LE-MEMSSA-NEXT: [[A:%.*]] = load i8, ptr [[P]], align 1741; LE-MEMSSA-NEXT: ret i8 [[A]]742;743; BE-MEMDEP-LABEL: define i8 @coerce_mustalias_pre0(744; BE-MEMDEP-SAME: ptr [[P:%.*]], i1 [[COND:%.*]]) {745; BE-MEMDEP-NEXT: br i1 [[COND]], label %[[T:.*]], label %[[F:.*]]746; BE-MEMDEP: [[T]]:747; BE-MEMDEP-NEXT: store i32 42, ptr [[P]], align 4748; BE-MEMDEP-NEXT: br label %[[CONT:.*]]749; BE-MEMDEP: [[F]]:750; BE-MEMDEP-NEXT: [[A_PRE:%.*]] = load i8, ptr [[P]], align 1751; BE-MEMDEP-NEXT: br label %[[CONT]]752; BE-MEMDEP: [[CONT]]:753; BE-MEMDEP-NEXT: [[A:%.*]] = phi i8 [ [[A_PRE]], %[[F]] ], [ 0, %[[T]] ]754; BE-MEMDEP-NEXT: ret i8 [[A]]755;756; BE-MEMSSA-LABEL: define i8 @coerce_mustalias_pre0(757; BE-MEMSSA-SAME: ptr [[P:%.*]], i1 [[COND:%.*]]) {758; BE-MEMSSA-NEXT: br i1 [[COND]], label %[[T:.*]], label %[[F:.*]]759; BE-MEMSSA: [[T]]:760; BE-MEMSSA-NEXT: store i32 42, ptr [[P]], align 4761; BE-MEMSSA-NEXT: br label %[[CONT:.*]]762; BE-MEMSSA: [[F]]:763; BE-MEMSSA-NEXT: br label %[[CONT]]764; BE-MEMSSA: [[CONT]]:765; BE-MEMSSA-NEXT: [[A:%.*]] = load i8, ptr [[P]], align 1766; BE-MEMSSA-NEXT: ret i8 [[A]]767;768 br i1 %cond, label %T, label %F769T:770 store i32 42, ptr %P771 br label %Cont772 773F:774 br label %Cont775 776Cont:777 %A = load i8, ptr %P778 ret i8 %A779 780}781 782;;===----------------------------------------------------------------------===;;783;; Store -> Load and Load -> Load forwarding where src and dst are different784;; types, and the reload is an offset from the store pointer.785;;===----------------------------------------------------------------------===;;786 787;; i32 -> i8 forwarding.788;; PR4216789define i8 @coerce_offset0(i32 %V, ptr %P) {790; LE-MEMDEP-LABEL: define i8 @coerce_offset0(791; LE-MEMDEP-SAME: i32 [[V:%.*]], ptr [[P:%.*]]) {792; LE-MEMDEP-NEXT: store i32 [[V]], ptr [[P]], align 4793; LE-MEMDEP-NEXT: [[TMP1:%.*]] = lshr i32 [[V]], 16794; LE-MEMDEP-NEXT: [[TMP2:%.*]] = trunc i32 [[TMP1]] to i8795; LE-MEMDEP-NEXT: ret i8 [[TMP2]]796;797; LE-MEMSSA-LABEL: define i8 @coerce_offset0(798; LE-MEMSSA-SAME: i32 [[V:%.*]], ptr [[P:%.*]]) {799; LE-MEMSSA-NEXT: store i32 [[V]], ptr [[P]], align 4800; LE-MEMSSA-NEXT: [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 2801; LE-MEMSSA-NEXT: [[A:%.*]] = load i8, ptr [[P3]], align 1802; LE-MEMSSA-NEXT: ret i8 [[A]]803;804; BE-MEMDEP-LABEL: define i8 @coerce_offset0(805; BE-MEMDEP-SAME: i32 [[V:%.*]], ptr [[P:%.*]]) {806; BE-MEMDEP-NEXT: store i32 [[V]], ptr [[P]], align 4807; BE-MEMDEP-NEXT: [[TMP1:%.*]] = lshr i32 [[V]], 8808; BE-MEMDEP-NEXT: [[TMP2:%.*]] = trunc i32 [[TMP1]] to i8809; BE-MEMDEP-NEXT: ret i8 [[TMP2]]810;811; BE-MEMSSA-LABEL: define i8 @coerce_offset0(812; BE-MEMSSA-SAME: i32 [[V:%.*]], ptr [[P:%.*]]) {813; BE-MEMSSA-NEXT: store i32 [[V]], ptr [[P]], align 4814; BE-MEMSSA-NEXT: [[P3:%.*]] = getelementptr i8, ptr [[P]], i32 2815; BE-MEMSSA-NEXT: [[A:%.*]] = load i8, ptr [[P3]], align 1816; BE-MEMSSA-NEXT: ret i8 [[A]]817;818 store i32 %V, ptr %P819 820 %P3 = getelementptr i8, ptr %P, i32 2821 822 %A = load i8, ptr %P3823 ret i8 %A824}825 826;; non-local i32/float -> i8 load forwarding.827define i8 @coerce_offset_nonlocal0(ptr %P, i1 %cond) {828; LE-MEMDEP-LABEL: define i8 @coerce_offset_nonlocal0(829; LE-MEMDEP-SAME: ptr [[P:%.*]], i1 [[COND:%.*]]) {830; LE-MEMDEP-NEXT: br i1 [[COND]], label %[[T:.*]], label %[[F:.*]]831; LE-MEMDEP: [[T]]:832; LE-MEMDEP-NEXT: store i32 57005, ptr [[P]], align 4833; LE-MEMDEP-NEXT: br label %[[CONT:.*]]834; LE-MEMDEP: [[F]]:835; LE-MEMDEP-NEXT: store float 1.000000e+00, ptr [[P]], align 4836; LE-MEMDEP-NEXT: br label %[[CONT]]837; LE-MEMDEP: [[CONT]]:838; LE-MEMDEP-NEXT: [[A:%.*]] = phi i8 [ -128, %[[F]] ], [ 0, %[[T]] ]839; LE-MEMDEP-NEXT: ret i8 [[A]]840;841; LE-MEMSSA-LABEL: define i8 @coerce_offset_nonlocal0(842; LE-MEMSSA-SAME: ptr [[P:%.*]], i1 [[COND:%.*]]) {843; LE-MEMSSA-NEXT: [[P4:%.*]] = getelementptr i8, ptr [[P]], i32 2844; LE-MEMSSA-NEXT: br i1 [[COND]], label %[[T:.*]], label %[[F:.*]]845; LE-MEMSSA: [[T]]:846; LE-MEMSSA-NEXT: store i32 57005, ptr [[P]], align 4847; LE-MEMSSA-NEXT: br label %[[CONT:.*]]848; LE-MEMSSA: [[F]]:849; LE-MEMSSA-NEXT: store float 1.000000e+00, ptr [[P]], align 4850; LE-MEMSSA-NEXT: br label %[[CONT]]851; LE-MEMSSA: [[CONT]]:852; LE-MEMSSA-NEXT: [[A:%.*]] = load i8, ptr [[P4]], align 1853; LE-MEMSSA-NEXT: ret i8 [[A]]854;855; BE-MEMDEP-LABEL: define i8 @coerce_offset_nonlocal0(856; BE-MEMDEP-SAME: ptr [[P:%.*]], i1 [[COND:%.*]]) {857; BE-MEMDEP-NEXT: br i1 [[COND]], label %[[T:.*]], label %[[F:.*]]858; BE-MEMDEP: [[T]]:859; BE-MEMDEP-NEXT: store i32 57005, ptr [[P]], align 4860; BE-MEMDEP-NEXT: br label %[[CONT:.*]]861; BE-MEMDEP: [[F]]:862; BE-MEMDEP-NEXT: store float 1.000000e+00, ptr [[P]], align 4863; BE-MEMDEP-NEXT: br label %[[CONT]]864; BE-MEMDEP: [[CONT]]:865; BE-MEMDEP-NEXT: [[A:%.*]] = phi i8 [ 0, %[[F]] ], [ -34, %[[T]] ]866; BE-MEMDEP-NEXT: ret i8 [[A]]867;868; BE-MEMSSA-LABEL: define i8 @coerce_offset_nonlocal0(869; BE-MEMSSA-SAME: ptr [[P:%.*]], i1 [[COND:%.*]]) {870; BE-MEMSSA-NEXT: [[P4:%.*]] = getelementptr i8, ptr [[P]], i32 2871; BE-MEMSSA-NEXT: br i1 [[COND]], label %[[T:.*]], label %[[F:.*]]872; BE-MEMSSA: [[T]]:873; BE-MEMSSA-NEXT: store i32 57005, ptr [[P]], align 4874; BE-MEMSSA-NEXT: br label %[[CONT:.*]]875; BE-MEMSSA: [[F]]:876; BE-MEMSSA-NEXT: store float 1.000000e+00, ptr [[P]], align 4877; BE-MEMSSA-NEXT: br label %[[CONT]]878; BE-MEMSSA: [[CONT]]:879; BE-MEMSSA-NEXT: [[A:%.*]] = load i8, ptr [[P4]], align 1880; BE-MEMSSA-NEXT: ret i8 [[A]]881;882 %P4 = getelementptr i8, ptr %P, i32 2883 br i1 %cond, label %T, label %F884T:885 store i32 57005, ptr %P886 br label %Cont887 888F:889 store float 1.0, ptr %P890 br label %Cont891 892Cont:893 %A = load i8, ptr %P4894 ret i8 %A895 896}897 898 899;; non-local i32 -> i8 partial redundancy load forwarding.900define i8 @coerce_offset_pre0(ptr %P, i1 %cond) {901; LE-MEMDEP-LABEL: define i8 @coerce_offset_pre0(902; LE-MEMDEP-SAME: ptr [[P:%.*]], i1 [[COND:%.*]]) {903; LE-MEMDEP-NEXT: [[P4:%.*]] = getelementptr i8, ptr [[P]], i32 2904; LE-MEMDEP-NEXT: br i1 [[COND]], label %[[T:.*]], label %[[F:.*]]905; LE-MEMDEP: [[T]]:906; LE-MEMDEP-NEXT: store i32 42, ptr [[P]], align 4907; LE-MEMDEP-NEXT: br label %[[CONT:.*]]908; LE-MEMDEP: [[F]]:909; LE-MEMDEP-NEXT: [[A_PRE:%.*]] = load i8, ptr [[P4]], align 1910; LE-MEMDEP-NEXT: br label %[[CONT]]911; LE-MEMDEP: [[CONT]]:912; LE-MEMDEP-NEXT: [[A:%.*]] = phi i8 [ [[A_PRE]], %[[F]] ], [ 0, %[[T]] ]913; LE-MEMDEP-NEXT: ret i8 [[A]]914;915; LE-MEMSSA-LABEL: define i8 @coerce_offset_pre0(916; LE-MEMSSA-SAME: ptr [[P:%.*]], i1 [[COND:%.*]]) {917; LE-MEMSSA-NEXT: [[P4:%.*]] = getelementptr i8, ptr [[P]], i32 2918; LE-MEMSSA-NEXT: br i1 [[COND]], label %[[T:.*]], label %[[F:.*]]919; LE-MEMSSA: [[T]]:920; LE-MEMSSA-NEXT: store i32 42, ptr [[P]], align 4921; LE-MEMSSA-NEXT: br label %[[CONT:.*]]922; LE-MEMSSA: [[F]]:923; LE-MEMSSA-NEXT: br label %[[CONT]]924; LE-MEMSSA: [[CONT]]:925; LE-MEMSSA-NEXT: [[A:%.*]] = load i8, ptr [[P4]], align 1926; LE-MEMSSA-NEXT: ret i8 [[A]]927;928; BE-MEMDEP-LABEL: define i8 @coerce_offset_pre0(929; BE-MEMDEP-SAME: ptr [[P:%.*]], i1 [[COND:%.*]]) {930; BE-MEMDEP-NEXT: [[P4:%.*]] = getelementptr i8, ptr [[P]], i32 2931; BE-MEMDEP-NEXT: br i1 [[COND]], label %[[T:.*]], label %[[F:.*]]932; BE-MEMDEP: [[T]]:933; BE-MEMDEP-NEXT: store i32 42, ptr [[P]], align 4934; BE-MEMDEP-NEXT: br label %[[CONT:.*]]935; BE-MEMDEP: [[F]]:936; BE-MEMDEP-NEXT: [[A_PRE:%.*]] = load i8, ptr [[P4]], align 1937; BE-MEMDEP-NEXT: br label %[[CONT]]938; BE-MEMDEP: [[CONT]]:939; BE-MEMDEP-NEXT: [[A:%.*]] = phi i8 [ [[A_PRE]], %[[F]] ], [ 0, %[[T]] ]940; BE-MEMDEP-NEXT: ret i8 [[A]]941;942; BE-MEMSSA-LABEL: define i8 @coerce_offset_pre0(943; BE-MEMSSA-SAME: ptr [[P:%.*]], i1 [[COND:%.*]]) {944; BE-MEMSSA-NEXT: [[P4:%.*]] = getelementptr i8, ptr [[P]], i32 2945; BE-MEMSSA-NEXT: br i1 [[COND]], label %[[T:.*]], label %[[F:.*]]946; BE-MEMSSA: [[T]]:947; BE-MEMSSA-NEXT: store i32 42, ptr [[P]], align 4948; BE-MEMSSA-NEXT: br label %[[CONT:.*]]949; BE-MEMSSA: [[F]]:950; BE-MEMSSA-NEXT: br label %[[CONT]]951; BE-MEMSSA: [[CONT]]:952; BE-MEMSSA-NEXT: [[A:%.*]] = load i8, ptr [[P4]], align 1953; BE-MEMSSA-NEXT: ret i8 [[A]]954;955 %P4 = getelementptr i8, ptr %P, i32 2956 br i1 %cond, label %T, label %F957T:958 store i32 42, ptr %P959 br label %Cont960 961F:962 br label %Cont963 964Cont:965 %A = load i8, ptr %P4966 ret i8 %A967 968}969 970define i32 @chained_load(ptr %p, i32 %x, i32 %y) {971; LE-MEMDEP-LABEL: define i32 @chained_load(972; LE-MEMDEP-SAME: ptr [[P:%.*]], i32 [[X:%.*]], i32 [[Y:%.*]]) {973; LE-MEMDEP-NEXT: [[BLOCK1:.*:]]974; LE-MEMDEP-NEXT: [[A:%.*]] = alloca ptr, align 4975; LE-MEMDEP-NEXT: [[Z:%.*]] = load ptr, ptr [[P]], align 4976; LE-MEMDEP-NEXT: store ptr [[Z]], ptr [[A]], align 4977; LE-MEMDEP-NEXT: [[CMP:%.*]] = icmp eq i32 [[X]], [[Y]]978; LE-MEMDEP-NEXT: br i1 [[CMP]], label %[[BLOCK2:.*]], label %[[BLOCK3:.*]]979; LE-MEMDEP: [[BLOCK2]]:980; LE-MEMDEP-NEXT: br label %[[BLOCK4:.*]]981; LE-MEMDEP: [[BLOCK3]]:982; LE-MEMDEP-NEXT: br label %[[BLOCK4]]983; LE-MEMDEP: [[BLOCK4]]:984; LE-MEMDEP-NEXT: [[D:%.*]] = load i32, ptr [[Z]], align 4985; LE-MEMDEP-NEXT: ret i32 [[D]]986;987; LE-MEMSSA-LABEL: define i32 @chained_load(988; LE-MEMSSA-SAME: ptr [[P:%.*]], i32 [[X:%.*]], i32 [[Y:%.*]]) {989; LE-MEMSSA-NEXT: [[BLOCK1:.*:]]990; LE-MEMSSA-NEXT: [[A:%.*]] = alloca ptr, align 4991; LE-MEMSSA-NEXT: [[Z:%.*]] = load ptr, ptr [[P]], align 4992; LE-MEMSSA-NEXT: store ptr [[Z]], ptr [[A]], align 4993; LE-MEMSSA-NEXT: [[CMP:%.*]] = icmp eq i32 [[X]], [[Y]]994; LE-MEMSSA-NEXT: br i1 [[CMP]], label %[[BLOCK2:.*]], label %[[BLOCK3:.*]]995; LE-MEMSSA: [[BLOCK2]]:996; LE-MEMSSA-NEXT: br label %[[BLOCK4:.*]]997; LE-MEMSSA: [[BLOCK3]]:998; LE-MEMSSA-NEXT: br label %[[BLOCK4]]999; LE-MEMSSA: [[BLOCK4]]:1000; LE-MEMSSA-NEXT: [[C:%.*]] = load ptr, ptr [[P]], align 41001; LE-MEMSSA-NEXT: [[D:%.*]] = load i32, ptr [[C]], align 41002; LE-MEMSSA-NEXT: ret i32 [[D]]1003;1004; BE-MEMDEP-LABEL: define i32 @chained_load(1005; BE-MEMDEP-SAME: ptr [[P:%.*]], i32 [[X:%.*]], i32 [[Y:%.*]]) {1006; BE-MEMDEP-NEXT: [[BLOCK1:.*:]]1007; BE-MEMDEP-NEXT: [[A:%.*]] = alloca ptr, align 41008; BE-MEMDEP-NEXT: [[Z:%.*]] = load ptr, ptr [[P]], align 41009; BE-MEMDEP-NEXT: store ptr [[Z]], ptr [[A]], align 41010; BE-MEMDEP-NEXT: [[CMP:%.*]] = icmp eq i32 [[X]], [[Y]]1011; BE-MEMDEP-NEXT: br i1 [[CMP]], label %[[BLOCK2:.*]], label %[[BLOCK3:.*]]1012; BE-MEMDEP: [[BLOCK2]]:1013; BE-MEMDEP-NEXT: br label %[[BLOCK4:.*]]1014; BE-MEMDEP: [[BLOCK3]]:1015; BE-MEMDEP-NEXT: br label %[[BLOCK4]]1016; BE-MEMDEP: [[BLOCK4]]:1017; BE-MEMDEP-NEXT: [[D:%.*]] = load i32, ptr [[Z]], align 41018; BE-MEMDEP-NEXT: ret i32 [[D]]1019;1020; BE-MEMSSA-LABEL: define i32 @chained_load(1021; BE-MEMSSA-SAME: ptr [[P:%.*]], i32 [[X:%.*]], i32 [[Y:%.*]]) {1022; BE-MEMSSA-NEXT: [[BLOCK1:.*:]]1023; BE-MEMSSA-NEXT: [[A:%.*]] = alloca ptr, align 41024; BE-MEMSSA-NEXT: [[Z:%.*]] = load ptr, ptr [[P]], align 41025; BE-MEMSSA-NEXT: store ptr [[Z]], ptr [[A]], align 41026; BE-MEMSSA-NEXT: [[CMP:%.*]] = icmp eq i32 [[X]], [[Y]]1027; BE-MEMSSA-NEXT: br i1 [[CMP]], label %[[BLOCK2:.*]], label %[[BLOCK3:.*]]1028; BE-MEMSSA: [[BLOCK2]]:1029; BE-MEMSSA-NEXT: br label %[[BLOCK4:.*]]1030; BE-MEMSSA: [[BLOCK3]]:1031; BE-MEMSSA-NEXT: br label %[[BLOCK4]]1032; BE-MEMSSA: [[BLOCK4]]:1033; BE-MEMSSA-NEXT: [[C:%.*]] = load ptr, ptr [[P]], align 41034; BE-MEMSSA-NEXT: [[D:%.*]] = load i32, ptr [[C]], align 41035; BE-MEMSSA-NEXT: ret i32 [[D]]1036;1037block1:1038 %A = alloca ptr1039 1040 %z = load ptr, ptr %p1041 store ptr %z, ptr %A1042 %cmp = icmp eq i32 %x, %y1043 br i1 %cmp, label %block2, label %block31044 1045block2:1046 %a = load ptr, ptr %p1047 br label %block41048 1049block3:1050 %b = load ptr, ptr %p1051 br label %block41052 1053block4:1054 %c = load ptr, ptr %p1055 %d = load i32, ptr %c1056 ret i32 %d1057 1058}1059 1060 1061declare i1 @cond() readonly1062declare i1 @cond2() readonly1063 1064define i32 @phi_trans2() {1065; CHECK-LABEL: define i32 @phi_trans2() {1066; CHECK-NEXT: [[ENTRY:.*]]:1067; CHECK-NEXT: [[P:%.*]] = alloca i32, i32 400, align 41068; CHECK-NEXT: br label %[[F1:.*]]1069; CHECK: [[F1]]:1070; CHECK-NEXT: [[A:%.*]] = phi i32 [ 1, %[[ENTRY]] ], [ 2, %[[F:.*]] ]1071; CHECK-NEXT: [[COND2:%.*]] = call i1 @cond()1072; CHECK-NEXT: br i1 [[COND2]], label %[[T1:.*]], label %[[TY:.*]]1073; CHECK: [[T1]]:1074; CHECK-NEXT: [[P2:%.*]] = getelementptr i32, ptr [[P]], i32 [[A]]1075; CHECK-NEXT: [[X:%.*]] = load i32, ptr [[P2]], align 41076; CHECK-NEXT: [[COND:%.*]] = call i1 @cond2()1077; CHECK-NEXT: br i1 [[COND]], label %[[TX:.*]], label %[[F]]1078; CHECK: [[F]]:1079; CHECK-NEXT: [[P3:%.*]] = getelementptr i32, ptr [[P]], i32 21080; CHECK-NEXT: store i32 17, ptr [[P3]], align 41081; CHECK-NEXT: store i32 42, ptr [[P2]], align 41082; CHECK-NEXT: br label %[[F1]]1083; CHECK: [[TX]]:1084; CHECK-NEXT: ret i32 [[X]]1085; CHECK: [[TY]]:1086; CHECK-NEXT: ret i32 01087;1088entry:1089 %P = alloca i32, i32 4001090 br label %F11091 1092F1:1093 %A = phi i32 [1, %entry], [2, %F]1094 %cond2 = call i1 @cond()1095 br i1 %cond2, label %T1, label %TY1096 1097T1:1098 %P2 = getelementptr i32, ptr %P, i32 %A1099 %x = load i32, ptr %P21100 %cond = call i1 @cond2()1101 br i1 %cond, label %TX, label %F1102 1103F:1104 %P3 = getelementptr i32, ptr %P, i32 21105 store i32 17, ptr %P31106 1107 store i32 42, ptr %P2 ; Provides "P[A]".1108 br label %F11109 1110TX:1111 ; This load should not be compiled to 'ret i32 42'. An overly clever1112 ; implementation of GVN would see that we're returning 17 if the loop1113 ; executes once or 42 if it executes more than that, but we'd have to do1114 ; loop restructuring to expose this, and GVN shouldn't do this sort of CFG1115 ; transformation.1116 1117 ret i32 %x1118TY:1119 ret i32 01120}1121 1122define i32 @phi_trans3(ptr %p, i32 %x, i32 %y, i32 %z) {1123; LE-MEMDEP-LABEL: define i32 @phi_trans3(1124; LE-MEMDEP-SAME: ptr [[P:%.*]], i32 [[X:%.*]], i32 [[Y:%.*]], i32 [[Z:%.*]]) {1125; LE-MEMDEP-NEXT: [[BLOCK1:.*:]]1126; LE-MEMDEP-NEXT: [[CMPXY:%.*]] = icmp eq i32 [[X]], [[Y]]1127; LE-MEMDEP-NEXT: br i1 [[CMPXY]], label %[[BLOCK2:.*]], label %[[BLOCK3:.*]]1128; LE-MEMDEP: [[BLOCK2]]:1129; LE-MEMDEP-NEXT: store i32 87, ptr [[P]], align 41130; LE-MEMDEP-NEXT: br label %[[BLOCK4:.*]]1131; LE-MEMDEP: [[BLOCK3]]:1132; LE-MEMDEP-NEXT: [[P2:%.*]] = getelementptr i32, ptr [[P]], i32 431133; LE-MEMDEP-NEXT: store i32 97, ptr [[P2]], align 41134; LE-MEMDEP-NEXT: br label %[[BLOCK4]]1135; LE-MEMDEP: [[BLOCK4]]:1136; LE-MEMDEP-NEXT: [[D:%.*]] = phi i32 [ 87, %[[BLOCK2]] ], [ 97, %[[BLOCK3]] ]1137; LE-MEMDEP-NEXT: br i1 [[CMPXY]], label %[[BLOCK5:.*]], label %[[EXIT:.*]]1138; LE-MEMDEP: [[BLOCK5]]:1139; LE-MEMDEP-NEXT: br i1 true, label %[[BLOCK6:.*]], label %[[BLOCK5_EXIT_CRIT_EDGE:.*]]1140; LE-MEMDEP: [[BLOCK5_EXIT_CRIT_EDGE]]:1141; LE-MEMDEP-NEXT: br label %[[EXIT]]1142; LE-MEMDEP: [[BLOCK6]]:1143; LE-MEMDEP-NEXT: br i1 true, label %[[BLOCK7:.*]], label %[[BLOCK6_EXIT_CRIT_EDGE:.*]]1144; LE-MEMDEP: [[BLOCK6_EXIT_CRIT_EDGE]]:1145; LE-MEMDEP-NEXT: br label %[[EXIT]]1146; LE-MEMDEP: [[BLOCK7]]:1147; LE-MEMDEP-NEXT: ret i32 [[D]]1148; LE-MEMDEP: [[EXIT]]:1149; LE-MEMDEP-NEXT: ret i32 -11150;1151; LE-MEMSSA-LABEL: define i32 @phi_trans3(1152; LE-MEMSSA-SAME: ptr [[P:%.*]], i32 [[X:%.*]], i32 [[Y:%.*]], i32 [[Z:%.*]]) {1153; LE-MEMSSA-NEXT: [[BLOCK1:.*:]]1154; LE-MEMSSA-NEXT: [[CMPXY:%.*]] = icmp eq i32 [[X]], [[Y]]1155; LE-MEMSSA-NEXT: br i1 [[CMPXY]], label %[[BLOCK2:.*]], label %[[BLOCK3:.*]]1156; LE-MEMSSA: [[BLOCK2]]:1157; LE-MEMSSA-NEXT: store i32 87, ptr [[P]], align 41158; LE-MEMSSA-NEXT: br label %[[BLOCK4:.*]]1159; LE-MEMSSA: [[BLOCK3]]:1160; LE-MEMSSA-NEXT: [[P2:%.*]] = getelementptr i32, ptr [[P]], i32 431161; LE-MEMSSA-NEXT: store i32 97, ptr [[P2]], align 41162; LE-MEMSSA-NEXT: br label %[[BLOCK4]]1163; LE-MEMSSA: [[BLOCK4]]:1164; LE-MEMSSA-NEXT: [[A:%.*]] = phi i32 [ -1, %[[BLOCK2]] ], [ 42, %[[BLOCK3]] ]1165; LE-MEMSSA-NEXT: br i1 [[CMPXY]], label %[[BLOCK5:.*]], label %[[EXIT:.*]]1166; LE-MEMSSA: [[BLOCK5]]:1167; LE-MEMSSA-NEXT: [[B:%.*]] = add i32 [[A]], 11168; LE-MEMSSA-NEXT: br i1 true, label %[[BLOCK6:.*]], label %[[BLOCK5_EXIT_CRIT_EDGE:.*]]1169; LE-MEMSSA: [[BLOCK5_EXIT_CRIT_EDGE]]:1170; LE-MEMSSA-NEXT: br label %[[EXIT]]1171; LE-MEMSSA: [[BLOCK6]]:1172; LE-MEMSSA-NEXT: [[C:%.*]] = getelementptr i32, ptr [[P]], i32 [[B]]1173; LE-MEMSSA-NEXT: br i1 true, label %[[BLOCK7:.*]], label %[[BLOCK6_EXIT_CRIT_EDGE:.*]]1174; LE-MEMSSA: [[BLOCK6_EXIT_CRIT_EDGE]]:1175; LE-MEMSSA-NEXT: br label %[[EXIT]]1176; LE-MEMSSA: [[BLOCK7]]:1177; LE-MEMSSA-NEXT: [[D:%.*]] = load i32, ptr [[C]], align 41178; LE-MEMSSA-NEXT: ret i32 [[D]]1179; LE-MEMSSA: [[EXIT]]:1180; LE-MEMSSA-NEXT: ret i32 -11181;1182; BE-MEMDEP-LABEL: define i32 @phi_trans3(1183; BE-MEMDEP-SAME: ptr [[P:%.*]], i32 [[X:%.*]], i32 [[Y:%.*]], i32 [[Z:%.*]]) {1184; BE-MEMDEP-NEXT: [[BLOCK1:.*:]]1185; BE-MEMDEP-NEXT: [[CMPXY:%.*]] = icmp eq i32 [[X]], [[Y]]1186; BE-MEMDEP-NEXT: br i1 [[CMPXY]], label %[[BLOCK2:.*]], label %[[BLOCK3:.*]]1187; BE-MEMDEP: [[BLOCK2]]:1188; BE-MEMDEP-NEXT: store i32 87, ptr [[P]], align 41189; BE-MEMDEP-NEXT: br label %[[BLOCK4:.*]]1190; BE-MEMDEP: [[BLOCK3]]:1191; BE-MEMDEP-NEXT: [[P2:%.*]] = getelementptr i32, ptr [[P]], i32 431192; BE-MEMDEP-NEXT: store i32 97, ptr [[P2]], align 41193; BE-MEMDEP-NEXT: br label %[[BLOCK4]]1194; BE-MEMDEP: [[BLOCK4]]:1195; BE-MEMDEP-NEXT: [[D:%.*]] = phi i32 [ 87, %[[BLOCK2]] ], [ 97, %[[BLOCK3]] ]1196; BE-MEMDEP-NEXT: br i1 [[CMPXY]], label %[[BLOCK5:.*]], label %[[EXIT:.*]]1197; BE-MEMDEP: [[BLOCK5]]:1198; BE-MEMDEP-NEXT: br i1 true, label %[[BLOCK6:.*]], label %[[BLOCK5_EXIT_CRIT_EDGE:.*]]1199; BE-MEMDEP: [[BLOCK5_EXIT_CRIT_EDGE]]:1200; BE-MEMDEP-NEXT: br label %[[EXIT]]1201; BE-MEMDEP: [[BLOCK6]]:1202; BE-MEMDEP-NEXT: br i1 true, label %[[BLOCK7:.*]], label %[[BLOCK6_EXIT_CRIT_EDGE:.*]]1203; BE-MEMDEP: [[BLOCK6_EXIT_CRIT_EDGE]]:1204; BE-MEMDEP-NEXT: br label %[[EXIT]]1205; BE-MEMDEP: [[BLOCK7]]:1206; BE-MEMDEP-NEXT: ret i32 [[D]]1207; BE-MEMDEP: [[EXIT]]:1208; BE-MEMDEP-NEXT: ret i32 -11209;1210; BE-MEMSSA-LABEL: define i32 @phi_trans3(1211; BE-MEMSSA-SAME: ptr [[P:%.*]], i32 [[X:%.*]], i32 [[Y:%.*]], i32 [[Z:%.*]]) {1212; BE-MEMSSA-NEXT: [[BLOCK1:.*:]]1213; BE-MEMSSA-NEXT: [[CMPXY:%.*]] = icmp eq i32 [[X]], [[Y]]1214; BE-MEMSSA-NEXT: br i1 [[CMPXY]], label %[[BLOCK2:.*]], label %[[BLOCK3:.*]]1215; BE-MEMSSA: [[BLOCK2]]:1216; BE-MEMSSA-NEXT: store i32 87, ptr [[P]], align 41217; BE-MEMSSA-NEXT: br label %[[BLOCK4:.*]]1218; BE-MEMSSA: [[BLOCK3]]:1219; BE-MEMSSA-NEXT: [[P2:%.*]] = getelementptr i32, ptr [[P]], i32 431220; BE-MEMSSA-NEXT: store i32 97, ptr [[P2]], align 41221; BE-MEMSSA-NEXT: br label %[[BLOCK4]]1222; BE-MEMSSA: [[BLOCK4]]:1223; BE-MEMSSA-NEXT: [[A:%.*]] = phi i32 [ -1, %[[BLOCK2]] ], [ 42, %[[BLOCK3]] ]1224; BE-MEMSSA-NEXT: br i1 [[CMPXY]], label %[[BLOCK5:.*]], label %[[EXIT:.*]]1225; BE-MEMSSA: [[BLOCK5]]:1226; BE-MEMSSA-NEXT: [[B:%.*]] = add i32 [[A]], 11227; BE-MEMSSA-NEXT: br i1 true, label %[[BLOCK6:.*]], label %[[BLOCK5_EXIT_CRIT_EDGE:.*]]1228; BE-MEMSSA: [[BLOCK5_EXIT_CRIT_EDGE]]:1229; BE-MEMSSA-NEXT: br label %[[EXIT]]1230; BE-MEMSSA: [[BLOCK6]]:1231; BE-MEMSSA-NEXT: [[C:%.*]] = getelementptr i32, ptr [[P]], i32 [[B]]1232; BE-MEMSSA-NEXT: br i1 true, label %[[BLOCK7:.*]], label %[[BLOCK6_EXIT_CRIT_EDGE:.*]]1233; BE-MEMSSA: [[BLOCK6_EXIT_CRIT_EDGE]]:1234; BE-MEMSSA-NEXT: br label %[[EXIT]]1235; BE-MEMSSA: [[BLOCK7]]:1236; BE-MEMSSA-NEXT: [[D:%.*]] = load i32, ptr [[C]], align 41237; BE-MEMSSA-NEXT: ret i32 [[D]]1238; BE-MEMSSA: [[EXIT]]:1239; BE-MEMSSA-NEXT: ret i32 -11240;1241block1:1242 %cmpxy = icmp eq i32 %x, %y1243 br i1 %cmpxy, label %block2, label %block31244 1245block2:1246 store i32 87, ptr %p1247 br label %block41248 1249block3:1250 %p2 = getelementptr i32, ptr %p, i32 431251 store i32 97, ptr %p21252 br label %block41253 1254block4:1255 %A = phi i32 [-1, %block2], [42, %block3]1256 br i1 %cmpxy, label %block5, label %exit1257 1258 1259block5:1260 %B = add i32 %A, 11261 br i1 %cmpxy, label %block6, label %exit1262 1263block6:1264 %C = getelementptr i32, ptr %p, i32 %B1265 br i1 %cmpxy, label %block7, label %exit1266 1267block7:1268 %D = load i32, ptr %C1269 ret i32 %D1270 1271 1272exit:1273 ret i32 -11274}1275 1276define i8 @phi_trans4(ptr %p) {1277; LE-MEMDEP-LABEL: define i8 @phi_trans4(1278; LE-MEMDEP-SAME: ptr [[P:%.*]]) {1279; LE-MEMDEP-NEXT: [[ENTRY:.*]]:1280; LE-MEMDEP-NEXT: [[X3:%.*]] = getelementptr i8, ptr [[P]], i32 1921281; LE-MEMDEP-NEXT: store i8 -64, ptr [[X3]], align 11282; LE-MEMDEP-NEXT: [[X:%.*]] = getelementptr i8, ptr [[P]], i32 41283; LE-MEMDEP-NEXT: [[Y:%.*]] = load i8, ptr [[X]], align 11284; LE-MEMDEP-NEXT: br label %[[LOOP:.*]]1285; LE-MEMDEP: [[LOOP]]:1286; LE-MEMDEP-NEXT: [[Y2:%.*]] = phi i8 [ [[Y]], %[[ENTRY]] ], [ 0, %[[LOOP]] ]1287; LE-MEMDEP-NEXT: [[COND:%.*]] = call i1 @cond2()1288; LE-MEMDEP-NEXT: store i32 0, ptr [[X3]], align 41289; LE-MEMDEP-NEXT: br i1 [[COND]], label %[[LOOP]], label %[[OUT:.*]]1290; LE-MEMDEP: [[OUT]]:1291; LE-MEMDEP-NEXT: [[R:%.*]] = add i8 [[Y]], [[Y2]]1292; LE-MEMDEP-NEXT: ret i8 [[R]]1293;1294; LE-MEMSSA-LABEL: define i8 @phi_trans4(1295; LE-MEMSSA-SAME: ptr [[P:%.*]]) {1296; LE-MEMSSA-NEXT: [[ENTRY:.*]]:1297; LE-MEMSSA-NEXT: [[X3:%.*]] = getelementptr i8, ptr [[P]], i32 1921298; LE-MEMSSA-NEXT: store i8 -64, ptr [[X3]], align 11299; LE-MEMSSA-NEXT: [[X:%.*]] = getelementptr i8, ptr [[P]], i32 41300; LE-MEMSSA-NEXT: [[Y:%.*]] = load i8, ptr [[X]], align 11301; LE-MEMSSA-NEXT: br label %[[LOOP:.*]]1302; LE-MEMSSA: [[LOOP]]:1303; LE-MEMSSA-NEXT: [[I:%.*]] = phi i32 [ 4, %[[ENTRY]] ], [ 192, %[[LOOP]] ]1304; LE-MEMSSA-NEXT: [[X2:%.*]] = getelementptr i8, ptr [[P]], i32 [[I]]1305; LE-MEMSSA-NEXT: [[Y2:%.*]] = load i8, ptr [[X2]], align 11306; LE-MEMSSA-NEXT: [[COND:%.*]] = call i1 @cond2()1307; LE-MEMSSA-NEXT: store i32 0, ptr [[X3]], align 41308; LE-MEMSSA-NEXT: br i1 [[COND]], label %[[LOOP]], label %[[OUT:.*]]1309; LE-MEMSSA: [[OUT]]:1310; LE-MEMSSA-NEXT: [[R:%.*]] = add i8 [[Y]], [[Y2]]1311; LE-MEMSSA-NEXT: ret i8 [[R]]1312;1313; BE-MEMDEP-LABEL: define i8 @phi_trans4(1314; BE-MEMDEP-SAME: ptr [[P:%.*]]) {1315; BE-MEMDEP-NEXT: [[ENTRY:.*]]:1316; BE-MEMDEP-NEXT: [[X3:%.*]] = getelementptr i8, ptr [[P]], i32 1921317; BE-MEMDEP-NEXT: store i8 -64, ptr [[X3]], align 11318; BE-MEMDEP-NEXT: [[X:%.*]] = getelementptr i8, ptr [[P]], i32 41319; BE-MEMDEP-NEXT: [[Y:%.*]] = load i8, ptr [[X]], align 11320; BE-MEMDEP-NEXT: br label %[[LOOP:.*]]1321; BE-MEMDEP: [[LOOP]]:1322; BE-MEMDEP-NEXT: [[Y2:%.*]] = phi i8 [ [[Y]], %[[ENTRY]] ], [ 0, %[[LOOP]] ]1323; BE-MEMDEP-NEXT: [[COND:%.*]] = call i1 @cond2()1324; BE-MEMDEP-NEXT: store i32 0, ptr [[X3]], align 41325; BE-MEMDEP-NEXT: br i1 [[COND]], label %[[LOOP]], label %[[OUT:.*]]1326; BE-MEMDEP: [[OUT]]:1327; BE-MEMDEP-NEXT: [[R:%.*]] = add i8 [[Y]], [[Y2]]1328; BE-MEMDEP-NEXT: ret i8 [[R]]1329;1330; BE-MEMSSA-LABEL: define i8 @phi_trans4(1331; BE-MEMSSA-SAME: ptr [[P:%.*]]) {1332; BE-MEMSSA-NEXT: [[ENTRY:.*]]:1333; BE-MEMSSA-NEXT: [[X3:%.*]] = getelementptr i8, ptr [[P]], i32 1921334; BE-MEMSSA-NEXT: store i8 -64, ptr [[X3]], align 11335; BE-MEMSSA-NEXT: [[X:%.*]] = getelementptr i8, ptr [[P]], i32 41336; BE-MEMSSA-NEXT: [[Y:%.*]] = load i8, ptr [[X]], align 11337; BE-MEMSSA-NEXT: br label %[[LOOP:.*]]1338; BE-MEMSSA: [[LOOP]]:1339; BE-MEMSSA-NEXT: [[I:%.*]] = phi i32 [ 4, %[[ENTRY]] ], [ 192, %[[LOOP]] ]1340; BE-MEMSSA-NEXT: [[X2:%.*]] = getelementptr i8, ptr [[P]], i32 [[I]]1341; BE-MEMSSA-NEXT: [[Y2:%.*]] = load i8, ptr [[X2]], align 11342; BE-MEMSSA-NEXT: [[COND:%.*]] = call i1 @cond2()1343; BE-MEMSSA-NEXT: store i32 0, ptr [[X3]], align 41344; BE-MEMSSA-NEXT: br i1 [[COND]], label %[[LOOP]], label %[[OUT:.*]]1345; BE-MEMSSA: [[OUT]]:1346; BE-MEMSSA-NEXT: [[R:%.*]] = add i8 [[Y]], [[Y2]]1347; BE-MEMSSA-NEXT: ret i8 [[R]]1348;1349entry:1350 %X3 = getelementptr i8, ptr %p, i32 1921351 store i8 192, ptr %X31352 1353 %X = getelementptr i8, ptr %p, i32 41354 %Y = load i8, ptr %X1355 br label %loop1356 1357loop:1358 %i = phi i32 [4, %entry], [192, %loop]1359 %X2 = getelementptr i8, ptr %p, i32 %i1360 %Y2 = load i8, ptr %X21361 1362 1363 %cond = call i1 @cond2()1364 1365 store i32 0, ptr %X31366 br i1 %cond, label %loop, label %out1367 1368out:1369 %R = add i8 %Y, %Y21370 ret i8 %R1371}1372 1373define i8 @phi_trans5(ptr %p) {1374; LE-MEMDEP-LABEL: define i8 @phi_trans5(1375; LE-MEMDEP-SAME: ptr [[P:%.*]]) {1376; LE-MEMDEP-NEXT: [[ENTRY:.*]]:1377; LE-MEMDEP-NEXT: [[X4:%.*]] = getelementptr i8, ptr [[P]], i32 21378; LE-MEMDEP-NEXT: store i8 19, ptr [[X4]], align 11379; LE-MEMDEP-NEXT: [[X:%.*]] = getelementptr i8, ptr [[P]], i32 41380; LE-MEMDEP-NEXT: [[Y:%.*]] = load i8, ptr [[X]], align 11381; LE-MEMDEP-NEXT: br label %[[LOOP:.*]]1382; LE-MEMDEP: [[LOOP]]:1383; LE-MEMDEP-NEXT: [[Y2:%.*]] = phi i8 [ [[Y]], %[[ENTRY]] ], [ [[Y2_PRE:%.*]], %[[CONT:.*]] ]1384; LE-MEMDEP-NEXT: [[I:%.*]] = phi i32 [ 4, %[[ENTRY]] ], [ 3, %[[CONT]] ]1385; LE-MEMDEP-NEXT: [[X2:%.*]] = getelementptr i8, ptr [[P]], i32 [[I]]1386; LE-MEMDEP-NEXT: [[COND:%.*]] = call i1 @cond2()1387; LE-MEMDEP-NEXT: br i1 [[COND]], label %[[CONT]], label %[[OUT:.*]]1388; LE-MEMDEP: [[CONT]]:1389; LE-MEMDEP-NEXT: [[Z:%.*]] = getelementptr i8, ptr [[X2]], i32 -11390; LE-MEMDEP-NEXT: store i32 50462976, ptr [[Z]], align 41391; LE-MEMDEP-NEXT: [[X2_PHI_TRANS_INSERT:%.*]] = getelementptr i8, ptr [[P]], i32 31392; LE-MEMDEP-NEXT: [[Y2_PRE]] = load i8, ptr [[X2_PHI_TRANS_INSERT]], align 11393; LE-MEMDEP-NEXT: br label %[[LOOP]]1394; LE-MEMDEP: [[OUT]]:1395; LE-MEMDEP-NEXT: [[R:%.*]] = add i8 [[Y]], [[Y2]]1396; LE-MEMDEP-NEXT: ret i8 [[R]]1397;1398; LE-MEMSSA-LABEL: define i8 @phi_trans5(1399; LE-MEMSSA-SAME: ptr [[P:%.*]]) {1400; LE-MEMSSA-NEXT: [[ENTRY:.*]]:1401; LE-MEMSSA-NEXT: [[X4:%.*]] = getelementptr i8, ptr [[P]], i32 21402; LE-MEMSSA-NEXT: store i8 19, ptr [[X4]], align 11403; LE-MEMSSA-NEXT: [[X:%.*]] = getelementptr i8, ptr [[P]], i32 41404; LE-MEMSSA-NEXT: [[Y:%.*]] = load i8, ptr [[X]], align 11405; LE-MEMSSA-NEXT: br label %[[LOOP:.*]]1406; LE-MEMSSA: [[LOOP]]:1407; LE-MEMSSA-NEXT: [[I:%.*]] = phi i32 [ 4, %[[ENTRY]] ], [ 3, %[[CONT:.*]] ]1408; LE-MEMSSA-NEXT: [[X2:%.*]] = getelementptr i8, ptr [[P]], i32 [[I]]1409; LE-MEMSSA-NEXT: [[Y2:%.*]] = load i8, ptr [[X2]], align 11410; LE-MEMSSA-NEXT: [[COND:%.*]] = call i1 @cond2()1411; LE-MEMSSA-NEXT: br i1 [[COND]], label %[[CONT]], label %[[OUT:.*]]1412; LE-MEMSSA: [[CONT]]:1413; LE-MEMSSA-NEXT: [[Z:%.*]] = getelementptr i8, ptr [[X2]], i32 -11414; LE-MEMSSA-NEXT: store i32 50462976, ptr [[Z]], align 41415; LE-MEMSSA-NEXT: br label %[[LOOP]]1416; LE-MEMSSA: [[OUT]]:1417; LE-MEMSSA-NEXT: [[R:%.*]] = add i8 [[Y]], [[Y2]]1418; LE-MEMSSA-NEXT: ret i8 [[R]]1419;1420; BE-MEMDEP-LABEL: define i8 @phi_trans5(1421; BE-MEMDEP-SAME: ptr [[P:%.*]]) {1422; BE-MEMDEP-NEXT: [[ENTRY:.*]]:1423; BE-MEMDEP-NEXT: [[X4:%.*]] = getelementptr i8, ptr [[P]], i32 21424; BE-MEMDEP-NEXT: store i8 19, ptr [[X4]], align 11425; BE-MEMDEP-NEXT: [[X:%.*]] = getelementptr i8, ptr [[P]], i32 41426; BE-MEMDEP-NEXT: [[Y:%.*]] = load i8, ptr [[X]], align 11427; BE-MEMDEP-NEXT: br label %[[LOOP:.*]]1428; BE-MEMDEP: [[LOOP]]:1429; BE-MEMDEP-NEXT: [[Y2:%.*]] = phi i8 [ [[Y]], %[[ENTRY]] ], [ [[Y2_PRE:%.*]], %[[CONT:.*]] ]1430; BE-MEMDEP-NEXT: [[I:%.*]] = phi i32 [ 4, %[[ENTRY]] ], [ 3, %[[CONT]] ]1431; BE-MEMDEP-NEXT: [[X2:%.*]] = getelementptr i8, ptr [[P]], i32 [[I]]1432; BE-MEMDEP-NEXT: [[COND:%.*]] = call i1 @cond2()1433; BE-MEMDEP-NEXT: br i1 [[COND]], label %[[CONT]], label %[[OUT:.*]]1434; BE-MEMDEP: [[CONT]]:1435; BE-MEMDEP-NEXT: [[Z:%.*]] = getelementptr i8, ptr [[X2]], i32 -11436; BE-MEMDEP-NEXT: store i32 50462976, ptr [[Z]], align 41437; BE-MEMDEP-NEXT: [[X2_PHI_TRANS_INSERT:%.*]] = getelementptr i8, ptr [[P]], i32 31438; BE-MEMDEP-NEXT: [[Y2_PRE]] = load i8, ptr [[X2_PHI_TRANS_INSERT]], align 11439; BE-MEMDEP-NEXT: br label %[[LOOP]]1440; BE-MEMDEP: [[OUT]]:1441; BE-MEMDEP-NEXT: [[R:%.*]] = add i8 [[Y]], [[Y2]]1442; BE-MEMDEP-NEXT: ret i8 [[R]]1443;1444; BE-MEMSSA-LABEL: define i8 @phi_trans5(1445; BE-MEMSSA-SAME: ptr [[P:%.*]]) {1446; BE-MEMSSA-NEXT: [[ENTRY:.*]]:1447; BE-MEMSSA-NEXT: [[X4:%.*]] = getelementptr i8, ptr [[P]], i32 21448; BE-MEMSSA-NEXT: store i8 19, ptr [[X4]], align 11449; BE-MEMSSA-NEXT: [[X:%.*]] = getelementptr i8, ptr [[P]], i32 41450; BE-MEMSSA-NEXT: [[Y:%.*]] = load i8, ptr [[X]], align 11451; BE-MEMSSA-NEXT: br label %[[LOOP:.*]]1452; BE-MEMSSA: [[LOOP]]:1453; BE-MEMSSA-NEXT: [[I:%.*]] = phi i32 [ 4, %[[ENTRY]] ], [ 3, %[[CONT:.*]] ]1454; BE-MEMSSA-NEXT: [[X2:%.*]] = getelementptr i8, ptr [[P]], i32 [[I]]1455; BE-MEMSSA-NEXT: [[Y2:%.*]] = load i8, ptr [[X2]], align 11456; BE-MEMSSA-NEXT: [[COND:%.*]] = call i1 @cond2()1457; BE-MEMSSA-NEXT: br i1 [[COND]], label %[[CONT]], label %[[OUT:.*]]1458; BE-MEMSSA: [[CONT]]:1459; BE-MEMSSA-NEXT: [[Z:%.*]] = getelementptr i8, ptr [[X2]], i32 -11460; BE-MEMSSA-NEXT: store i32 50462976, ptr [[Z]], align 41461; BE-MEMSSA-NEXT: br label %[[LOOP]]1462; BE-MEMSSA: [[OUT]]:1463; BE-MEMSSA-NEXT: [[R:%.*]] = add i8 [[Y]], [[Y2]]1464; BE-MEMSSA-NEXT: ret i8 [[R]]1465;1466entry:1467 1468 %X4 = getelementptr i8, ptr %p, i32 21469 store i8 19, ptr %X41470 1471 %X = getelementptr i8, ptr %p, i32 41472 %Y = load i8, ptr %X1473 br label %loop1474 1475loop:1476 %i = phi i32 [4, %entry], [3, %cont]1477 %X2 = getelementptr i8, ptr %p, i32 %i1478 %Y2 = load i8, ptr %X2 ; Ensure this load is not being incorrectly replaced.1479 %cond = call i1 @cond2()1480 br i1 %cond, label %cont, label %out1481 1482cont:1483 %Z = getelementptr i8, ptr %X2, i32 -11484 store i32 50462976, ptr %Z ;; (1 << 8) | (2 << 16) | (3 << 24)1485 1486 1487 br label %loop1488 1489out:1490 %R = add i8 %Y, %Y21491 ret i8 %R1492}1493 1494declare void @use_i32(i32) readonly1495 1496; indirectbr currently prevents MergeBlockIntoPredecessor from merging latch1497; into header. Make sure we translate the address for %l1 correctly where1498; parts of the address computations are in different basic blocks.1499define i32 @phi_trans6(ptr noalias nocapture readonly %x, i1 %cond) {1500; LE-MEMDEP-LABEL: define i32 @phi_trans6(1501; LE-MEMDEP-SAME: ptr noalias readonly captures(none) [[X:%.*]], i1 [[COND:%.*]]) {1502; LE-MEMDEP-NEXT: [[ENTRY:.*]]:1503; LE-MEMDEP-NEXT: [[L0:%.*]] = load i32, ptr [[X]], align 41504; LE-MEMDEP-NEXT: call void @use_i32(i32 [[L0]])1505; LE-MEMDEP-NEXT: br label %[[HEADER:.*]]1506; LE-MEMDEP: [[HEADER]]:1507; LE-MEMDEP-NEXT: [[L1:%.*]] = phi i32 [ [[L0]], %[[ENTRY]] ], [ [[L1_PRE:%.*]], %[[LATCH_HEADER_CRIT_EDGE:.*]] ]1508; LE-MEMDEP-NEXT: [[IV:%.*]] = phi i32 [ 0, %[[ENTRY]] ], [ [[IV_NEXT:%.*]], %[[LATCH_HEADER_CRIT_EDGE]] ]1509; LE-MEMDEP-NEXT: indirectbr ptr blockaddress(@phi_trans6, %[[LATCH:.*]]), [label %latch]1510; LE-MEMDEP: [[LATCH]]:1511; LE-MEMDEP-NEXT: [[IV_NEXT]] = add i32 [[IV]], 11512; LE-MEMDEP-NEXT: br i1 [[COND]], label %[[EXIT:.*]], label %[[LATCH_HEADER_CRIT_EDGE]]1513; LE-MEMDEP: [[LATCH_HEADER_CRIT_EDGE]]:1514; LE-MEMDEP-NEXT: [[GEP_1_PHI_TRANS_INSERT_PHI_TRANS_INSERT:%.*]] = getelementptr i32, ptr [[X]], i32 [[IV_NEXT]]1515; LE-MEMDEP-NEXT: [[L1_PRE]] = load i32, ptr [[GEP_1_PHI_TRANS_INSERT_PHI_TRANS_INSERT]], align 41516; LE-MEMDEP-NEXT: br label %[[HEADER]]1517; LE-MEMDEP: [[EXIT]]:1518; LE-MEMDEP-NEXT: ret i32 [[L1]]1519;1520; LE-MEMSSA-LABEL: define i32 @phi_trans6(1521; LE-MEMSSA-SAME: ptr noalias readonly captures(none) [[X:%.*]], i1 [[COND:%.*]]) {1522; LE-MEMSSA-NEXT: [[ENTRY:.*]]:1523; LE-MEMSSA-NEXT: [[L0:%.*]] = load i32, ptr [[X]], align 41524; LE-MEMSSA-NEXT: call void @use_i32(i32 [[L0]])1525; LE-MEMSSA-NEXT: br label %[[HEADER:.*]]1526; LE-MEMSSA: [[HEADER]]:1527; LE-MEMSSA-NEXT: [[IV:%.*]] = phi i32 [ 0, %[[ENTRY]] ], [ [[IV_NEXT:%.*]], %[[LATCH:.*]] ]1528; LE-MEMSSA-NEXT: indirectbr ptr blockaddress(@phi_trans6, %[[LATCH]]), [label %latch]1529; LE-MEMSSA: [[LATCH]]:1530; LE-MEMSSA-NEXT: [[GEP_1:%.*]] = getelementptr i32, ptr [[X]], i32 [[IV]]1531; LE-MEMSSA-NEXT: [[L1:%.*]] = load i32, ptr [[GEP_1]], align 41532; LE-MEMSSA-NEXT: [[IV_NEXT]] = add i32 [[IV]], 11533; LE-MEMSSA-NEXT: br i1 [[COND]], label %[[EXIT:.*]], label %[[HEADER]]1534; LE-MEMSSA: [[EXIT]]:1535; LE-MEMSSA-NEXT: ret i32 [[L1]]1536;1537; BE-MEMDEP-LABEL: define i32 @phi_trans6(1538; BE-MEMDEP-SAME: ptr noalias readonly captures(none) [[X:%.*]], i1 [[COND:%.*]]) {1539; BE-MEMDEP-NEXT: [[ENTRY:.*]]:1540; BE-MEMDEP-NEXT: [[L0:%.*]] = load i32, ptr [[X]], align 41541; BE-MEMDEP-NEXT: call void @use_i32(i32 [[L0]])1542; BE-MEMDEP-NEXT: br label %[[HEADER:.*]]1543; BE-MEMDEP: [[HEADER]]:1544; BE-MEMDEP-NEXT: [[L1:%.*]] = phi i32 [ [[L0]], %[[ENTRY]] ], [ [[L1_PRE:%.*]], %[[LATCH_HEADER_CRIT_EDGE:.*]] ]1545; BE-MEMDEP-NEXT: [[IV:%.*]] = phi i32 [ 0, %[[ENTRY]] ], [ [[IV_NEXT:%.*]], %[[LATCH_HEADER_CRIT_EDGE]] ]1546; BE-MEMDEP-NEXT: indirectbr ptr blockaddress(@phi_trans6, %[[LATCH:.*]]), [label %latch]1547; BE-MEMDEP: [[LATCH]]:1548; BE-MEMDEP-NEXT: [[IV_NEXT]] = add i32 [[IV]], 11549; BE-MEMDEP-NEXT: br i1 [[COND]], label %[[EXIT:.*]], label %[[LATCH_HEADER_CRIT_EDGE]]1550; BE-MEMDEP: [[LATCH_HEADER_CRIT_EDGE]]:1551; BE-MEMDEP-NEXT: [[GEP_1_PHI_TRANS_INSERT_PHI_TRANS_INSERT:%.*]] = getelementptr i32, ptr [[X]], i32 [[IV_NEXT]]1552; BE-MEMDEP-NEXT: [[L1_PRE]] = load i32, ptr [[GEP_1_PHI_TRANS_INSERT_PHI_TRANS_INSERT]], align 41553; BE-MEMDEP-NEXT: br label %[[HEADER]]1554; BE-MEMDEP: [[EXIT]]:1555; BE-MEMDEP-NEXT: ret i32 [[L1]]1556;1557; BE-MEMSSA-LABEL: define i32 @phi_trans6(1558; BE-MEMSSA-SAME: ptr noalias readonly captures(none) [[X:%.*]], i1 [[COND:%.*]]) {1559; BE-MEMSSA-NEXT: [[ENTRY:.*]]:1560; BE-MEMSSA-NEXT: [[L0:%.*]] = load i32, ptr [[X]], align 41561; BE-MEMSSA-NEXT: call void @use_i32(i32 [[L0]])1562; BE-MEMSSA-NEXT: br label %[[HEADER:.*]]1563; BE-MEMSSA: [[HEADER]]:1564; BE-MEMSSA-NEXT: [[IV:%.*]] = phi i32 [ 0, %[[ENTRY]] ], [ [[IV_NEXT:%.*]], %[[LATCH:.*]] ]1565; BE-MEMSSA-NEXT: indirectbr ptr blockaddress(@phi_trans6, %[[LATCH]]), [label %latch]1566; BE-MEMSSA: [[LATCH]]:1567; BE-MEMSSA-NEXT: [[GEP_1:%.*]] = getelementptr i32, ptr [[X]], i32 [[IV]]1568; BE-MEMSSA-NEXT: [[L1:%.*]] = load i32, ptr [[GEP_1]], align 41569; BE-MEMSSA-NEXT: [[IV_NEXT]] = add i32 [[IV]], 11570; BE-MEMSSA-NEXT: br i1 [[COND]], label %[[EXIT:.*]], label %[[HEADER]]1571; BE-MEMSSA: [[EXIT]]:1572; BE-MEMSSA-NEXT: ret i32 [[L1]]1573;1574entry:1575 %l0 = load i32, ptr %x1576 call void @use_i32(i32 %l0)1577 br label %header1578 1579header:1580 %iv = phi i32 [0, %entry], [ %iv.next, %latch]1581 indirectbr ptr blockaddress(@phi_trans6, %latch), [label %latch]1582 1583latch:1584 %gep.1 = getelementptr i32, ptr %x, i32 %iv1585 %l1 = load i32, ptr %gep.11586 %iv.next = add i32 %iv, 11587 br i1 %cond, label %exit, label %header1588 1589exit:1590 ret i32 %l11591}1592 1593; FIXME: Currently we fail to translate the PHI in this case.1594define i32 @phi_trans7(ptr noalias nocapture readonly %x, i1 %cond) {1595; LE-MEMDEP-LABEL: define i32 @phi_trans7(1596; LE-MEMDEP-SAME: ptr noalias readonly captures(none) [[X:%.*]], i1 [[COND:%.*]]) {1597; LE-MEMDEP-NEXT: [[ENTRY:.*]]:1598; LE-MEMDEP-NEXT: [[L0:%.*]] = load i32, ptr [[X]], align 41599; LE-MEMDEP-NEXT: call void @use_i32(i32 [[L0]])1600; LE-MEMDEP-NEXT: br label %[[HEADER:.*]]1601; LE-MEMDEP: [[HEADER]]:1602; LE-MEMDEP-NEXT: [[IV:%.*]] = phi i32 [ 2, %[[ENTRY]] ], [ [[IV_NEXT:%.*]], %[[LATCH_HEADER_CRIT_EDGE:.*]] ]1603; LE-MEMDEP-NEXT: [[OFFSET:%.*]] = add i32 [[IV]], -21604; LE-MEMDEP-NEXT: indirectbr ptr blockaddress(@phi_trans7, %[[LATCH:.*]]), [label %latch]1605; LE-MEMDEP: [[LATCH]]:1606; LE-MEMDEP-NEXT: [[GEP_1:%.*]] = getelementptr i32, ptr [[X]], i32 [[OFFSET]]1607; LE-MEMDEP-NEXT: [[L1:%.*]] = load i32, ptr [[GEP_1]], align 41608; LE-MEMDEP-NEXT: [[IV_NEXT]] = add i32 [[IV]], 11609; LE-MEMDEP-NEXT: br i1 [[COND]], label %[[EXIT:.*]], label %[[LATCH_HEADER_CRIT_EDGE]]1610; LE-MEMDEP: [[LATCH_HEADER_CRIT_EDGE]]:1611; LE-MEMDEP-NEXT: br label %[[HEADER]]1612; LE-MEMDEP: [[EXIT]]:1613; LE-MEMDEP-NEXT: ret i32 [[L1]]1614;1615; LE-MEMSSA-LABEL: define i32 @phi_trans7(1616; LE-MEMSSA-SAME: ptr noalias readonly captures(none) [[X:%.*]], i1 [[COND:%.*]]) {1617; LE-MEMSSA-NEXT: [[ENTRY:.*]]:1618; LE-MEMSSA-NEXT: [[L0:%.*]] = load i32, ptr [[X]], align 41619; LE-MEMSSA-NEXT: call void @use_i32(i32 [[L0]])1620; LE-MEMSSA-NEXT: br label %[[HEADER:.*]]1621; LE-MEMSSA: [[HEADER]]:1622; LE-MEMSSA-NEXT: [[IV:%.*]] = phi i32 [ 2, %[[ENTRY]] ], [ [[IV_NEXT:%.*]], %[[LATCH:.*]] ]1623; LE-MEMSSA-NEXT: [[OFFSET:%.*]] = add i32 [[IV]], -21624; LE-MEMSSA-NEXT: indirectbr ptr blockaddress(@phi_trans7, %[[LATCH]]), [label %latch]1625; LE-MEMSSA: [[LATCH]]:1626; LE-MEMSSA-NEXT: [[GEP_1:%.*]] = getelementptr i32, ptr [[X]], i32 [[OFFSET]]1627; LE-MEMSSA-NEXT: [[L1:%.*]] = load i32, ptr [[GEP_1]], align 41628; LE-MEMSSA-NEXT: [[IV_NEXT]] = add i32 [[IV]], 11629; LE-MEMSSA-NEXT: br i1 [[COND]], label %[[EXIT:.*]], label %[[HEADER]]1630; LE-MEMSSA: [[EXIT]]:1631; LE-MEMSSA-NEXT: ret i32 [[L1]]1632;1633; BE-MEMDEP-LABEL: define i32 @phi_trans7(1634; BE-MEMDEP-SAME: ptr noalias readonly captures(none) [[X:%.*]], i1 [[COND:%.*]]) {1635; BE-MEMDEP-NEXT: [[ENTRY:.*]]:1636; BE-MEMDEP-NEXT: [[L0:%.*]] = load i32, ptr [[X]], align 41637; BE-MEMDEP-NEXT: call void @use_i32(i32 [[L0]])1638; BE-MEMDEP-NEXT: br label %[[HEADER:.*]]1639; BE-MEMDEP: [[HEADER]]:1640; BE-MEMDEP-NEXT: [[IV:%.*]] = phi i32 [ 2, %[[ENTRY]] ], [ [[IV_NEXT:%.*]], %[[LATCH_HEADER_CRIT_EDGE:.*]] ]1641; BE-MEMDEP-NEXT: [[OFFSET:%.*]] = add i32 [[IV]], -21642; BE-MEMDEP-NEXT: indirectbr ptr blockaddress(@phi_trans7, %[[LATCH:.*]]), [label %latch]1643; BE-MEMDEP: [[LATCH]]:1644; BE-MEMDEP-NEXT: [[GEP_1:%.*]] = getelementptr i32, ptr [[X]], i32 [[OFFSET]]1645; BE-MEMDEP-NEXT: [[L1:%.*]] = load i32, ptr [[GEP_1]], align 41646; BE-MEMDEP-NEXT: [[IV_NEXT]] = add i32 [[IV]], 11647; BE-MEMDEP-NEXT: br i1 [[COND]], label %[[EXIT:.*]], label %[[LATCH_HEADER_CRIT_EDGE]]1648; BE-MEMDEP: [[LATCH_HEADER_CRIT_EDGE]]:1649; BE-MEMDEP-NEXT: br label %[[HEADER]]1650; BE-MEMDEP: [[EXIT]]:1651; BE-MEMDEP-NEXT: ret i32 [[L1]]1652;1653; BE-MEMSSA-LABEL: define i32 @phi_trans7(1654; BE-MEMSSA-SAME: ptr noalias readonly captures(none) [[X:%.*]], i1 [[COND:%.*]]) {1655; BE-MEMSSA-NEXT: [[ENTRY:.*]]:1656; BE-MEMSSA-NEXT: [[L0:%.*]] = load i32, ptr [[X]], align 41657; BE-MEMSSA-NEXT: call void @use_i32(i32 [[L0]])1658; BE-MEMSSA-NEXT: br label %[[HEADER:.*]]1659; BE-MEMSSA: [[HEADER]]:1660; BE-MEMSSA-NEXT: [[IV:%.*]] = phi i32 [ 2, %[[ENTRY]] ], [ [[IV_NEXT:%.*]], %[[LATCH:.*]] ]1661; BE-MEMSSA-NEXT: [[OFFSET:%.*]] = add i32 [[IV]], -21662; BE-MEMSSA-NEXT: indirectbr ptr blockaddress(@phi_trans7, %[[LATCH]]), [label %latch]1663; BE-MEMSSA: [[LATCH]]:1664; BE-MEMSSA-NEXT: [[GEP_1:%.*]] = getelementptr i32, ptr [[X]], i32 [[OFFSET]]1665; BE-MEMSSA-NEXT: [[L1:%.*]] = load i32, ptr [[GEP_1]], align 41666; BE-MEMSSA-NEXT: [[IV_NEXT]] = add i32 [[IV]], 11667; BE-MEMSSA-NEXT: br i1 [[COND]], label %[[EXIT:.*]], label %[[HEADER]]1668; BE-MEMSSA: [[EXIT]]:1669; BE-MEMSSA-NEXT: ret i32 [[L1]]1670;1671entry:1672 %l0 = load i32, ptr %x1673 call void @use_i32(i32 %l0)1674 br label %header1675 1676header:1677 %iv = phi i32 [2, %entry], [ %iv.next, %latch]1678 %offset = add i32 %iv, -21679 indirectbr ptr blockaddress(@phi_trans7, %latch), [label %latch]1680 1681latch:1682 %gep.1 = getelementptr i32, ptr %x, i32 %offset1683 %l1 = load i32, ptr %gep.11684 %iv.next = add i32 %iv, 11685 br i1 %cond, label %exit, label %header1686 1687exit:1688 ret i32 %l11689}1690 1691; FIXME: Currently we fail to translate the PHI in this case.1692define i32 @phi_trans8(ptr noalias nocapture readonly %x, i1 %cond) {1693; LE-MEMDEP-LABEL: define i32 @phi_trans8(1694; LE-MEMDEP-SAME: ptr noalias readonly captures(none) [[X:%.*]], i1 [[COND:%.*]]) {1695; LE-MEMDEP-NEXT: [[ENTRY:.*]]:1696; LE-MEMDEP-NEXT: [[L0:%.*]] = load i32, ptr [[X]], align 41697; LE-MEMDEP-NEXT: call void @use_i32(i32 [[L0]])1698; LE-MEMDEP-NEXT: br label %[[HEADER:.*]]1699; LE-MEMDEP: [[HEADER]]:1700; LE-MEMDEP-NEXT: [[IV:%.*]] = phi i32 [ 2, %[[ENTRY]] ], [ [[IV_NEXT:%.*]], %[[LATCH_HEADER_CRIT_EDGE:.*]] ]1701; LE-MEMDEP-NEXT: indirectbr ptr blockaddress(@phi_trans8, %[[LATCH:.*]]), [label %latch]1702; LE-MEMDEP: [[LATCH]]:1703; LE-MEMDEP-NEXT: [[OFFSET:%.*]] = add i32 [[IV]], -21704; LE-MEMDEP-NEXT: [[GEP_1:%.*]] = getelementptr i32, ptr [[X]], i32 [[OFFSET]]1705; LE-MEMDEP-NEXT: [[L1:%.*]] = load i32, ptr [[GEP_1]], align 41706; LE-MEMDEP-NEXT: [[IV_NEXT]] = add i32 [[IV]], 11707; LE-MEMDEP-NEXT: br i1 [[COND]], label %[[EXIT:.*]], label %[[LATCH_HEADER_CRIT_EDGE]]1708; LE-MEMDEP: [[LATCH_HEADER_CRIT_EDGE]]:1709; LE-MEMDEP-NEXT: br label %[[HEADER]]1710; LE-MEMDEP: [[EXIT]]:1711; LE-MEMDEP-NEXT: ret i32 [[L1]]1712;1713; LE-MEMSSA-LABEL: define i32 @phi_trans8(1714; LE-MEMSSA-SAME: ptr noalias readonly captures(none) [[X:%.*]], i1 [[COND:%.*]]) {1715; LE-MEMSSA-NEXT: [[ENTRY:.*]]:1716; LE-MEMSSA-NEXT: [[L0:%.*]] = load i32, ptr [[X]], align 41717; LE-MEMSSA-NEXT: call void @use_i32(i32 [[L0]])1718; LE-MEMSSA-NEXT: br label %[[HEADER:.*]]1719; LE-MEMSSA: [[HEADER]]:1720; LE-MEMSSA-NEXT: [[IV:%.*]] = phi i32 [ 2, %[[ENTRY]] ], [ [[IV_NEXT:%.*]], %[[LATCH:.*]] ]1721; LE-MEMSSA-NEXT: indirectbr ptr blockaddress(@phi_trans8, %[[LATCH]]), [label %latch]1722; LE-MEMSSA: [[LATCH]]:1723; LE-MEMSSA-NEXT: [[OFFSET:%.*]] = add i32 [[IV]], -21724; LE-MEMSSA-NEXT: [[GEP_1:%.*]] = getelementptr i32, ptr [[X]], i32 [[OFFSET]]1725; LE-MEMSSA-NEXT: [[L1:%.*]] = load i32, ptr [[GEP_1]], align 41726; LE-MEMSSA-NEXT: [[IV_NEXT]] = add i32 [[IV]], 11727; LE-MEMSSA-NEXT: br i1 [[COND]], label %[[EXIT:.*]], label %[[HEADER]]1728; LE-MEMSSA: [[EXIT]]:1729; LE-MEMSSA-NEXT: ret i32 [[L1]]1730;1731; BE-MEMDEP-LABEL: define i32 @phi_trans8(1732; BE-MEMDEP-SAME: ptr noalias readonly captures(none) [[X:%.*]], i1 [[COND:%.*]]) {1733; BE-MEMDEP-NEXT: [[ENTRY:.*]]:1734; BE-MEMDEP-NEXT: [[L0:%.*]] = load i32, ptr [[X]], align 41735; BE-MEMDEP-NEXT: call void @use_i32(i32 [[L0]])1736; BE-MEMDEP-NEXT: br label %[[HEADER:.*]]1737; BE-MEMDEP: [[HEADER]]:1738; BE-MEMDEP-NEXT: [[IV:%.*]] = phi i32 [ 2, %[[ENTRY]] ], [ [[IV_NEXT:%.*]], %[[LATCH_HEADER_CRIT_EDGE:.*]] ]1739; BE-MEMDEP-NEXT: indirectbr ptr blockaddress(@phi_trans8, %[[LATCH:.*]]), [label %latch]1740; BE-MEMDEP: [[LATCH]]:1741; BE-MEMDEP-NEXT: [[OFFSET:%.*]] = add i32 [[IV]], -21742; BE-MEMDEP-NEXT: [[GEP_1:%.*]] = getelementptr i32, ptr [[X]], i32 [[OFFSET]]1743; BE-MEMDEP-NEXT: [[L1:%.*]] = load i32, ptr [[GEP_1]], align 41744; BE-MEMDEP-NEXT: [[IV_NEXT]] = add i32 [[IV]], 11745; BE-MEMDEP-NEXT: br i1 [[COND]], label %[[EXIT:.*]], label %[[LATCH_HEADER_CRIT_EDGE]]1746; BE-MEMDEP: [[LATCH_HEADER_CRIT_EDGE]]:1747; BE-MEMDEP-NEXT: br label %[[HEADER]]1748; BE-MEMDEP: [[EXIT]]:1749; BE-MEMDEP-NEXT: ret i32 [[L1]]1750;1751; BE-MEMSSA-LABEL: define i32 @phi_trans8(1752; BE-MEMSSA-SAME: ptr noalias readonly captures(none) [[X:%.*]], i1 [[COND:%.*]]) {1753; BE-MEMSSA-NEXT: [[ENTRY:.*]]:1754; BE-MEMSSA-NEXT: [[L0:%.*]] = load i32, ptr [[X]], align 41755; BE-MEMSSA-NEXT: call void @use_i32(i32 [[L0]])1756; BE-MEMSSA-NEXT: br label %[[HEADER:.*]]1757; BE-MEMSSA: [[HEADER]]:1758; BE-MEMSSA-NEXT: [[IV:%.*]] = phi i32 [ 2, %[[ENTRY]] ], [ [[IV_NEXT:%.*]], %[[LATCH:.*]] ]1759; BE-MEMSSA-NEXT: indirectbr ptr blockaddress(@phi_trans8, %[[LATCH]]), [label %latch]1760; BE-MEMSSA: [[LATCH]]:1761; BE-MEMSSA-NEXT: [[OFFSET:%.*]] = add i32 [[IV]], -21762; BE-MEMSSA-NEXT: [[GEP_1:%.*]] = getelementptr i32, ptr [[X]], i32 [[OFFSET]]1763; BE-MEMSSA-NEXT: [[L1:%.*]] = load i32, ptr [[GEP_1]], align 41764; BE-MEMSSA-NEXT: [[IV_NEXT]] = add i32 [[IV]], 11765; BE-MEMSSA-NEXT: br i1 [[COND]], label %[[EXIT:.*]], label %[[HEADER]]1766; BE-MEMSSA: [[EXIT]]:1767; BE-MEMSSA-NEXT: ret i32 [[L1]]1768;1769entry:1770 %l0 = load i32, ptr %x1771 call void @use_i32(i32 %l0)1772 br label %header1773 1774header:1775 %iv = phi i32 [2, %entry], [ %iv.next, %latch]1776 indirectbr ptr blockaddress(@phi_trans8, %latch), [label %latch]1777 1778latch:1779 %offset = add i32 %iv, -21780 %gep.1 = getelementptr i32, ptr %x, i32 %offset1781 %l1 = load i32, ptr %gep.11782 %iv.next = add i32 %iv, 11783 br i1 %cond, label %exit, label %header1784 1785exit:1786 ret i32 %l11787}1788 1789 1790 1791; PR66421792define i32 @memset_to_load() nounwind readnone {1793; LE-MEMDEP-LABEL: define i32 @memset_to_load(1794; LE-MEMDEP-SAME: ) #[[ATTR2:[0-9]+]] {1795; LE-MEMDEP-NEXT: [[ENTRY:.*:]]1796; LE-MEMDEP-NEXT: [[X:%.*]] = alloca [256 x i32], align 41797; LE-MEMDEP-NEXT: call void @llvm.memset.p0.i64(ptr align 4 [[X]], i8 0, i64 1024, i1 false)1798; LE-MEMDEP-NEXT: ret i32 01799;1800; LE-MEMSSA-LABEL: define i32 @memset_to_load(1801; LE-MEMSSA-SAME: ) #[[ATTR2:[0-9]+]] {1802; LE-MEMSSA-NEXT: [[ENTRY:.*:]]1803; LE-MEMSSA-NEXT: [[X:%.*]] = alloca [256 x i32], align 41804; LE-MEMSSA-NEXT: call void @llvm.memset.p0.i64(ptr align 4 [[X]], i8 0, i64 1024, i1 false)1805; LE-MEMSSA-NEXT: [[TTMP1:%.*]] = load i32, ptr [[X]], align 41806; LE-MEMSSA-NEXT: ret i32 [[TTMP1]]1807;1808; BE-MEMDEP-LABEL: define i32 @memset_to_load(1809; BE-MEMDEP-SAME: ) #[[ATTR2:[0-9]+]] {1810; BE-MEMDEP-NEXT: [[ENTRY:.*:]]1811; BE-MEMDEP-NEXT: [[X:%.*]] = alloca [256 x i32], align 41812; BE-MEMDEP-NEXT: call void @llvm.memset.p0.i64(ptr align 4 [[X]], i8 0, i64 1024, i1 false)1813; BE-MEMDEP-NEXT: ret i32 01814;1815; BE-MEMSSA-LABEL: define i32 @memset_to_load(1816; BE-MEMSSA-SAME: ) #[[ATTR2:[0-9]+]] {1817; BE-MEMSSA-NEXT: [[ENTRY:.*:]]1818; BE-MEMSSA-NEXT: [[X:%.*]] = alloca [256 x i32], align 41819; BE-MEMSSA-NEXT: call void @llvm.memset.p0.i64(ptr align 4 [[X]], i8 0, i64 1024, i1 false)1820; BE-MEMSSA-NEXT: [[TTMP1:%.*]] = load i32, ptr [[X]], align 41821; BE-MEMSSA-NEXT: ret i32 [[TTMP1]]1822;1823entry:1824 %x = alloca [256 x i32], align 4 ; <ptr> [#uses=2]1825 call void @llvm.memset.p0.i64(ptr align 4 %x, i8 0, i64 1024, i1 false)1826 %arraydecay = getelementptr inbounds [256 x i32], ptr %x, i32 0, i32 0 ; <ptr>1827 %ttmp1 = load i32, ptr %arraydecay ; <i32> [#uses=1]1828 ret i32 %ttmp11829}1830 1831 1832;;===----------------------------------------------------------------------===;;1833;; Load -> Load forwarding in partial alias case.1834;;===----------------------------------------------------------------------===;;1835 1836define i32 @load_load_partial_alias(ptr %P) nounwind ssp {1837; LE-MEMDEP-LABEL: define i32 @load_load_partial_alias(1838; LE-MEMDEP-SAME: ptr [[P:%.*]]) #[[ATTR0]] {1839; LE-MEMDEP-NEXT: [[ENTRY:.*:]]1840; LE-MEMDEP-NEXT: [[TTMP2:%.*]] = load i32, ptr [[P]], align 41841; LE-MEMDEP-NEXT: [[TMP0:%.*]] = lshr i32 [[TTMP2]], 81842; LE-MEMDEP-NEXT: [[TMP1:%.*]] = trunc i32 [[TMP0]] to i81843; LE-MEMDEP-NEXT: [[CONV:%.*]] = zext i8 [[TMP1]] to i321844; LE-MEMDEP-NEXT: [[ADD:%.*]] = add nsw i32 [[TTMP2]], [[CONV]]1845; LE-MEMDEP-NEXT: ret i32 [[ADD]]1846;1847; LE-MEMSSA-LABEL: define i32 @load_load_partial_alias(1848; LE-MEMSSA-SAME: ptr [[P:%.*]]) #[[ATTR0]] {1849; LE-MEMSSA-NEXT: [[ENTRY:.*:]]1850; LE-MEMSSA-NEXT: [[TTMP2:%.*]] = load i32, ptr [[P]], align 41851; LE-MEMSSA-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds i8, ptr [[P]], i64 11852; LE-MEMSSA-NEXT: [[TTMP5:%.*]] = load i8, ptr [[ADD_PTR]], align 11853; LE-MEMSSA-NEXT: [[CONV:%.*]] = zext i8 [[TTMP5]] to i321854; LE-MEMSSA-NEXT: [[ADD:%.*]] = add nsw i32 [[TTMP2]], [[CONV]]1855; LE-MEMSSA-NEXT: ret i32 [[ADD]]1856;1857; BE-MEMDEP-LABEL: define i32 @load_load_partial_alias(1858; BE-MEMDEP-SAME: ptr [[P:%.*]]) #[[ATTR0]] {1859; BE-MEMDEP-NEXT: [[ENTRY:.*:]]1860; BE-MEMDEP-NEXT: [[TTMP2:%.*]] = load i32, ptr [[P]], align 41861; BE-MEMDEP-NEXT: [[TMP0:%.*]] = lshr i32 [[TTMP2]], 161862; BE-MEMDEP-NEXT: [[TMP1:%.*]] = trunc i32 [[TMP0]] to i81863; BE-MEMDEP-NEXT: [[CONV:%.*]] = zext i8 [[TMP1]] to i321864; BE-MEMDEP-NEXT: [[ADD:%.*]] = add nsw i32 [[TTMP2]], [[CONV]]1865; BE-MEMDEP-NEXT: ret i32 [[ADD]]1866;1867; BE-MEMSSA-LABEL: define i32 @load_load_partial_alias(1868; BE-MEMSSA-SAME: ptr [[P:%.*]]) #[[ATTR0]] {1869; BE-MEMSSA-NEXT: [[ENTRY:.*:]]1870; BE-MEMSSA-NEXT: [[TTMP2:%.*]] = load i32, ptr [[P]], align 41871; BE-MEMSSA-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds i8, ptr [[P]], i64 11872; BE-MEMSSA-NEXT: [[TTMP5:%.*]] = load i8, ptr [[ADD_PTR]], align 11873; BE-MEMSSA-NEXT: [[CONV:%.*]] = zext i8 [[TTMP5]] to i321874; BE-MEMSSA-NEXT: [[ADD:%.*]] = add nsw i32 [[TTMP2]], [[CONV]]1875; BE-MEMSSA-NEXT: ret i32 [[ADD]]1876;1877entry:1878 %ttmp2 = load i32, ptr %P1879 %add.ptr = getelementptr inbounds i8, ptr %P, i64 11880 %ttmp5 = load i8, ptr %add.ptr1881 %conv = zext i8 %ttmp5 to i321882 %add = add nsw i32 %ttmp2, %conv1883 ret i32 %add1884}1885 1886 1887; Cross block partial alias case.1888define i32 @load_load_partial_alias_cross_block(ptr %P) nounwind ssp {1889; LE-MEMDEP-LABEL: define i32 @load_load_partial_alias_cross_block(1890; LE-MEMDEP-SAME: ptr [[P:%.*]]) #[[ATTR0]] {1891; LE-MEMDEP-NEXT: [[ENTRY:.*:]]1892; LE-MEMDEP-NEXT: [[X1:%.*]] = load i32, ptr [[P]], align 41893; LE-MEMDEP-NEXT: [[CMP:%.*]] = icmp eq i32 [[X1]], 1271894; LE-MEMDEP-NEXT: [[TMP0:%.*]] = lshr i32 [[X1]], 81895; LE-MEMDEP-NEXT: [[TMP1:%.*]] = trunc i32 [[TMP0]] to i81896; LE-MEMDEP-NEXT: br i1 [[CMP]], label %[[LAND_LHS_TRUE:.*]], label %[[IF_END:.*]]1897; LE-MEMDEP: [[LAND_LHS_TRUE]]:1898; LE-MEMDEP-NEXT: [[CONV6:%.*]] = zext i8 [[TMP1]] to i321899; LE-MEMDEP-NEXT: ret i32 [[CONV6]]1900; LE-MEMDEP: [[IF_END]]:1901; LE-MEMDEP-NEXT: ret i32 521902;1903; LE-MEMSSA-LABEL: define i32 @load_load_partial_alias_cross_block(1904; LE-MEMSSA-SAME: ptr [[P:%.*]]) #[[ATTR0]] {1905; LE-MEMSSA-NEXT: [[ENTRY:.*:]]1906; LE-MEMSSA-NEXT: [[X1:%.*]] = load i32, ptr [[P]], align 41907; LE-MEMSSA-NEXT: [[CMP:%.*]] = icmp eq i32 [[X1]], 1271908; LE-MEMSSA-NEXT: br i1 [[CMP]], label %[[LAND_LHS_TRUE:.*]], label %[[IF_END:.*]]1909; LE-MEMSSA: [[LAND_LHS_TRUE]]:1910; LE-MEMSSA-NEXT: [[ARRAYIDX4:%.*]] = getelementptr inbounds i8, ptr [[P]], i64 11911; LE-MEMSSA-NEXT: [[TTMP5:%.*]] = load i8, ptr [[ARRAYIDX4]], align 11912; LE-MEMSSA-NEXT: [[CONV6:%.*]] = zext i8 [[TTMP5]] to i321913; LE-MEMSSA-NEXT: ret i32 [[CONV6]]1914; LE-MEMSSA: [[IF_END]]:1915; LE-MEMSSA-NEXT: ret i32 521916;1917; BE-MEMDEP-LABEL: define i32 @load_load_partial_alias_cross_block(1918; BE-MEMDEP-SAME: ptr [[P:%.*]]) #[[ATTR0]] {1919; BE-MEMDEP-NEXT: [[ENTRY:.*:]]1920; BE-MEMDEP-NEXT: [[X1:%.*]] = load i32, ptr [[P]], align 41921; BE-MEMDEP-NEXT: [[CMP:%.*]] = icmp eq i32 [[X1]], 1271922; BE-MEMDEP-NEXT: [[TMP0:%.*]] = lshr i32 [[X1]], 161923; BE-MEMDEP-NEXT: [[TMP1:%.*]] = trunc i32 [[TMP0]] to i81924; BE-MEMDEP-NEXT: br i1 [[CMP]], label %[[LAND_LHS_TRUE:.*]], label %[[IF_END:.*]]1925; BE-MEMDEP: [[LAND_LHS_TRUE]]:1926; BE-MEMDEP-NEXT: [[CONV6:%.*]] = zext i8 [[TMP1]] to i321927; BE-MEMDEP-NEXT: ret i32 [[CONV6]]1928; BE-MEMDEP: [[IF_END]]:1929; BE-MEMDEP-NEXT: ret i32 521930;1931; BE-MEMSSA-LABEL: define i32 @load_load_partial_alias_cross_block(1932; BE-MEMSSA-SAME: ptr [[P:%.*]]) #[[ATTR0]] {1933; BE-MEMSSA-NEXT: [[ENTRY:.*:]]1934; BE-MEMSSA-NEXT: [[X1:%.*]] = load i32, ptr [[P]], align 41935; BE-MEMSSA-NEXT: [[CMP:%.*]] = icmp eq i32 [[X1]], 1271936; BE-MEMSSA-NEXT: br i1 [[CMP]], label %[[LAND_LHS_TRUE:.*]], label %[[IF_END:.*]]1937; BE-MEMSSA: [[LAND_LHS_TRUE]]:1938; BE-MEMSSA-NEXT: [[ARRAYIDX4:%.*]] = getelementptr inbounds i8, ptr [[P]], i64 11939; BE-MEMSSA-NEXT: [[TTMP5:%.*]] = load i8, ptr [[ARRAYIDX4]], align 11940; BE-MEMSSA-NEXT: [[CONV6:%.*]] = zext i8 [[TTMP5]] to i321941; BE-MEMSSA-NEXT: ret i32 [[CONV6]]1942; BE-MEMSSA: [[IF_END]]:1943; BE-MEMSSA-NEXT: ret i32 521944;1945entry:1946 %x1 = load i32, ptr %P, align 41947 %cmp = icmp eq i32 %x1, 1271948 br i1 %cmp, label %land.lhs.true, label %if.end1949 1950land.lhs.true: ; preds = %entry1951 %arrayidx4 = getelementptr inbounds i8, ptr %P, i64 11952 %ttmp5 = load i8, ptr %arrayidx4, align 11953 %conv6 = zext i8 %ttmp5 to i321954 ret i32 %conv61955 1956if.end:1957 ret i32 521958}1959 1960define i32 @load_load_partial_alias_cross_block_phi_trans(ptr %P) nounwind {1961; LE-MEMDEP-LABEL: define i32 @load_load_partial_alias_cross_block_phi_trans(1962; LE-MEMDEP-SAME: ptr [[P:%.*]]) #[[ATTR3]] {1963; LE-MEMDEP-NEXT: [[ENTRY:.*:]]1964; LE-MEMDEP-NEXT: [[X1:%.*]] = load i32, ptr [[P]], align 41965; LE-MEMDEP-NEXT: [[CMP:%.*]] = icmp eq i32 [[X1]], 1271966; LE-MEMDEP-NEXT: [[TMP0:%.*]] = lshr i32 [[X1]], 161967; LE-MEMDEP-NEXT: [[TMP1:%.*]] = trunc i32 [[TMP0]] to i81968; LE-MEMDEP-NEXT: [[TMP2:%.*]] = lshr i32 [[X1]], 81969; LE-MEMDEP-NEXT: [[TMP3:%.*]] = trunc i32 [[TMP2]] to i81970; LE-MEMDEP-NEXT: br i1 [[CMP]], label %[[IF:.*]], label %[[ELSE:.*]]1971; LE-MEMDEP: [[IF]]:1972; LE-MEMDEP-NEXT: br label %[[JOIN:.*]]1973; LE-MEMDEP: [[ELSE]]:1974; LE-MEMDEP-NEXT: br label %[[JOIN]]1975; LE-MEMDEP: [[JOIN]]:1976; LE-MEMDEP-NEXT: [[TTMP5:%.*]] = phi i8 [ [[TMP3]], %[[IF]] ], [ [[TMP1]], %[[ELSE]] ]1977; LE-MEMDEP-NEXT: [[CONV6:%.*]] = zext i8 [[TTMP5]] to i321978; LE-MEMDEP-NEXT: ret i32 [[CONV6]]1979; LE-MEMDEP: [[IF_END:.*:]]1980; LE-MEMDEP-NEXT: ret i32 521981;1982; LE-MEMSSA-LABEL: define i32 @load_load_partial_alias_cross_block_phi_trans(1983; LE-MEMSSA-SAME: ptr [[P:%.*]]) #[[ATTR3]] {1984; LE-MEMSSA-NEXT: [[ENTRY:.*:]]1985; LE-MEMSSA-NEXT: [[X1:%.*]] = load i32, ptr [[P]], align 41986; LE-MEMSSA-NEXT: [[CMP:%.*]] = icmp eq i32 [[X1]], 1271987; LE-MEMSSA-NEXT: br i1 [[CMP]], label %[[IF:.*]], label %[[ELSE:.*]]1988; LE-MEMSSA: [[IF]]:1989; LE-MEMSSA-NEXT: br label %[[JOIN:.*]]1990; LE-MEMSSA: [[ELSE]]:1991; LE-MEMSSA-NEXT: br label %[[JOIN]]1992; LE-MEMSSA: [[JOIN]]:1993; LE-MEMSSA-NEXT: [[IDX:%.*]] = phi i64 [ 1, %[[IF]] ], [ 2, %[[ELSE]] ]1994; LE-MEMSSA-NEXT: [[ARRAYIDX4:%.*]] = getelementptr inbounds i8, ptr [[P]], i64 [[IDX]]1995; LE-MEMSSA-NEXT: [[TTMP5:%.*]] = load i8, ptr [[ARRAYIDX4]], align 11996; LE-MEMSSA-NEXT: [[CONV6:%.*]] = zext i8 [[TTMP5]] to i321997; LE-MEMSSA-NEXT: ret i32 [[CONV6]]1998; LE-MEMSSA: [[IF_END:.*:]]1999; LE-MEMSSA-NEXT: ret i32 522000;2001; BE-MEMDEP-LABEL: define i32 @load_load_partial_alias_cross_block_phi_trans(2002; BE-MEMDEP-SAME: ptr [[P:%.*]]) #[[ATTR3]] {2003; BE-MEMDEP-NEXT: [[ENTRY:.*:]]2004; BE-MEMDEP-NEXT: [[X1:%.*]] = load i32, ptr [[P]], align 42005; BE-MEMDEP-NEXT: [[CMP:%.*]] = icmp eq i32 [[X1]], 1272006; BE-MEMDEP-NEXT: [[TMP0:%.*]] = lshr i32 [[X1]], 82007; BE-MEMDEP-NEXT: [[TMP1:%.*]] = trunc i32 [[TMP0]] to i82008; BE-MEMDEP-NEXT: [[TMP2:%.*]] = lshr i32 [[X1]], 162009; BE-MEMDEP-NEXT: [[TMP3:%.*]] = trunc i32 [[TMP2]] to i82010; BE-MEMDEP-NEXT: br i1 [[CMP]], label %[[IF:.*]], label %[[ELSE:.*]]2011; BE-MEMDEP: [[IF]]:2012; BE-MEMDEP-NEXT: br label %[[JOIN:.*]]2013; BE-MEMDEP: [[ELSE]]:2014; BE-MEMDEP-NEXT: br label %[[JOIN]]2015; BE-MEMDEP: [[JOIN]]:2016; BE-MEMDEP-NEXT: [[TTMP5:%.*]] = phi i8 [ [[TMP3]], %[[IF]] ], [ [[TMP1]], %[[ELSE]] ]2017; BE-MEMDEP-NEXT: [[CONV6:%.*]] = zext i8 [[TTMP5]] to i322018; BE-MEMDEP-NEXT: ret i32 [[CONV6]]2019; BE-MEMDEP: [[IF_END:.*:]]2020; BE-MEMDEP-NEXT: ret i32 522021;2022; BE-MEMSSA-LABEL: define i32 @load_load_partial_alias_cross_block_phi_trans(2023; BE-MEMSSA-SAME: ptr [[P:%.*]]) #[[ATTR3]] {2024; BE-MEMSSA-NEXT: [[ENTRY:.*:]]2025; BE-MEMSSA-NEXT: [[X1:%.*]] = load i32, ptr [[P]], align 42026; BE-MEMSSA-NEXT: [[CMP:%.*]] = icmp eq i32 [[X1]], 1272027; BE-MEMSSA-NEXT: br i1 [[CMP]], label %[[IF:.*]], label %[[ELSE:.*]]2028; BE-MEMSSA: [[IF]]:2029; BE-MEMSSA-NEXT: br label %[[JOIN:.*]]2030; BE-MEMSSA: [[ELSE]]:2031; BE-MEMSSA-NEXT: br label %[[JOIN]]2032; BE-MEMSSA: [[JOIN]]:2033; BE-MEMSSA-NEXT: [[IDX:%.*]] = phi i64 [ 1, %[[IF]] ], [ 2, %[[ELSE]] ]2034; BE-MEMSSA-NEXT: [[ARRAYIDX4:%.*]] = getelementptr inbounds i8, ptr [[P]], i64 [[IDX]]2035; BE-MEMSSA-NEXT: [[TTMP5:%.*]] = load i8, ptr [[ARRAYIDX4]], align 12036; BE-MEMSSA-NEXT: [[CONV6:%.*]] = zext i8 [[TTMP5]] to i322037; BE-MEMSSA-NEXT: ret i32 [[CONV6]]2038; BE-MEMSSA: [[IF_END:.*:]]2039; BE-MEMSSA-NEXT: ret i32 522040;2041entry:2042 %x1 = load i32, ptr %P, align 42043 %cmp = icmp eq i32 %x1, 1272044 br i1 %cmp, label %if, label %else2045 2046if:2047 %arrayidx.if = getelementptr inbounds i8, ptr %P, i64 12048 br label %join2049 2050else:2051 %arrayidx.else = getelementptr inbounds i8, ptr %P, i64 22052 br label %join2053 2054join:2055 %idx = phi i64 [ 1, %if ], [ 2, %else ]2056 %arrayidx4 = getelementptr inbounds i8, ptr %P, i64 %idx2057 %ttmp5 = load i8, ptr %arrayidx4, align 12058 %conv6 = zext i8 %ttmp5 to i322059 ret i32 %conv62060 2061if.end:2062 ret i32 522063}2064 2065define void @load_load_partial_alias_loop(ptr %P) {2066; LE-MEMDEP-LABEL: define void @load_load_partial_alias_loop(2067; LE-MEMDEP-SAME: ptr [[P:%.*]]) {2068; LE-MEMDEP-NEXT: [[ENTRY:.*]]:2069; LE-MEMDEP-NEXT: [[P_1:%.*]] = getelementptr i8, ptr [[P]], i64 12070; LE-MEMDEP-NEXT: [[V_1:%.*]] = load i8, ptr [[P_1]], align 12071; LE-MEMDEP-NEXT: call void @use.i8(i8 [[V_1]])2072; LE-MEMDEP-NEXT: [[V_1_32:%.*]] = load i32, ptr [[P_1]], align 42073; LE-MEMDEP-NEXT: call void @use.i32(i32 [[V_1_32]])2074; LE-MEMDEP-NEXT: [[TMP0:%.*]] = trunc i32 [[V_1_32]] to i82075; LE-MEMDEP-NEXT: br label %[[LOOP:.*]]2076; LE-MEMDEP: [[LOOP]]:2077; LE-MEMDEP-NEXT: [[V_I:%.*]] = phi i8 [ [[TMP0]], %[[ENTRY]] ], [ [[TMP2:%.*]], %[[LOOP_LOOP_CRIT_EDGE:.*]] ]2078; LE-MEMDEP-NEXT: [[I:%.*]] = phi i64 [ 1, %[[ENTRY]] ], [ [[I_INC:%.*]], %[[LOOP_LOOP_CRIT_EDGE]] ]2079; LE-MEMDEP-NEXT: [[P_I:%.*]] = getelementptr i8, ptr [[P]], i64 [[I]]2080; LE-MEMDEP-NEXT: call void @use.i8(i8 [[V_I]])2081; LE-MEMDEP-NEXT: [[V_I_32:%.*]] = load i32, ptr [[P_I]], align 42082; LE-MEMDEP-NEXT: call void @use.i32(i32 [[V_I_32]])2083; LE-MEMDEP-NEXT: [[I_INC]] = add i64 [[I]], 12084; LE-MEMDEP-NEXT: [[CMP:%.*]] = icmp ne i64 [[I_INC]], 642085; LE-MEMDEP-NEXT: [[TMP1:%.*]] = lshr i32 [[V_I_32]], 82086; LE-MEMDEP-NEXT: [[TMP2]] = trunc i32 [[TMP1]] to i82087; LE-MEMDEP-NEXT: br i1 [[CMP]], label %[[LOOP_LOOP_CRIT_EDGE]], label %[[EXIT:.*]]2088; LE-MEMDEP: [[LOOP_LOOP_CRIT_EDGE]]:2089; LE-MEMDEP-NEXT: br label %[[LOOP]]2090; LE-MEMDEP: [[EXIT]]:2091; LE-MEMDEP-NEXT: ret void2092;2093; LE-MEMSSA-LABEL: define void @load_load_partial_alias_loop(2094; LE-MEMSSA-SAME: ptr [[P:%.*]]) {2095; LE-MEMSSA-NEXT: [[ENTRY:.*]]:2096; LE-MEMSSA-NEXT: [[P_1:%.*]] = getelementptr i8, ptr [[P]], i64 12097; LE-MEMSSA-NEXT: [[V_1:%.*]] = load i8, ptr [[P_1]], align 12098; LE-MEMSSA-NEXT: call void @use.i8(i8 [[V_1]])2099; LE-MEMSSA-NEXT: [[V_1_32:%.*]] = load i32, ptr [[P_1]], align 42100; LE-MEMSSA-NEXT: call void @use.i32(i32 [[V_1_32]])2101; LE-MEMSSA-NEXT: br label %[[LOOP:.*]]2102; LE-MEMSSA: [[LOOP]]:2103; LE-MEMSSA-NEXT: [[I:%.*]] = phi i64 [ 1, %[[ENTRY]] ], [ [[I_INC:%.*]], %[[LOOP]] ]2104; LE-MEMSSA-NEXT: [[P_I:%.*]] = getelementptr i8, ptr [[P]], i64 [[I]]2105; LE-MEMSSA-NEXT: [[V_I:%.*]] = load i8, ptr [[P_I]], align 12106; LE-MEMSSA-NEXT: call void @use.i8(i8 [[V_I]])2107; LE-MEMSSA-NEXT: [[V_I_32:%.*]] = load i32, ptr [[P_I]], align 42108; LE-MEMSSA-NEXT: call void @use.i32(i32 [[V_I_32]])2109; LE-MEMSSA-NEXT: [[I_INC]] = add i64 [[I]], 12110; LE-MEMSSA-NEXT: [[CMP:%.*]] = icmp ne i64 [[I_INC]], 642111; LE-MEMSSA-NEXT: br i1 [[CMP]], label %[[LOOP]], label %[[EXIT:.*]]2112; LE-MEMSSA: [[EXIT]]:2113; LE-MEMSSA-NEXT: ret void2114;2115; BE-MEMDEP-LABEL: define void @load_load_partial_alias_loop(2116; BE-MEMDEP-SAME: ptr [[P:%.*]]) {2117; BE-MEMDEP-NEXT: [[ENTRY:.*]]:2118; BE-MEMDEP-NEXT: [[P_1:%.*]] = getelementptr i8, ptr [[P]], i64 12119; BE-MEMDEP-NEXT: [[V_1:%.*]] = load i8, ptr [[P_1]], align 12120; BE-MEMDEP-NEXT: call void @use.i8(i8 [[V_1]])2121; BE-MEMDEP-NEXT: [[V_1_32:%.*]] = load i32, ptr [[P_1]], align 42122; BE-MEMDEP-NEXT: call void @use.i32(i32 [[V_1_32]])2123; BE-MEMDEP-NEXT: [[TMP0:%.*]] = lshr i32 [[V_1_32]], 242124; BE-MEMDEP-NEXT: [[TMP1:%.*]] = trunc i32 [[TMP0]] to i82125; BE-MEMDEP-NEXT: br label %[[LOOP:.*]]2126; BE-MEMDEP: [[LOOP]]:2127; BE-MEMDEP-NEXT: [[V_I:%.*]] = phi i8 [ [[TMP1]], %[[ENTRY]] ], [ [[TMP3:%.*]], %[[LOOP_LOOP_CRIT_EDGE:.*]] ]2128; BE-MEMDEP-NEXT: [[I:%.*]] = phi i64 [ 1, %[[ENTRY]] ], [ [[I_INC:%.*]], %[[LOOP_LOOP_CRIT_EDGE]] ]2129; BE-MEMDEP-NEXT: [[P_I:%.*]] = getelementptr i8, ptr [[P]], i64 [[I]]2130; BE-MEMDEP-NEXT: call void @use.i8(i8 [[V_I]])2131; BE-MEMDEP-NEXT: [[V_I_32:%.*]] = load i32, ptr [[P_I]], align 42132; BE-MEMDEP-NEXT: call void @use.i32(i32 [[V_I_32]])2133; BE-MEMDEP-NEXT: [[I_INC]] = add i64 [[I]], 12134; BE-MEMDEP-NEXT: [[CMP:%.*]] = icmp ne i64 [[I_INC]], 642135; BE-MEMDEP-NEXT: [[TMP2:%.*]] = lshr i32 [[V_I_32]], 162136; BE-MEMDEP-NEXT: [[TMP3]] = trunc i32 [[TMP2]] to i82137; BE-MEMDEP-NEXT: br i1 [[CMP]], label %[[LOOP_LOOP_CRIT_EDGE]], label %[[EXIT:.*]]2138; BE-MEMDEP: [[LOOP_LOOP_CRIT_EDGE]]:2139; BE-MEMDEP-NEXT: br label %[[LOOP]]2140; BE-MEMDEP: [[EXIT]]:2141; BE-MEMDEP-NEXT: ret void2142;2143; BE-MEMSSA-LABEL: define void @load_load_partial_alias_loop(2144; BE-MEMSSA-SAME: ptr [[P:%.*]]) {2145; BE-MEMSSA-NEXT: [[ENTRY:.*]]:2146; BE-MEMSSA-NEXT: [[P_1:%.*]] = getelementptr i8, ptr [[P]], i64 12147; BE-MEMSSA-NEXT: [[V_1:%.*]] = load i8, ptr [[P_1]], align 12148; BE-MEMSSA-NEXT: call void @use.i8(i8 [[V_1]])2149; BE-MEMSSA-NEXT: [[V_1_32:%.*]] = load i32, ptr [[P_1]], align 42150; BE-MEMSSA-NEXT: call void @use.i32(i32 [[V_1_32]])2151; BE-MEMSSA-NEXT: br label %[[LOOP:.*]]2152; BE-MEMSSA: [[LOOP]]:2153; BE-MEMSSA-NEXT: [[I:%.*]] = phi i64 [ 1, %[[ENTRY]] ], [ [[I_INC:%.*]], %[[LOOP]] ]2154; BE-MEMSSA-NEXT: [[P_I:%.*]] = getelementptr i8, ptr [[P]], i64 [[I]]2155; BE-MEMSSA-NEXT: [[V_I:%.*]] = load i8, ptr [[P_I]], align 12156; BE-MEMSSA-NEXT: call void @use.i8(i8 [[V_I]])2157; BE-MEMSSA-NEXT: [[V_I_32:%.*]] = load i32, ptr [[P_I]], align 42158; BE-MEMSSA-NEXT: call void @use.i32(i32 [[V_I_32]])2159; BE-MEMSSA-NEXT: [[I_INC]] = add i64 [[I]], 12160; BE-MEMSSA-NEXT: [[CMP:%.*]] = icmp ne i64 [[I_INC]], 642161; BE-MEMSSA-NEXT: br i1 [[CMP]], label %[[LOOP]], label %[[EXIT:.*]]2162; BE-MEMSSA: [[EXIT]]:2163; BE-MEMSSA-NEXT: ret void2164;2165entry:2166 %P.1 = getelementptr i8, ptr %P, i64 12167 %v.1 = load i8, ptr %P.12168 call void @use.i8(i8 %v.1)2169 %v.1.32 = load i32, ptr %P.12170 call void @use.i32(i32 %v.1.32)2171 br label %loop2172 2173loop:2174 %i = phi i64 [ 1, %entry ], [ %i.inc, %loop ]2175 %P.i = getelementptr i8, ptr %P, i64 %i2176 %v.i = load i8, ptr %P.i2177 call void @use.i8(i8 %v.i)2178 %v.i.32 = load i32, ptr %P.i2179 call void @use.i32(i32 %v.i.32)2180 %i.inc = add i64 %i, 12181 %cmp = icmp ne i64 %i.inc, 642182 br i1 %cmp, label %loop, label %exit2183 2184exit:2185 ret void2186}2187 2188declare void @use.i8(i8) readnone2189declare void @use.i32(i32) readnone2190 2191@global = external local_unnamed_addr global i8, align 42192 2193define void @load_load_partial_alias_atomic(ptr %arg) {2194; LE-MEMDEP-LABEL: define void @load_load_partial_alias_atomic(2195; LE-MEMDEP-SAME: ptr [[ARG:%.*]]) {2196; LE-MEMDEP-NEXT: [[BB:.*]]:2197; LE-MEMDEP-NEXT: [[TMP2_1:%.*]] = getelementptr inbounds i8, ptr [[ARG]], i64 12198; LE-MEMDEP-NEXT: [[TMP2_3:%.*]] = load i64, ptr [[TMP2_1]], align 42199; LE-MEMDEP-NEXT: [[TMP3_1:%.*]] = getelementptr inbounds i8, ptr [[ARG]], i64 22200; LE-MEMDEP-NEXT: [[TMP0:%.*]] = lshr i64 [[TMP2_3]], 82201; LE-MEMDEP-NEXT: [[TMP1:%.*]] = trunc i64 [[TMP0]] to i82202; LE-MEMDEP-NEXT: br label %[[BB5:.*]]2203; LE-MEMDEP: [[BB5]]:2204; LE-MEMDEP-NEXT: [[TMP4_1:%.*]] = phi i8 [ [[TMP4_1_PRE:%.*]], %[[BB5]] ], [ [[TMP1]], %[[BB]] ]2205; LE-MEMDEP-NEXT: [[TMP6_1:%.*]] = load atomic i8, ptr @global acquire, align 42206; LE-MEMDEP-NEXT: [[TMP7_1:%.*]] = add i8 [[TMP6_1]], [[TMP4_1]]2207; LE-MEMDEP-NEXT: store i8 [[TMP7_1]], ptr [[ARG]], align 12208; LE-MEMDEP-NEXT: [[TMP4_1_PRE]] = load i8, ptr [[TMP3_1]], align 42209; LE-MEMDEP-NEXT: br label %[[BB5]]2210;2211; LE-MEMSSA-LABEL: define void @load_load_partial_alias_atomic(2212; LE-MEMSSA-SAME: ptr [[ARG:%.*]]) {2213; LE-MEMSSA-NEXT: [[BB:.*:]]2214; LE-MEMSSA-NEXT: [[TMP3_1:%.*]] = getelementptr inbounds i8, ptr [[ARG]], i64 22215; LE-MEMSSA-NEXT: br label %[[BB5:.*]]2216; LE-MEMSSA: [[BB5]]:2217; LE-MEMSSA-NEXT: [[TMP4_1:%.*]] = load i8, ptr [[TMP3_1]], align 42218; LE-MEMSSA-NEXT: [[TMP6_1:%.*]] = load atomic i8, ptr @global acquire, align 42219; LE-MEMSSA-NEXT: [[TMP7_1:%.*]] = add i8 [[TMP6_1]], [[TMP4_1]]2220; LE-MEMSSA-NEXT: store i8 [[TMP7_1]], ptr [[ARG]], align 12221; LE-MEMSSA-NEXT: br label %[[BB5]]2222;2223; BE-MEMDEP-LABEL: define void @load_load_partial_alias_atomic(2224; BE-MEMDEP-SAME: ptr [[ARG:%.*]]) {2225; BE-MEMDEP-NEXT: [[BB:.*]]:2226; BE-MEMDEP-NEXT: [[TMP2_1:%.*]] = getelementptr inbounds i8, ptr [[ARG]], i64 12227; BE-MEMDEP-NEXT: [[TMP2_3:%.*]] = load i64, ptr [[TMP2_1]], align 42228; BE-MEMDEP-NEXT: [[TMP3_1:%.*]] = getelementptr inbounds i8, ptr [[ARG]], i64 22229; BE-MEMDEP-NEXT: [[TMP0:%.*]] = lshr i64 [[TMP2_3]], 482230; BE-MEMDEP-NEXT: [[TMP1:%.*]] = trunc i64 [[TMP0]] to i82231; BE-MEMDEP-NEXT: br label %[[BB5:.*]]2232; BE-MEMDEP: [[BB5]]:2233; BE-MEMDEP-NEXT: [[TMP4_1:%.*]] = phi i8 [ [[TMP4_1_PRE:%.*]], %[[BB5]] ], [ [[TMP1]], %[[BB]] ]2234; BE-MEMDEP-NEXT: [[TMP6_1:%.*]] = load atomic i8, ptr @global acquire, align 42235; BE-MEMDEP-NEXT: [[TMP7_1:%.*]] = add i8 [[TMP6_1]], [[TMP4_1]]2236; BE-MEMDEP-NEXT: store i8 [[TMP7_1]], ptr [[ARG]], align 12237; BE-MEMDEP-NEXT: [[TMP4_1_PRE]] = load i8, ptr [[TMP3_1]], align 42238; BE-MEMDEP-NEXT: br label %[[BB5]]2239;2240; BE-MEMSSA-LABEL: define void @load_load_partial_alias_atomic(2241; BE-MEMSSA-SAME: ptr [[ARG:%.*]]) {2242; BE-MEMSSA-NEXT: [[BB:.*:]]2243; BE-MEMSSA-NEXT: [[TMP3_1:%.*]] = getelementptr inbounds i8, ptr [[ARG]], i64 22244; BE-MEMSSA-NEXT: br label %[[BB5:.*]]2245; BE-MEMSSA: [[BB5]]:2246; BE-MEMSSA-NEXT: [[TMP4_1:%.*]] = load i8, ptr [[TMP3_1]], align 42247; BE-MEMSSA-NEXT: [[TMP6_1:%.*]] = load atomic i8, ptr @global acquire, align 42248; BE-MEMSSA-NEXT: [[TMP7_1:%.*]] = add i8 [[TMP6_1]], [[TMP4_1]]2249; BE-MEMSSA-NEXT: store i8 [[TMP7_1]], ptr [[ARG]], align 12250; BE-MEMSSA-NEXT: br label %[[BB5]]2251;2252bb:2253 %tmp2.1 = getelementptr inbounds i8, ptr %arg, i64 12254 %tmp2.3 = load i64, ptr %tmp2.1, align 42255 %tmp2.4 = icmp ugt i64 %tmp2.3, 12256 2257 %tmp3.1 = getelementptr inbounds i8, ptr %arg, i64 22258 br label %bb52259 2260bb5: ; preds = %bb14, %bb2261 %tmp4.1 = load i8, ptr %tmp3.1, align 42262 %tmp6.1 = load atomic i8, ptr @global acquire, align 42263 %tmp7.1 = add i8 %tmp6.1, %tmp4.12264 store i8 %tmp7.1, ptr %arg2265 br label %bb52266 2267}2268 2269;;===----------------------------------------------------------------------===;;2270;; Load Widening2271;; We explicitly choose NOT to widen. And are testing to make sure we don't.2272;;===----------------------------------------------------------------------===;;2273 2274%widening1 = type { i32, i8, i8, i8, i8 }2275 2276@f = global %widening1 zeroinitializer, align 42277 2278define i32 @test_widening1(ptr %P) nounwind ssp noredzone {2279; CHECK-LABEL: define i32 @test_widening1(2280; CHECK-SAME: ptr [[P:%.*]]) #[[ATTR5:[0-9]+]] {2281; CHECK-NEXT: [[ENTRY:.*:]]2282; CHECK-NEXT: [[TTMP:%.*]] = load i8, ptr getelementptr inbounds ([[WIDENING1:%.*]], ptr @f, i64 0, i32 1), align 42283; CHECK-NEXT: [[CONV:%.*]] = zext i8 [[TTMP]] to i322284; CHECK-NEXT: [[TTMP1:%.*]] = load i8, ptr getelementptr inbounds ([[WIDENING1]], ptr @f, i64 0, i32 2), align 12285; CHECK-NEXT: [[CONV2:%.*]] = zext i8 [[TTMP1]] to i322286; CHECK-NEXT: [[ADD:%.*]] = add nsw i32 [[CONV]], [[CONV2]]2287; CHECK-NEXT: ret i32 [[ADD]]2288;2289entry:2290 %ttmp = load i8, ptr getelementptr inbounds (%widening1, ptr @f, i64 0, i32 1), align 42291 %conv = zext i8 %ttmp to i322292 %ttmp1 = load i8, ptr getelementptr inbounds (%widening1, ptr @f, i64 0, i32 2), align 12293 %conv2 = zext i8 %ttmp1 to i322294 %add = add nsw i32 %conv, %conv22295 ret i32 %add2296}2297 2298define i32 @test_widening2() nounwind ssp noredzone {2299; CHECK-LABEL: define i32 @test_widening2(2300; CHECK-SAME: ) #[[ATTR5]] {2301; CHECK-NEXT: [[ENTRY:.*:]]2302; CHECK-NEXT: [[TTMP:%.*]] = load i8, ptr getelementptr inbounds ([[WIDENING1:%.*]], ptr @f, i64 0, i32 1), align 42303; CHECK-NEXT: [[CONV:%.*]] = zext i8 [[TTMP]] to i322304; CHECK-NEXT: [[TTMP1:%.*]] = load i8, ptr getelementptr inbounds ([[WIDENING1]], ptr @f, i64 0, i32 2), align 12305; CHECK-NEXT: [[CONV2:%.*]] = zext i8 [[TTMP1]] to i322306; CHECK-NEXT: [[ADD:%.*]] = add nsw i32 [[CONV]], [[CONV2]]2307; CHECK-NEXT: [[TTMP2:%.*]] = load i8, ptr getelementptr inbounds ([[WIDENING1]], ptr @f, i64 0, i32 3), align 22308; CHECK-NEXT: [[CONV3:%.*]] = zext i8 [[TTMP2]] to i322309; CHECK-NEXT: [[ADD2:%.*]] = add nsw i32 [[ADD]], [[CONV3]]2310; CHECK-NEXT: [[TTMP3:%.*]] = load i8, ptr getelementptr inbounds ([[WIDENING1]], ptr @f, i64 0, i32 4), align 12311; CHECK-NEXT: [[CONV4:%.*]] = zext i8 [[TTMP3]] to i322312; CHECK-NEXT: [[ADD3:%.*]] = add nsw i32 [[ADD2]], [[CONV4]]2313; CHECK-NEXT: ret i32 [[ADD3]]2314;2315entry:2316 %ttmp = load i8, ptr getelementptr inbounds (%widening1, ptr @f, i64 0, i32 1), align 42317 %conv = zext i8 %ttmp to i322318 %ttmp1 = load i8, ptr getelementptr inbounds (%widening1, ptr @f, i64 0, i32 2), align 12319 %conv2 = zext i8 %ttmp1 to i322320 %add = add nsw i32 %conv, %conv22321 2322 %ttmp2 = load i8, ptr getelementptr inbounds (%widening1, ptr @f, i64 0, i32 3), align 22323 %conv3 = zext i8 %ttmp2 to i322324 %add2 = add nsw i32 %add, %conv32325 2326 %ttmp3 = load i8, ptr getelementptr inbounds (%widening1, ptr @f, i64 0, i32 4), align 12327 %conv4 = zext i8 %ttmp3 to i322328 %add3 = add nsw i32 %add2, %conv42329 2330 ret i32 %add32331}2332 2333 2334declare void @llvm.memset.p0.i64(ptr nocapture, i8, i64, i1) nounwind2335 2336declare void @llvm.memcpy.p0.p0.i64(ptr nocapture, ptr nocapture, i64, i1) nounwind2337declare void @llvm.memcpy.p0.p1.i64(ptr nocapture, ptr addrspace(1) nocapture, i64, i1) nounwind2338 2339 2340;;===----------------------------------------------------------------------===;;2341;; Load -> Store dependency which isn't interfered with by a call that happens2342;; before the pointer was captured.2343;;===----------------------------------------------------------------------===;;2344 2345%class.X = type { [8 x i8] }2346 2347@_ZTV1X = weak_odr constant [5 x ptr] zeroinitializer2348@_ZTV1Y = weak_odr constant [5 x ptr] zeroinitializer2349 2350declare void @use()2351declare void @use3(ptr, ptr)2352 2353; PR89082354define void @test_escape1() nounwind {2355; LE-MEMDEP-LABEL: define void @test_escape1(2356; LE-MEMDEP-SAME: ) #[[ATTR3]] {2357; LE-MEMDEP-NEXT: [[X:%.*]] = alloca ptr, align 82358; LE-MEMDEP-NEXT: store ptr getelementptr inbounds ([5 x ptr], ptr @_ZTV1X, i64 0, i64 2), ptr [[X]], align 82359; LE-MEMDEP-NEXT: call void @use() #[[ATTR3]]2360; LE-MEMDEP-NEXT: call void @use3(ptr [[X]], ptr getelementptr inbounds ([5 x ptr], ptr @_ZTV1X, i64 0, i64 2)) #[[ATTR3]]2361; LE-MEMDEP-NEXT: ret void2362;2363; LE-MEMSSA-LABEL: define void @test_escape1(2364; LE-MEMSSA-SAME: ) #[[ATTR3]] {2365; LE-MEMSSA-NEXT: [[X:%.*]] = alloca ptr, align 82366; LE-MEMSSA-NEXT: store ptr getelementptr inbounds ([5 x ptr], ptr @_ZTV1X, i64 0, i64 2), ptr [[X]], align 82367; LE-MEMSSA-NEXT: call void @use() #[[ATTR3]]2368; LE-MEMSSA-NEXT: [[DEAD:%.*]] = load ptr, ptr [[X]], align 82369; LE-MEMSSA-NEXT: call void @use3(ptr [[X]], ptr [[DEAD]]) #[[ATTR3]]2370; LE-MEMSSA-NEXT: ret void2371;2372; BE-MEMDEP-LABEL: define void @test_escape1(2373; BE-MEMDEP-SAME: ) #[[ATTR3]] {2374; BE-MEMDEP-NEXT: [[X:%.*]] = alloca ptr, align 82375; BE-MEMDEP-NEXT: store ptr getelementptr inbounds ([5 x ptr], ptr @_ZTV1X, i64 0, i64 2), ptr [[X]], align 82376; BE-MEMDEP-NEXT: call void @use() #[[ATTR3]]2377; BE-MEMDEP-NEXT: call void @use3(ptr [[X]], ptr getelementptr inbounds ([5 x ptr], ptr @_ZTV1X, i64 0, i64 2)) #[[ATTR3]]2378; BE-MEMDEP-NEXT: ret void2379;2380; BE-MEMSSA-LABEL: define void @test_escape1(2381; BE-MEMSSA-SAME: ) #[[ATTR3]] {2382; BE-MEMSSA-NEXT: [[X:%.*]] = alloca ptr, align 82383; BE-MEMSSA-NEXT: store ptr getelementptr inbounds ([5 x ptr], ptr @_ZTV1X, i64 0, i64 2), ptr [[X]], align 82384; BE-MEMSSA-NEXT: call void @use() #[[ATTR3]]2385; BE-MEMSSA-NEXT: [[DEAD:%.*]] = load ptr, ptr [[X]], align 82386; BE-MEMSSA-NEXT: call void @use3(ptr [[X]], ptr [[DEAD]]) #[[ATTR3]]2387; BE-MEMSSA-NEXT: ret void2388;2389 %x = alloca ptr, align 82390 store ptr getelementptr inbounds ([5 x ptr], ptr @_ZTV1X, i64 0, i64 2), ptr %x, align 82391 call void @use() nounwind2392 %DEAD = load ptr, ptr %x, align 82393 call void @use3(ptr %x, ptr %DEAD) nounwind2394 ret void2395}2396;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:2397; BE: {{.*}}2398; LE: {{.*}}2399