This is an archive of the discontinued LLVM Phabricator instance.

Differential D101563

[lldb] [test] Extend aarch64-gp-read test to cover all registers
Needs RevisionPublic

Authored by mgorny on Apr 29 2021, 12:54 PM.

Details

Reviewers
labath
emaste
krytarowski
mstorsjo
Summary

Extend the general-purpose/vector register test for AArch64 to test
all regular registers rather than just the first eight. While this
might seem redundant, we've historically had a bug in reading a single
registers due to a typo.

While at it, use a single array of values for the test. I have
permitted myself to use a different values that were relatively easy
to generate via the following script:

for x in range(32):
    print('    { ', end='')
    for y in range(2):
        print('0x', end='')
        for z in range(8):
            print('%02X' % (x+(1-y)*8+z), end='')
        if y == 0:
            print(', ', end='')
    print(' },')

x8 is used as the special register to hold the data pointer, as this
is what clang is forcing on my system (and it should use it anyway since
it's the only register not in the clobber list), so it is overwritten
last. x29 (fp) is backed up on the stack. The stack pointer (x31)
is tested via pushing the respective value to the stack and then reading
it rather than modifying it directly.

Diff Detail

Event Timeline

mgorny created this revision.Apr 29 2021, 12:54 PM
Herald added subscribers: danielkiss, kristof.beyls. · View Herald TranscriptApr 29 2021, 12:54 PM
mgorny requested review of this revision.Apr 29 2021, 12:54 PM
Harbormaster completed remote builds in B101711: Diff 341613.Apr 29 2021, 2:23 PM
mstorsjo added inline comments.May 3 2021, 3:46 AM
lldb/test/Shell/Register/Inputs/aarch64-gp-read.cpp
57

I'm not quite sure what this bit actually tests, with regards to inspecting registers - as it loads a value to a simple register and writes it somewhere else. I guess the thing it tests is expressions involving $sp though?

I guess that's fine but it'd be nice to have it spelled out a bit clearer about the aspect that it actually tests.

67

You're not allowed to clobber x18 on windows (and on darwin, but it's less fatal there).

Building this for windows gives this warning:

<inline asm>:1:1: warning: inline asm clobber list contains reserved registers: X18
        ld1      {v0.2d,  v1.2d,  v2.2d,  v3.2d},  [x8], #64
^^^^^^^^
<inline asm>:1:1: note: Reserved registers on the clobber list may not be preserved across the asm statement, and clobbering them may lead to undefined behaviour.
        ld1      {v0.2d,  v1.2d,  v2.2d,  v3.2d},  [x8], #64
^^^^^^^^

And after overwriting x18, things fail when we try to stop for the breakpoint.

mgorny added inline comments.May 3 2021, 4:10 AM
lldb/test/Shell/Register/Inputs/aarch64-gp-read.cpp
57

It backs up x29 and stores another test value on the stack to test $sp below.

67

Would backing it up on the stack and restoring after the trap work or is it entirely forbidden?

mstorsjo added inline comments.May 3 2021, 4:17 AM
lldb/test/Shell/Register/Inputs/aarch64-gp-read.cpp
57

Sure. Just clarify that this corresponds with the read of an expression relative to $sp in the test script.

67

It's pretty much forbidden - the problem here seems to be that having x18 set to an incorrect value breaks things when hitting the trap. In a straight-line code segment with no external interaction you can have x18 set to something else intermittently, but it must be correct whenever you interact with something else, and traps seem to be a case where it's read by something, somewhere, too.

79

