329 lines · plain
1; Test loading of 64-bit constants.2;3; RUN: llc < %s -mtriple=s390x-linux-gnu | FileCheck %s4 5declare void @foo(i64, i64, i64, i64)6declare void @llvm.memcpy.p0.p0.i64(ptr nocapture, ptr nocapture, i64, i1 immarg)7 8; Check 0.9define i64 @f1() {10; CHECK-LABEL: f1:11; CHECK: lghi %r2, 012; CHECK-NEXT: br %r1413 ret i64 014}15 16; Check the high end of the LGHI range.17define i64 @f2() {18; CHECK-LABEL: f2:19; CHECK: lghi %r2, 3276720; CHECK-NEXT: br %r1421 ret i64 3276722}23 24; Check the next value up, which must use LLILL instead.25define i64 @f3() {26; CHECK-LABEL: f3:27; CHECK: llill %r2, 3276828; CHECK-NEXT: br %r1429 ret i64 3276830}31 32; Check the high end of the LLILL range.33define i64 @f4() {34; CHECK-LABEL: f4:35; CHECK: llill %r2, 6553536; CHECK-NEXT: br %r1437 ret i64 6553538}39 40; Check the first useful LLILH value, which is the next one up.41define i64 @f5() {42; CHECK-LABEL: f5:43; CHECK: llilh %r2, 144; CHECK-NEXT: br %r1445 ret i64 6553646}47 48; Check the first useful LGFI value, which is the next one up again.49define i64 @f6() {50; CHECK-LABEL: f6:51; CHECK: lgfi %r2, 6553752; CHECK-NEXT: br %r1453 ret i64 6553754}55 56; Check the high end of the LGFI range.57define i64 @f7() {58; CHECK-LABEL: f7:59; CHECK: lgfi %r2, 214748364760; CHECK-NEXT: br %r1461 ret i64 214748364762}63 64; Check the next value up, which should use LLILH instead.65define i64 @f8() {66; CHECK-LABEL: f8:67; CHECK: llilh %r2, 3276868; CHECK-NEXT: br %r1469 ret i64 214748364870}71 72; Check the next value up again, which should use LLILF.73define i64 @f9() {74; CHECK-LABEL: f9:75; CHECK: llilf %r2, 214748364976; CHECK-NEXT: br %r1477 ret i64 214748364978}79 80; Check the high end of the LLILH range.81define i64 @f10() {82; CHECK-LABEL: f10:83; CHECK: llilh %r2, 6553584; CHECK-NEXT: br %r1485 ret i64 429490176086}87 88; Check the next value up, which must use LLILF.89define i64 @f11() {90; CHECK-LABEL: f11:91; CHECK: llilf %r2, 429490176192; CHECK-NEXT: br %r1493 ret i64 429490176194}95 96; Check the high end of the LLILF range.97define i64 @f12() {98; CHECK-LABEL: f12:99; CHECK: llilf %r2, 4294967295100; CHECK-NEXT: br %r14101 ret i64 4294967295102}103 104; Check the lowest useful LLIHL value, which is the next one up.105define i64 @f13() {106; CHECK-LABEL: f13:107; CHECK: llihl %r2, 1108; CHECK-NEXT: br %r14109 ret i64 4294967296110}111 112; Check the next value up, which must use a combination of two instructions.113define i64 @f14() {114; CHECK-LABEL: f14:115; CHECK: llihl %r2, 1116; CHECK-NEXT: oill %r2, 1117; CHECK-NEXT: br %r14118 ret i64 4294967297119}120 121; Check the high end of the OILL range.122define i64 @f15() {123; CHECK-LABEL: f15:124; CHECK: llihl %r2, 1125; CHECK-NEXT: oill %r2, 65535126; CHECK-NEXT: br %r14127 ret i64 4295032831128}129 130; Check the next value up, which should use OILH instead.131define i64 @f16() {132; CHECK-LABEL: f16:133; CHECK: llihl %r2, 1134; CHECK-NEXT: oilh %r2, 1135; CHECK-NEXT: br %r14136 ret i64 4295032832137}138 139; Check the next value up again, which should use OILF.140define i64 @f17() {141; CHECK-LABEL: f17:142; CHECK: llihl %r2, 1143; CHECK-NEXT: oilf %r2, 65537144; CHECK-NEXT: br %r14145 ret i64 4295032833146}147 148; Check the high end of the OILH range.149define i64 @f18() {150; CHECK-LABEL: f18:151; CHECK: llihl %r2, 1152; CHECK-NEXT: oilh %r2, 65535153; CHECK-NEXT: br %r14154 ret i64 8589869056155}156 157; Check the high end of the OILF range.158define i64 @f19() {159; CHECK-LABEL: f19:160; CHECK: llihl %r2, 1161; CHECK-NEXT: oilf %r2, 4294967295162; CHECK-NEXT: br %r14163 ret i64 8589934591164}165 166; Check the high end of the LLIHL range.167define i64 @f20() {168; CHECK-LABEL: f20:169; CHECK: llihl %r2, 65535170; CHECK-NEXT: br %r14171 ret i64 281470681743360172}173 174; Check the lowest useful LLIHH value, which is 1<<32 greater than the above.175define i64 @f21() {176; CHECK-LABEL: f21:177; CHECK: llihh %r2, 1178; CHECK-NEXT: br %r14179 ret i64 281474976710656180}181 182; Check the lowest useful LLIHF value, which is 1<<32 greater again.183define i64 @f22() {184; CHECK-LABEL: f22:185; CHECK: llihf %r2, 65537186; CHECK-NEXT: br %r14187 ret i64 281479271677952188}189 190; Check the highest end of the LLIHH range.191define i64 @f23() {192; CHECK-LABEL: f23:193; CHECK: llihh %r2, 65535194; CHECK-NEXT: br %r14195 ret i64 -281474976710656196}197 198; Check the next value up, which must use OILL too.199define i64 @f24() {200; CHECK-LABEL: f24:201; CHECK: llihh %r2, 65535202; CHECK-NEXT: oill %r2, 1203; CHECK-NEXT: br %r14204 ret i64 -281474976710655205}206 207; Check the high end of the LLIHF range.208define i64 @f25() {209; CHECK-LABEL: f25:210; CHECK: llihf %r2, 4294967295211; CHECK-NEXT: br %r14212 ret i64 -4294967296213}214 215; Check -1.216define i64 @f26() {217; CHECK-LABEL: f26:218; CHECK: lghi %r2, -1219; CHECK-NEXT: br %r14220 ret i64 -1221}222 223; Check the low end of the LGHI range.224define i64 @f27() {225; CHECK-LABEL: f27:226; CHECK: lghi %r2, -32768227; CHECK-NEXT: br %r14228 ret i64 -32768229}230 231; Check the next value down, which must use LGFI instead.232define i64 @f28() {233; CHECK-LABEL: f28:234; CHECK: lgfi %r2, -32769235; CHECK-NEXT: br %r14236 ret i64 -32769237}238 239; Check the low end of the LGFI range.240define i64 @f29() {241; CHECK-LABEL: f29:242; CHECK: lgfi %r2, -2147483648243; CHECK-NEXT: br %r14244 ret i64 -2147483648245}246 247; Check the next value down, which needs a two-instruction sequence.248define i64 @f30() {249; CHECK-LABEL: f30:250; CHECK: llihf %r2, 4294967295251; CHECK-NEXT: oilf %r2, 2147483647252; CHECK-NEXT: br %r14253 ret i64 -2147483649254}255 256; Check that constant loads are rematerialized.257define i64 @f31() {258; CHECK-LABEL: f31:259; CHECK-DAG: lghi %r2, 42260; CHECK-DAG: lgfi %r3, 65537261; CHECK-DAG: llilf %r4, 2147483649262; CHECK-DAG: llihf %r5, 65537263; CHECK: brasl %r14, foo@PLT264; CHECK-DAG: llill %r2, 32768265; CHECK-DAG: llilh %r3, 1266; CHECK-DAG: llihl %r4, 1267; CHECK-DAG: llihh %r5, 1268; CHECK: brasl %r14, foo@PLT269; CHECK-DAG: lghi %r2, 42270; CHECK-DAG: lgfi %r3, 65537271; CHECK-DAG: llilf %r4, 2147483649272; CHECK-DAG: llihf %r5, 65537273; CHECK: brasl %r14, foo@PLT274; CHECK-DAG: llill %r2, 32768275; CHECK-DAG: llilh %r3, 1276; CHECK-DAG: llihl %r4, 1277; CHECK-DAG: llihh %r5, 1278; CHECK: brasl %r14, foo@PLT279; CHECK: lghi %r2, 42280; CHECK: br %r14281 call void @foo(i64 42, i64 65537, i64 2147483649, i64 281479271677952)282 call void @foo(i64 32768, i64 65536, i64 4294967296, i64 281474976710656)283 call void @foo(i64 42, i64 65537, i64 2147483649, i64 281479271677952)284 call void @foo(i64 32768, i64 65536, i64 4294967296, i64 281474976710656)285 ret i64 42286}287 288; Verify that we do not crash on OR with two constant inputs289; (this was PR34859).290define i64 @f32(ptr %ptr) {291; CHECK-LABEL: f32:292; CHECK: llihf %r1, 918324340293; CHECK: oilf %r1, 1806197964294; CHECK: la %r0, 1(%r1)295 store i64 -1, ptr %ptr, align 8296 %1 = load i64, ptr %ptr, align 8297 %2 = icmp ne i64 %1, 0298 %3 = zext i1 %2 to i64299 %4 = or i64 %3, 3944173009226982604300 store i64 %4, ptr %ptr, align 8301 ret i64 3944173009226982604302}303 304; Check that huge constants can be loaded during isel pseudo expansion. This305; is the iteration count loaded into a register after dividing by 256.306define void @f33(ptr %Src, ptr %Dst) {307; CHECK-LABEL: f33:308; CHECK: iihf %r0, 1309; CHECK: iilf %r0, 1310 call void @llvm.memcpy.p0.p0.i64(ptr %Src, ptr %Dst, i64 1099511628032, i1 false)311 ret void312}313 314define void @f34(ptr %Src, ptr %Dst) {315; CHECK-LABEL: f34:316; CHECK: iihf %r0, 2317; CHECK: iilf %r0, 0318 call void @llvm.memcpy.p0.p0.i64(ptr %Src, ptr %Dst, i64 2199023255552, i1 false)319 ret void320}321 322define void @f35(ptr %Src, ptr %Dst) {323; CHECK-LABEL: f35:324; CHECK: iihf %r0, 8388607325; CHECK: iilf %r0, 4294967295326 call void @llvm.memcpy.p0.p0.i64(ptr %Src, ptr %Dst, i64 9223372036854775800, i1 false)327 ret void328}329