llvm/test/CodeGen/MIR/X86/memory-operands.mir

   1 # RUN: llc -march=x86-64 -run-pass none -o - %s | FileCheck %s
   2 # This test ensures that the MIR parser parses the machine memory operands
   3 # correctly.
   4
   5 --- |
   6
   7   define i32 @test(ptr %a) {
   8   entry:
   9     %b = load i32, ptr %a
  10     store i32 42, ptr %a
  11     ret i32 %b
  12   }
  13
  14   define void @test2(ptr %"a value") {
  15   entry2:
  16     %b = load i32, ptr %"a value"
  17     %c = add i32 %b, 1
  18     store i32 %c, ptr %"a value"
  19     ret void
  20   }
  21
  22   define void @test3(ptr) {
  23   entry3:
  24     %1 = alloca i32
  25     %b = load i32, ptr %0
  26     %c = add i32 %b, 1
  27     store i32 %c, ptr %1
  28     ret void
  29   }
  30
  31   define i32 @volatile_inc(ptr %x) {
  32   entry:
  33     %0 = load volatile i32, ptr %x
  34     %1 = add i32 %0, 1
  35     store volatile i32 %1, ptr %x
  36     ret i32 %1
  37   }
  38
  39   define void @non_temporal_store(ptr %a, i32 %b) {
  40   entry:
  41     store i32 %b, ptr %a, align 16, !nontemporal !0
  42     ret void
  43   }
  44
  45   !0 = !{i32 1}
  46
  47   define i32 @invariant_load(ptr %x) {
  48   entry:
  49     %v = load i32, ptr %x, !invariant.load !1
  50     ret i32 %v
  51   }
  52
  53   !1 = !{}
  54
  55   define void @memory_offset(ptr %vec) {
  56   entry:
  57     %v = load <8 x float>, ptr %vec
  58     %v2 = insertelement <8 x float> %v, float 0.0, i32 4
  59     store <8 x float> %v2, ptr %vec
  60     ret void
  61   }
  62
  63   define void @memory_alignment(ptr %vec) {
  64   entry:
  65     %v = load <16 x float>, ptr %vec
  66     %v2 = insertelement <16 x float> %v, float 0.0, i32 4
  67     store <16 x float> %v2, ptr %vec
  68     ret void
  69   }
  70
  71   define double @constant_pool_psv(double %a) {
  72   entry:
  73     %b = fadd double %a, 3.250000e+00
  74     ret double %b
  75   }
  76
  77   declare x86_fp80 @cosl(x86_fp80) #0
  78
  79   define x86_fp80 @stack_psv(x86_fp80 %x) {
  80   entry:
  81     %y = call x86_fp80 @cosl(x86_fp80 %x) #0
  82     ret x86_fp80 %y
  83   }
  84
  85   attributes #0 = { readonly }
  86
  87   @G = external global i32
  88
  89   define i32 @got_psv() {
  90   entry:
  91     %a = load i32, ptr @G
  92     %b = add i32 %a, 1
  93     ret i32 %b
  94   }
  95
  96   @0 = external global i32
  97
  98   define i32 @global_value() {
  99   entry:
 100     %a = load i32, ptr @G
 101     %b = add i32 %a, 1
 102     %c = load i32, ptr @0
 103     %d = add i32 %b, %c
 104     ret i32 %d
 105   }
 106
 107   define i32 @jumptable_psv(i32 %in) {
 108   entry:
 109     switch i32 %in, label %def [
 110       i32 0, label %lbl1
 111       i32 1, label %lbl2
 112       i32 2, label %lbl3
 113       i32 3, label %lbl4
 114     ]
 115   def:
 116     ret i32 0
 117   lbl1:
 118     ret i32 1
 119   lbl2:
 120     ret i32 2
 121   lbl3:
 122     ret i32 4
 123   lbl4:
 124     ret i32 8
 125   }
 126
 127   %struct.XXH_state64_t = type { i32, i32, i64, i64, i64 }
 128
 129   @a = common global i32 0, align 4
 130
 131   define i32 @tbaa_metadata() {
 132   entry:
 133     %0 = load i32, ptr @a, align 4, !tbaa !2
 134     %1 = inttoptr i32 %0 to ptr
 135     %2 = load i32, ptr %1, align 4, !tbaa !6
 136     ret i32 %2
 137   }
 138
 139   !2 = !{!3, !3, i64 0}
 140   !3 = !{!"int", !4, i64 0}
 141   !4 = !{!"omnipotent char", !5, i64 0}
 142   !5 = !{!"Simple C/C++ TBAA"}
 143   !6 = !{!7, !3, i64 0}
 144   !7 = !{!"XXH_state64_t", !3, i64 0, !3, i64 4, !8, i64 8, !8, i64 16, !8, i64 24}
 145   !8 = !{!"long long", !4, i64 0}
 146
 147   define void @aa_scope(ptr nocapture %a, ptr nocapture readonly %c) #1 {
 148   entry:
 149     %0 = load float, ptr %c, align 4, !alias.scope !9
 150     %arrayidx.i = getelementptr inbounds float, ptr %a, i64 5
 151     store float %0, ptr %arrayidx.i, align 4, !noalias !9
 152     %1 = load float, ptr %c, align 4
 153     %arrayidx = getelementptr inbounds float, ptr %a, i64 7
 154     store float %1, ptr %arrayidx, align 4
 155     ret void
 156   }
 157
 158   attributes #1 = { nounwind uwtable }
 159
 160   !9 = !{!10}
 161   !10 = distinct !{!10, !11, !"some scope"}
 162   !11 = distinct !{!11, !"some domain"}
 163
 164   define zeroext i1 @range_metadata(ptr %x) {
 165   entry:
 166     %0 = load i8, ptr %x, align 1, !range !12
 167     %tobool = trunc i8 %0 to i1
 168     ret i1 %tobool
 169   }
 170
 171   !12 = !{i8 0, i8 2}
 172
 173   %st = type { i32, i32 }
 174
 175   @values = common global [50 x %st] zeroinitializer, align 16
 176
 177   define void @gep_value(i64 %d) {
 178   entry:
 179     %conv = trunc i64 %d to i32
 180     store i32 %conv, ptr @values, align 16
 181     ret void
 182   }
 183
 184   define ptr @undef_value() {
 185   entry:
 186     %0 = load ptr, ptr undef, align 8
 187     ret ptr %0
 188   }
 189
 190   define void @dummy0() { ret void }
 191   define void @dummy1() { ret void }
 192   define void @dummy2() { ret void }
 193   define void @dummy3() { ret void }
 194 ...
 195 ---
 196 name:            test
 197 tracksRegLiveness: true
 198 liveins:
 199   - { reg: '$rdi' }
 200 body: |
 201   bb.0.entry:
 202     liveins: $rdi
 203   ; CHECK:      $eax = MOV32rm $rdi, 1, $noreg, 0, $noreg :: (load (s32) from %ir.a)
 204   ; CHECK-NEXT: MOV32mi killed $rdi, 1, $noreg, 0, $noreg, 42 :: (store (s32) into %ir.a)
 205     $eax = MOV32rm $rdi, 1, _, 0, _ :: (load (s32) from %ir.a)
 206     MOV32mi killed $rdi, 1, _, 0, _, 42 :: (store (s32) into %ir.a)
 207     RET64 $eax
 208 ...
 209 ---
 210 name:            test2
 211 tracksRegLiveness: true
 212 liveins:
 213   - { reg: '$rdi' }
 214 body: |
 215   bb.0.entry2:
 216     liveins: $rdi
 217   ; CHECK: INC32m killed $rdi, 1, $noreg, 0, $noreg, implicit-def dead $eflags :: (store (s32) into %ir."a value"), (load (s32) from %ir."a value")
 218     INC32m killed $rdi, 1, _, 0, _, implicit-def dead $eflags :: (store (s32) into %ir."a value"), (load (s32) from %ir."a value")
 219     RET64
 220 ...
 221 ---
 222 name:            test3
 223 tracksRegLiveness: true
 224 liveins:
 225   - { reg: '$rdi' }
 226 frameInfo:
 227   maxAlignment:    4
 228 stack:
 229   - { id: 0, offset: -12, size: 4, alignment: 4 }
 230 body: |
 231   bb.0.entry3:
 232     liveins: $rdi
 233   ; Verify that the unnamed local values can be serialized.
 234   ; CHECK-LABEL: name: test3
 235   ; CHECK: $eax = MOV32rm killed $rdi, 1, $noreg, 0, $noreg :: (load (s32) from %ir.0)
 236   ; CHECK: MOV32mr $rsp, 1, $noreg, -4, $noreg, killed $eax :: (store (s32) into %ir.1)
 237     $eax = MOV32rm killed $rdi, 1, _, 0, _ :: (load (s32) from %ir.0)
 238     $eax = INC32r killed $eax, implicit-def dead $eflags
 239     MOV32mr $rsp, 1, _, -4, _, killed $eax :: (store (s32) into %ir.1)
 240     RET64
 241 ...
 242 ---
 243 name:            volatile_inc
 244 tracksRegLiveness: true
 245 liveins:
 246   - { reg: '$rdi' }
 247 body: |
 248   bb.0.entry:
 249     liveins: $rdi
 250     ; CHECK: name: volatile_inc
 251     ; CHECK: $eax = MOV32rm $rdi, 1, $noreg, 0, $noreg :: (volatile load (s32) from %ir.x)
 252     ; CHECK: MOV32mr killed $rdi, 1, $noreg, 0, $noreg, $eax :: (volatile store (s32) into %ir.x)
 253     $eax = MOV32rm $rdi, 1, _, 0, _ :: (volatile load (s32) from %ir.x)
 254     $eax = INC32r killed $eax, implicit-def dead $eflags
 255     MOV32mr killed $rdi, 1, _, 0, _, $eax :: (volatile store (s32) into %ir.x)
 256     RET64 $eax
 257 ...
 258 ---
 259 name:            non_temporal_store
 260 tracksRegLiveness: true
 261 liveins:
 262   - { reg: '$rdi' }
 263   - { reg: '$esi' }
 264 body: |
 265   bb.0.entry:
 266     liveins: $esi, $rdi
 267   ; CHECK: name: non_temporal_store
 268   ; CHECK: MOVNTImr killed $rdi, 1, $noreg, 0, $noreg, killed $esi :: (non-temporal store (s32) into %ir.a)
 269     MOVNTImr killed $rdi, 1, _, 0, _, killed $esi :: (non-temporal store (s32) into %ir.a)
 270     RET64
 271 ...
 272 ---
 273 name:            invariant_load
 274 tracksRegLiveness: true
 275 liveins:
 276   - { reg: '$rdi' }
 277 body: |
 278   bb.0.entry:
 279     liveins: $rdi
 280   ; CHECK: name: invariant_load
 281   ; CHECK: $eax = MOV32rm killed $rdi, 1, $noreg, 0, $noreg :: (invariant load (s32) from %ir.x)
 282     $eax = MOV32rm killed $rdi, 1, _, 0, _ :: (invariant load (s32) from %ir.x)
 283     RET64 $eax
 284 ...
 285 ---
 286 name:            memory_offset
 287 tracksRegLiveness: true
 288 liveins:
 289   - { reg: '$rdi' }
 290 body: |
 291   bb.0.entry:
 292     liveins: $rdi
 293   ; CHECK: name: memory_offset
 294   ; CHECK:      $xmm0 = MOVAPSrm $rdi, 1, $noreg, 0, $noreg :: (load (s128) from %ir.vec)
 295   ; CHECK-NEXT: $xmm1 = MOVAPSrm $rdi, 1, $noreg, 16, $noreg :: (load (s128) from %ir.vec + 16)
 296   ; CHECK:      MOVAPSmr $rdi, 1, $noreg, 0, $noreg, killed $xmm0 :: (store (s128) into %ir.vec)
 297   ; CHECK-NEXT: MOVAPSmr killed $rdi, 1, $noreg, 16, $noreg, killed $xmm1 :: (store (s128) into %ir.vec + 16)
 298     $xmm0 = MOVAPSrm $rdi, 1, _, 0, _ :: (load (s128) from %ir.vec)
 299     $xmm1 = MOVAPSrm $rdi, 1, _, 16, _ :: (load (s128) from %ir.vec + 16)
 300     $xmm2 = FsFLD0SS
 301     $xmm1 = MOVSSrr killed $xmm1, killed $xmm2
 302     MOVAPSmr $rdi, 1, _, 0, _, killed $xmm0 :: (store (s128) into %ir.vec)
 303     MOVAPSmr killed $rdi, 1, _, 16, _, killed $xmm1 :: (store (s128) into %ir.vec + 16)
 304     RET64
 305 ...
 306 ---
 307 name:            memory_alignment
 308 tracksRegLiveness: true
 309 liveins:
 310   - { reg: '$rdi' }
 311 body: |
 312   bb.0.entry:
 313     liveins: $rdi
 314   ; CHECK: name: memory_alignment
 315   ; CHECK:      $xmm0 = MOVAPSrm $rdi, 1, $noreg, 0, $noreg :: (load (s128) from %ir.vec, align 64)
 316   ; CHECK-NEXT: $xmm1 = MOVAPSrm $rdi, 1, $noreg, 16, $noreg :: (load (s128) from %ir.vec + 16, basealign 64)
 317   ; CHECK-NEXT: $xmm2 = MOVAPSrm $rdi, 1, $noreg, 32, $noreg :: (load (s128) from %ir.vec + 32, align 32, basealign 64)
 318   ; CHECK-NEXT: $xmm3 = MOVAPSrm $rdi, 1, $noreg, 48, $noreg :: (load (s128) from %ir.vec + 48, basealign 64)
 319   ; CHECK:      MOVAPSmr $rdi, 1, $noreg, 0, $noreg, killed $xmm0 :: (store (s128) into %ir.vec, align 64)
 320   ; CHECK-NEXT: MOVAPSmr $rdi, 1, $noreg, 16, $noreg, killed $xmm1 :: (store (s128) into %ir.vec + 16, basealign 64)
 321   ; CHECK-NEXT: MOVAPSmr $rdi, 1, $noreg, 32, $noreg, killed $xmm2 :: (store (s128) into %ir.vec + 32, align 32, basealign 64)
 322   ; CHECK-NEXT: MOVAPSmr killed $rdi, 1, $noreg, 48, $noreg, killed $xmm3 :: (store (s128) into %ir.vec + 48, basealign 64)
 323     $xmm0 = MOVAPSrm $rdi, 1, _, 0, _ :: (load (s128) from %ir.vec, align 64)
 324     $xmm1 = MOVAPSrm $rdi, 1, _, 16, _ :: (load (s128) from %ir.vec + 16, basealign 64)
 325     $xmm2 = MOVAPSrm $rdi, 1, _, 32, _ :: (load (s128) from %ir.vec + 32, align 32, basealign 64)
 326     $xmm3 = MOVAPSrm $rdi, 1, _, 48, _ :: (load (s128) from %ir.vec + 48, basealign 64)
 327     $xmm4 = FsFLD0SS
 328     $xmm1 = MOVSSrr killed $xmm1, killed $xmm4
 329     MOVAPSmr $rdi, 1, _, 0, _, killed $xmm0 :: (store (s128) into %ir.vec, align 64)
 330     MOVAPSmr $rdi, 1, _, 16, _, killed $xmm1 :: (store (s128) into %ir.vec + 16, basealign 64)
 331     MOVAPSmr $rdi, 1, _, 32, _, killed $xmm2 :: (store (s128) into %ir.vec + 32, align 32, basealign 64)
 332     MOVAPSmr killed $rdi, 1, _, 48, _, killed $xmm3 :: (store (s128) into %ir.vec + 48, basealign 64)
 333     RET64
 334 ...
 335 ---
 336 name:            constant_pool_psv
 337 tracksRegLiveness: true
 338 liveins:
 339   - { reg: '$xmm0' }
 340 constants:
 341   - id:          0
 342     value:       'double 3.250000e+00'
 343 body: |
 344   bb.0.entry:
 345     liveins: $xmm0
 346   ; CHECK: name: constant_pool_psv
 347   ; CHECK:      $xmm0 = ADDSDrm killed $xmm0, $rip, 1, $noreg, %const.0, $noreg, implicit $mxcsr :: (load (s64) from constant-pool)
 348   ; CHECK-NEXT: $xmm0 = ADDSDrm killed $xmm0, $rip, 1, $noreg, %const.0, $noreg, implicit $mxcsr :: (load (s64) from constant-pool + 8)
 349     $xmm0 = ADDSDrm killed $xmm0, $rip, 1, _, %const.0, _, implicit $mxcsr :: (load (s64) from constant-pool)
 350     $xmm0 = ADDSDrm killed $xmm0, $rip, 1, _, %const.0, _, implicit $mxcsr :: (load (s64) from constant-pool + 8)
 351     RET64 $xmm0
 352 ...
 353 ---
 354 name:            stack_psv
 355 tracksRegLiveness: true
 356 frameInfo:
 357   stackSize:       24
 358   maxAlignment:    16
 359   adjustsStack:    true
 360   hasCalls:        true
 361   maxCallFrameSize: 16
 362 fixedStack:
 363   - { id: 0, offset: 0, size: 10, alignment: 16, isImmutable: true, isAliased: false }
 364 body: |
 365   bb.0.entry:
 366     $rsp = frame-setup SUB64ri8 $rsp, 24, implicit-def dead $eflags
 367     CFI_INSTRUCTION def_cfa_offset 32
 368     LD_F80m $rsp, 1, $noreg, 32, $noreg, implicit-def dead $fpsw, implicit $fpcw
 369   ; CHECK: name: stack_psv
 370   ; CHECK: ST_FP80m $rsp, 1, $noreg, 0, $noreg, implicit-def dead $fpsw, implicit $fpcw :: (store (s80) into stack, align 16)
 371     ST_FP80m $rsp, 1, _, 0, _, implicit-def dead $fpsw, implicit $fpcw :: (store (s80) into stack, align 16)
 372     CALL64pcrel32 &cosl, csr_64, implicit $rsp, implicit-def $rsp, implicit-def $fp0
 373     $rsp = ADD64ri8 $rsp, 24, implicit-def dead $eflags
 374     RET64
 375 ...
 376 ---
 377 name:            got_psv
 378 tracksRegLiveness: true
 379 body: |
 380   bb.0.entry:
 381   ; CHECK: name: got_psv
 382   ; CHECK: $rax = MOV64rm $rip, 1, $noreg, @G, $noreg :: (load (s64) from got)
 383     $rax = MOV64rm $rip, 1, _, @G, _ :: (load (s64) from got)
 384     $eax = MOV32rm killed $rax, 1, _, 0, _
 385     $eax = INC32r killed $eax, implicit-def dead $eflags
 386     RET64 $eax
 387 ...
 388 ---
 389 name:            global_value
 390 tracksRegLiveness: true
 391 body: |
 392   bb.0.entry:
 393     $rax = MOV64rm $rip, 1, _, @G, _
 394   ; CHECK-LABEL: name: global_value
 395   ; CHECK: $eax = MOV32rm killed $rax, 1, $noreg, 0, $noreg, implicit-def $rax :: (load (s32) from @G)
 396   ; CHECK: $ecx = MOV32rm killed $rcx, 1, $noreg, 0, $noreg, implicit-def $rcx :: (load (s32) from @0)
 397     $eax = MOV32rm killed $rax, 1, _, 0, _, implicit-def $rax :: (load (s32) from @G)
 398     $rcx = MOV64rm $rip, 1, _, @0, _
 399     $ecx = MOV32rm killed $rcx, 1, _, 0, _, implicit-def $rcx :: (load (s32) from @0)
 400     $eax = LEA64_32r killed $rax, 1, killed $rcx, 1, _
 401     RET64 $eax
 402 ...
 403 ---
 404 name:            jumptable_psv
 405 tracksRegLiveness: true
 406 liveins:
 407   - { reg: '$edi' }
 408 jumpTable:
 409   kind:          label-difference32
 410   entries:
 411     - id:        0
 412       blocks:    [ '%bb.3.lbl1', '%bb.4.lbl2', '%bb.5.lbl3', '%bb.6.lbl4' ]
 413 body: |
 414   bb.0.entry:
 415     successors: %bb.2.def, %bb.1.entry
 416     liveins: $edi
 417
 418     $eax = MOV32rr $edi, implicit-def $rax
 419     CMP32ri8 killed $edi, 3, implicit-def $eflags
 420     JCC_1 %bb.2.def, 7, implicit killed $eflags
 421
 422   bb.1.entry:
 423     successors: %bb.3.lbl1, %bb.4.lbl2, %bb.5.lbl3, %bb.6.lbl4
 424     liveins: $rax
 425
 426     $rcx = LEA64r $rip, 1, _, %jump-table.0, _
 427   ; CHECK: name: jumptable_psv
 428   ; CHECK: $rax = MOVSX64rm32 $rcx, 4, killed $rax, 0, $noreg :: (load (s32) from jump-table, align 8)
 429     $rax = MOVSX64rm32 $rcx, 4, killed $rax, 0, _ :: (load (s32) from jump-table, align 8)
 430     $rax = ADD64rr killed $rax, killed $rcx, implicit-def dead $eflags
 431     JMP64r killed $rax
 432
 433   bb.2.def:
 434     $eax = MOV32r0 implicit-def dead $eflags
 435     RET64 $eax
 436
 437   bb.3.lbl1:
 438     $eax = MOV32ri 1
 439     RET64 $eax
 440
 441   bb.4.lbl2:
 442     $eax = MOV32ri 2
 443     RET64 $eax
 444
 445   bb.5.lbl3:
 446     $eax = MOV32ri 4
 447     RET64 $eax
 448
 449   bb.6.lbl4:
 450     $eax = MOV32ri 8
 451     RET64 $eax
 452 ...
 453 ---
 454 name:            tbaa_metadata
 455 tracksRegLiveness: true
 456 body: |
 457   bb.0.entry:
 458     $rax = MOV64rm $rip, 1, _, @a, _ :: (load (s64) from got)
 459   ; CHECK-LABEL: name: tbaa_metadata
 460   ; CHECK:      $eax = MOV32rm killed $rax, 1, $noreg, 0, $noreg, implicit-def $rax :: (load (s32) from @a, !tbaa !2)
 461   ; CHECK-NEXT: $eax = MOV32rm killed $rax, 1, $noreg, 0, $noreg :: (load (s32) from %ir.1, !tbaa !6)
 462     $eax = MOV32rm killed $rax, 1, _, 0, _, implicit-def $rax :: (load (s32) from @a, !tbaa !2)
 463     $eax = MOV32rm killed $rax, 1, _, 0, _ :: (load (s32) from %ir.1, !tbaa !6)
 464     RET64 $eax
 465 ...
 466 ---
 467 name:            aa_scope
 468 tracksRegLiveness: true
 469 liveins:
 470   - { reg: '$rdi' }
 471   - { reg: '$rsi' }
 472 body: |
 473   bb.0.entry:
 474     liveins: $rdi, $rsi
 475   ; CHECK-LABEL: name: aa_scope
 476   ; CHECK: $xmm0 = MOVSSrm_alt $rsi, 1, $noreg, 0, $noreg :: (load (s32) from %ir.c, !alias.scope !9)
 477     $xmm0 = MOVSSrm_alt $rsi, 1, _, 0, _ :: (load (s32) from %ir.c, !alias.scope !9)
 478   ; CHECK-NEXT: MOVSSmr $rdi, 1, $noreg, 20, $noreg, killed $xmm0 :: (store (s32) into %ir.arrayidx.i, !noalias !9)
 479     MOVSSmr $rdi, 1, _, 20, _, killed $xmm0 :: (store (s32) into %ir.arrayidx.i, !noalias !9)
 480     $xmm0 = MOVSSrm_alt killed $rsi, 1, _, 0, _ :: (load (s32) from %ir.c)
 481     MOVSSmr killed $rdi, 1, _, 28, _, killed $xmm0 :: (store (s32) into %ir.arrayidx)
 482     RET64
 483 ...
 484 ---
 485 name:            range_metadata
 486 tracksRegLiveness: true
 487 liveins:
 488   - { reg: '$rdi' }
 489 body: |
 490   bb.0.entry:
 491     liveins: $rdi
 492   ; CHECK-LABEL: name: range_metadata
 493   ; CHECK: $al = MOV8rm killed $rdi, 1, $noreg, 0, $noreg :: (load (s8) from %ir.x, !range !11)
 494     $al = MOV8rm killed $rdi, 1, _, 0, _ :: (load (s8) from %ir.x, !range !11)
 495     RET64 $al
 496 ...
 497 ---
 498 name:            gep_value
 499 tracksRegLiveness: true
 500 liveins:
 501   - { reg: '$rdi' }
 502 body: |
 503   bb.0.entry:
 504     liveins: $rdi
 505
 506     $rax = MOV64rm $rip, 1, _, @values, _ :: (load (s64) from got)
 507   ; CHECK-LABEL: gep_value
 508   ; CHECK: MOV32mr killed $rax, 1, $noreg, 0, $noreg, $edi, implicit killed $rdi :: (store (s32) into @values, align 16)
 509     MOV32mr killed $rax, 1, _, 0, _, $edi, implicit killed $rdi :: (store (s32) into @values, align 16)
 510     RET64
 511 ...
 512 ---
 513 name:            undef_value
 514 tracksRegLiveness: true
 515 body: |
 516   bb.0.entry:
 517   ; CHECK-LABEL: name: undef_value
 518   ; CHECK: $rax = MOV64rm undef $rax, 1, $noreg, 0, $noreg :: (load (s64) from `ptr undef`)
 519     $rax = MOV64rm undef $rax, 1, _, 0, _ :: (load (s64) from `ptr undef`)
 520     RET64 $rax
 521 ...
 522 ---
 523 # Test memory operand without associated value.
 524 # CHECK-LABEL: name: dummy0
 525 # CHECK: $rax = MOV64rm undef $rax, 1, $noreg, 0, $noreg :: (load (s64))
 526 name: dummy0
 527 tracksRegLiveness: true
 528 body: |
 529   bb.0:
 530     $rax = MOV64rm undef $rax, 1, _, 0, _ :: (load (s64))
 531     RET64 $rax
 532 ...
 533 ---
 534 # Test parsing of stack references in machine memory operands.
 535 # CHECK-LABEL: name: dummy1
 536 # CHECK: $rax = MOV64rm $rsp, 1, $noreg, 0, $noreg :: (load (s64) from %stack.0)
 537 name: dummy1
 538 tracksRegLiveness: true
 539 stack:
 540   - { id: 0, size: 4, alignment: 4 }
 541 body: |
 542   bb.0:
 543     $rax = MOV64rm $rsp, 1, _, 0, _ :: (load (s64) from %stack.0)
 544     RET64 $rax
 545 ...
 546 ---
 547 # Test parsing of unknown size in machine memory operands without alignment.
 548 # CHECK-LABEL: name: dummy2
 549 # CHECK: $rax = MOV64rm $rsp, 1, $noreg, 0, $noreg :: (load unknown-size from %stack.0, align 1)
 550 name: dummy2
 551 tracksRegLiveness: true
 552 stack:
 553   - { id: 0, size: 4, alignment: 4 }
 554 body: |
 555   bb.0:
 556     $rax = MOV64rm $rsp, 1, _, 0, _ :: (load unknown-size from %stack.0)
 557     RET64 $rax
 558 ...
 559 ---
 560 # Test parsing of unknown size in machine memory operands with alignment.
 561 # CHECK-LABEL: name: dummy3
 562 # CHECK: $rax = MOV64rm $rsp, 1, $noreg, 0, $noreg :: (load unknown-size from %stack.0, align 4)
 563 name: dummy3
 564 tracksRegLiveness: true
 565 stack:
 566   - { id: 0, size: 4, alignment: 4 }
 567 body: |
 568   bb.0:
 569     $rax = MOV64rm $rsp, 1, _, 0, _ :: (load unknown-size from %stack.0, align 4)
 570     RET64 $rax
 571 ...