This could just as well be a ldr x29, [sp, #-16] right?

krytarowski accepted this revision.Sep 8 2021, 12:08 AM
This revision is now accepted and ready to land.Sep 8 2021, 12:08 AM
krytarowski requested changes to this revision.Sep 8 2021, 1:12 AM

There is an unhandled comment.

This revision now requires changes to proceed.Sep 8 2021, 1:12 AM

Revision Contents

PathSize
lldb/
test/
Shell/
Register/
Inputs/
94 lines
115 lines

Diff 341613

lldb/test/Shell/Register/Inputs/aarch64-gp-read.cpp

#include <cstdint> #include <cstdint>
struct alignas(16) vec_t { struct alignas(16) vec_t {
uint64_t a, b; uint64_t a, b;
}; };
int main() { int main() {
constexpr uint64_t gprs[] = {
0x0001020304050607,
0x1011121314151617,
0x2021222324252627,
0x3031323334353637,
0x4041424344454647,
0x5051525354555657,
0x6061626364656667,
0x7071727374757677,
};
constexpr vec_t vecs[] = { constexpr vec_t vecs[] = {
{ 0x0F0E0D0C0B0A0908, 0x1716151413121110, }, { 0x08090A0B0C0D0E0F, 0x0001020304050607 },
{ 0x100F0E0D0C0B0A09, 0x1817161514131211, }, { 0x090A0B0C0D0E0F10, 0x0102030405060708 },
{ 0x11100F0E0D0C0B0A, 0x1918171615141312, }, { 0x0A0B0C0D0E0F1011, 0x0203040506070809 },
{ 0x1211100F0E0D0C0B, 0x1A19181716151413, }, { 0x0B0C0D0E0F101112, 0x030405060708090A },
{ 0x131211100F0E0D0C, 0x1B1A191817161514, }, { 0x0C0D0E0F10111213, 0x0405060708090A0B },
{ 0x14131211100F0E0D, 0x1C1B1A1918171615, }, { 0x0D0E0F1011121314, 0x05060708090A0B0C },
{ 0x1514131211100F0E, 0x1D1C1B1A19181716, }, { 0x0E0F101112131415, 0x060708090A0B0C0D },
{ 0x161514131211100F, 0x1E1D1C1B1A191817, }, { 0x0F10111213141516, 0x0708090A0B0C0D0E },
{ 0x1011121314151617, 0x08090A0B0C0D0E0F },
{ 0x1112131415161718, 0x090A0B0C0D0E0F10 },
{ 0x1213141516171819, 0x0A0B0C0D0E0F1011 },
{ 0x131415161718191A, 0x0B0C0D0E0F101112 },
{ 0x1415161718191A1B, 0x0C0D0E0F10111213 },
{ 0x15161718191A1B1C, 0x0D0E0F1011121314 },
{ 0x161718191A1B1C1D, 0x0E0F101112131415 },
{ 0x1718191A1B1C1D1E, 0x0F10111213141516 },
{ 0x18191A1B1C1D1E1F, 0x1011121314151617 },
{ 0x191A1B1C1D1E1F20, 0x1112131415161718 },
{ 0x1A1B1C1D1E1F2021, 0x1213141516171819 },
{ 0x1B1C1D1E1F202122, 0x131415161718191A },
{ 0x1C1D1E1F20212223, 0x1415161718191A1B },
{ 0x1D1E1F2021222324, 0x15161718191A1B1C },
{ 0x1E1F202122232425, 0x161718191A1B1C1D },
{ 0x1F20212223242526, 0x1718191A1B1C1D1E },
{ 0x2021222324252627, 0x18191A1B1C1D1E1F },
{ 0x2122232425262728, 0x191A1B1C1D1E1F20 },
{ 0x2223242526272829, 0x1A1B1C1D1E1F2021 },
{ 0x232425262728292A, 0x1B1C1D1E1F202122 },
{ 0x2425262728292A2B, 0x1C1D1E1F20212223 },
{ 0x25262728292A2B2C, 0x1D1E1F2021222324 },
{ 0x262728292A2B2C2D, 0x1E1F202122232425 },
{ 0x2728292A2B2C2D2E, 0x1F20212223242526 },
}; };
asm volatile( asm volatile(
"ld1 {v0.2d, v1.2d, v2.2d, v3.2d}, [%0], #64\n\t"
"ld1 {v4.2d, v5.2d, v6.2d, v7.2d}, [%0], #64\n\t"
"ld1 {v8.2d, v9.2d, v10.2d, v11.2d}, [%0], #64\n\t"
"ld1 {v12.2d, v13.2d, v14.2d, v15.2d}, [%0], #64\n\t"
"ld1 {v16.2d, v17.2d, v18.2d, v19.2d}, [%0], #64\n\t"
"ld1 {v20.2d, v21.2d, v22.2d, v23.2d}, [%0], #64\n\t"
"ld1 {v24.2d, v25.2d, v26.2d, v27.2d}, [%0], #64\n\t"
"ld1 {v28.2d, v29.2d, v30.2d, v31.2d}, [%0], #64\n\t"
"sub %0, %0, #512\n\t"
"\n\t"
// we can't easily overwrite sp, so put the value on stack instead,
// and back x29 up while at it
"ldr x0, [%0, #248]\n\t"
"stp x29, x0, [sp, #-16]\n\t"
mstorsjoUnsubmitted
Not Done
ReplyInline Actions

I'm not quite sure what this bit actually tests, with regards to inspecting registers - as it loads a value to a simple register and writes it somewhere else. I guess the thing it tests is expressions involving $sp though?

I guess that's fine but it'd be nice to have it spelled out a bit clearer about the aspect that it actually tests.

mstorsjo: I'm not quite sure what this bit actually tests, with regards to inspecting registers - as it…
mgornyAuthorUnsubmitted
Done
ReplyInline Actions

It backs up x29 and stores another test value on the stack to test $sp below.

mgorny: It backs up `x29` and stores another test value on the stack to test `$sp` below.
mstorsjoUnsubmitted
Not Done
ReplyInline Actions

Sure. Just clarify that this corresponds with the read of an expression relative to $sp in the test script.

mstorsjo: Sure. Just clarify that this corresponds with the read of an expression relative to `$sp` in…
"\n\t"
"ldp x0, x1, [%0]\n\t" "ldp x0, x1, [%0]\n\t"
"ldp x2, x3, [%0, #16]\n\t" "ldp x2, x3, [%0, #16]\n\t"
"ldp x4, x5, [%0, #32]\n\t" "ldp x4, x5, [%0, #32]\n\t"
"ldp x6, x7, [%0, #48]\n\t" "ldp x6, x7, [%0, #48]\n\t"
"\n\t" "ldp x10, x11, [%0, #80]\n\t"
"ld1 {v0.2d, v1.2d, v2.2d, v3.2d}, [%1], #64\n\t" "ldp x12, x13, [%0, #96]\n\t"
"ld1 {v4.2d, v5.2d, v6.2d, v7.2d}, [%1], #64\n\t" "ldp x14, x15, [%0, #112]\n\t"
"ldp x16, x17, [%0, #128]\n\t"
"ldp x18, x19, [%0, #144]\n\t"
mstorsjoUnsubmitted
Not Done
ReplyInline Actions

You're not allowed to clobber x18 on windows (and on darwin, but it's less fatal there).

Building this for windows gives this warning:

<inline asm>:1:1: warning: inline asm clobber list contains reserved registers: X18
        ld1      {v0.2d,  v1.2d,  v2.2d,  v3.2d},  [x8], #64
^^^^^^^^
<inline asm>:1:1: note: Reserved registers on the clobber list may not be preserved across the asm statement, and clobbering them may lead to undefined behaviour.
        ld1      {v0.2d,  v1.2d,  v2.2d,  v3.2d},  [x8], #64
^^^^^^^^

And after overwriting x18, things fail when we try to stop for the breakpoint.

mstorsjo: You're not allowed to clobber x18 on windows (and on darwin, but it's less fatal there).
mgornyAuthorUnsubmitted
Done
ReplyInline Actions

Would backing it up on the stack and restoring after the trap work or is it entirely forbidden?

mgorny: Would backing it up on the stack and restoring after the trap work or is it entirely forbidden?
mstorsjoUnsubmitted
Not Done
ReplyInline Actions

It's pretty much forbidden - the problem here seems to be that having x18 set to an incorrect value breaks things when hitting the trap. In a straight-line code segment with no external interaction you can have x18 set to something else intermittently, but it must be correct whenever you interact with something else, and traps seem to be a case where it's read by something, somewhere, too.

mstorsjo: It's pretty much forbidden - the problem here seems to be that having x18 set to an incorrect…
"ldp x20, x21, [%0, #160]\n\t"
"ldp x22, x23, [%0, #176]\n\t"
"ldp x24, x25, [%0, #192]\n\t"
"ldp x26, x27, [%0, #208]\n\t"
"ldp x28, x29, [%0, #224]\n\t"
"ldr x30, [%0, #240]\n\t"
"ldp x8, x9, [%0, #64]\n\t"
"\n\t" "\n\t"
"brk #0\n\t" "brk #0\n\t"
"\n\t"
// restore x29, discard the other value
"ldp x29, xzr, [sp, #-16]\n\t"
mstorsjoUnsubmitted
Not Done
ReplyInline Actions

This could just as well be a ldr x29, [sp, #-16] right?

mstorsjo: This could just as well be a `ldr x29, [sp, #-16]` right?
: :
: "r"(gprs), "r"(vecs) : "r"(vecs)
: "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7", : "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
"v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7" "x9", "x10", "x11", "x12", "x13", "x14", "x15",
"x16", "x17", "x18", "x19", "x20", "x21", "x22",
"x23", "x24", "x25", "x26", "x27", "x28", "x30",
"v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
"v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
"v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
"v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31"
); );
return 0; return 0;
} }

