test/CodeGen/WebAssembly/simd-load-store-alignment.ll

   1 ; RUN: llc < %s -asm-verbose=false -verify-machineinstrs -disable-wasm-fallthrough-return-opt -wasm-disable-explicit-locals -wasm-keep-registers -mattr=+unimplemented-simd128 | FileCheck %s
   2
   3 ; Test loads and stores with custom alignment values.
   4
   5 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
   6 target triple = "wasm32-unknown-unknown"
   7
   8 ; ==============================================================================
   9 ; 16 x i8
  10 ; ==============================================================================
  11
  12 ; CHECK-LABEL: load_v16i8_a1:
  13 ; CHECK-NEXT: .functype load_v16i8_a1 (i32) -> (v128){{$}}
  14 ; CHECK-NEXT: v128.load $push[[R:[0-9]+]]=, 0($0):p2align=0{{$}}
  15 ; CHECK-NEXT: return $pop[[R]]{{$}}
  16 define <16 x i8> @load_v16i8_a1(<16 x i8> *%p) {
  17   %v = load <16 x i8>, <16 x i8>* %p, align 1
  18   ret <16 x i8> %v
  19 }
  20
  21 ; CHECK-LABEL: load_v16i8_a4:
  22 ; CHECK-NEXT: .functype load_v16i8_a4 (i32) -> (v128){{$}}
  23 ; CHECK-NEXT: v128.load $push[[R:[0-9]+]]=, 0($0):p2align=2{{$}}
  24 ; CHECK-NEXT: return $pop[[R]]{{$}}
  25 define <16 x i8> @load_v16i8_a4(<16 x i8> *%p) {
  26   %v = load <16 x i8>, <16 x i8>* %p, align 4
  27   ret <16 x i8> %v
  28 }
  29
  30 ; 16 is the default alignment for v128 so no attribute is needed.
  31
  32 ; CHECK-LABEL: load_v16i8_a16:
  33 ; CHECK-NEXT: .functype load_v16i8_a16 (i32) -> (v128){{$}}
  34 ; CHECK-NEXT: v128.load $push[[R:[0-9]+]]=, 0($0){{$}}
  35 ; CHECK-NEXT: return $pop[[R]]{{$}}
  36 define <16 x i8> @load_v16i8_a16(<16 x i8> *%p) {
  37   %v = load <16 x i8>, <16 x i8>* %p, align 16
  38   ret <16 x i8> %v
  39 }
  40
  41 ; 32 is greater than the default alignment so it is ignored.
  42
  43 ; CHECK-LABEL: load_v16i8_a32:
  44 ; CHECK-NEXT: .functype load_v16i8_a32 (i32) -> (v128){{$}}
  45 ; CHECK-NEXT: v128.load $push[[R:[0-9]+]]=, 0($0){{$}}
  46 ; CHECK-NEXT: return $pop[[R]]{{$}}
  47 define <16 x i8> @load_v16i8_a32(<16 x i8> *%p) {
  48   %v = load <16 x i8>, <16 x i8>* %p, align 32
  49   ret <16 x i8> %v
  50 }
  51
  52 ; CHECK-LABEL: store_v16i8_a1:
  53 ; CHECK-NEXT: .functype store_v16i8_a1 (i32, v128) -> (){{$}}
  54 ; CHECK-NEXT: v128.store 0($0):p2align=0, $1{{$}}
  55 ; CHECK-NEXT: return{{$}}
  56 define void @store_v16i8_a1(<16 x i8> *%p, <16 x i8> %v) {
  57   store <16 x i8> %v, <16 x i8>* %p, align 1
  58   ret void
  59 }
  60
  61 ; CHECK-LABEL: store_v16i8_a4:
  62 ; CHECK-NEXT: .functype store_v16i8_a4 (i32, v128) -> (){{$}}
  63 ; CHECK-NEXT: v128.store 0($0):p2align=2, $1{{$}}
  64 ; CHECK-NEXT: return{{$}}
  65 define void @store_v16i8_a4(<16 x i8> *%p, <16 x i8> %v) {
  66   store <16 x i8> %v, <16 x i8>* %p, align 4
  67   ret void
  68 }
  69
  70 ; 16 is the default alignment for v128 so no attribute is needed.
  71
  72 ; CHECK-LABEL: store_v16i8_a16:
  73 ; CHECK-NEXT: .functype store_v16i8_a16 (i32, v128) -> (){{$}}
  74 ; CHECK-NEXT: v128.store 0($0), $1{{$}}
  75 ; CHECK-NEXT: return{{$}}
  76 define void @store_v16i8_a16(<16 x i8> *%p, <16 x i8> %v) {
  77   store <16 x i8> %v, <16 x i8>* %p, align 16
  78   ret void
  79 }
  80
  81 ; 32 is greater than the default alignment so it is ignored.
  82
  83 ; CHECK-LABEL: store_v16i8_a32:
  84 ; CHECK-NEXT: .functype store_v16i8_a32 (i32, v128) -> (){{$}}
  85 ; CHECK-NEXT: v128.store 0($0), $1{{$}}
  86 ; CHECK-NEXT: return{{$}}
  87 define void @store_v16i8_a32(<16 x i8> *%p, <16 x i8> %v) {
  88   store <16 x i8> %v, <16 x i8>* %p, align 32
  89   ret void
  90 }
  91
  92 ; ==============================================================================
  93 ; 8 x i16
  94 ; ==============================================================================
  95
  96 ; CHECK-LABEL: load_v8i16_a1:
  97 ; CHECK-NEXT: .functype load_v8i16_a1 (i32) -> (v128){{$}}
  98 ; CHECK-NEXT: v128.load $push[[R:[0-9]+]]=, 0($0):p2align=0{{$}}
  99 ; CHECK-NEXT: return $pop[[R]]{{$}}
 100 define <8 x i16> @load_v8i16_a1(<8 x i16> *%p) {
 101   %v = load <8 x i16>, <8 x i16>* %p, align 1
 102   ret <8 x i16> %v
 103 }
 104
 105 ; CHECK-LABEL: load_v8i16_a4:
 106 ; CHECK-NEXT: .functype load_v8i16_a4 (i32) -> (v128){{$}}
 107 ; CHECK-NEXT: v128.load $push[[R:[0-9]+]]=, 0($0):p2align=2{{$}}
 108 ; CHECK-NEXT: return $pop[[R]]{{$}}
 109 define <8 x i16> @load_v8i16_a4(<8 x i16> *%p) {
 110   %v = load <8 x i16>, <8 x i16>* %p, align 4
 111   ret <8 x i16> %v
 112 }
 113
 114 ; 8 is the default alignment for v128 so no attribute is needed.
 115
 116 ; CHECK-LABEL: load_v8i16_a16:
 117 ; CHECK-NEXT: .functype load_v8i16_a16 (i32) -> (v128){{$}}
 118 ; CHECK-NEXT: v128.load $push[[R:[0-9]+]]=, 0($0){{$}}
 119 ; CHECK-NEXT: return $pop[[R]]{{$}}
 120 define <8 x i16> @load_v8i16_a16(<8 x i16> *%p) {
 121   %v = load <8 x i16>, <8 x i16>* %p, align 16
 122   ret <8 x i16> %v
 123 }
 124
 125 ; 32 is greater than the default alignment so it is ignored.
 126
 127 ; CHECK-LABEL: load_v8i16_a32:
 128 ; CHECK-NEXT: .functype load_v8i16_a32 (i32) -> (v128){{$}}
 129 ; CHECK-NEXT: v128.load $push[[R:[0-9]+]]=, 0($0){{$}}
 130 ; CHECK-NEXT: return $pop[[R]]{{$}}
 131 define <8 x i16> @load_v8i16_a32(<8 x i16> *%p) {
 132   %v = load <8 x i16>, <8 x i16>* %p, align 32
 133   ret <8 x i16> %v
 134 }
 135
 136 ; CHECK-LABEL: store_v8i16_a1:
 137 ; CHECK-NEXT: .functype store_v8i16_a1 (i32, v128) -> (){{$}}
 138 ; CHECK-NEXT: v128.store 0($0):p2align=0, $1{{$}}
 139 ; CHECK-NEXT: return{{$}}
 140 define void @store_v8i16_a1(<8 x i16> *%p, <8 x i16> %v) {
 141   store <8 x i16> %v, <8 x i16>* %p, align 1
 142   ret void
 143 }
 144
 145 ; CHECK-LABEL: store_v8i16_a4:
 146 ; CHECK-NEXT: .functype store_v8i16_a4 (i32, v128) -> (){{$}}
 147 ; CHECK-NEXT: v128.store 0($0):p2align=2, $1{{$}}
 148 ; CHECK-NEXT: return{{$}}
 149 define void @store_v8i16_a4(<8 x i16> *%p, <8 x i16> %v) {
 150   store <8 x i16> %v, <8 x i16>* %p, align 4
 151   ret void
 152 }
 153
 154 ; 16 is the default alignment for v128 so no attribute is needed.
 155
 156 ; CHECK-LABEL: store_v8i16_a16:
 157 ; CHECK-NEXT: .functype store_v8i16_a16 (i32, v128) -> (){{$}}
 158 ; CHECK-NEXT: v128.store 0($0), $1{{$}}
 159 ; CHECK-NEXT: return{{$}}
 160 define void @store_v8i16_a16(<8 x i16> *%p, <8 x i16> %v) {
 161   store <8 x i16> %v, <8 x i16>* %p, align 16
 162   ret void
 163 }
 164
 165 ; 32 is greater than the default alignment so it is ignored.
 166
 167 ; CHECK-LABEL: store_v8i16_a32:
 168 ; CHECK-NEXT: .functype store_v8i16_a32 (i32, v128) -> (){{$}}
 169 ; CHECK-NEXT: v128.store 0($0), $1{{$}}
 170 ; CHECK-NEXT: return{{$}}
 171 define void @store_v8i16_a32(<8 x i16> *%p, <8 x i16> %v) {
 172   store <8 x i16> %v, <8 x i16>* %p, align 32
 173   ret void
 174 }
 175
 176 ; ==============================================================================
 177 ; 4 x i32
 178 ; ==============================================================================
 179
 180 ; CHECK-LABEL: load_v4i32_a1:
 181 ; CHECK-NEXT: .functype load_v4i32_a1 (i32) -> (v128){{$}}
 182 ; CHECK-NEXT: v128.load $push[[R:[0-9]+]]=, 0($0):p2align=0{{$}}
 183 ; CHECK-NEXT: return $pop[[R]]{{$}}
 184 define <4 x i32> @load_v4i32_a1(<4 x i32> *%p) {
 185   %v = load <4 x i32>, <4 x i32>* %p, align 1
 186   ret <4 x i32> %v
 187 }
 188
 189 ; CHECK-LABEL: load_v4i32_a4:
 190 ; CHECK-NEXT: .functype load_v4i32_a4 (i32) -> (v128){{$}}
 191 ; CHECK-NEXT: v128.load $push[[R:[0-9]+]]=, 0($0):p2align=2{{$}}
 192 ; CHECK-NEXT: return $pop[[R]]{{$}}
 193 define <4 x i32> @load_v4i32_a4(<4 x i32> *%p) {
 194   %v = load <4 x i32>, <4 x i32>* %p, align 4
 195   ret <4 x i32> %v
 196 }
 197
 198 ; 4 is the default alignment for v128 so no attribute is needed.
 199
 200 ; CHECK-LABEL: load_v4i32_a16:
 201 ; CHECK-NEXT: .functype load_v4i32_a16 (i32) -> (v128){{$}}
 202 ; CHECK-NEXT: v128.load $push[[R:[0-9]+]]=, 0($0){{$}}
 203 ; CHECK-NEXT: return $pop[[R]]{{$}}
 204 define <4 x i32> @load_v4i32_a16(<4 x i32> *%p) {
 205   %v = load <4 x i32>, <4 x i32>* %p, align 16
 206   ret <4 x i32> %v
 207 }
 208
 209 ; 32 is greater than the default alignment so it is ignored.
 210
 211 ; CHECK-LABEL: load_v4i32_a32:
 212 ; CHECK-NEXT: .functype load_v4i32_a32 (i32) -> (v128){{$}}
 213 ; CHECK-NEXT: v128.load $push[[R:[0-9]+]]=, 0($0){{$}}
 214 ; CHECK-NEXT: return $pop[[R]]{{$}}
 215 define <4 x i32> @load_v4i32_a32(<4 x i32> *%p) {
 216   %v = load <4 x i32>, <4 x i32>* %p, align 32
 217   ret <4 x i32> %v
 218 }
 219
 220 ; CHECK-LABEL: store_v4i32_a1:
 221 ; CHECK-NEXT: .functype store_v4i32_a1 (i32, v128) -> (){{$}}
 222 ; CHECK-NEXT: v128.store 0($0):p2align=0, $1{{$}}
 223 ; CHECK-NEXT: return{{$}}
 224 define void @store_v4i32_a1(<4 x i32> *%p, <4 x i32> %v) {
 225   store <4 x i32> %v, <4 x i32>* %p, align 1
 226   ret void
 227 }
 228
 229 ; CHECK-LABEL: store_v4i32_a4:
 230 ; CHECK-NEXT: .functype store_v4i32_a4 (i32, v128) -> (){{$}}
 231 ; CHECK-NEXT: v128.store 0($0):p2align=2, $1{{$}}
 232 ; CHECK-NEXT: return{{$}}
 233 define void @store_v4i32_a4(<4 x i32> *%p, <4 x i32> %v) {
 234   store <4 x i32> %v, <4 x i32>* %p, align 4
 235   ret void
 236 }
 237
 238 ; 16 is the default alignment for v128 so no attribute is needed.
 239
 240 ; CHECK-LABEL: store_v4i32_a16:
 241 ; CHECK-NEXT: .functype store_v4i32_a16 (i32, v128) -> (){{$}}
 242 ; CHECK-NEXT: v128.store 0($0), $1{{$}}
 243 ; CHECK-NEXT: return{{$}}
 244 define void @store_v4i32_a16(<4 x i32> *%p, <4 x i32> %v) {
 245   store <4 x i32> %v, <4 x i32>* %p, align 16
 246   ret void
 247 }
 248
 249 ; 32 is greater than the default alignment so it is ignored.
 250
 251 ; CHECK-LABEL: store_v4i32_a32:
 252 ; CHECK-NEXT: .functype store_v4i32_a32 (i32, v128) -> (){{$}}
 253 ; CHECK-NEXT: v128.store 0($0), $1{{$}}
 254 ; CHECK-NEXT: return{{$}}
 255 define void @store_v4i32_a32(<4 x i32> *%p, <4 x i32> %v) {
 256   store <4 x i32> %v, <4 x i32>* %p, align 32
 257   ret void
 258 }
 259
 260 ; ==============================================================================
 261 ; 2 x i64
 262 ; ==============================================================================
 263
 264 ; CHECK-LABEL: load_v2i64_a1:
 265 ; CHECK-NEXT: .functype load_v2i64_a1 (i32) -> (v128){{$}}
 266 ; CHECK-NEXT: v128.load $push[[R:[0-9]+]]=, 0($0):p2align=0{{$}}
 267 ; CHECK-NEXT: return $pop[[R]]{{$}}
 268 define <2 x i64> @load_v2i64_a1(<2 x i64> *%p) {
 269   %v = load <2 x i64>, <2 x i64>* %p, align 1
 270   ret <2 x i64> %v
 271 }
 272
 273 ; CHECK-LABEL: load_v2i64_a4:
 274 ; CHECK-NEXT: .functype load_v2i64_a4 (i32) -> (v128){{$}}
 275 ; CHECK-NEXT: v128.load $push[[R:[0-9]+]]=, 0($0):p2align=2{{$}}
 276 ; CHECK-NEXT: return $pop[[R]]{{$}}
 277 define <2 x i64> @load_v2i64_a4(<2 x i64> *%p) {
 278   %v = load <2 x i64>, <2 x i64>* %p, align 4
 279   ret <2 x i64> %v
 280 }
 281
 282 ; 2 is the default alignment for v128 so no attribute is needed.
 283
 284 ; CHECK-LABEL: load_v2i64_a16:
 285 ; CHECK-NEXT: .functype load_v2i64_a16 (i32) -> (v128){{$}}
 286 ; CHECK-NEXT: v128.load $push[[R:[0-9]+]]=, 0($0){{$}}
 287 ; CHECK-NEXT: return $pop[[R]]{{$}}
 288 define <2 x i64> @load_v2i64_a16(<2 x i64> *%p) {
 289   %v = load <2 x i64>, <2 x i64>* %p, align 16
 290   ret <2 x i64> %v
 291 }
 292
 293 ; 32 is greater than the default alignment so it is ignored.
 294
 295 ; CHECK-LABEL: load_v2i64_a32:
 296 ; CHECK-NEXT: .functype load_v2i64_a32 (i32) -> (v128){{$}}
 297 ; CHECK-NEXT: v128.load $push[[R:[0-9]+]]=, 0($0){{$}}
 298 ; CHECK-NEXT: return $pop[[R]]{{$}}
 299 define <2 x i64> @load_v2i64_a32(<2 x i64> *%p) {
 300   %v = load <2 x i64>, <2 x i64>* %p, align 32
 301   ret <2 x i64> %v
 302 }
 303
 304 ; CHECK-LABEL: store_v2i64_a1:
 305 ; CHECK-NEXT: .functype store_v2i64_a1 (i32, v128) -> (){{$}}
 306 ; CHECK-NEXT: v128.store 0($0):p2align=0, $1{{$}}
 307 ; CHECK-NEXT: return{{$}}
 308 define void @store_v2i64_a1(<2 x i64> *%p, <2 x i64> %v) {
 309   store <2 x i64> %v, <2 x i64>* %p, align 1
 310   ret void
 311 }
 312
 313 ; CHECK-LABEL: store_v2i64_a4:
 314 ; CHECK-NEXT: .functype store_v2i64_a4 (i32, v128) -> (){{$}}
 315 ; CHECK-NEXT: v128.store 0($0):p2align=2, $1{{$}}
 316 ; CHECK-NEXT: return{{$}}
 317 define void @store_v2i64_a4(<2 x i64> *%p, <2 x i64> %v) {
 318   store <2 x i64> %v, <2 x i64>* %p, align 4
 319   ret void
 320 }
 321
 322 ; 16 is the default alignment for v128 so no attribute is needed.
 323
 324 ; CHECK-LABEL: store_v2i64_a16:
 325 ; CHECK-NEXT: .functype store_v2i64_a16 (i32, v128) -> (){{$}}
 326 ; CHECK-NEXT: v128.store 0($0), $1{{$}}
 327 ; CHECK-NEXT: return{{$}}
 328 define void @store_v2i64_a16(<2 x i64> *%p, <2 x i64> %v) {
 329   store <2 x i64> %v, <2 x i64>* %p, align 16
 330   ret void
 331 }
 332
 333 ; 32 is greater than the default alignment so it is ignored.
 334
 335 ; CHECK-LABEL: store_v2i64_a32:
 336 ; CHECK-NEXT: .functype store_v2i64_a32 (i32, v128) -> (){{$}}
 337 ; CHECK-NEXT: v128.store 0($0), $1{{$}}
 338 ; CHECK-NEXT: return{{$}}
 339 define void @store_v2i64_a32(<2 x i64> *%p, <2 x i64> %v) {
 340   store <2 x i64> %v, <2 x i64>* %p, align 32
 341   ret void
 342 }
 343
 344 ; ==============================================================================
 345 ; 4 x float
 346 ; ==============================================================================
 347
 348 ; CHECK-LABEL: load_v4f32_a1:
 349 ; CHECK-NEXT: .functype load_v4f32_a1 (i32) -> (v128){{$}}
 350 ; CHECK-NEXT: v128.load $push[[R:[0-9]+]]=, 0($0):p2align=0{{$}}
 351 ; CHECK-NEXT: return $pop[[R]]{{$}}
 352 define <4 x float> @load_v4f32_a1(<4 x float> *%p) {
 353   %v = load <4 x float>, <4 x float>* %p, align 1
 354   ret <4 x float> %v
 355 }
 356
 357 ; CHECK-LABEL: load_v4f32_a4:
 358 ; CHECK-NEXT: .functype load_v4f32_a4 (i32) -> (v128){{$}}
 359 ; CHECK-NEXT: v128.load $push[[R:[0-9]+]]=, 0($0):p2align=2{{$}}
 360 ; CHECK-NEXT: return $pop[[R]]{{$}}
 361 define <4 x float> @load_v4f32_a4(<4 x float> *%p) {
 362   %v = load <4 x float>, <4 x float>* %p, align 4
 363   ret <4 x float> %v
 364 }
 365
 366 ; 4 is the default alignment for v128 so no attribute is needed.
 367
 368 ; CHECK-LABEL: load_v4f32_a16:
 369 ; CHECK-NEXT: .functype load_v4f32_a16 (i32) -> (v128){{$}}
 370 ; CHECK-NEXT: v128.load $push[[R:[0-9]+]]=, 0($0){{$}}
 371 ; CHECK-NEXT: return $pop[[R]]{{$}}
 372 define <4 x float> @load_v4f32_a16(<4 x float> *%p) {
 373   %v = load <4 x float>, <4 x float>* %p, align 16
 374   ret <4 x float> %v
 375 }
 376
 377 ; 32 is greater than the default alignment so it is ignored.
 378
 379 ; CHECK-LABEL: load_v4f32_a32:
 380 ; CHECK-NEXT: .functype load_v4f32_a32 (i32) -> (v128){{$}}
 381 ; CHECK-NEXT: v128.load $push[[R:[0-9]+]]=, 0($0){{$}}
 382 ; CHECK-NEXT: return $pop[[R]]{{$}}
 383 define <4 x float> @load_v4f32_a32(<4 x float> *%p) {
 384   %v = load <4 x float>, <4 x float>* %p, align 32
 385   ret <4 x float> %v
 386 }
 387
 388 ; CHECK-LABEL: store_v4f32_a1:
 389 ; CHECK-NEXT: .functype store_v4f32_a1 (i32, v128) -> (){{$}}
 390 ; CHECK-NEXT: v128.store 0($0):p2align=0, $1{{$}}
 391 ; CHECK-NEXT: return{{$}}
 392 define void @store_v4f32_a1(<4 x float> *%p, <4 x float> %v) {
 393   store <4 x float> %v, <4 x float>* %p, align 1
 394   ret void
 395 }
 396
 397 ; CHECK-LABEL: store_v4f32_a4:
 398 ; CHECK-NEXT: .functype store_v4f32_a4 (i32, v128) -> (){{$}}
 399 ; CHECK-NEXT: v128.store 0($0):p2align=2, $1{{$}}
 400 ; CHECK-NEXT: return{{$}}
 401 define void @store_v4f32_a4(<4 x float> *%p, <4 x float> %v) {
 402   store <4 x float> %v, <4 x float>* %p, align 4
 403   ret void
 404 }
 405
 406 ; 16 is the default alignment for v128 so no attribute is needed.
 407
 408 ; CHECK-LABEL: store_v4f32_a16:
 409 ; CHECK-NEXT: .functype store_v4f32_a16 (i32, v128) -> (){{$}}
 410 ; CHECK-NEXT: v128.store 0($0), $1{{$}}
 411 ; CHECK-NEXT: return{{$}}
 412 define void @store_v4f32_a16(<4 x float> *%p, <4 x float> %v) {
 413   store <4 x float> %v, <4 x float>* %p, align 16
 414   ret void
 415 }
 416
 417 ; 32 is greater than the default alignment so it is ignored.
 418
 419 ; CHECK-LABEL: store_v4f32_a32:
 420 ; CHECK-NEXT: .functype store_v4f32_a32 (i32, v128) -> (){{$}}
 421 ; CHECK-NEXT: v128.store 0($0), $1{{$}}
 422 ; CHECK-NEXT: return{{$}}
 423 define void @store_v4f32_a32(<4 x float> *%p, <4 x float> %v) {
 424   store <4 x float> %v, <4 x float>* %p, align 32
 425   ret void
 426 }
 427
 428 ; ==============================================================================
 429 ; 2 x double
 430 ; ==============================================================================
 431
 432 ; CHECK-LABEL: load_v2f64_a1:
 433 ; CHECK-NEXT: .functype load_v2f64_a1 (i32) -> (v128){{$}}
 434 ; CHECK-NEXT: v128.load $push[[R:[0-9]+]]=, 0($0):p2align=0{{$}}
 435 ; CHECK-NEXT: return $pop[[R]]{{$}}
 436 define <2 x double> @load_v2f64_a1(<2 x double> *%p) {
 437   %v = load <2 x double>, <2 x double>* %p, align 1
 438   ret <2 x double> %v
 439 }
 440
 441 ; CHECK-LABEL: load_v2f64_a4:
 442 ; CHECK-NEXT: .functype load_v2f64_a4 (i32) -> (v128){{$}}
 443 ; CHECK-NEXT: v128.load $push[[R:[0-9]+]]=, 0($0):p2align=2{{$}}
 444 ; CHECK-NEXT: return $pop[[R]]{{$}}
 445 define <2 x double> @load_v2f64_a4(<2 x double> *%p) {
 446   %v = load <2 x double>, <2 x double>* %p, align 4
 447   ret <2 x double> %v
 448 }
 449
 450 ; 2 is the default alignment for v128 so no attribute is needed.
 451
 452 ; CHECK-LABEL: load_v2f64_a16:
 453 ; CHECK-NEXT: .functype load_v2f64_a16 (i32) -> (v128){{$}}
 454 ; CHECK-NEXT: v128.load $push[[R:[0-9]+]]=, 0($0){{$}}
 455 ; CHECK-NEXT: return $pop[[R]]{{$}}
 456 define <2 x double> @load_v2f64_a16(<2 x double> *%p) {
 457   %v = load <2 x double>, <2 x double>* %p, align 16
 458   ret <2 x double> %v
 459 }
 460
 461 ; 32 is greater than the default alignment so it is ignored.
 462
 463 ; CHECK-LABEL: load_v2f64_a32:
 464 ; CHECK-NEXT: .functype load_v2f64_a32 (i32) -> (v128){{$}}
 465 ; CHECK-NEXT: v128.load $push[[R:[0-9]+]]=, 0($0){{$}}
 466 ; CHECK-NEXT: return $pop[[R]]{{$}}
 467 define <2 x double> @load_v2f64_a32(<2 x double> *%p) {
 468   %v = load <2 x double>, <2 x double>* %p, align 32
 469   ret <2 x double> %v
 470 }
 471
 472 ; CHECK-LABEL: store_v2f64_a1:
 473 ; CHECK-NEXT: .functype store_v2f64_a1 (i32, v128) -> (){{$}}
 474 ; CHECK-NEXT: v128.store 0($0):p2align=0, $1{{$}}
 475 ; CHECK-NEXT: return{{$}}
 476 define void @store_v2f64_a1(<2 x double> *%p, <2 x double> %v) {
 477   store <2 x double> %v, <2 x double>* %p, align 1
 478   ret void
 479 }
 480
 481 ; CHECK-LABEL: store_v2f64_a4:
 482 ; CHECK-NEXT: .functype store_v2f64_a4 (i32, v128) -> (){{$}}
 483 ; CHECK-NEXT: v128.store 0($0):p2align=2, $1{{$}}
 484 ; CHECK-NEXT: return{{$}}
 485 define void @store_v2f64_a4(<2 x double> *%p, <2 x double> %v) {
 486   store <2 x double> %v, <2 x double>* %p, align 4
 487   ret void
 488 }
 489
 490 ; 16 is the default alignment for v128 so no attribute is needed.
 491
 492 ; CHECK-LABEL: store_v2f64_a16:
 493 ; CHECK-NEXT: .functype store_v2f64_a16 (i32, v128) -> (){{$}}
 494 ; CHECK-NEXT: v128.store 0($0), $1{{$}}
 495 ; CHECK-NEXT: return{{$}}
 496 define void @store_v2f64_a16(<2 x double> *%p, <2 x double> %v) {
 497   store <2 x double> %v, <2 x double>* %p, align 16
 498   ret void
 499 }
 500
 501 ; 32 is greater than the default alignment so it is ignored.
 502
 503 ; CHECK-LABEL: store_v2f64_a32:
 504 ; CHECK-NEXT: .functype store_v2f64_a32 (i32, v128) -> (){{$}}
 505 ; CHECK-NEXT: v128.store 0($0), $1{{$}}
 506 ; CHECK-NEXT: return{{$}}
 507 define void @store_v2f64_a32(<2 x double> *%p, <2 x double> %v) {
 508   store <2 x double> %v, <2 x double>* %p, align 32
 509   ret void
 510 }