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(i32* %a) {
   8   entry:
   9     %b = load i32, i32* %a
  10     store i32 42, i32* %a
  11     ret i32 %b
  12   }
  13
  14   define void @test2(i32* %"a value") {
  15   entry2:
  16     %b = load i32, i32* %"a value"
  17     %c = add i32 %b, 1
  18     store i32 %c, i32* %"a value"
  19     ret void
  20   }
  21
  22   define void @test3(i32*) {
  23   entry3:
  24     %1 = alloca i32
  25     %b = load i32, i32* %0
  26     %c = add i32 %b, 1
  27     store i32 %c, i32* %1
  28     ret void
  29   }
  30
  31   define i32 @volatile_inc(i32* %x) {
  32   entry:
  33     %0 = load volatile i32, i32* %x
  34     %1 = add i32 %0, 1
  35     store volatile i32 %1, i32* %x
  36     ret i32 %1
  37   }
  38
  39   define void @non_temporal_store(i32* %a, i32 %b) {
  40   entry:
  41     store i32 %b, i32* %a, align 16, !nontemporal !0
  42     ret void
  43   }
  44
  45   !0 = !{i32 1}
  46
  47   define i32 @invariant_load(i32* %x) {
  48   entry:
  49     %v = load i32, i32* %x, !invariant.load !1
  50     ret i32 %v
  51   }
  52
  53   !1 = !{}
  54
  55   define void @memory_offset(<8 x float>* %vec) {
  56   entry:
  57     %v = load <8 x float>, <8 x float>* %vec
  58     %v2 = insertelement <8 x float> %v, float 0.0, i32 4
  59     store <8 x float> %v2, <8 x float>* %vec
  60     ret void
  61   }
  62
  63   define void @memory_alignment(<8 x float>* %vec) {
  64   entry:
  65     %v = load <8 x float>, <8 x float>* %vec
  66     %v2 = insertelement <8 x float> %v, float 0.0, i32 4
  67     store <8 x float> %v2, <8 x float>* %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, i32* @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, i32* @G
 101     %b = add i32 %a, 1
 102     %c = load i32, i32* @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, i32* @a, align 4, !tbaa !2
 134     %1 = inttoptr i32 %0 to %struct.XXH_state64_t*
 135     %total_len2 = bitcast %struct.XXH_state64_t* %1 to i32*
 136     %2 = load i32, i32* %total_len2, align 4, !tbaa !6
 137     ret i32 %2
 138   }
 139
 140   !2 = !{!3, !3, i64 0}
 141   !3 = !{!"int", !4, i64 0}
 142   !4 = !{!"omnipotent char", !5, i64 0}
 143   !5 = !{!"Simple C/C++ TBAA"}
 144   !6 = !{!7, !3, i64 0}
 145   !7 = !{!"XXH_state64_t", !3, i64 0, !3, i64 4, !8, i64 8, !8, i64 16, !8, i64 24}
 146   !8 = !{!"long long", !4, i64 0}
 147
 148   define void @aa_scope(float* nocapture %a, float* nocapture readonly %c) #1 {
 149   entry:
 150     %0 = load float, float* %c, align 4, !alias.scope !9
 151     %arrayidx.i = getelementptr inbounds float, float* %a, i64 5
 152     store float %0, float* %arrayidx.i, align 4, !noalias !9
 153     %1 = load float, float* %c, align 4
 154     %arrayidx = getelementptr inbounds float, float* %a, i64 7
 155     store float %1, float* %arrayidx, align 4
 156     ret void
 157   }
 158
 159   attributes #1 = { nounwind uwtable }
 160
 161   !9 = distinct !{!9, !10, !"some scope"}
 162   !10 = distinct !{!10, !"some domain"}
 163
 164   define zeroext i1 @range_metadata(i8* %x) {
 165   entry:
 166     %0 = load i8, i8* %x, align 1, !range !11
 167     %tobool = trunc i8 %0 to i1
 168     ret i1 %tobool
 169   }
 170
 171   !11 = !{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, i32* getelementptr inbounds ([50 x %st], [50 x %st]* @values, i64 0, i64 0, i32 0), align 16
 181     ret void
 182   }
 183
 184   define i8* @undef_value() {
 185   entry:
 186     %0 = load i8*, i8** undef, align 8
 187     ret i8* %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 4 from %ir.a)
 204   ; CHECK-NEXT: MOV32mi killed $rdi, 1, $noreg, 0, $noreg, 42 :: (store 4 into %ir.a)
 205     $eax = MOV32rm $rdi, 1, _, 0, _ :: (load 4 from %ir.a)
 206     MOV32mi killed $rdi, 1, _, 0, _, 42 :: (store 4 into %ir.a)
 207     RETQ $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 4 into %ir."a value"), (load 4 from %ir."a value")
 218     INC32m killed $rdi, 1, _, 0, _, implicit-def dead $eflags :: (store 4 into %ir."a value"), (load 4 from %ir."a value")
 219     RETQ
 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 4 from %ir.0)
 236   ; CHECK: MOV32mr $rsp, 1, $noreg, -4, $noreg, killed $eax :: (store 4 into %ir.1)
 237     $eax = MOV32rm killed $rdi, 1, _, 0, _ :: (load 4 from %ir.0)
 238     $eax = INC32r killed $eax, implicit-def dead $eflags
 239     MOV32mr $rsp, 1, _, -4, _, killed $eax :: (store 4 into %ir.1)
 240     RETQ
 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 4 from %ir.x)
 252     ; CHECK: MOV32mr killed $rdi, 1, $noreg, 0, $noreg, $eax :: (volatile store 4 into %ir.x)
 253     $eax = MOV32rm $rdi, 1, _, 0, _ :: (volatile load 4 from %ir.x)
 254     $eax = INC32r killed $eax, implicit-def dead $eflags
 255     MOV32mr killed $rdi, 1, _, 0, _, $eax :: (volatile store 4 into %ir.x)
 256     RETQ $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 4 into %ir.a)
 269     MOVNTImr killed $rdi, 1, _, 0, _, killed $esi :: (non-temporal store 4 into %ir.a)
 270     RETQ
 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 4 from %ir.x)
 282     $eax = MOV32rm killed $rdi, 1, _, 0, _ :: (invariant load 4 from %ir.x)
 283     RETQ $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 16 from %ir.vec)
 295   ; CHECK-NEXT: $xmm1 = MOVAPSrm $rdi, 1, $noreg, 16, $noreg :: (load 16 from %ir.vec + 16)
 296   ; CHECK:      MOVAPSmr $rdi, 1, $noreg, 0, $noreg, killed $xmm0 :: (store 16 into %ir.vec)
 297   ; CHECK-NEXT: MOVAPSmr killed $rdi, 1, $noreg, 16, $noreg, killed $xmm1 :: (store 16 into %ir.vec + 16)
 298     $xmm0 = MOVAPSrm $rdi, 1, _, 0, _ :: (load 16 from %ir.vec)
 299     $xmm1 = MOVAPSrm $rdi, 1, _, 16, _ :: (load 16 from %ir.vec + 16)
 300     $xmm2 = FsFLD0SS
 301     $xmm1 = MOVSSrr killed $xmm1, killed $xmm2
 302     MOVAPSmr $rdi, 1, _, 0, _, killed $xmm0 :: (store 16 into %ir.vec)
 303     MOVAPSmr killed $rdi, 1, _, 16, _, killed $xmm1 :: (store 16 into %ir.vec + 16)
 304     RETQ
 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 16 from %ir.vec, align 32)
 316   ; CHECK-NEXT: $xmm1 = MOVAPSrm $rdi, 1, $noreg, 16, $noreg :: (load 16 from %ir.vec + 16, align 32)
 317   ; CHECK:      MOVAPSmr $rdi, 1, $noreg, 0, $noreg, killed $xmm0 :: (store 16 into %ir.vec, align 32)
 318   ; CHECK-NEXT: MOVAPSmr killed $rdi, 1, $noreg, 16, $noreg, killed $xmm1 :: (store 16 into %ir.vec + 16, align 32)
 319     $xmm0 = MOVAPSrm $rdi, 1, _, 0, _ :: (load 16 from %ir.vec, align 32)
 320     $xmm1 = MOVAPSrm $rdi, 1, _, 16, _ :: (load 16 from %ir.vec + 16, align 32)
 321     $xmm2 = FsFLD0SS
 322     $xmm1 = MOVSSrr killed $xmm1, killed $xmm2
 323     MOVAPSmr $rdi, 1, _, 0, _, killed $xmm0 :: (store 16 into %ir.vec, align 32)
 324     MOVAPSmr killed $rdi, 1, _, 16, _, killed $xmm1 :: (store 16 into %ir.vec + 16, align 32)
 325     RETQ
 326 ...
 327 ---
 328 name:            constant_pool_psv
 329 tracksRegLiveness: true
 330 liveins:
 331   - { reg: '$xmm0' }
 332 constants:
 333   - id:          0
 334     value:       'double 3.250000e+00'
 335 body: |
 336   bb.0.entry:
 337     liveins: $xmm0
 338   ; CHECK: name: constant_pool_psv
 339   ; CHECK:      $xmm0 = ADDSDrm killed $xmm0, $rip, 1, $noreg, %const.0, $noreg :: (load 8 from constant-pool)
 340   ; CHECK-NEXT: $xmm0 = ADDSDrm killed $xmm0, $rip, 1, $noreg, %const.0, $noreg :: (load 8 from constant-pool + 8)
 341     $xmm0 = ADDSDrm killed $xmm0, $rip, 1, _, %const.0, _ :: (load 8 from constant-pool)
 342     $xmm0 = ADDSDrm killed $xmm0, $rip, 1, _, %const.0, _ :: (load 8 from constant-pool + 8)
 343     RETQ $xmm0
 344 ...
 345 ---
 346 name:            stack_psv
 347 tracksRegLiveness: true
 348 frameInfo:
 349   stackSize:       24
 350   maxAlignment:    16
 351   adjustsStack:    true
 352   hasCalls:        true
 353   maxCallFrameSize: 16
 354 fixedStack:
 355   - { id: 0, offset: 0, size: 10, alignment: 16, isImmutable: true, isAliased: false }
 356 body: |
 357   bb.0.entry:
 358     $rsp = frame-setup SUB64ri8 $rsp, 24, implicit-def dead $eflags
 359     CFI_INSTRUCTION def_cfa_offset 32
 360     LD_F80m $rsp, 1, $noreg, 32, $noreg, implicit-def dead $fpsw, implicit $fpcw
 361   ; CHECK: name: stack_psv
 362   ; CHECK: ST_FP80m $rsp, 1, $noreg, 0, $noreg, implicit-def dead $fpsw, implicit $fpcw :: (store 10 into stack, align 16)
 363     ST_FP80m $rsp, 1, _, 0, _, implicit-def dead $fpsw, implicit $fpcw :: (store 10 into stack, align 16)
 364     CALL64pcrel32 &cosl, csr_64, implicit $rsp, implicit-def $rsp, implicit-def $fp0
 365     $rsp = ADD64ri8 $rsp, 24, implicit-def dead $eflags
 366     RETQ
 367 ...
 368 ---
 369 name:            got_psv
 370 tracksRegLiveness: true
 371 body: |
 372   bb.0.entry:
 373   ; CHECK: name: got_psv
 374   ; CHECK: $rax = MOV64rm $rip, 1, $noreg, @G, $noreg :: (load 8 from got)
 375     $rax = MOV64rm $rip, 1, _, @G, _ :: (load 8 from got)
 376     $eax = MOV32rm killed $rax, 1, _, 0, _
 377     $eax = INC32r killed $eax, implicit-def dead $eflags
 378     RETQ $eax
 379 ...
 380 ---
 381 name:            global_value
 382 tracksRegLiveness: true
 383 body: |
 384   bb.0.entry:
 385     $rax = MOV64rm $rip, 1, _, @G, _
 386   ; CHECK-LABEL: name: global_value
 387   ; CHECK: $eax = MOV32rm killed $rax, 1, $noreg, 0, $noreg, implicit-def $rax :: (load 4 from @G)
 388   ; CHECK: $ecx = MOV32rm killed $rcx, 1, $noreg, 0, $noreg, implicit-def $rcx :: (load 4 from @0)
 389     $eax = MOV32rm killed $rax, 1, _, 0, _, implicit-def $rax :: (load 4 from @G)
 390     $rcx = MOV64rm $rip, 1, _, @0, _
 391     $ecx = MOV32rm killed $rcx, 1, _, 0, _, implicit-def $rcx :: (load 4 from @0)
 392     $eax = LEA64_32r killed $rax, 1, killed $rcx, 1, _
 393     RETQ $eax
 394 ...
 395 ---
 396 name:            jumptable_psv
 397 tracksRegLiveness: true
 398 liveins:
 399   - { reg: '$edi' }
 400 jumpTable:
 401   kind:          label-difference32
 402   entries:
 403     - id:        0
 404       blocks:    [ '%bb.3.lbl1', '%bb.4.lbl2', '%bb.5.lbl3', '%bb.6.lbl4' ]
 405 body: |
 406   bb.0.entry:
 407     successors: %bb.2.def, %bb.1.entry
 408     liveins: $edi
 409
 410     $eax = MOV32rr $edi, implicit-def $rax
 411     CMP32ri8 killed $edi, 3, implicit-def $eflags
 412     JCC_1 %bb.2.def, 7, implicit killed $eflags
 413
 414   bb.1.entry:
 415     successors: %bb.3.lbl1, %bb.4.lbl2, %bb.5.lbl3, %bb.6.lbl4
 416     liveins: $rax
 417
 418     $rcx = LEA64r $rip, 1, _, %jump-table.0, _
 419   ; CHECK: name: jumptable_psv
 420   ; CHECK: $rax = MOVSX64rm32 $rcx, 4, killed $rax, 0, $noreg :: (load 4 from jump-table, align 8)
 421     $rax = MOVSX64rm32 $rcx, 4, killed $rax, 0, _ :: (load 4 from jump-table, align 8)
 422     $rax = ADD64rr killed $rax, killed $rcx, implicit-def dead $eflags
 423     JMP64r killed $rax
 424
 425   bb.2.def:
 426     $eax = MOV32r0 implicit-def dead $eflags
 427     RETQ $eax
 428
 429   bb.3.lbl1:
 430     $eax = MOV32ri 1
 431     RETQ $eax
 432
 433   bb.4.lbl2:
 434     $eax = MOV32ri 2
 435     RETQ $eax
 436
 437   bb.5.lbl3:
 438     $eax = MOV32ri 4
 439     RETQ $eax
 440
 441   bb.6.lbl4:
 442     $eax = MOV32ri 8
 443     RETQ $eax
 444 ...
 445 ---
 446 name:            tbaa_metadata
 447 tracksRegLiveness: true
 448 body: |
 449   bb.0.entry:
 450     $rax = MOV64rm $rip, 1, _, @a, _ :: (load 8 from got)
 451   ; CHECK-LABEL: name: tbaa_metadata
 452   ; CHECK:      $eax = MOV32rm killed $rax, 1, $noreg, 0, $noreg, implicit-def $rax :: (load 4 from @a, !tbaa !2)
 453   ; CHECK-NEXT: $eax = MOV32rm killed $rax, 1, $noreg, 0, $noreg :: (load 4 from %ir.total_len2, !tbaa !6)
 454     $eax = MOV32rm killed $rax, 1, _, 0, _, implicit-def $rax :: (load 4 from @a, !tbaa !2)
 455     $eax = MOV32rm killed $rax, 1, _, 0, _ :: (load 4 from %ir.total_len2, !tbaa !6)
 456     RETQ $eax
 457 ...
 458 ---
 459 name:            aa_scope
 460 tracksRegLiveness: true
 461 liveins:
 462   - { reg: '$rdi' }
 463   - { reg: '$rsi' }
 464 body: |
 465   bb.0.entry:
 466     liveins: $rdi, $rsi
 467   ; CHECK-LABEL: name: aa_scope
 468   ; CHECK: $xmm0 = MOVSSrm_alt $rsi, 1, $noreg, 0, $noreg :: (load 4 from %ir.c, !alias.scope !9)
 469     $xmm0 = MOVSSrm_alt $rsi, 1, _, 0, _ :: (load 4 from %ir.c, !alias.scope !9)
 470   ; CHECK-NEXT: MOVSSmr $rdi, 1, $noreg, 20, $noreg, killed $xmm0 :: (store 4 into %ir.arrayidx.i, !noalias !9)
 471     MOVSSmr $rdi, 1, _, 20, _, killed $xmm0 :: (store 4 into %ir.arrayidx.i, !noalias !9)
 472     $xmm0 = MOVSSrm_alt killed $rsi, 1, _, 0, _ :: (load 4 from %ir.c)
 473     MOVSSmr killed $rdi, 1, _, 28, _, killed $xmm0 :: (store 4 into %ir.arrayidx)
 474     RETQ
 475 ...
 476 ---
 477 name:            range_metadata
 478 tracksRegLiveness: true
 479 liveins:
 480   - { reg: '$rdi' }
 481 body: |
 482   bb.0.entry:
 483     liveins: $rdi
 484   ; CHECK-LABEL: name: range_metadata
 485   ; CHECK: $al = MOV8rm killed $rdi, 1, $noreg, 0, $noreg :: (load 1 from %ir.x, !range !11)
 486     $al = MOV8rm killed $rdi, 1, _, 0, _ :: (load 1 from %ir.x, !range !11)
 487     RETQ $al
 488 ...
 489 ---
 490 name:            gep_value
 491 tracksRegLiveness: true
 492 liveins:
 493   - { reg: '$rdi' }
 494 body: |
 495   bb.0.entry:
 496     liveins: $rdi
 497
 498     $rax = MOV64rm $rip, 1, _, @values, _ :: (load 8 from got)
 499   ; CHECK-LABEL: gep_value
 500   ; CHECK: MOV32mr killed $rax, 1, $noreg, 0, $noreg, $edi, implicit killed $rdi :: (store 4 into `i32* getelementptr inbounds ([50 x %st], [50 x %st]* @values, i64 0, i64 0, i32 0)`, align 16)
 501     MOV32mr killed $rax, 1, _, 0, _, $edi, implicit killed $rdi :: (store 4 into `i32* getelementptr inbounds ([50 x %st], [50 x %st]* @values, i64 0, i64 0, i32 0)`, align 16)
 502     RETQ
 503 ...
 504 ---
 505 name:            undef_value
 506 tracksRegLiveness: true
 507 body: |
 508   bb.0.entry:
 509   ; CHECK-LABEL: name: undef_value
 510   ; CHECK: $rax = MOV64rm undef $rax, 1, $noreg, 0, $noreg :: (load 8 from `i8** undef`)
 511     $rax = MOV64rm undef $rax, 1, _, 0, _ :: (load 8 from `i8** undef`)
 512     RETQ $rax
 513 ...
 514 ---
 515 # Test memory operand without associated value.
 516 # CHECK-LABEL: name: dummy0
 517 # CHECK: $rax = MOV64rm undef $rax, 1, $noreg, 0, $noreg :: (load 8)
 518 name: dummy0
 519 tracksRegLiveness: true
 520 body: |
 521   bb.0:
 522     $rax = MOV64rm undef $rax, 1, _, 0, _ :: (load 8)
 523     RETQ $rax
 524 ...
 525 ---
 526 # Test parsing of stack references in machine memory operands.
 527 # CHECK-LABEL: name: dummy1
 528 # CHECK: $rax = MOV64rm $rsp, 1, $noreg, 0, $noreg :: (load 8 from %stack.0)
 529 name: dummy1
 530 tracksRegLiveness: true
 531 stack:
 532   - { id: 0, size: 4, alignment: 4 }
 533 body: |
 534   bb.0:
 535     $rax = MOV64rm $rsp, 1, _, 0, _ :: (load 8 from %stack.0)
 536     RETQ $rax
 537 ...
 538 ---
 539 # Test parsing of unknown size in machine memory operands without alignment.
 540 # CHECK-LABEL: name: dummy2
 541 # CHECK: $rax = MOV64rm $rsp, 1, $noreg, 0, $noreg :: (load unknown-size from %stack.0, align 1)
 542 name: dummy2
 543 tracksRegLiveness: true
 544 stack:
 545   - { id: 0, size: 4, alignment: 4 }
 546 body: |
 547   bb.0:
 548     $rax = MOV64rm $rsp, 1, _, 0, _ :: (load unknown-size from %stack.0)
 549     RETQ $rax
 550 ...
 551 ---
 552 # Test parsing of unknown size in machine memory operands with alignment.
 553 # CHECK-LABEL: name: dummy3
 554 # CHECK: $rax = MOV64rm $rsp, 1, $noreg, 0, $noreg :: (load unknown-size from %stack.0, align 4)
 555 name: dummy3
 556 tracksRegLiveness: true
 557 stack:
 558   - { id: 0, size: 4, alignment: 4 }
 559 body: |
 560   bb.0:
 561     $rax = MOV64rm $rsp, 1, _, 0, _ :: (load unknown-size from %stack.0, align 4)
 562     RETQ $rax
 563 ...