lldb/test/Shell/Register/aarch64-gp-read.test

# REQUIRES: native && target-aarch64 # REQUIRES: native && target-aarch64
# RUN: %clangxx_host -fomit-frame-pointer %p/Inputs/aarch64-gp-read.cpp -o %t # RUN: %clangxx_host -fomit-frame-pointer %p/Inputs/aarch64-gp-read.cpp -o %t
# RUN: %lldb -b -s %s %t | FileCheck %s # RUN: %lldb -b -s %s %t | FileCheck %s
process launch process launch
register read --all register read --all
# CHECK-DAG: x0 = 0x0001020304050607 # CHECK-DAG: x0 = 0x08090a0b0c0d0e0f
# CHECK-DAG: x1 = 0x1011121314151617 # CHECK-DAG: x1 = 0x0001020304050607
# CHECK-DAG: x2 = 0x2021222324252627 # CHECK-DAG: x2 = 0x090a0b0c0d0e0f10
# CHECK-DAG: x3 = 0x3031323334353637 # CHECK-DAG: x3 = 0x0102030405060708
# CHECK-DAG: x4 = 0x4041424344454647 # CHECK-DAG: x4 = 0x0a0b0c0d0e0f1011
# CHECK-DAG: x5 = 0x5051525354555657 # CHECK-DAG: x5 = 0x0203040506070809
# CHECK-DAG: x6 = 0x6061626364656667 # CHECK-DAG: x6 = 0x0b0c0d0e0f101112
# CHECK-DAG: x7 = 0x7071727374757677 # CHECK-DAG: x7 = 0x030405060708090a
# CHECK-DAG: w0 = 0x04050607 # CHECK-DAG: x8 = 0x0c0d0e0f10111213
# CHECK-DAG: x9 = 0x0405060708090a0b
# CHECK-DAG: x10 = 0x0d0e0f1011121314
# CHECK-DAG: x11 = 0x05060708090a0b0c
# CHECK-DAG: x12 = 0x0e0f101112131415
# CHECK-DAG: x13 = 0x060708090a0b0c0d
# CHECK-DAG: x14 = 0x0f10111213141516
# CHECK-DAG: x15 = 0x0708090a0b0c0d0e
# CHECK-DAG: x16 = 0x1011121314151617
# CHECK-DAG: x17 = 0x08090a0b0c0d0e0f
# CHECK-DAG: x18 = 0x1112131415161718
# CHECK-DAG: x19 = 0x090a0b0c0d0e0f10
# CHECK-DAG: x20 = 0x1213141516171819
# CHECK-DAG: x21 = 0x0a0b0c0d0e0f1011
# CHECK-DAG: x22 = 0x131415161718191a
# CHECK-DAG: x23 = 0x0b0c0d0e0f101112
# CHECK-DAG: x24 = 0x1415161718191a1b
# CHECK-DAG: x25 = 0x0c0d0e0f10111213
# CHECK-DAG: x26 = 0x15161718191a1b1c
# CHECK-DAG: x27 = 0x0d0e0f1011121314
# CHECK-DAG: x28 = 0x161718191a1b1c1d
# CHECK-DAG: fp = 0x0e0f101112131415
# CHECK-DAG: lr = 0x1718191a1b1c1d1e
# CHECK-DAG: v0 = {0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f 0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17} # CHECK-DAG: pc = 0x{{[0-9a-f]+}} aarch64-gp-read.test.tmp`main
# CHECK-DAG: v1 = {0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f 0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18}
# CHECK-DAG: v2 = {0x0a 0x0b 0x0c 0x0d 0x0e 0x0f 0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19} # CHECK-DAG: w0 = 0x0c0d0e0f
# CHECK-DAG: v3 = {0x0b 0x0c 0x0d 0x0e 0x0f 0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a} # CHECK-DAG: w1 = 0x04050607
# CHECK-DAG: v4 = {0x0c 0x0d 0x0e 0x0f 0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b} # CHECK-DAG: w2 = 0x0d0e0f10
# CHECK-DAG: v5 = {0x0d 0x0e 0x0f 0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c} # CHECK-DAG: w3 = 0x05060708
# CHECK-DAG: v6 = {0x0e 0x0f 0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d} # CHECK-DAG: w4 = 0x0e0f1011
# CHECK-DAG: v7 = {0x0f 0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e} # CHECK-DAG: w5 = 0x06070809
# CHECK-DAG: w6 = 0x0f101112
# CHECK-DAG: w7 = 0x0708090a
# CHECK-DAG: w8 = 0x10111213
# CHECK-DAG: w9 = 0x08090a0b
# CHECK-DAG: w10 = 0x11121314
# CHECK-DAG: w11 = 0x090a0b0c
# CHECK-DAG: w12 = 0x12131415
# CHECK-DAG: w13 = 0x0a0b0c0d
# CHECK-DAG: w14 = 0x13141516
# CHECK-DAG: w15 = 0x0b0c0d0e
# CHECK-DAG: w16 = 0x14151617
# CHECK-DAG: w17 = 0x0c0d0e0f
# CHECK-DAG: w18 = 0x15161718
# CHECK-DAG: w19 = 0x0d0e0f10
# CHECK-DAG: w20 = 0x16171819
# CHECK-DAG: w21 = 0x0e0f1011
# CHECK-DAG: w22 = 0x1718191a
# CHECK-DAG: w23 = 0x0f101112
# CHECK-DAG: w24 = 0x18191a1b
# CHECK-DAG: w25 = 0x10111213
# CHECK-DAG: w26 = 0x191a1b1c
# CHECK-DAG: w27 = 0x11121314
# CHECK-DAG: w28 = 0x1a1b1c1d
#
# CHECK-DAG: v0 = {0x0f 0x0e 0x0d 0x0c 0x0b 0x0a 0x09 0x08 0x07 0x06 0x05 0x04 0x03 0x02 0x01 0x00}
# CHECK-DAG: v1 = {0x10 0x0f 0x0e 0x0d 0x0c 0x0b 0x0a 0x09 0x08 0x07 0x06 0x05 0x04 0x03 0x02 0x01}
# CHECK-DAG: v2 = {0x11 0x10 0x0f 0x0e 0x0d 0x0c 0x0b 0x0a 0x09 0x08 0x07 0x06 0x05 0x04 0x03 0x02}
# CHECK-DAG: v3 = {0x12 0x11 0x10 0x0f 0x0e 0x0d 0x0c 0x0b 0x0a 0x09 0x08 0x07 0x06 0x05 0x04 0x03}
# CHECK-DAG: v4 = {0x13 0x12 0x11 0x10 0x0f 0x0e 0x0d 0x0c 0x0b 0x0a 0x09 0x08 0x07 0x06 0x05 0x04}
# CHECK-DAG: v5 = {0x14 0x13 0x12 0x11 0x10 0x0f 0x0e 0x0d 0x0c 0x0b 0x0a 0x09 0x08 0x07 0x06 0x05}
# CHECK-DAG: v6 = {0x15 0x14 0x13 0x12 0x11 0x10 0x0f 0x0e 0x0d 0x0c 0x0b 0x0a 0x09 0x08 0x07 0x06}
# CHECK-DAG: v7 = {0x16 0x15 0x14 0x13 0x12 0x11 0x10 0x0f 0x0e 0x0d 0x0c 0x0b 0x0a 0x09 0x08 0x07}
# CHECK-DAG: v8 = {0x17 0x16 0x15 0x14 0x13 0x12 0x11 0x10 0x0f 0x0e 0x0d 0x0c 0x0b 0x0a 0x09 0x08}
# CHECK-DAG: v9 = {0x18 0x17 0x16 0x15 0x14 0x13 0x12 0x11 0x10 0x0f 0x0e 0x0d 0x0c 0x0b 0x0a 0x09}
# CHECK-DAG: v10 = {0x19 0x18 0x17 0x16 0x15 0x14 0x13 0x12 0x11 0x10 0x0f 0x0e 0x0d 0x0c 0x0b 0x0a}
# CHECK-DAG: v11 = {0x1a 0x19 0x18 0x17 0x16 0x15 0x14 0x13 0x12 0x11 0x10 0x0f 0x0e 0x0d 0x0c 0x0b}
# CHECK-DAG: v12 = {0x1b 0x1a 0x19 0x18 0x17 0x16 0x15 0x14 0x13 0x12 0x11 0x10 0x0f 0x0e 0x0d 0x0c}
# CHECK-DAG: v13 = {0x1c 0x1b 0x1a 0x19 0x18 0x17 0x16 0x15 0x14 0x13 0x12 0x11 0x10 0x0f 0x0e 0x0d}
# CHECK-DAG: v14 = {0x1d 0x1c 0x1b 0x1a 0x19 0x18 0x17 0x16 0x15 0x14 0x13 0x12 0x11 0x10 0x0f 0x0e}
# CHECK-DAG: v15 = {0x1e 0x1d 0x1c 0x1b 0x1a 0x19 0x18 0x17 0x16 0x15 0x14 0x13 0x12 0x11 0x10 0x0f}
# CHECK-DAG: v16 = {0x1f 0x1e 0x1d 0x1c 0x1b 0x1a 0x19 0x18 0x17 0x16 0x15 0x14 0x13 0x12 0x11 0x10}
# CHECK-DAG: v17 = {0x20 0x1f 0x1e 0x1d 0x1c 0x1b 0x1a 0x19 0x18 0x17 0x16 0x15 0x14 0x13 0x12 0x11}
# CHECK-DAG: v18 = {0x21 0x20 0x1f 0x1e 0x1d 0x1c 0x1b 0x1a 0x19 0x18 0x17 0x16 0x15 0x14 0x13 0x12}
# CHECK-DAG: v19 = {0x22 0x21 0x20 0x1f 0x1e 0x1d 0x1c 0x1b 0x1a 0x19 0x18 0x17 0x16 0x15 0x14 0x13}
# CHECK-DAG: v20 = {0x23 0x22 0x21 0x20 0x1f 0x1e 0x1d 0x1c 0x1b 0x1a 0x19 0x18 0x17 0x16 0x15 0x14}
# CHECK-DAG: v21 = {0x24 0x23 0x22 0x21 0x20 0x1f 0x1e 0x1d 0x1c 0x1b 0x1a 0x19 0x18 0x17 0x16 0x15}
# CHECK-DAG: v22 = {0x25 0x24 0x23 0x22 0x21 0x20 0x1f 0x1e 0x1d 0x1c 0x1b 0x1a 0x19 0x18 0x17 0x16}
# CHECK-DAG: v23 = {0x26 0x25 0x24 0x23 0x22 0x21 0x20 0x1f 0x1e 0x1d 0x1c 0x1b 0x1a 0x19 0x18 0x17}
# CHECK-DAG: v24 = {0x27 0x26 0x25 0x24 0x23 0x22 0x21 0x20 0x1f 0x1e 0x1d 0x1c 0x1b 0x1a 0x19 0x18}
# CHECK-DAG: v25 = {0x28 0x27 0x26 0x25 0x24 0x23 0x22 0x21 0x20 0x1f 0x1e 0x1d 0x1c 0x1b 0x1a 0x19}
# CHECK-DAG: v26 = {0x29 0x28 0x27 0x26 0x25 0x24 0x23 0x22 0x21 0x20 0x1f 0x1e 0x1d 0x1c 0x1b 0x1a}
# CHECK-DAG: v27 = {0x2a 0x29 0x28 0x27 0x26 0x25 0x24 0x23 0x22 0x21 0x20 0x1f 0x1e 0x1d 0x1c 0x1b}
# CHECK-DAG: v28 = {0x2b 0x2a 0x29 0x28 0x27 0x26 0x25 0x24 0x23 0x22 0x21 0x20 0x1f 0x1e 0x1d 0x1c}
# CHECK-DAG: v29 = {0x2c 0x2b 0x2a 0x29 0x28 0x27 0x26 0x25 0x24 0x23 0x22 0x21 0x20 0x1f 0x1e 0x1d}
# CHECK-DAG: v30 = {0x2d 0x2c 0x2b 0x2a 0x29 0x28 0x27 0x26 0x25 0x24 0x23 0x22 0x21 0x20 0x1f 0x1e}
# CHECK-DAG: v31 = {0x2e 0x2d 0x2c 0x2b 0x2a 0x29 0x28 0x27 0x26 0x25 0x24 0x23 0x22 0x21 0x20 0x1f}
expression -f hex -- *(uint64_t*)($sp-8)
# CHECK: (uint64_t) $0 = 0x0f10111213141516