1527 lines · plain
1; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py2; RUN: llc < %s -verify-machineinstrs -mattr=+simd128 | FileCheck %s3 4; Test loads and stores with custom alignment values.5 6target triple = "wasm32-unknown-unknown"7 8; ==============================================================================9; 16 x i810; ==============================================================================11 12define <16 x i8> @load_v16i8_a1(ptr %p) {13; CHECK-LABEL: load_v16i8_a1:14; CHECK: .functype load_v16i8_a1 (i32) -> (v128)15; CHECK-NEXT: # %bb.0:16; CHECK-NEXT: local.get 017; CHECK-NEXT: v128.load 0:p2align=018; CHECK-NEXT: # fallthrough-return19 %v = load <16 x i8>, ptr %p, align 120 ret <16 x i8> %v21}22 23define <16 x i8> @load_v16i8_a4(ptr %p) {24; CHECK-LABEL: load_v16i8_a4:25; CHECK: .functype load_v16i8_a4 (i32) -> (v128)26; CHECK-NEXT: # %bb.0:27; CHECK-NEXT: local.get 028; CHECK-NEXT: v128.load 0:p2align=229; CHECK-NEXT: # fallthrough-return30 %v = load <16 x i8>, ptr %p, align 431 ret <16 x i8> %v32}33 34; 16 is the default alignment for v128 so no attribute is needed.35define <16 x i8> @load_v16i8_a16(ptr %p) {36; CHECK-LABEL: load_v16i8_a16:37; CHECK: .functype load_v16i8_a16 (i32) -> (v128)38; CHECK-NEXT: # %bb.0:39; CHECK-NEXT: local.get 040; CHECK-NEXT: v128.load 041; CHECK-NEXT: # fallthrough-return42 %v = load <16 x i8>, ptr %p, align 1643 ret <16 x i8> %v44}45 46; 32 is greater than the default alignment so it is ignored.47define <16 x i8> @load_v16i8_a32(ptr %p) {48; CHECK-LABEL: load_v16i8_a32:49; CHECK: .functype load_v16i8_a32 (i32) -> (v128)50; CHECK-NEXT: # %bb.0:51; CHECK-NEXT: local.get 052; CHECK-NEXT: v128.load 053; CHECK-NEXT: # fallthrough-return54 %v = load <16 x i8>, ptr %p, align 3255 ret <16 x i8> %v56}57 58define void @store_v16i8_a1(ptr %p, <16 x i8> %v) {59; CHECK-LABEL: store_v16i8_a1:60; CHECK: .functype store_v16i8_a1 (i32, v128) -> ()61; CHECK-NEXT: # %bb.0:62; CHECK-NEXT: local.get 063; CHECK-NEXT: local.get 164; CHECK-NEXT: v128.store 0:p2align=065; CHECK-NEXT: # fallthrough-return66 store <16 x i8> %v, ptr %p, align 167 ret void68}69 70define void @store_v16i8_a4(ptr %p, <16 x i8> %v) {71; CHECK-LABEL: store_v16i8_a4:72; CHECK: .functype store_v16i8_a4 (i32, v128) -> ()73; CHECK-NEXT: # %bb.0:74; CHECK-NEXT: local.get 075; CHECK-NEXT: local.get 176; CHECK-NEXT: v128.store 0:p2align=277; CHECK-NEXT: # fallthrough-return78 store <16 x i8> %v, ptr %p, align 479 ret void80}81 82; 16 is the default alignment for v128 so no attribute is needed.83define void @store_v16i8_a16(ptr %p, <16 x i8> %v) {84; CHECK-LABEL: store_v16i8_a16:85; CHECK: .functype store_v16i8_a16 (i32, v128) -> ()86; CHECK-NEXT: # %bb.0:87; CHECK-NEXT: local.get 088; CHECK-NEXT: local.get 189; CHECK-NEXT: v128.store 090; CHECK-NEXT: # fallthrough-return91 store <16 x i8> %v, ptr %p, align 1692 ret void93}94 95; 32 is greater than the default alignment so it is ignored.96define void @store_v16i8_a32(ptr %p, <16 x i8> %v) {97; CHECK-LABEL: store_v16i8_a32:98; CHECK: .functype store_v16i8_a32 (i32, v128) -> ()99; CHECK-NEXT: # %bb.0:100; CHECK-NEXT: local.get 0101; CHECK-NEXT: local.get 1102; CHECK-NEXT: v128.store 0103; CHECK-NEXT: # fallthrough-return104 store <16 x i8> %v, ptr %p, align 32105 ret void106}107 108; 1 is the default alignment for v128.load8_splat so no attribute is needed.109define <16 x i8> @load_splat_v16i8_a1(ptr %p) {110; CHECK-LABEL: load_splat_v16i8_a1:111; CHECK: .functype load_splat_v16i8_a1 (i32) -> (v128)112; CHECK-NEXT: # %bb.0:113; CHECK-NEXT: local.get 0114; CHECK-NEXT: v128.load8_splat 0115; CHECK-NEXT: # fallthrough-return116 %e = load i8, ptr %p, align 1117 %v1 = insertelement <16 x i8> undef, i8 %e, i32 0118 %v2 = shufflevector <16 x i8> %v1, <16 x i8> undef, <16 x i32> zeroinitializer119 ret <16 x i8> %v2120}121 122; 2 is greater than the default alignment so it is ignored.123define <16 x i8> @load_splat_v16i8_a2(ptr %p) {124; CHECK-LABEL: load_splat_v16i8_a2:125; CHECK: .functype load_splat_v16i8_a2 (i32) -> (v128)126; CHECK-NEXT: # %bb.0:127; CHECK-NEXT: local.get 0128; CHECK-NEXT: v128.load8_splat 0129; CHECK-NEXT: # fallthrough-return130 %e = load i8, ptr %p, align 2131 %v1 = insertelement <16 x i8> undef, i8 %e, i32 0132 %v2 = shufflevector <16 x i8> %v1, <16 x i8> undef, <16 x i32> zeroinitializer133 ret <16 x i8> %v2134}135 136; 1 is the default alignment for v128.load8_lane so no attribute is needed.137define <16 x i8> @load_lane_i8_a1(ptr %p, <16 x i8> %v) {138; CHECK-LABEL: load_lane_i8_a1:139; CHECK: .functype load_lane_i8_a1 (i32, v128) -> (v128)140; CHECK-NEXT: # %bb.0:141; CHECK-NEXT: local.get 0142; CHECK-NEXT: local.get 1143; CHECK-NEXT: v128.load8_lane 0, 0144; CHECK-NEXT: # fallthrough-return145 %e = load i8, ptr %p, align 1146 %v1 = insertelement <16 x i8> %v, i8 %e, i32 0147 ret <16 x i8> %v1148}149 150; 2 is greater than the default alignment so it is ignored.151define <16 x i8> @load_lane_i8_a2(ptr %p, <16 x i8> %v) {152; CHECK-LABEL: load_lane_i8_a2:153; CHECK: .functype load_lane_i8_a2 (i32, v128) -> (v128)154; CHECK-NEXT: # %bb.0:155; CHECK-NEXT: local.get 0156; CHECK-NEXT: local.get 1157; CHECK-NEXT: v128.load8_lane 0, 0158; CHECK-NEXT: # fallthrough-return159 %e = load i8, ptr %p, align 2160 %v1 = insertelement <16 x i8> %v, i8 %e, i32 0161 ret <16 x i8> %v1162}163 164; 1 is the default alignment for v128.store8_lane so no attribute is needed.165define void @store_lane_i8_a1(<16 x i8> %v, ptr %p) {166; CHECK-LABEL: store_lane_i8_a1:167; CHECK: .functype store_lane_i8_a1 (v128, i32) -> ()168; CHECK-NEXT: # %bb.0:169; CHECK-NEXT: local.get 1170; CHECK-NEXT: local.get 0171; CHECK-NEXT: v128.store8_lane 0, 0172; CHECK-NEXT: # fallthrough-return173 %x = extractelement <16 x i8> %v, i32 0174 store i8 %x, ptr %p, align 1175 ret void176}177 178; 2 is greater than the default alignment so it is ignored.179define void @store_lane_i8_a2(<16 x i8> %v, ptr %p) {180; CHECK-LABEL: store_lane_i8_a2:181; CHECK: .functype store_lane_i8_a2 (v128, i32) -> ()182; CHECK-NEXT: # %bb.0:183; CHECK-NEXT: local.get 1184; CHECK-NEXT: local.get 0185; CHECK-NEXT: v128.store8_lane 0, 0186; CHECK-NEXT: # fallthrough-return187 %x = extractelement <16 x i8> %v, i32 0188 store i8 %x, ptr %p, align 2189 ret void190}191 192; ==============================================================================193; 8 x i16194; ==============================================================================195 196define <8 x i16> @load_v8i16_a1(ptr %p) {197; CHECK-LABEL: load_v8i16_a1:198; CHECK: .functype load_v8i16_a1 (i32) -> (v128)199; CHECK-NEXT: # %bb.0:200; CHECK-NEXT: local.get 0201; CHECK-NEXT: v128.load 0:p2align=0202; CHECK-NEXT: # fallthrough-return203 %v = load <8 x i16>, ptr %p, align 1204 ret <8 x i16> %v205}206 207define <8 x i16> @load_v8i16_a4(ptr %p) {208; CHECK-LABEL: load_v8i16_a4:209; CHECK: .functype load_v8i16_a4 (i32) -> (v128)210; CHECK-NEXT: # %bb.0:211; CHECK-NEXT: local.get 0212; CHECK-NEXT: v128.load 0:p2align=2213; CHECK-NEXT: # fallthrough-return214 %v = load <8 x i16>, ptr %p, align 4215 ret <8 x i16> %v216}217 218; 8 is the default alignment for v128 so no attribute is needed.219define <8 x i16> @load_v8i16_a16(ptr %p) {220; CHECK-LABEL: load_v8i16_a16:221; CHECK: .functype load_v8i16_a16 (i32) -> (v128)222; CHECK-NEXT: # %bb.0:223; CHECK-NEXT: local.get 0224; CHECK-NEXT: v128.load 0225; CHECK-NEXT: # fallthrough-return226 %v = load <8 x i16>, ptr %p, align 16227 ret <8 x i16> %v228}229 230; 32 is greater than the default alignment so it is ignored.231define <8 x i16> @load_v8i16_a32(ptr %p) {232; CHECK-LABEL: load_v8i16_a32:233; CHECK: .functype load_v8i16_a32 (i32) -> (v128)234; CHECK-NEXT: # %bb.0:235; CHECK-NEXT: local.get 0236; CHECK-NEXT: v128.load 0237; CHECK-NEXT: # fallthrough-return238 %v = load <8 x i16>, ptr %p, align 32239 ret <8 x i16> %v240}241 242define void @store_v8i16_a1(ptr %p, <8 x i16> %v) {243; CHECK-LABEL: store_v8i16_a1:244; CHECK: .functype store_v8i16_a1 (i32, v128) -> ()245; CHECK-NEXT: # %bb.0:246; CHECK-NEXT: local.get 0247; CHECK-NEXT: local.get 1248; CHECK-NEXT: v128.store 0:p2align=0249; CHECK-NEXT: # fallthrough-return250 store <8 x i16> %v, ptr %p, align 1251 ret void252}253 254define void @store_v8i16_a4(ptr %p, <8 x i16> %v) {255; CHECK-LABEL: store_v8i16_a4:256; CHECK: .functype store_v8i16_a4 (i32, v128) -> ()257; CHECK-NEXT: # %bb.0:258; CHECK-NEXT: local.get 0259; CHECK-NEXT: local.get 1260; CHECK-NEXT: v128.store 0:p2align=2261; CHECK-NEXT: # fallthrough-return262 store <8 x i16> %v, ptr %p, align 4263 ret void264}265 266; 16 is the default alignment for v128 so no attribute is needed.267define void @store_v8i16_a16(ptr %p, <8 x i16> %v) {268; CHECK-LABEL: store_v8i16_a16:269; CHECK: .functype store_v8i16_a16 (i32, v128) -> ()270; CHECK-NEXT: # %bb.0:271; CHECK-NEXT: local.get 0272; CHECK-NEXT: local.get 1273; CHECK-NEXT: v128.store 0274; CHECK-NEXT: # fallthrough-return275 store <8 x i16> %v, ptr %p, align 16276 ret void277}278 279; 32 is greater than the default alignment so it is ignored.280define void @store_v8i16_a32(ptr %p, <8 x i16> %v) {281; CHECK-LABEL: store_v8i16_a32:282; CHECK: .functype store_v8i16_a32 (i32, v128) -> ()283; CHECK-NEXT: # %bb.0:284; CHECK-NEXT: local.get 0285; CHECK-NEXT: local.get 1286; CHECK-NEXT: v128.store 0287; CHECK-NEXT: # fallthrough-return288 store <8 x i16> %v, ptr %p, align 32289 ret void290}291 292define <8 x i8> @load_ext_v8i16_a1(ptr %p) {293; CHECK-LABEL: load_ext_v8i16_a1:294; CHECK: .functype load_ext_v8i16_a1 (i32) -> (v128)295; CHECK-NEXT: # %bb.0:296; CHECK-NEXT: local.get 0297; CHECK-NEXT: v128.load64_zero 0:p2align=0298; CHECK-NEXT: # fallthrough-return299 %v = load <8 x i8>, ptr %p, align 1300 ret <8 x i8> %v301}302 303define <8 x i8> @load_ext_v8i16_a2(ptr %p) {304; CHECK-LABEL: load_ext_v8i16_a2:305; CHECK: .functype load_ext_v8i16_a2 (i32) -> (v128)306; CHECK-NEXT: # %bb.0:307; CHECK-NEXT: local.get 0308; CHECK-NEXT: v128.load64_zero 0:p2align=1309; CHECK-NEXT: # fallthrough-return310 %v = load <8 x i8>, ptr %p, align 2311 ret <8 x i8> %v312}313 314define <8 x i8> @load_ext_v8i16_a4(ptr %p) {315; CHECK-LABEL: load_ext_v8i16_a4:316; CHECK: .functype load_ext_v8i16_a4 (i32) -> (v128)317; CHECK-NEXT: # %bb.0:318; CHECK-NEXT: local.get 0319; CHECK-NEXT: v128.load64_zero 0:p2align=2320; CHECK-NEXT: # fallthrough-return321 %v = load <8 x i8>, ptr %p, align 4322 ret <8 x i8> %v323}324 325; 8 is the default alignment for v128 extending load so no attribute is needed.326define <8 x i8> @load_ext_v8i16_a8(ptr %p) {327; CHECK-LABEL: load_ext_v8i16_a8:328; CHECK: .functype load_ext_v8i16_a8 (i32) -> (v128)329; CHECK-NEXT: # %bb.0:330; CHECK-NEXT: local.get 0331; CHECK-NEXT: v128.load64_zero 0332; CHECK-NEXT: # fallthrough-return333 %v = load <8 x i8>, ptr %p, align 8334 ret <8 x i8> %v335}336 337; 16 is greater than the default alignment so it is ignored.338define <8 x i8> @load_ext_v8i16_a16(ptr %p) {339; CHECK-LABEL: load_ext_v8i16_a16:340; CHECK: .functype load_ext_v8i16_a16 (i32) -> (v128)341; CHECK-NEXT: # %bb.0:342; CHECK-NEXT: local.get 0343; CHECK-NEXT: v128.load 0344; CHECK-NEXT: # fallthrough-return345 %v = load <8 x i8>, ptr %p, align 16346 ret <8 x i8> %v347}348 349define <8 x i16> @load_sext_v8i16_a1(ptr %p) {350; CHECK-LABEL: load_sext_v8i16_a1:351; CHECK: .functype load_sext_v8i16_a1 (i32) -> (v128)352; CHECK-NEXT: # %bb.0:353; CHECK-NEXT: local.get 0354; CHECK-NEXT: i16x8.load8x8_s 0:p2align=0355; CHECK-NEXT: # fallthrough-return356 %v = load <8 x i8>, ptr %p, align 1357 %v2 = sext <8 x i8> %v to <8 x i16>358 ret <8 x i16> %v2359}360 361define <8 x i16> @load_sext_v8i16_a2(ptr %p) {362; CHECK-LABEL: load_sext_v8i16_a2:363; CHECK: .functype load_sext_v8i16_a2 (i32) -> (v128)364; CHECK-NEXT: # %bb.0:365; CHECK-NEXT: local.get 0366; CHECK-NEXT: i16x8.load8x8_s 0:p2align=1367; CHECK-NEXT: # fallthrough-return368 %v = load <8 x i8>, ptr %p, align 2369 %v2 = sext <8 x i8> %v to <8 x i16>370 ret <8 x i16> %v2371}372 373define <8 x i16> @load_sext_v8i16_a4(ptr %p) {374; CHECK-LABEL: load_sext_v8i16_a4:375; CHECK: .functype load_sext_v8i16_a4 (i32) -> (v128)376; CHECK-NEXT: # %bb.0:377; CHECK-NEXT: local.get 0378; CHECK-NEXT: i16x8.load8x8_s 0:p2align=2379; CHECK-NEXT: # fallthrough-return380 %v = load <8 x i8>, ptr %p, align 4381 %v2 = sext <8 x i8> %v to <8 x i16>382 ret <8 x i16> %v2383}384 385; 8 is the default alignment for v128 extending load so no attribute is needed.386define <8 x i16> @load_sext_v8i16_a8(ptr %p) {387; CHECK-LABEL: load_sext_v8i16_a8:388; CHECK: .functype load_sext_v8i16_a8 (i32) -> (v128)389; CHECK-NEXT: # %bb.0:390; CHECK-NEXT: local.get 0391; CHECK-NEXT: i16x8.load8x8_s 0392; CHECK-NEXT: # fallthrough-return393 %v = load <8 x i8>, ptr %p, align 8394 %v2 = sext <8 x i8> %v to <8 x i16>395 ret <8 x i16> %v2396}397 398; 16 is greater than the default alignment so it is ignored.399define <8 x i16> @load_sext_v8i16_a16(ptr %p) {400; CHECK-LABEL: load_sext_v8i16_a16:401; CHECK: .functype load_sext_v8i16_a16 (i32) -> (v128)402; CHECK-NEXT: # %bb.0:403; CHECK-NEXT: local.get 0404; CHECK-NEXT: i16x8.load8x8_s 0405; CHECK-NEXT: # fallthrough-return406 %v = load <8 x i8>, ptr %p, align 16407 %v2 = sext <8 x i8> %v to <8 x i16>408 ret <8 x i16> %v2409}410 411define <8 x i16> @load_splat_v8i16_a1(ptr %p) {412; CHECK-LABEL: load_splat_v8i16_a1:413; CHECK: .functype load_splat_v8i16_a1 (i32) -> (v128)414; CHECK-NEXT: # %bb.0:415; CHECK-NEXT: local.get 0416; CHECK-NEXT: v128.load16_splat 0:p2align=0417; CHECK-NEXT: # fallthrough-return418 %e = load i16, ptr %p, align 1419 %v1 = insertelement <8 x i16> undef, i16 %e, i32 0420 %v2 = shufflevector <8 x i16> %v1, <8 x i16> undef, <8 x i32> zeroinitializer421 ret <8 x i16> %v2422}423 424; 2 is the default alignment for v128.load16_splat so no attribute is needed.425define <8 x i16> @load_splat_v8i16_a2(ptr %p) {426; CHECK-LABEL: load_splat_v8i16_a2:427; CHECK: .functype load_splat_v8i16_a2 (i32) -> (v128)428; CHECK-NEXT: # %bb.0:429; CHECK-NEXT: local.get 0430; CHECK-NEXT: v128.load16_splat 0431; CHECK-NEXT: # fallthrough-return432 %e = load i16, ptr %p, align 2433 %v1 = insertelement <8 x i16> undef, i16 %e, i32 0434 %v2 = shufflevector <8 x i16> %v1, <8 x i16> undef, <8 x i32> zeroinitializer435 ret <8 x i16> %v2436}437 438; 4 is greater than the default alignment so it is ignored.439define <8 x i16> @load_splat_v8i16_a4(ptr %p) {440; CHECK-LABEL: load_splat_v8i16_a4:441; CHECK: .functype load_splat_v8i16_a4 (i32) -> (v128)442; CHECK-NEXT: # %bb.0:443; CHECK-NEXT: local.get 0444; CHECK-NEXT: v128.load16_splat 0445; CHECK-NEXT: # fallthrough-return446 %e = load i16, ptr %p, align 4447 %v1 = insertelement <8 x i16> undef, i16 %e, i32 0448 %v2 = shufflevector <8 x i16> %v1, <8 x i16> undef, <8 x i32> zeroinitializer449 ret <8 x i16> %v2450}451 452define <8 x i16> @load_lane_i16_a1(ptr %p, <8 x i16> %v) {453; CHECK-LABEL: load_lane_i16_a1:454; CHECK: .functype load_lane_i16_a1 (i32, v128) -> (v128)455; CHECK-NEXT: # %bb.0:456; CHECK-NEXT: local.get 0457; CHECK-NEXT: local.get 1458; CHECK-NEXT: v128.load16_lane 0:p2align=0, 0459; CHECK-NEXT: # fallthrough-return460 %e = load i16, ptr %p, align 1461 %v1 = insertelement <8 x i16> %v, i16 %e, i32 0462 ret <8 x i16> %v1463}464 465; 2 is the default alignment for v128.load16_lane so no attribute is needed.466define <8 x i16> @load_lane_i16_a2(ptr %p, <8 x i16> %v) {467; CHECK-LABEL: load_lane_i16_a2:468; CHECK: .functype load_lane_i16_a2 (i32, v128) -> (v128)469; CHECK-NEXT: # %bb.0:470; CHECK-NEXT: local.get 0471; CHECK-NEXT: local.get 1472; CHECK-NEXT: v128.load16_lane 0, 0473; CHECK-NEXT: # fallthrough-return474 %e = load i16, ptr %p, align 2475 %v1 = insertelement <8 x i16> %v, i16 %e, i32 0476 ret <8 x i16> %v1477}478 479; 4 is greater than the default alignment so it is ignored.480define <8 x i16> @load_lane_i16_a4(ptr %p, <8 x i16> %v) {481; CHECK-LABEL: load_lane_i16_a4:482; CHECK: .functype load_lane_i16_a4 (i32, v128) -> (v128)483; CHECK-NEXT: # %bb.0:484; CHECK-NEXT: local.get 0485; CHECK-NEXT: local.get 1486; CHECK-NEXT: v128.load16_lane 0, 0487; CHECK-NEXT: # fallthrough-return488 %e = load i16, ptr %p, align 4489 %v1 = insertelement <8 x i16> %v, i16 %e, i32 0490 ret <8 x i16> %v1491}492 493define void @store_lane_i16_a1(<8 x i16> %v, ptr %p) {494; CHECK-LABEL: store_lane_i16_a1:495; CHECK: .functype store_lane_i16_a1 (v128, i32) -> ()496; CHECK-NEXT: # %bb.0:497; CHECK-NEXT: local.get 1498; CHECK-NEXT: local.get 0499; CHECK-NEXT: v128.store16_lane 0:p2align=0, 0500; CHECK-NEXT: # fallthrough-return501 %x = extractelement <8 x i16> %v, i32 0502 store i16 %x, ptr %p, align 1503 ret void504}505 506; 2 is the default alignment for v128.store16_lane so no attribute is needed.507define void @store_lane_i16_a2(<8 x i16> %v, ptr %p) {508; CHECK-LABEL: store_lane_i16_a2:509; CHECK: .functype store_lane_i16_a2 (v128, i32) -> ()510; CHECK-NEXT: # %bb.0:511; CHECK-NEXT: local.get 1512; CHECK-NEXT: local.get 0513; CHECK-NEXT: v128.store16_lane 0, 0514; CHECK-NEXT: # fallthrough-return515 %x = extractelement <8 x i16> %v, i32 0516 store i16 %x, ptr %p, align 2517 ret void518}519 520; 4 is greater than the default alignment so it is ignored.521define void @store_lane_i16_a4(<8 x i16> %v, ptr %p) {522; CHECK-LABEL: store_lane_i16_a4:523; CHECK: .functype store_lane_i16_a4 (v128, i32) -> ()524; CHECK-NEXT: # %bb.0:525; CHECK-NEXT: local.get 1526; CHECK-NEXT: local.get 0527; CHECK-NEXT: v128.store16_lane 0, 0528; CHECK-NEXT: # fallthrough-return529 %x = extractelement <8 x i16> %v, i32 0530 store i16 %x, ptr %p, align 4531 ret void532}533 534; ==============================================================================535; 4 x i32536; ==============================================================================537 538define <4 x i32> @load_v4i32_a1(ptr %p) {539; CHECK-LABEL: load_v4i32_a1:540; CHECK: .functype load_v4i32_a1 (i32) -> (v128)541; CHECK-NEXT: # %bb.0:542; CHECK-NEXT: local.get 0543; CHECK-NEXT: v128.load 0:p2align=0544; CHECK-NEXT: # fallthrough-return545 %v = load <4 x i32>, ptr %p, align 1546 ret <4 x i32> %v547}548 549define <4 x i32> @load_v4i32_a4(ptr %p) {550; CHECK-LABEL: load_v4i32_a4:551; CHECK: .functype load_v4i32_a4 (i32) -> (v128)552; CHECK-NEXT: # %bb.0:553; CHECK-NEXT: local.get 0554; CHECK-NEXT: v128.load 0:p2align=2555; CHECK-NEXT: # fallthrough-return556 %v = load <4 x i32>, ptr %p, align 4557 ret <4 x i32> %v558}559 560; 4 is the default alignment for v128 so no attribute is needed.561define <4 x i32> @load_v4i32_a16(ptr %p) {562; CHECK-LABEL: load_v4i32_a16:563; CHECK: .functype load_v4i32_a16 (i32) -> (v128)564; CHECK-NEXT: # %bb.0:565; CHECK-NEXT: local.get 0566; CHECK-NEXT: v128.load 0567; CHECK-NEXT: # fallthrough-return568 %v = load <4 x i32>, ptr %p, align 16569 ret <4 x i32> %v570}571 572; 32 is greater than the default alignment so it is ignored.573define <4 x i32> @load_v4i32_a32(ptr %p) {574; CHECK-LABEL: load_v4i32_a32:575; CHECK: .functype load_v4i32_a32 (i32) -> (v128)576; CHECK-NEXT: # %bb.0:577; CHECK-NEXT: local.get 0578; CHECK-NEXT: v128.load 0579; CHECK-NEXT: # fallthrough-return580 %v = load <4 x i32>, ptr %p, align 32581 ret <4 x i32> %v582}583 584define void @store_v4i32_a1(ptr %p, <4 x i32> %v) {585; CHECK-LABEL: store_v4i32_a1:586; CHECK: .functype store_v4i32_a1 (i32, v128) -> ()587; CHECK-NEXT: # %bb.0:588; CHECK-NEXT: local.get 0589; CHECK-NEXT: local.get 1590; CHECK-NEXT: v128.store 0:p2align=0591; CHECK-NEXT: # fallthrough-return592 store <4 x i32> %v, ptr %p, align 1593 ret void594}595 596define void @store_v4i32_a4(ptr %p, <4 x i32> %v) {597; CHECK-LABEL: store_v4i32_a4:598; CHECK: .functype store_v4i32_a4 (i32, v128) -> ()599; CHECK-NEXT: # %bb.0:600; CHECK-NEXT: local.get 0601; CHECK-NEXT: local.get 1602; CHECK-NEXT: v128.store 0:p2align=2603; CHECK-NEXT: # fallthrough-return604 store <4 x i32> %v, ptr %p, align 4605 ret void606}607 608; 16 is the default alignment for v128 so no attribute is needed.609define void @store_v4i32_a16(ptr %p, <4 x i32> %v) {610; CHECK-LABEL: store_v4i32_a16:611; CHECK: .functype store_v4i32_a16 (i32, v128) -> ()612; CHECK-NEXT: # %bb.0:613; CHECK-NEXT: local.get 0614; CHECK-NEXT: local.get 1615; CHECK-NEXT: v128.store 0616; CHECK-NEXT: # fallthrough-return617 store <4 x i32> %v, ptr %p, align 16618 ret void619}620 621; 32 is greater than the default alignment so it is ignored.622define void @store_v4i32_a32(ptr %p, <4 x i32> %v) {623; CHECK-LABEL: store_v4i32_a32:624; CHECK: .functype store_v4i32_a32 (i32, v128) -> ()625; CHECK-NEXT: # %bb.0:626; CHECK-NEXT: local.get 0627; CHECK-NEXT: local.get 1628; CHECK-NEXT: v128.store 0629; CHECK-NEXT: # fallthrough-return630 store <4 x i32> %v, ptr %p, align 32631 ret void632}633 634define <4 x i16> @load_ext_v4i32_a1(ptr %p) {635; CHECK-LABEL: load_ext_v4i32_a1:636; CHECK: .functype load_ext_v4i32_a1 (i32) -> (v128)637; CHECK-NEXT: # %bb.0:638; CHECK-NEXT: local.get 0639; CHECK-NEXT: v128.load64_zero 0:p2align=0640; CHECK-NEXT: # fallthrough-return641 %v = load <4 x i16>, ptr %p, align 1642 ret <4 x i16> %v643}644 645define <4 x i16> @load_ext_v4i32_a2(ptr %p) {646; CHECK-LABEL: load_ext_v4i32_a2:647; CHECK: .functype load_ext_v4i32_a2 (i32) -> (v128)648; CHECK-NEXT: # %bb.0:649; CHECK-NEXT: local.get 0650; CHECK-NEXT: v128.load64_zero 0:p2align=1651; CHECK-NEXT: # fallthrough-return652 %v = load <4 x i16>, ptr %p, align 2653 ret <4 x i16> %v654}655 656define <4 x i16> @load_ext_v4i32_a4(ptr %p) {657; CHECK-LABEL: load_ext_v4i32_a4:658; CHECK: .functype load_ext_v4i32_a4 (i32) -> (v128)659; CHECK-NEXT: # %bb.0:660; CHECK-NEXT: local.get 0661; CHECK-NEXT: v128.load64_zero 0:p2align=2662; CHECK-NEXT: # fallthrough-return663 %v = load <4 x i16>, ptr %p, align 4664 ret <4 x i16> %v665}666 667; 8 is the default alignment for v128 extending load so no attribute is needed.668define <4 x i16> @load_ext_v4i32_a8(ptr %p) {669; CHECK-LABEL: load_ext_v4i32_a8:670; CHECK: .functype load_ext_v4i32_a8 (i32) -> (v128)671; CHECK-NEXT: # %bb.0:672; CHECK-NEXT: local.get 0673; CHECK-NEXT: v128.load64_zero 0674; CHECK-NEXT: # fallthrough-return675 %v = load <4 x i16>, ptr %p, align 8676 ret <4 x i16> %v677}678 679; 16 is greater than the default alignment so it is ignored.680define <4 x i16> @load_ext_v4i32_a16(ptr %p) {681; CHECK-LABEL: load_ext_v4i32_a16:682; CHECK: .functype load_ext_v4i32_a16 (i32) -> (v128)683; CHECK-NEXT: # %bb.0:684; CHECK-NEXT: local.get 0685; CHECK-NEXT: v128.load 0686; CHECK-NEXT: # fallthrough-return687 %v = load <4 x i16>, ptr %p, align 16688 ret <4 x i16> %v689}690 691define <4 x i32> @load_sext_v4i32_a1(ptr %p) {692; CHECK-LABEL: load_sext_v4i32_a1:693; CHECK: .functype load_sext_v4i32_a1 (i32) -> (v128)694; CHECK-NEXT: # %bb.0:695; CHECK-NEXT: local.get 0696; CHECK-NEXT: i32x4.load16x4_s 0:p2align=0697; CHECK-NEXT: # fallthrough-return698 %v = load <4 x i16>, ptr %p, align 1699 %v2 = sext <4 x i16> %v to <4 x i32>700 ret <4 x i32> %v2701}702 703define <4 x i32> @load_sext_v4i32_a2(ptr %p) {704; CHECK-LABEL: load_sext_v4i32_a2:705; CHECK: .functype load_sext_v4i32_a2 (i32) -> (v128)706; CHECK-NEXT: # %bb.0:707; CHECK-NEXT: local.get 0708; CHECK-NEXT: i32x4.load16x4_s 0:p2align=1709; CHECK-NEXT: # fallthrough-return710 %v = load <4 x i16>, ptr %p, align 2711 %v2 = sext <4 x i16> %v to <4 x i32>712 ret <4 x i32> %v2713}714 715define <4 x i32> @load_sext_v4i32_a4(ptr %p) {716; CHECK-LABEL: load_sext_v4i32_a4:717; CHECK: .functype load_sext_v4i32_a4 (i32) -> (v128)718; CHECK-NEXT: # %bb.0:719; CHECK-NEXT: local.get 0720; CHECK-NEXT: i32x4.load16x4_s 0:p2align=2721; CHECK-NEXT: # fallthrough-return722 %v = load <4 x i16>, ptr %p, align 4723 %v2 = sext <4 x i16> %v to <4 x i32>724 ret <4 x i32> %v2725}726 727; 8 is the default alignment for v128 extending load so no attribute is needed.728define <4 x i32> @load_sext_v4i32_a8(ptr %p) {729; CHECK-LABEL: load_sext_v4i32_a8:730; CHECK: .functype load_sext_v4i32_a8 (i32) -> (v128)731; CHECK-NEXT: # %bb.0:732; CHECK-NEXT: local.get 0733; CHECK-NEXT: i32x4.load16x4_s 0734; CHECK-NEXT: # fallthrough-return735 %v = load <4 x i16>, ptr %p, align 8736 %v2 = sext <4 x i16> %v to <4 x i32>737 ret <4 x i32> %v2738}739 740; 16 is greater than the default alignment so it is ignored.741define <4 x i32> @load_sext_v4i32_a16(ptr %p) {742; CHECK-LABEL: load_sext_v4i32_a16:743; CHECK: .functype load_sext_v4i32_a16 (i32) -> (v128)744; CHECK-NEXT: # %bb.0:745; CHECK-NEXT: local.get 0746; CHECK-NEXT: i32x4.load16x4_s 0747; CHECK-NEXT: # fallthrough-return748 %v = load <4 x i16>, ptr %p, align 16749 %v2 = sext <4 x i16> %v to <4 x i32>750 ret <4 x i32> %v2751}752 753define <4 x i32> @load_splat_v4i32_a1(ptr %addr) {754; CHECK-LABEL: load_splat_v4i32_a1:755; CHECK: .functype load_splat_v4i32_a1 (i32) -> (v128)756; CHECK-NEXT: # %bb.0:757; CHECK-NEXT: local.get 0758; CHECK-NEXT: v128.load32_splat 0:p2align=0759; CHECK-NEXT: # fallthrough-return760 %e = load i32, ptr %addr, align 1761 %v1 = insertelement <4 x i32> undef, i32 %e, i32 0762 %v2 = shufflevector <4 x i32> %v1, <4 x i32> undef, <4 x i32> zeroinitializer763 ret <4 x i32> %v2764}765 766define <4 x i32> @load_splat_v4i32_a2(ptr %addr) {767; CHECK-LABEL: load_splat_v4i32_a2:768; CHECK: .functype load_splat_v4i32_a2 (i32) -> (v128)769; CHECK-NEXT: # %bb.0:770; CHECK-NEXT: local.get 0771; CHECK-NEXT: v128.load32_splat 0:p2align=1772; CHECK-NEXT: # fallthrough-return773 %e = load i32, ptr %addr, align 2774 %v1 = insertelement <4 x i32> undef, i32 %e, i32 0775 %v2 = shufflevector <4 x i32> %v1, <4 x i32> undef, <4 x i32> zeroinitializer776 ret <4 x i32> %v2777}778 779; 4 is the default alignment for v128.load32_splat so no attribute is needed.780define <4 x i32> @load_splat_v4i32_a4(ptr %addr) {781; CHECK-LABEL: load_splat_v4i32_a4:782; CHECK: .functype load_splat_v4i32_a4 (i32) -> (v128)783; CHECK-NEXT: # %bb.0:784; CHECK-NEXT: local.get 0785; CHECK-NEXT: v128.load32_splat 0786; CHECK-NEXT: # fallthrough-return787 %e = load i32, ptr %addr, align 4788 %v1 = insertelement <4 x i32> undef, i32 %e, i32 0789 %v2 = shufflevector <4 x i32> %v1, <4 x i32> undef, <4 x i32> zeroinitializer790 ret <4 x i32> %v2791}792 793; 8 is greater than the default alignment so it is ignored.794define <4 x i32> @load_splat_v4i32_a8(ptr %addr) {795; CHECK-LABEL: load_splat_v4i32_a8:796; CHECK: .functype load_splat_v4i32_a8 (i32) -> (v128)797; CHECK-NEXT: # %bb.0:798; CHECK-NEXT: local.get 0799; CHECK-NEXT: v128.load32_splat 0800; CHECK-NEXT: # fallthrough-return801 %e = load i32, ptr %addr, align 8802 %v1 = insertelement <4 x i32> undef, i32 %e, i32 0803 %v2 = shufflevector <4 x i32> %v1, <4 x i32> undef, <4 x i32> zeroinitializer804 ret <4 x i32> %v2805}806 807define <4 x i32> @load_lane_i32_a1(ptr %p, <4 x i32> %v) {808; CHECK-LABEL: load_lane_i32_a1:809; CHECK: .functype load_lane_i32_a1 (i32, v128) -> (v128)810; CHECK-NEXT: # %bb.0:811; CHECK-NEXT: local.get 0812; CHECK-NEXT: local.get 1813; CHECK-NEXT: v128.load32_lane 0:p2align=0, 0814; CHECK-NEXT: # fallthrough-return815 %e = load i32, ptr %p, align 1816 %v1 = insertelement <4 x i32> %v, i32 %e, i32 0817 ret <4 x i32> %v1818}819 820define <4 x i32> @load_lane_i32_a2(ptr %p, <4 x i32> %v) {821; CHECK-LABEL: load_lane_i32_a2:822; CHECK: .functype load_lane_i32_a2 (i32, v128) -> (v128)823; CHECK-NEXT: # %bb.0:824; CHECK-NEXT: local.get 0825; CHECK-NEXT: local.get 1826; CHECK-NEXT: v128.load32_lane 0:p2align=1, 0827; CHECK-NEXT: # fallthrough-return828 %e = load i32, ptr %p, align 2829 %v1 = insertelement <4 x i32> %v, i32 %e, i32 0830 ret <4 x i32> %v1831}832 833; 4 is the default alignment for v128.load32_lane so no attribute is needed.834define <4 x i32> @load_lane_i32_a4(ptr %p, <4 x i32> %v) {835; CHECK-LABEL: load_lane_i32_a4:836; CHECK: .functype load_lane_i32_a4 (i32, v128) -> (v128)837; CHECK-NEXT: # %bb.0:838; CHECK-NEXT: local.get 0839; CHECK-NEXT: local.get 1840; CHECK-NEXT: v128.load32_lane 0, 0841; CHECK-NEXT: # fallthrough-return842 %e = load i32, ptr %p, align 4843 %v1 = insertelement <4 x i32> %v, i32 %e, i32 0844 ret <4 x i32> %v1845}846 847; 8 is greater than the default alignment so it is ignored.848define <4 x i32> @load_lane_i32_a8(ptr %p, <4 x i32> %v) {849; CHECK-LABEL: load_lane_i32_a8:850; CHECK: .functype load_lane_i32_a8 (i32, v128) -> (v128)851; CHECK-NEXT: # %bb.0:852; CHECK-NEXT: local.get 0853; CHECK-NEXT: local.get 1854; CHECK-NEXT: v128.load32_lane 0, 0855; CHECK-NEXT: # fallthrough-return856 %e = load i32, ptr %p, align 8857 %v1 = insertelement <4 x i32> %v, i32 %e, i32 0858 ret <4 x i32> %v1859}860 861define void @store_lane_i32_a1(<4 x i32> %v, ptr %p) {862; CHECK-LABEL: store_lane_i32_a1:863; CHECK: .functype store_lane_i32_a1 (v128, i32) -> ()864; CHECK-NEXT: # %bb.0:865; CHECK-NEXT: local.get 1866; CHECK-NEXT: local.get 0867; CHECK-NEXT: v128.store32_lane 0:p2align=0, 0868; CHECK-NEXT: # fallthrough-return869 %x = extractelement <4 x i32> %v, i32 0870 store i32 %x, ptr %p, align 1871 ret void872}873 874define void @store_lane_i32_a2(<4 x i32> %v, ptr %p) {875; CHECK-LABEL: store_lane_i32_a2:876; CHECK: .functype store_lane_i32_a2 (v128, i32) -> ()877; CHECK-NEXT: # %bb.0:878; CHECK-NEXT: local.get 1879; CHECK-NEXT: local.get 0880; CHECK-NEXT: v128.store32_lane 0:p2align=1, 0881; CHECK-NEXT: # fallthrough-return882 %x = extractelement <4 x i32> %v, i32 0883 store i32 %x, ptr %p, align 2884 ret void885}886 887; 4 is the default alignment for v128.store32_lane so no attribute is needed.888define void @store_lane_i32_a4(<4 x i32> %v, ptr %p) {889; CHECK-LABEL: store_lane_i32_a4:890; CHECK: .functype store_lane_i32_a4 (v128, i32) -> ()891; CHECK-NEXT: # %bb.0:892; CHECK-NEXT: local.get 1893; CHECK-NEXT: local.get 0894; CHECK-NEXT: v128.store32_lane 0, 0895; CHECK-NEXT: # fallthrough-return896 %x = extractelement <4 x i32> %v, i32 0897 store i32 %x, ptr %p, align 4898 ret void899}900 901; 8 is greater than the default alignment so it is ignored.902define void @store_lane_i32_a8(<4 x i32> %v, ptr %p) {903; CHECK-LABEL: store_lane_i32_a8:904; CHECK: .functype store_lane_i32_a8 (v128, i32) -> ()905; CHECK-NEXT: # %bb.0:906; CHECK-NEXT: local.get 1907; CHECK-NEXT: local.get 0908; CHECK-NEXT: v128.store32_lane 0, 0909; CHECK-NEXT: # fallthrough-return910 %x = extractelement <4 x i32> %v, i32 0911 store i32 %x, ptr %p, align 8912 ret void913}914 915define <4 x i32> @load_zero_i32_a1(ptr %p) {916; CHECK-LABEL: load_zero_i32_a1:917; CHECK: .functype load_zero_i32_a1 (i32) -> (v128)918; CHECK-NEXT: # %bb.0:919; CHECK-NEXT: local.get 0920; CHECK-NEXT: v128.load32_zero 0:p2align=0921; CHECK-NEXT: # fallthrough-return922 %x = load i32, ptr %p, align 1923 %v = insertelement <4 x i32> zeroinitializer, i32 %x, i32 0924 ret <4 x i32> %v925}926 927define <4 x i32> @load_zero_i32_a2(ptr %p) {928; CHECK-LABEL: load_zero_i32_a2:929; CHECK: .functype load_zero_i32_a2 (i32) -> (v128)930; CHECK-NEXT: # %bb.0:931; CHECK-NEXT: local.get 0932; CHECK-NEXT: v128.load32_zero 0:p2align=1933; CHECK-NEXT: # fallthrough-return934 %x = load i32, ptr %p, align 2935 %v = insertelement <4 x i32> zeroinitializer, i32 %x, i32 0936 ret <4 x i32> %v937}938 939; 4 is the default alignment for v128.load32_zero so no attribute is needed.940define <4 x i32> @load_zero_i32_a4(ptr %p) {941; CHECK-LABEL: load_zero_i32_a4:942; CHECK: .functype load_zero_i32_a4 (i32) -> (v128)943; CHECK-NEXT: # %bb.0:944; CHECK-NEXT: local.get 0945; CHECK-NEXT: v128.load32_zero 0946; CHECK-NEXT: # fallthrough-return947 %x = load i32, ptr %p, align 4948 %v = insertelement <4 x i32> zeroinitializer, i32 %x, i32 0949 ret <4 x i32> %v950}951 952; 8 is greater than the default alignment so it is ignored.953define <4 x i32> @load_zero_i32_a8(ptr %p) {954; CHECK-LABEL: load_zero_i32_a8:955; CHECK: .functype load_zero_i32_a8 (i32) -> (v128)956; CHECK-NEXT: # %bb.0:957; CHECK-NEXT: local.get 0958; CHECK-NEXT: v128.load32_zero 0959; CHECK-NEXT: # fallthrough-return960 %x = load i32, ptr %p, align 8961 %v = insertelement <4 x i32> zeroinitializer, i32 %x, i32 0962 ret <4 x i32> %v963}964 965; ==============================================================================966; 2 x i64967; ==============================================================================968 969define <2 x i64> @load_v2i64_a1(ptr %p) {970; CHECK-LABEL: load_v2i64_a1:971; CHECK: .functype load_v2i64_a1 (i32) -> (v128)972; CHECK-NEXT: # %bb.0:973; CHECK-NEXT: local.get 0974; CHECK-NEXT: v128.load 0:p2align=0975; CHECK-NEXT: # fallthrough-return976 %v = load <2 x i64>, ptr %p, align 1977 ret <2 x i64> %v978}979 980define <2 x i64> @load_v2i64_a4(ptr %p) {981; CHECK-LABEL: load_v2i64_a4:982; CHECK: .functype load_v2i64_a4 (i32) -> (v128)983; CHECK-NEXT: # %bb.0:984; CHECK-NEXT: local.get 0985; CHECK-NEXT: v128.load 0:p2align=2986; CHECK-NEXT: # fallthrough-return987 %v = load <2 x i64>, ptr %p, align 4988 ret <2 x i64> %v989}990 991; 2 is the default alignment for v128 so no attribute is needed.992define <2 x i64> @load_v2i64_a16(ptr %p) {993; CHECK-LABEL: load_v2i64_a16:994; CHECK: .functype load_v2i64_a16 (i32) -> (v128)995; CHECK-NEXT: # %bb.0:996; CHECK-NEXT: local.get 0997; CHECK-NEXT: v128.load 0998; CHECK-NEXT: # fallthrough-return999 %v = load <2 x i64>, ptr %p, align 161000 ret <2 x i64> %v1001}1002 1003; 32 is greater than the default alignment so it is ignored.1004define <2 x i64> @load_v2i64_a32(ptr %p) {1005; CHECK-LABEL: load_v2i64_a32:1006; CHECK: .functype load_v2i64_a32 (i32) -> (v128)1007; CHECK-NEXT: # %bb.0:1008; CHECK-NEXT: local.get 01009; CHECK-NEXT: v128.load 01010; CHECK-NEXT: # fallthrough-return1011 %v = load <2 x i64>, ptr %p, align 321012 ret <2 x i64> %v1013}1014 1015define void @store_v2i64_a1(ptr %p, <2 x i64> %v) {1016; CHECK-LABEL: store_v2i64_a1:1017; CHECK: .functype store_v2i64_a1 (i32, v128) -> ()1018; CHECK-NEXT: # %bb.0:1019; CHECK-NEXT: local.get 01020; CHECK-NEXT: local.get 11021; CHECK-NEXT: v128.store 0:p2align=01022; CHECK-NEXT: # fallthrough-return1023 store <2 x i64> %v, ptr %p, align 11024 ret void1025}1026 1027define void @store_v2i64_a4(ptr %p, <2 x i64> %v) {1028; CHECK-LABEL: store_v2i64_a4:1029; CHECK: .functype store_v2i64_a4 (i32, v128) -> ()1030; CHECK-NEXT: # %bb.0:1031; CHECK-NEXT: local.get 01032; CHECK-NEXT: local.get 11033; CHECK-NEXT: v128.store 0:p2align=21034; CHECK-NEXT: # fallthrough-return1035 store <2 x i64> %v, ptr %p, align 41036 ret void1037}1038 1039; 16 is the default alignment for v128 so no attribute is needed.1040define void @store_v2i64_a16(ptr %p, <2 x i64> %v) {1041; CHECK-LABEL: store_v2i64_a16:1042; CHECK: .functype store_v2i64_a16 (i32, v128) -> ()1043; CHECK-NEXT: # %bb.0:1044; CHECK-NEXT: local.get 01045; CHECK-NEXT: local.get 11046; CHECK-NEXT: v128.store 01047; CHECK-NEXT: # fallthrough-return1048 store <2 x i64> %v, ptr %p, align 161049 ret void1050}1051 1052; 32 is greater than the default alignment so it is ignored.1053define void @store_v2i64_a32(ptr %p, <2 x i64> %v) {1054; CHECK-LABEL: store_v2i64_a32:1055; CHECK: .functype store_v2i64_a32 (i32, v128) -> ()1056; CHECK-NEXT: # %bb.0:1057; CHECK-NEXT: local.get 01058; CHECK-NEXT: local.get 11059; CHECK-NEXT: v128.store 01060; CHECK-NEXT: # fallthrough-return1061 store <2 x i64> %v, ptr %p, align 321062 ret void1063}1064 1065define <2 x i64> @load_splat_v2i64_a1(ptr %p) {1066; CHECK-LABEL: load_splat_v2i64_a1:1067; CHECK: .functype load_splat_v2i64_a1 (i32) -> (v128)1068; CHECK-NEXT: # %bb.0:1069; CHECK-NEXT: local.get 01070; CHECK-NEXT: v128.load64_splat 0:p2align=01071; CHECK-NEXT: # fallthrough-return1072 %e = load i64, ptr %p, align 11073 %v1 = insertelement <2 x i64> undef, i64 %e, i32 01074 %v2 = shufflevector <2 x i64> %v1, <2 x i64> undef, <2 x i32> zeroinitializer1075 ret <2 x i64> %v21076}1077 1078define <2 x i64> @load_splat_v2i64_a2(ptr %p) {1079; CHECK-LABEL: load_splat_v2i64_a2:1080; CHECK: .functype load_splat_v2i64_a2 (i32) -> (v128)1081; CHECK-NEXT: # %bb.0:1082; CHECK-NEXT: local.get 01083; CHECK-NEXT: v128.load64_splat 0:p2align=11084; CHECK-NEXT: # fallthrough-return1085 %e = load i64, ptr %p, align 21086 %v1 = insertelement <2 x i64> undef, i64 %e, i32 01087 %v2 = shufflevector <2 x i64> %v1, <2 x i64> undef, <2 x i32> zeroinitializer1088 ret <2 x i64> %v21089}1090 1091define <2 x i64> @load_splat_v2i64_a4(ptr %p) {1092; CHECK-LABEL: load_splat_v2i64_a4:1093; CHECK: .functype load_splat_v2i64_a4 (i32) -> (v128)1094; CHECK-NEXT: # %bb.0:1095; CHECK-NEXT: local.get 01096; CHECK-NEXT: v128.load64_splat 0:p2align=21097; CHECK-NEXT: # fallthrough-return1098 %e = load i64, ptr %p, align 41099 %v1 = insertelement <2 x i64> undef, i64 %e, i32 01100 %v2 = shufflevector <2 x i64> %v1, <2 x i64> undef, <2 x i32> zeroinitializer1101 ret <2 x i64> %v21102}1103 1104; 8 is the default alignment for v128.load64_splat so no attribute is needed.1105define <2 x i64> @load_splat_v2i64_a8(ptr %p) {1106; CHECK-LABEL: load_splat_v2i64_a8:1107; CHECK: .functype load_splat_v2i64_a8 (i32) -> (v128)1108; CHECK-NEXT: # %bb.0:1109; CHECK-NEXT: local.get 01110; CHECK-NEXT: v128.load64_splat 01111; CHECK-NEXT: # fallthrough-return1112 %e = load i64, ptr %p, align 81113 %v1 = insertelement <2 x i64> undef, i64 %e, i32 01114 %v2 = shufflevector <2 x i64> %v1, <2 x i64> undef, <2 x i32> zeroinitializer1115 ret <2 x i64> %v21116}1117 1118; 16 is greater than the default alignment so it is ignored.1119define <2 x i64> @load_splat_v2i64_a16(ptr %p) {1120; CHECK-LABEL: load_splat_v2i64_a16:1121; CHECK: .functype load_splat_v2i64_a16 (i32) -> (v128)1122; CHECK-NEXT: # %bb.0:1123; CHECK-NEXT: local.get 01124; CHECK-NEXT: v128.load64_splat 01125; CHECK-NEXT: # fallthrough-return1126 %e = load i64, ptr %p, align 161127 %v1 = insertelement <2 x i64> undef, i64 %e, i32 01128 %v2 = shufflevector <2 x i64> %v1, <2 x i64> undef, <2 x i32> zeroinitializer1129 ret <2 x i64> %v21130}1131 1132define <2 x i64> @load_lane_i64_a1(ptr %p, <2 x i64> %v) {1133; CHECK-LABEL: load_lane_i64_a1:1134; CHECK: .functype load_lane_i64_a1 (i32, v128) -> (v128)1135; CHECK-NEXT: # %bb.0:1136; CHECK-NEXT: local.get 01137; CHECK-NEXT: local.get 11138; CHECK-NEXT: v128.load64_lane 0:p2align=0, 01139; CHECK-NEXT: # fallthrough-return1140 %e = load i64, ptr %p, align 11141 %v1 = insertelement <2 x i64> %v, i64 %e, i32 01142 ret <2 x i64> %v11143}1144 1145define <2 x i64> @load_lane_i64_a2(ptr %p, <2 x i64> %v) {1146; CHECK-LABEL: load_lane_i64_a2:1147; CHECK: .functype load_lane_i64_a2 (i32, v128) -> (v128)1148; CHECK-NEXT: # %bb.0:1149; CHECK-NEXT: local.get 01150; CHECK-NEXT: local.get 11151; CHECK-NEXT: v128.load64_lane 0:p2align=1, 01152; CHECK-NEXT: # fallthrough-return1153 %e = load i64, ptr %p, align 21154 %v1 = insertelement <2 x i64> %v, i64 %e, i32 01155 ret <2 x i64> %v11156}1157 1158define <2 x i64> @load_lane_i64_a4(ptr %p, <2 x i64> %v) {1159; CHECK-LABEL: load_lane_i64_a4:1160; CHECK: .functype load_lane_i64_a4 (i32, v128) -> (v128)1161; CHECK-NEXT: # %bb.0:1162; CHECK-NEXT: local.get 01163; CHECK-NEXT: local.get 11164; CHECK-NEXT: v128.load64_lane 0:p2align=2, 01165; CHECK-NEXT: # fallthrough-return1166 %e = load i64, ptr %p, align 41167 %v1 = insertelement <2 x i64> %v, i64 %e, i32 01168 ret <2 x i64> %v11169}1170 1171; 8 is the default alignment for v128.load64_lane so no attribute is needed.1172define <2 x i64> @load_lane_i64_a8(ptr %p, <2 x i64> %v) {1173; CHECK-LABEL: load_lane_i64_a8:1174; CHECK: .functype load_lane_i64_a8 (i32, v128) -> (v128)1175; CHECK-NEXT: # %bb.0:1176; CHECK-NEXT: local.get 01177; CHECK-NEXT: local.get 11178; CHECK-NEXT: v128.load64_lane 0, 01179; CHECK-NEXT: # fallthrough-return1180 %e = load i64, ptr %p, align 81181 %v1 = insertelement <2 x i64> %v, i64 %e, i32 01182 ret <2 x i64> %v11183}1184 1185; 16 is greater than the default alignment so it is ignored.1186define <2 x i64> @load_lane_i64_a16(ptr %p, <2 x i64> %v) {1187; CHECK-LABEL: load_lane_i64_a16:1188; CHECK: .functype load_lane_i64_a16 (i32, v128) -> (v128)1189; CHECK-NEXT: # %bb.0:1190; CHECK-NEXT: local.get 01191; CHECK-NEXT: local.get 11192; CHECK-NEXT: v128.load64_lane 0, 01193; CHECK-NEXT: # fallthrough-return1194 %e = load i64, ptr %p, align 161195 %v1 = insertelement <2 x i64> %v, i64 %e, i32 01196 ret <2 x i64> %v11197}1198 1199define void @store_lane_i64_a1(<2 x i64> %v, ptr %p) {1200; CHECK-LABEL: store_lane_i64_a1:1201; CHECK: .functype store_lane_i64_a1 (v128, i32) -> ()1202; CHECK-NEXT: # %bb.0:1203; CHECK-NEXT: local.get 11204; CHECK-NEXT: local.get 01205; CHECK-NEXT: v128.store64_lane 0:p2align=0, 01206; CHECK-NEXT: # fallthrough-return1207 %x = extractelement <2 x i64> %v, i32 01208 store i64 %x, ptr %p, align 11209 ret void1210}1211 1212define void @store_lane_i64_a2(<2 x i64> %v, ptr %p) {1213; CHECK-LABEL: store_lane_i64_a2:1214; CHECK: .functype store_lane_i64_a2 (v128, i32) -> ()1215; CHECK-NEXT: # %bb.0:1216; CHECK-NEXT: local.get 11217; CHECK-NEXT: local.get 01218; CHECK-NEXT: v128.store64_lane 0:p2align=1, 01219; CHECK-NEXT: # fallthrough-return1220 %x = extractelement <2 x i64> %v, i32 01221 store i64 %x, ptr %p, align 21222 ret void1223}1224 1225define void @store_lane_i64_a4(<2 x i64> %v, ptr %p) {1226; CHECK-LABEL: store_lane_i64_a4:1227; CHECK: .functype store_lane_i64_a4 (v128, i32) -> ()1228; CHECK-NEXT: # %bb.0:1229; CHECK-NEXT: local.get 11230; CHECK-NEXT: local.get 01231; CHECK-NEXT: v128.store64_lane 0:p2align=2, 01232; CHECK-NEXT: # fallthrough-return1233 %x = extractelement <2 x i64> %v, i32 01234 store i64 %x, ptr %p, align 41235 ret void1236}1237 1238; 8 is the default alignment for v128.store64_lane so no attribute is needed.1239define void @store_lane_i64_a8(<2 x i64> %v, ptr %p) {1240; CHECK-LABEL: store_lane_i64_a8:1241; CHECK: .functype store_lane_i64_a8 (v128, i32) -> ()1242; CHECK-NEXT: # %bb.0:1243; CHECK-NEXT: local.get 11244; CHECK-NEXT: local.get 01245; CHECK-NEXT: v128.store64_lane 0, 01246; CHECK-NEXT: # fallthrough-return1247 %x = extractelement <2 x i64> %v, i32 01248 store i64 %x, ptr %p, align 81249 ret void1250}1251 1252; 16 is greater than the default alignment so it is ignored.1253define void @store_lane_i64_a16(<2 x i64> %v, ptr %p) {1254; CHECK-LABEL: store_lane_i64_a16:1255; CHECK: .functype store_lane_i64_a16 (v128, i32) -> ()1256; CHECK-NEXT: # %bb.0:1257; CHECK-NEXT: local.get 11258; CHECK-NEXT: local.get 01259; CHECK-NEXT: v128.store64_lane 0, 01260; CHECK-NEXT: # fallthrough-return1261 %x = extractelement <2 x i64> %v, i32 01262 store i64 %x, ptr %p, align 161263 ret void1264}1265 1266define <2 x i64> @load_zero_i64_a1(ptr %p) {1267; CHECK-LABEL: load_zero_i64_a1:1268; CHECK: .functype load_zero_i64_a1 (i32) -> (v128)1269; CHECK-NEXT: # %bb.0:1270; CHECK-NEXT: local.get 01271; CHECK-NEXT: v128.load64_zero 0:p2align=01272; CHECK-NEXT: # fallthrough-return1273 %x = load i64, ptr %p, align 11274 %v = insertelement <2 x i64> zeroinitializer, i64 %x, i32 01275 ret <2 x i64> %v1276}1277 1278define <2 x i64> @load_zero_i64_a2(ptr %p) {1279; CHECK-LABEL: load_zero_i64_a2:1280; CHECK: .functype load_zero_i64_a2 (i32) -> (v128)1281; CHECK-NEXT: # %bb.0:1282; CHECK-NEXT: local.get 01283; CHECK-NEXT: v128.load64_zero 0:p2align=11284; CHECK-NEXT: # fallthrough-return1285 %x = load i64, ptr %p, align 21286 %v = insertelement <2 x i64> zeroinitializer, i64 %x, i32 01287 ret <2 x i64> %v1288}1289 1290define <2 x i64> @load_zero_i64_a4(ptr %p) {1291; CHECK-LABEL: load_zero_i64_a4:1292; CHECK: .functype load_zero_i64_a4 (i32) -> (v128)1293; CHECK-NEXT: # %bb.0:1294; CHECK-NEXT: local.get 01295; CHECK-NEXT: v128.load64_zero 0:p2align=21296; CHECK-NEXT: # fallthrough-return1297 %x = load i64, ptr %p, align 41298 %v = insertelement <2 x i64> zeroinitializer, i64 %x, i32 01299 ret <2 x i64> %v1300}1301 1302; 8 is the default alignment for v128.load64_zero so no attribute is needed.1303define <2 x i64> @load_zero_i64_a8(ptr %p) {1304; CHECK-LABEL: load_zero_i64_a8:1305; CHECK: .functype load_zero_i64_a8 (i32) -> (v128)1306; CHECK-NEXT: # %bb.0:1307; CHECK-NEXT: local.get 01308; CHECK-NEXT: v128.load64_zero 01309; CHECK-NEXT: # fallthrough-return1310 %x = load i64, ptr %p, align 81311 %v = insertelement <2 x i64> zeroinitializer, i64 %x, i32 01312 ret <2 x i64> %v1313}1314 1315; 16 is greater than the default alignment so it is ignored.1316define <2 x i64> @load_zero_i64_a16(ptr %p) {1317; CHECK-LABEL: load_zero_i64_a16:1318; CHECK: .functype load_zero_i64_a16 (i32) -> (v128)1319; CHECK-NEXT: # %bb.0:1320; CHECK-NEXT: local.get 01321; CHECK-NEXT: v128.load64_zero 01322; CHECK-NEXT: # fallthrough-return1323 %x = load i64, ptr %p, align 161324 %v = insertelement <2 x i64> zeroinitializer, i64 %x, i32 01325 ret <2 x i64> %v1326}1327 1328; ==============================================================================1329; 4 x float1330; ==============================================================================1331 1332define <4 x float> @load_v4f32_a1(ptr %p) {1333; CHECK-LABEL: load_v4f32_a1:1334; CHECK: .functype load_v4f32_a1 (i32) -> (v128)1335; CHECK-NEXT: # %bb.0:1336; CHECK-NEXT: local.get 01337; CHECK-NEXT: v128.load 0:p2align=01338; CHECK-NEXT: # fallthrough-return1339 %v = load <4 x float>, ptr %p, align 11340 ret <4 x float> %v1341}1342 1343define <4 x float> @load_v4f32_a4(ptr %p) {1344; CHECK-LABEL: load_v4f32_a4:1345; CHECK: .functype load_v4f32_a4 (i32) -> (v128)1346; CHECK-NEXT: # %bb.0:1347; CHECK-NEXT: local.get 01348; CHECK-NEXT: v128.load 0:p2align=21349; CHECK-NEXT: # fallthrough-return1350 %v = load <4 x float>, ptr %p, align 41351 ret <4 x float> %v1352}1353 1354; 4 is the default alignment for v128 so no attribute is needed.1355define <4 x float> @load_v4f32_a16(ptr %p) {1356; CHECK-LABEL: load_v4f32_a16:1357; CHECK: .functype load_v4f32_a16 (i32) -> (v128)1358; CHECK-NEXT: # %bb.0:1359; CHECK-NEXT: local.get 01360; CHECK-NEXT: v128.load 01361; CHECK-NEXT: # fallthrough-return1362 %v = load <4 x float>, ptr %p, align 161363 ret <4 x float> %v1364}1365 1366; 32 is greater than the default alignment so it is ignored.1367define <4 x float> @load_v4f32_a32(ptr %p) {1368; CHECK-LABEL: load_v4f32_a32:1369; CHECK: .functype load_v4f32_a32 (i32) -> (v128)1370; CHECK-NEXT: # %bb.0:1371; CHECK-NEXT: local.get 01372; CHECK-NEXT: v128.load 01373; CHECK-NEXT: # fallthrough-return1374 %v = load <4 x float>, ptr %p, align 321375 ret <4 x float> %v1376}1377 1378define void @store_v4f32_a1(ptr %p, <4 x float> %v) {1379; CHECK-LABEL: store_v4f32_a1:1380; CHECK: .functype store_v4f32_a1 (i32, v128) -> ()1381; CHECK-NEXT: # %bb.0:1382; CHECK-NEXT: local.get 01383; CHECK-NEXT: local.get 11384; CHECK-NEXT: v128.store 0:p2align=01385; CHECK-NEXT: # fallthrough-return1386 store <4 x float> %v, ptr %p, align 11387 ret void1388}1389 1390define void @store_v4f32_a4(ptr %p, <4 x float> %v) {1391; CHECK-LABEL: store_v4f32_a4:1392; CHECK: .functype store_v4f32_a4 (i32, v128) -> ()1393; CHECK-NEXT: # %bb.0:1394; CHECK-NEXT: local.get 01395; CHECK-NEXT: local.get 11396; CHECK-NEXT: v128.store 0:p2align=21397; CHECK-NEXT: # fallthrough-return1398 store <4 x float> %v, ptr %p, align 41399 ret void1400}1401 1402; 16 is the default alignment for v128 so no attribute is needed.1403define void @store_v4f32_a16(ptr %p, <4 x float> %v) {1404; CHECK-LABEL: store_v4f32_a16:1405; CHECK: .functype store_v4f32_a16 (i32, v128) -> ()1406; CHECK-NEXT: # %bb.0:1407; CHECK-NEXT: local.get 01408; CHECK-NEXT: local.get 11409; CHECK-NEXT: v128.store 01410; CHECK-NEXT: # fallthrough-return1411 store <4 x float> %v, ptr %p, align 161412 ret void1413}1414 1415; 32 is greater than the default alignment so it is ignored.1416define void @store_v4f32_a32(ptr %p, <4 x float> %v) {1417; CHECK-LABEL: store_v4f32_a32:1418; CHECK: .functype store_v4f32_a32 (i32, v128) -> ()1419; CHECK-NEXT: # %bb.0:1420; CHECK-NEXT: local.get 01421; CHECK-NEXT: local.get 11422; CHECK-NEXT: v128.store 01423; CHECK-NEXT: # fallthrough-return1424 store <4 x float> %v, ptr %p, align 321425 ret void1426}1427 1428; ==============================================================================1429; 2 x double1430; ==============================================================================1431 1432define <2 x double> @load_v2f64_a1(ptr %p) {1433; CHECK-LABEL: load_v2f64_a1:1434; CHECK: .functype load_v2f64_a1 (i32) -> (v128)1435; CHECK-NEXT: # %bb.0:1436; CHECK-NEXT: local.get 01437; CHECK-NEXT: v128.load 0:p2align=01438; CHECK-NEXT: # fallthrough-return1439 %v = load <2 x double>, ptr %p, align 11440 ret <2 x double> %v1441}1442 1443define <2 x double> @load_v2f64_a4(ptr %p) {1444; CHECK-LABEL: load_v2f64_a4:1445; CHECK: .functype load_v2f64_a4 (i32) -> (v128)1446; CHECK-NEXT: # %bb.0:1447; CHECK-NEXT: local.get 01448; CHECK-NEXT: v128.load 0:p2align=21449; CHECK-NEXT: # fallthrough-return1450 %v = load <2 x double>, ptr %p, align 41451 ret <2 x double> %v1452}1453 1454; 2 is the default alignment for v128 so no attribute is needed.1455define <2 x double> @load_v2f64_a16(ptr %p) {1456; CHECK-LABEL: load_v2f64_a16:1457; CHECK: .functype load_v2f64_a16 (i32) -> (v128)1458; CHECK-NEXT: # %bb.0:1459; CHECK-NEXT: local.get 01460; CHECK-NEXT: v128.load 01461; CHECK-NEXT: # fallthrough-return1462 %v = load <2 x double>, ptr %p, align 161463 ret <2 x double> %v1464}1465 1466; 32 is greater than the default alignment so it is ignored.1467define <2 x double> @load_v2f64_a32(ptr %p) {1468; CHECK-LABEL: load_v2f64_a32:1469; CHECK: .functype load_v2f64_a32 (i32) -> (v128)1470; CHECK-NEXT: # %bb.0:1471; CHECK-NEXT: local.get 01472; CHECK-NEXT: v128.load 01473; CHECK-NEXT: # fallthrough-return1474 %v = load <2 x double>, ptr %p, align 321475 ret <2 x double> %v1476}1477 1478define void @store_v2f64_a1(ptr %p, <2 x double> %v) {1479; CHECK-LABEL: store_v2f64_a1:1480; CHECK: .functype store_v2f64_a1 (i32, v128) -> ()1481; CHECK-NEXT: # %bb.0:1482; CHECK-NEXT: local.get 01483; CHECK-NEXT: local.get 11484; CHECK-NEXT: v128.store 0:p2align=01485; CHECK-NEXT: # fallthrough-return1486 store <2 x double> %v, ptr %p, align 11487 ret void1488}1489 1490define void @store_v2f64_a4(ptr %p, <2 x double> %v) {1491; CHECK-LABEL: store_v2f64_a4:1492; CHECK: .functype store_v2f64_a4 (i32, v128) -> ()1493; CHECK-NEXT: # %bb.0:1494; CHECK-NEXT: local.get 01495; CHECK-NEXT: local.get 11496; CHECK-NEXT: v128.store 0:p2align=21497; CHECK-NEXT: # fallthrough-return1498 store <2 x double> %v, ptr %p, align 41499 ret void1500}1501 1502; 16 is the default alignment for v128 so no attribute is needed.1503define void @store_v2f64_a16(ptr %p, <2 x double> %v) {1504; CHECK-LABEL: store_v2f64_a16:1505; CHECK: .functype store_v2f64_a16 (i32, v128) -> ()1506; CHECK-NEXT: # %bb.0:1507; CHECK-NEXT: local.get 01508; CHECK-NEXT: local.get 11509; CHECK-NEXT: v128.store 01510; CHECK-NEXT: # fallthrough-return1511 store <2 x double> %v, ptr %p, align 161512 ret void1513}1514 1515; 32 is greater than the default alignment so it is ignored.1516define void @store_v2f64_a32(ptr %p, <2 x double> %v) {1517; CHECK-LABEL: store_v2f64_a32:1518; CHECK: .functype store_v2f64_a32 (i32, v128) -> ()1519; CHECK-NEXT: # %bb.0:1520; CHECK-NEXT: local.get 01521; CHECK-NEXT: local.get 11522; CHECK-NEXT: v128.store 01523; CHECK-NEXT: # fallthrough-return1524 store <2 x double> %v, ptr %p, align 321525 ret void1526}1527