500 lines · plain
1; Test vector extraction to memory.2;3; RUN: llc < %s -mtriple=s390x-linux-gnu -mcpu=z13 | FileCheck %s4 5; Test v16i8 extraction from the first element.6define void @f1(<16 x i8> %val, ptr %ptr) {7; CHECK-LABEL: f1:8; CHECK: vsteb %v24, 0(%r2), 09; CHECK: br %r1410 %element = extractelement <16 x i8> %val, i32 011 store i8 %element, ptr %ptr12 ret void13}14 15; Test v16i8 extraction from the last element.16define void @f2(<16 x i8> %val, ptr %ptr) {17; CHECK-LABEL: f2:18; CHECK: vsteb %v24, 0(%r2), 1519; CHECK: br %r1420 %element = extractelement <16 x i8> %val, i32 1521 store i8 %element, ptr %ptr22 ret void23}24 25; Test v16i8 extraction of an invalid element. This must compile,26; but we don't care what it does.27define void @f3(<16 x i8> %val, ptr %ptr) {28; CHECK-LABEL: f3:29; CHECK-NOT: vsteb %v24, 0(%r2), 1630; CHECK: br %r1431 %element = extractelement <16 x i8> %val, i32 1632 store i8 %element, ptr %ptr33 ret void34}35 36; Test v16i8 extraction with the highest in-range offset.37define void @f4(<16 x i8> %val, ptr %base) {38; CHECK-LABEL: f4:39; CHECK: vsteb %v24, 4095(%r2), 1040; CHECK: br %r1441 %ptr = getelementptr i8, ptr %base, i32 409542 %element = extractelement <16 x i8> %val, i32 1043 store i8 %element, ptr %ptr44 ret void45}46 47; Test v16i8 extraction with the first ouf-of-range offset.48define void @f5(<16 x i8> %val, ptr %base) {49; CHECK-LABEL: f5:50; CHECK: aghi %r2, 409651; CHECK: vsteb %v24, 0(%r2), 552; CHECK: br %r1453 %ptr = getelementptr i8, ptr %base, i32 409654 %element = extractelement <16 x i8> %val, i32 555 store i8 %element, ptr %ptr56 ret void57}58 59; Test v16i8 extraction from a variable element.60define void @f6(<16 x i8> %val, ptr %ptr, i32 %index) {61; CHECK-LABEL: f6:62; CHECK-NOT: vsteb63; CHECK: br %r1464 %element = extractelement <16 x i8> %val, i32 %index65 store i8 %element, ptr %ptr66 ret void67}68 69; Test v8i16 extraction from the first element.70define void @f7(<8 x i16> %val, ptr %ptr) {71; CHECK-LABEL: f7:72; CHECK: vsteh %v24, 0(%r2), 073; CHECK: br %r1474 %element = extractelement <8 x i16> %val, i32 075 store i16 %element, ptr %ptr76 ret void77}78 79; Test v8i16 extraction from the last element.80define void @f8(<8 x i16> %val, ptr %ptr) {81; CHECK-LABEL: f8:82; CHECK: vsteh %v24, 0(%r2), 783; CHECK: br %r1484 %element = extractelement <8 x i16> %val, i32 785 store i16 %element, ptr %ptr86 ret void87}88 89; Test v8i16 extraction of an invalid element. This must compile,90; but we don't care what it does.91define void @f9(<8 x i16> %val, ptr %ptr) {92; CHECK-LABEL: f9:93; CHECK-NOT: vsteh %v24, 0(%r2), 894; CHECK: br %r1495 %element = extractelement <8 x i16> %val, i32 896 store i16 %element, ptr %ptr97 ret void98}99 100; Test v8i16 extraction with the highest in-range offset.101define void @f10(<8 x i16> %val, ptr %base) {102; CHECK-LABEL: f10:103; CHECK: vsteh %v24, 4094(%r2), 5104; CHECK: br %r14105 %ptr = getelementptr i16, ptr %base, i32 2047106 %element = extractelement <8 x i16> %val, i32 5107 store i16 %element, ptr %ptr108 ret void109}110 111; Test v8i16 extraction with the first ouf-of-range offset.112define void @f11(<8 x i16> %val, ptr %base) {113; CHECK-LABEL: f11:114; CHECK: aghi %r2, 4096115; CHECK: vsteh %v24, 0(%r2), 1116; CHECK: br %r14117 %ptr = getelementptr i16, ptr %base, i32 2048118 %element = extractelement <8 x i16> %val, i32 1119 store i16 %element, ptr %ptr120 ret void121}122 123; Test v8i16 extraction from a variable element.124define void @f12(<8 x i16> %val, ptr %ptr, i32 %index) {125; CHECK-LABEL: f12:126; CHECK-NOT: vsteh127; CHECK: br %r14128 %element = extractelement <8 x i16> %val, i32 %index129 store i16 %element, ptr %ptr130 ret void131}132 133; Test v4i32 extraction from the first element.134define void @f13(<4 x i32> %val, ptr %ptr) {135; CHECK-LABEL: f13:136; CHECK: vstef %v24, 0(%r2), 0137; CHECK: br %r14138 %element = extractelement <4 x i32> %val, i32 0139 store i32 %element, ptr %ptr140 ret void141}142 143; Test v4i32 extraction from the last element.144define void @f14(<4 x i32> %val, ptr %ptr) {145; CHECK-LABEL: f14:146; CHECK: vstef %v24, 0(%r2), 3147; CHECK: br %r14148 %element = extractelement <4 x i32> %val, i32 3149 store i32 %element, ptr %ptr150 ret void151}152 153; Test v4i32 extraction of an invalid element. This must compile,154; but we don't care what it does.155define void @f15(<4 x i32> %val, ptr %ptr) {156; CHECK-LABEL: f15:157; CHECK-NOT: vstef %v24, 0(%r2), 4158; CHECK: br %r14159 %element = extractelement <4 x i32> %val, i32 4160 store i32 %element, ptr %ptr161 ret void162}163 164; Test v4i32 extraction with the highest in-range offset.165define void @f16(<4 x i32> %val, ptr %base) {166; CHECK-LABEL: f16:167; CHECK: vstef %v24, 4092(%r2), 2168; CHECK: br %r14169 %ptr = getelementptr i32, ptr %base, i32 1023170 %element = extractelement <4 x i32> %val, i32 2171 store i32 %element, ptr %ptr172 ret void173}174 175; Test v4i32 extraction with the first ouf-of-range offset.176define void @f17(<4 x i32> %val, ptr %base) {177; CHECK-LABEL: f17:178; CHECK: aghi %r2, 4096179; CHECK: vstef %v24, 0(%r2), 1180; CHECK: br %r14181 %ptr = getelementptr i32, ptr %base, i32 1024182 %element = extractelement <4 x i32> %val, i32 1183 store i32 %element, ptr %ptr184 ret void185}186 187; Test v4i32 extraction from a variable element.188define void @f18(<4 x i32> %val, ptr %ptr, i32 %index) {189; CHECK-LABEL: f18:190; CHECK-NOT: vstef191; CHECK: br %r14192 %element = extractelement <4 x i32> %val, i32 %index193 store i32 %element, ptr %ptr194 ret void195}196 197; Test v2i64 extraction from the first element.198define void @f19(<2 x i64> %val, ptr %ptr) {199; CHECK-LABEL: f19:200; CHECK: vsteg %v24, 0(%r2), 0201; CHECK: br %r14202 %element = extractelement <2 x i64> %val, i32 0203 store i64 %element, ptr %ptr204 ret void205}206 207; Test v2i64 extraction from the last element.208define void @f20(<2 x i64> %val, ptr %ptr) {209; CHECK-LABEL: f20:210; CHECK: vsteg %v24, 0(%r2), 1211; CHECK: br %r14212 %element = extractelement <2 x i64> %val, i32 1213 store i64 %element, ptr %ptr214 ret void215}216 217; Test v2i64 extraction of an invalid element. This must compile,218; but we don't care what it does.219define void @f21(<2 x i64> %val, ptr %ptr) {220; CHECK-LABEL: f21:221; CHECK-NOT: vsteg %v24, 0(%r2), 2222; CHECK: br %r14223 %element = extractelement <2 x i64> %val, i32 2224 store i64 %element, ptr %ptr225 ret void226}227 228; Test v2i64 extraction with the highest in-range offset.229define void @f22(<2 x i64> %val, ptr %base) {230; CHECK-LABEL: f22:231; CHECK: vsteg %v24, 4088(%r2), 1232; CHECK: br %r14233 %ptr = getelementptr i64, ptr %base, i32 511234 %element = extractelement <2 x i64> %val, i32 1235 store i64 %element, ptr %ptr236 ret void237}238 239; Test v2i64 extraction with the first ouf-of-range offset.240define void @f23(<2 x i64> %val, ptr %base) {241; CHECK-LABEL: f23:242; CHECK: aghi %r2, 4096243; CHECK: vsteg %v24, 0(%r2), 0244; CHECK: br %r14245 %ptr = getelementptr i64, ptr %base, i32 512246 %element = extractelement <2 x i64> %val, i32 0247 store i64 %element, ptr %ptr248 ret void249}250 251; Test v2i64 extraction from a variable element.252define void @f24(<2 x i64> %val, ptr %ptr, i32 %index) {253; CHECK-LABEL: f24:254; CHECK-NOT: vsteg255; CHECK: br %r14256 %element = extractelement <2 x i64> %val, i32 %index257 store i64 %element, ptr %ptr258 ret void259}260 261; Test v4f32 extraction from the first element.262define void @f25(<4 x float> %val, ptr %ptr) {263; CHECK-LABEL: f25:264; CHECK: vstef %v24, 0(%r2), 0265; CHECK: br %r14266 %element = extractelement <4 x float> %val, i32 0267 store float %element, ptr %ptr268 ret void269}270 271; Test v4f32 extraction from the last element.272define void @f26(<4 x float> %val, ptr %ptr) {273; CHECK-LABEL: f26:274; CHECK: vstef %v24, 0(%r2), 3275; CHECK: br %r14276 %element = extractelement <4 x float> %val, i32 3277 store float %element, ptr %ptr278 ret void279}280 281; Test v4f32 extraction of an invalid element. This must compile,282; but we don't care what it does.283define void @f27(<4 x float> %val, ptr %ptr) {284; CHECK-LABEL: f27:285; CHECK-NOT: vstef %v24, 0(%r2), 4286; CHECK: br %r14287 %element = extractelement <4 x float> %val, i32 4288 store float %element, ptr %ptr289 ret void290}291 292; Test v4f32 extraction with the highest in-range offset.293define void @f28(<4 x float> %val, ptr %base) {294; CHECK-LABEL: f28:295; CHECK: vstef %v24, 4092(%r2), 2296; CHECK: br %r14297 %ptr = getelementptr float, ptr %base, i32 1023298 %element = extractelement <4 x float> %val, i32 2299 store float %element, ptr %ptr300 ret void301}302 303; Test v4f32 extraction with the first ouf-of-range offset.304define void @f29(<4 x float> %val, ptr %base) {305; CHECK-LABEL: f29:306; CHECK: aghi %r2, 4096307; CHECK: vstef %v24, 0(%r2), 1308; CHECK: br %r14309 %ptr = getelementptr float, ptr %base, i32 1024310 %element = extractelement <4 x float> %val, i32 1311 store float %element, ptr %ptr312 ret void313}314 315; Test v4f32 extraction from a variable element.316define void @f30(<4 x float> %val, ptr %ptr, i32 %index) {317; CHECK-LABEL: f30:318; CHECK-NOT: vstef319; CHECK: br %r14320 %element = extractelement <4 x float> %val, i32 %index321 store float %element, ptr %ptr322 ret void323}324 325; Test v2f64 extraction from the first element.326define void @f32(<2 x double> %val, ptr %ptr) {327; CHECK-LABEL: f32:328; CHECK: vsteg %v24, 0(%r2), 0329; CHECK: br %r14330 %element = extractelement <2 x double> %val, i32 0331 store double %element, ptr %ptr332 ret void333}334 335; Test v2f64 extraction from the last element.336define void @f33(<2 x double> %val, ptr %ptr) {337; CHECK-LABEL: f33:338; CHECK: vsteg %v24, 0(%r2), 1339; CHECK: br %r14340 %element = extractelement <2 x double> %val, i32 1341 store double %element, ptr %ptr342 ret void343}344 345; Test v2f64 extraction with the highest in-range offset.346define void @f34(<2 x double> %val, ptr %base) {347; CHECK-LABEL: f34:348; CHECK: vsteg %v24, 4088(%r2), 1349; CHECK: br %r14350 %ptr = getelementptr double, ptr %base, i32 511351 %element = extractelement <2 x double> %val, i32 1352 store double %element, ptr %ptr353 ret void354}355 356; Test v2f64 extraction with the first ouf-of-range offset.357define void @f35(<2 x double> %val, ptr %base) {358; CHECK-LABEL: f35:359; CHECK: aghi %r2, 4096360; CHECK: vsteg %v24, 0(%r2), 0361; CHECK: br %r14362 %ptr = getelementptr double, ptr %base, i32 512363 %element = extractelement <2 x double> %val, i32 0364 store double %element, ptr %ptr365 ret void366}367 368; Test v2f64 extraction from a variable element.369define void @f36(<2 x double> %val, ptr %ptr, i32 %index) {370; CHECK-LABEL: f36:371; CHECK-NOT: vsteg372; CHECK: br %r14373 %element = extractelement <2 x double> %val, i32 %index374 store double %element, ptr %ptr375 ret void376}377 378; Test a v4i32 scatter of the first element.379define void @f37(<4 x i32> %val, <4 x i32> %index, i64 %base) {380; CHECK-LABEL: f37:381; CHECK: vscef %v24, 0(%v26,%r2), 0382; CHECK: br %r14383 %elem = extractelement <4 x i32> %index, i32 0384 %ext = zext i32 %elem to i64385 %add = add i64 %base, %ext386 %ptr = inttoptr i64 %add to ptr387 %element = extractelement <4 x i32> %val, i32 0388 store i32 %element, ptr %ptr389 ret void390}391 392; Test a v4i32 scatter of the last element.393define void @f38(<4 x i32> %val, <4 x i32> %index, i64 %base) {394; CHECK-LABEL: f38:395; CHECK: vscef %v24, 0(%v26,%r2), 3396; CHECK: br %r14397 %elem = extractelement <4 x i32> %index, i32 3398 %ext = zext i32 %elem to i64399 %add = add i64 %base, %ext400 %ptr = inttoptr i64 %add to ptr401 %element = extractelement <4 x i32> %val, i32 3402 store i32 %element, ptr %ptr403 ret void404}405 406; Test a v4i32 scatter with the highest in-range offset.407define void @f39(<4 x i32> %val, <4 x i32> %index, i64 %base) {408; CHECK-LABEL: f39:409; CHECK: vscef %v24, 4095(%v26,%r2), 1410; CHECK: br %r14411 %elem = extractelement <4 x i32> %index, i32 1412 %ext = zext i32 %elem to i64413 %add1 = add i64 %base, %ext414 %add2 = add i64 %add1, 4095415 %ptr = inttoptr i64 %add2 to ptr416 %element = extractelement <4 x i32> %val, i32 1417 store i32 %element, ptr %ptr418 ret void419}420 421; Test a v2i64 scatter of the first element.422define void @f40(<2 x i64> %val, <2 x i64> %index, i64 %base) {423; CHECK-LABEL: f40:424; CHECK: vsceg %v24, 0(%v26,%r2), 0425; CHECK: br %r14426 %elem = extractelement <2 x i64> %index, i32 0427 %add = add i64 %base, %elem428 %ptr = inttoptr i64 %add to ptr429 %element = extractelement <2 x i64> %val, i32 0430 store i64 %element, ptr %ptr431 ret void432}433 434; Test a v2i64 scatter of the last element.435define void @f41(<2 x i64> %val, <2 x i64> %index, i64 %base) {436; CHECK-LABEL: f41:437; CHECK: vsceg %v24, 0(%v26,%r2), 1438; CHECK: br %r14439 %elem = extractelement <2 x i64> %index, i32 1440 %add = add i64 %base, %elem441 %ptr = inttoptr i64 %add to ptr442 %element = extractelement <2 x i64> %val, i32 1443 store i64 %element, ptr %ptr444 ret void445}446 447; Test a v4f32 scatter of the first element.448define void @f42(<4 x float> %val, <4 x i32> %index, i64 %base) {449; CHECK-LABEL: f42:450; CHECK: vscef %v24, 0(%v26,%r2), 0451; CHECK: br %r14452 %elem = extractelement <4 x i32> %index, i32 0453 %ext = zext i32 %elem to i64454 %add = add i64 %base, %ext455 %ptr = inttoptr i64 %add to ptr456 %element = extractelement <4 x float> %val, i32 0457 store float %element, ptr %ptr458 ret void459}460 461; Test a v4f32 scatter of the last element.462define void @f43(<4 x float> %val, <4 x i32> %index, i64 %base) {463; CHECK-LABEL: f43:464; CHECK: vscef %v24, 0(%v26,%r2), 3465; CHECK: br %r14466 %elem = extractelement <4 x i32> %index, i32 3467 %ext = zext i32 %elem to i64468 %add = add i64 %base, %ext469 %ptr = inttoptr i64 %add to ptr470 %element = extractelement <4 x float> %val, i32 3471 store float %element, ptr %ptr472 ret void473}474 475; Test a v2f64 scatter of the first element.476define void @f44(<2 x double> %val, <2 x i64> %index, i64 %base) {477; CHECK-LABEL: f44:478; CHECK: vsceg %v24, 0(%v26,%r2), 0479; CHECK: br %r14480 %elem = extractelement <2 x i64> %index, i32 0481 %add = add i64 %base, %elem482 %ptr = inttoptr i64 %add to ptr483 %element = extractelement <2 x double> %val, i32 0484 store double %element, ptr %ptr485 ret void486}487 488; Test a v2f64 scatter of the last element.489define void @f45(<2 x double> %val, <2 x i64> %index, i64 %base) {490; CHECK-LABEL: f45:491; CHECK: vsceg %v24, 0(%v26,%r2), 1492; CHECK: br %r14493 %elem = extractelement <2 x i64> %index, i32 1494 %add = add i64 %base, %elem495 %ptr = inttoptr i64 %add to ptr496 %element = extractelement <2 x double> %val, i32 1497 store double %element, ptr %ptr498 ret void499}500