[test-suite] Towards runtime tests for stackmaps

[vext01]

Summary

Hi,

As you know, I've been improving testing for stackmaps.

The LLVM test suite contains static stackmap tests: static in the sense that they only check that the emitted stackmap section looks somewhat feasible.

I wanted to add tests that check that the locations described in the stackmap section do in fact hold the correct data *at runtime*.

This diff is a start at that. It needs more work (test more types and location kinds) but I wanted to raise a "draft" for early comments.

OK, so how does this work?

For each architecture there is a input_$ARCH.ll containing a function called @run_test. In that function is a series of pairs of calls like:

call void llvm.experimental.stackmap(i64 0, i32 0, i32 50);
call void sm_inspect()

The former emits the stackmap section at compile time, the latter checks *at runtime* that the storage referenced by the stackmap: a) is in the expected kind of storage (register, memory, constant etc.), and b) contains the right value. It does this by printing stuff to stdout which is then checked by your usual llvm-lit reference output stuff.

(For the above example, we expect some bytes stored directly inside the stackmap record's constant field to be, when casted to i32 , the integer value 50).

I've only made an x86_64 input so far. This demonstrates constant integers and integers in registers.

One nasty thing I've realised is that there is no guarantee that the live state isn't trashed between the call to llvm.experimental.stackmap() and sm_inspect(). It works in practice (by chance?) but only because:

• sm_inspect() takes no arguments, so the argument registers are untouched.
• I've added some notail, as tail call optimisations were moving stuff around between the two calls.

But in general, I think the compiler could do anything it wants to realise the call to sm_inspect(). How do we feel about this? Maybe we can't reliably test llvm.experimental.stackmap, but we may be able to test llvm.experimental.patchpoint as it emits stackmaps *and* does a call "atomically". There should be no window in which state could be trashed(?). I've not tried that, it's just a theory.

Other small questions:

• Is LLVM going to be deterministic with regards to where values are being stored?
• Do we need to test different optimisation levels? It occurs to me that I'm not sure what opt level I'm actually testing here!
• In CMakelists.txt is ${ARCH} the right variable to use? I'm only testing 64-bit x86 here, but ${ARCH} is x86 for me... Will it try to run my tests on 32-bit x86?

(If we want to test other arches, someone with the machines will need to add test inputs and reference outputs -- I only have x86_64).

[vext01]

Further to my last comment, here's a revised diff which uses llvm.experimental.patchpoint instead of llvm.experimental.stackmap.

In addition:

• The test input now specifies how many bytes should be inspected for each stackmap record (sm_set_inspect_sizes()) -- this allows us to reliably check values if the size is not known, or if the size reported by the stackmap would include undefined bytes that can't be tested.
• Some changes to testing infrastructure to allow this to run only on x86_64 for now.

The tests are structured with one call to patchpoint per function, due to this bug: https://github.com/llvm/llvm-project/issues/35420

We don't yet test all of the various types, but I think this is good enough for now. Follow up diffs can test more stuff.

Any comments?

[vext01]

Sorry, there was a small mistake in the test inputs. Fixed.

[vext01]

Added a couple of reviewers: people who have recently worked in MultiSource/UnitTests. Hope that's OK.

[aaron.ballman]

Normally I'd be happy to review, but I don't feel confident I know enough about stackmaps or the test-suite to have much to say, so I'm resigning as a review for this one. You might try asking some of the folks who have previously reviewed your stackmap work if they could review it over here as well, as one possible way to get more review eyeballs on this.

[vext01]

You might try asking some of the folks who have previously reviewed your stackmap work if they could review it over here as well

The problem is, very few people know about stackmaps. @reames would be the ideal reviewer, but I assume he is otherwise engaged.

[arsenm]

MultiSource/UnitTests/Stackmaps/CMakeLists.txt

2–3

I'm surprised to see text IR here. It's not stable so this could be problematic. Are there other existing tests written in text IR?

MultiSource/UnitTests/Stackmaps/Harness.cpp

2

cassert?

9

cstring etc

MultiSource/UnitTests/Stackmaps/StackMapParser.cpp

2

I don't know about test suite conventions but all of these are missing license headers

[vext01]

Address @arsenm's comments.

MultiSource/UnitTests/Stackmaps/CMakeLists.txt

2–3

Yes, there are a handful of them:

https://github.com/llvm/llvm-test-suite/tree/main/LLVMSource

MultiSource/UnitTests/Stackmaps/Harness.cpp

2

Thanks, I didn't know about these headers.

MultiSource/UnitTests/Stackmaps/StackMapParser.cpp

2

The other tests in MultiSource/UnitTest likewise have no license headers.

The way I interpret LICENSE.txt is that all files are under the LLVM license unless explicitly listed under "Software from third parties included in the LLVM Project".

[vext01]

Is there a way to run my new tests on other x86_64 platforms before we merge the change? I've only tested linux.

[vext01]

@arsenm ping. Would this be OK to land please?

[arsenm]

MultiSource/UnitTests/Stackmaps/Harness.cpp

45

puts?

[vext01]

I spoke with @lhames about this change on discord.

We are going to try and make this test an lli test in the main LLVM repo, where having .ll inputs would be more appropriate.

We've arranged to meet up in August, when @lhames is back from holidays. Until then, let's not let this hold up D125680.

[arichardson]

cleanup of review queue

MultiSource/UnitTests/CMakeLists.txt

 add_subdirectory(C++11)
+add_subdirectory(Stackmaps)
 if(ARCH STREQUAL "Mips")
   add_subdirectory(Mips)
 endif()

MultiSource/UnitTests/Stackmaps/CMakeLists.txt

+file(GLOB llsources ${CMAKE_CURRENT_SOURCE_DIR}/*.ll)
+SET_SOURCE_FILES_PROPERTIES(${llsources} PROPERTIES LANGUAGE CXX)
+
+set(STACKMAP_TEST_COMMON_FILES
+    ${CMAKE_CURRENT_SOURCE_DIR}/Harness.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/StackMapParser.cpp)
+
+if(CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64")
+llvm_multisource(stackmaps
+    ${STACKMAP_TEST_COMMON_FILES}
+    ${CMAKE_CURRENT_SOURCE_DIR}/input_${CMAKE_SYSTEM_PROCESSOR}.ll
+)
+endif()

MultiSource/UnitTests/Stackmaps/Harness.cpp

+#include <elf.h>
+#include <err.h>
+#include <fcntl.h>
+#include <inttypes.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <cassert>
+#include <cstring>
+#include <iostream>
+#include <vector>
+
+#include "StackMapParser.h"
+
+using namespace std;
+
+StackMapParser *SMPRef = nullptr;
+uint64_t NextID = 0;
+vector<size_t> InspectSizes;
+
+// Defined in the `.ll` file for the platform under test.
+extern "C" void run_tests();
+
+extern "C" void sm_set_inspect_sizes(int NumArgs, ...) {
+  va_list VA;
+  va_start(VA, NumArgs);
+
+  InspectSizes.clear();
+  for (int I = 0; I < NumArgs; I++)
+    InspectSizes.push_back(va_arg(VA, size_t));
+
+  va_end(VA);
+}
+
+void dumpMem(const char *Ptr, size_t Size) {
+  for (size_t I = 0; I < Size; I++) {
+    printf("%02x", (unsigned char)Ptr[I]);
+    if (I != Size - 1)
+      printf(" ");
+  }
+  printf("\n");
+}
+
+char *getStackMapSectionAddr(char *Path, void **OutMap, off_t *OutMapSize) {
+  // First map the binary into our adress space.
+  struct stat St;
+  if (stat(Path, &St) == -1)
+    err(EXIT_FAILURE, "stat");
+
+  int Fd = open(Path, O_RDONLY);
+  if (Fd == -1)
+    err(EXIT_FAILURE, "open");
+
+  void *Map = mmap(nullptr, St.st_size, PROT_READ, MAP_SHARED, Fd, 0);
+  if (Map == MAP_FAILED)
+    err(EXIT_FAILURE, "mmap");
+
+  close(Fd);
+
+  // Report mmap result back to caller, so it can be unmapped later.
+  *OutMap = Map;
+  *OutMapSize = St.st_size;
+
+  // Now find the stackmap section inside what we just mapped in.
+  Elf64_Ehdr *Ehdr = static_cast<Elf64_Ehdr *>(Map);
+  assert(*Ehdr[0].e_ident == EI_MAG0);
+  assert(*Ehdr[1].e_ident == EI_MAG1);
+  assert(*Ehdr[2].e_ident == EI_MAG2);
+  assert(*Ehdr[3].e_ident == EI_MAG3);
+
+  Elf64_Shdr *Shdrs = static_cast<Elf64_Shdr *>(
+      static_cast<void *>(static_cast<char *>(Map) + Ehdr->e_shoff));
+
+  // Find the string table for the section names.
+  uint16_t StrTabShIdx = Ehdr->e_shstrndx;
+  assert(StrTabShIdx != SHN_UNDEF);
+  if (StrTabShIdx >= SHN_LORESERVE)
+    return nullptr; // not yet implemented. See `elf(5)` manual.
+
+  Elf64_Shdr *StrTabSh = &Shdrs[StrTabShIdx];
+  assert(StrTabSh->sh_type == ELF::SHT_STRTAB);
+  Elf64_Off StrTabOff = StrTabSh->sh_offset;
+
+  void *Data = nullptr;
+  for (uint16_t SI = 0; SI < Ehdr->e_shentsize; SI++) {
+    Elf64_Shdr *Shdr = &Shdrs[SI];
+    char *name = static_cast<char *>(Map) + StrTabOff + Shdr->sh_name;
+    if (strcmp(name, ".llvm_stackmaps") == 0)
+      return static_cast<char *>(Map) + Shdr->sh_offset;
+  }
+  return nullptr;
+}
+
+// Get a pointer to the start of the storage referenced by `Loc`.
+//
+// This code assumes that a register is the size of a pointer. We get away with
+// this for now since we don't test any vector registers.
+char *getMemForLoc(SMLoc *Loc, uintptr_t RegVals[]) {
+  switch (Loc->Where) {
+  case Reg:
+    // Get the saved register values off of the stack.
+    return reinterpret_cast<char *>(&RegVals[Loc->RegNum]);
+  case Direct:
+  case Indirect:
+    // Note: In the case of `Direct`, the record is describing a pointer value
+    // (pointing to the stack). We report the memory the pointer points to, not
+    // the memory of the pointer itself.
+    return reinterpret_cast<char *>(RegVals[Loc->RegNum]) +
+           Loc->OffsetOrSmallConst;
+  case Const:
+    // Get the constant directly from the stackmap record.
+    return reinterpret_cast<char *>(&Loc->OffsetOrSmallConst);
+  case ConstIndex:
+    errx(EXIT_FAILURE, "ConstIndex locations unimplemented");
+  default:
+    errx(EXIT_FAILURE, "unexpected storage class: %u\n", Loc->Where);
+  }
+}
+
+extern "C" void do_sm_inspect(uintptr_t RegVals[]) {
+  SMRec *Rec = SMPRef->getRecord(NextID);
+  if (Rec == nullptr)
+    errx(EXIT_FAILURE, "Failed to find stackmap record #%" PRIu64 "\n", NextID);
+
+  cout << "StackMap #" << NextID << "\n";
+  size_t LocNum = 0;
+  vector<size_t>::iterator InspectSizesIt = InspectSizes.begin();
+  for (auto Loc : Rec->Locs) {
+    char *GotPtr = getMemForLoc(&Loc, RegVals);
+    size_t InspectSize = *InspectSizesIt;
+
+    cout << "  Location #" << LocNum << "\n";
+    cout << "    Storage:      " << getStorageClassName(Loc.Where) << "\n";
+    cout << "    Storage Size: " << Loc.Size << "\n";
+    cout << "    Inspect Size: " << InspectSize << "\n";
+    cout << "    Bytes:        ";
+    dumpMem(GotPtr, InspectSize);
+    LocNum++;
+    InspectSizesIt++;
+  }
+  NextID++;
+  cout << "\n";
+  assert(InspectSizesIt == InspectSizes.end() && "too many inspect sizes");
+}
+
+#ifdef __x86_64__
+__attribute__((naked)) extern "C" void sm_inspect() {
+  asm volatile(".intel_syntax noprefix\n"
+               // Save register state onto the stack in reverse DWARF register
+               // number order.
+               "push r15\n"
+               "push r14\n"
+               "push r13\n"
+               "push r12\n"
+               "push r11\n"
+               "push r10\n"
+               "push r9\n"
+               "push r8\n"
+               "push rsp\n"
+               "push rbp\n"
+               "push rdi\n"
+               "push rsi\n"
+               "push rbx\n"
+               "push rcx\n"
+               "push rdx\n"
+               "push rax\n"
+
+               // Call do_sm_inspect().
+               //
+               // Arg: pointer to saved registers.
+               "mov rdi, rsp\n"
+               "call do_sm_inspect\n"
+
+               // Restore registers we saved earlier.
+               "pop rax\n"
+               "pop rdx\n"
+               "pop rcx\n"
+               "pop rbx\n"
+               "pop rsi\n"
+               "pop rdi\n"
+               "pop rbp\n"
+               "pop rsp\n"
+               "pop r8\n"
+               "pop r9\n"
+               "pop r10\n"
+               "pop r11\n"
+               "pop r12\n"
+               "pop r13\n"
+               "pop r14\n"
+               "pop r15\n"
+               "ret");
+}
+#endif // __x86_64__
+
+int main(int argc, char *argv[]) {
+  void *Map;
+  off_t MapSize;
+  char *SMData = getStackMapSectionAddr(argv[0], &Map, &MapSize);
+  if (SMData == nullptr)
+    errx(EXIT_FAILURE, "couldn't find stackmaps");
+
+  StackMapParser SMP(SMData);
+  munmap(Map, MapSize);
+
+  SMPRef = &SMP;
+  run_tests();
+
+  return EXIT_SUCCESS;
+}

MultiSource/UnitTests/Stackmaps/StackMapParser.h

+#ifndef TEST_SUITE_STACKMAP_PARSER_H
+#define TEST_SUITE_STACKMAP_PARSER_H
+
+#include <inttypes.h>
+#include <unistd.h>
+
+#include <map>
+#include <vector>
+
+using namespace std;
+
+const uint8_t SMVersion = 3;
+
+enum StorageClass {
+  Reg = 1,
+  Direct = 2,
+  Indirect = 3,
+  Const = 4,
+  ConstIndex = 5
+};
+
+struct SMFunc {
+  uint64_t Addr;
+  uint64_t Size;
+  uint64_t RecCt;
+};
+
+struct SMLoc {
+  StorageClass Where;
+  uint16_t Size;
+  uint16_t RegNum;
+  int32_t OffsetOrSmallConst;
+};
+
+struct SMLiveOut {
+  uint16_t RegNo;
+  uint8_t Size;
+};
+
+struct SMRec {
+  uint32_t InstrOff;
+  vector<SMLoc> Locs;
+  vector<SMLiveOut> LiveOuts;
+};
+
+// A simple (copying) Stackmap parser.
+// https://llvm.org/docs/StackMaps.html#stack-map-format
+class StackMapParser {
+private:
+  vector<SMFunc> Funcs;
+  vector<uint64_t> Consts;
+  map<uint64_t, SMRec> Recs;
+
+  template <typename T> T read(char **SMData);
+  void alignTo(char **SMData, size_t To);
+
+public:
+  StackMapParser(char *SMData);
+  SMRec *getRecord(uint64_t ID);
+};
+
+string getStorageClassName(StorageClass C);
+
+#endif // TEST_SUITE_STACKMAP_PARSER_H

MultiSource/UnitTests/Stackmaps/StackMapParser.cpp

+#include <err.h>
+
+#include <cassert>
+#include <iostream>
+
+#include "StackMapParser.h"
+
+using namespace std;
+
+template <typename T> T StackMapParser::read(char **SMData) {
+  T Ret = *reinterpret_cast<T *>(*SMData);
+  *SMData += sizeof(T);
+  return Ret;
+}
+
+void StackMapParser::alignTo(char **SMData, size_t To) {
+  *SMData += reinterpret_cast<uintptr_t>(*SMData) % To;
+}
+
+StackMapParser::StackMapParser(char *SMData) {
+  // Header.
+  uint8_t Version = read<uint8_t>(&SMData);
+  if (Version != SMVersion)
+    errx(EXIT_FAILURE, "expected stackmap version '%d', got version '%d'",
+         SMVersion, Version);
+  read<uint8_t>(&SMData);  // Skip reserved.
+  read<uint16_t>(&SMData); // Skip reserved.
+
+  // Multiplicities of tables.
+  uint32_t NumFunctions = read<uint32_t>(&SMData);
+  uint32_t NumConstants = read<uint32_t>(&SMData);
+  uint32_t NumRecords = read<uint32_t>(&SMData);
+
+  // Functions.
+  for (uint32_t I = 0; I < NumFunctions; I++)
+    Funcs.push_back({read<uint64_t>(&SMData), read<uint64_t>(&SMData),
+                     read<uint64_t>(&SMData)});
+
+  // Constants.
+  for (uint64_t I = 0; I < NumConstants; I++)
+    Consts.push_back(read<uint64_t>(&SMData));
+
+  // Records.
+  for (uint64_t I = 0; I < NumRecords; I++) {
+    uint64_t ID = read<uint64_t>(&SMData);
+    uint32_t InstrOff = read<uint32_t>(&SMData);
+    read<uint16_t>(&SMData); // skip reserved.
+    uint16_t NumLocs = read<uint16_t>(&SMData);
+
+    vector<SMLoc> Locs;
+    for (uint16_t J = 0; J < NumLocs; J++) {
+      uint8_t Where = read<uint8_t>(&SMData);
+      read<uint8_t>(&SMData); // Skip reserved.
+      uint16_t Size = read<uint16_t>(&SMData);
+      uint16_t RegNum = read<uint16_t>(&SMData);
+      read<uint16_t>(&SMData); // Skip reserved.
+      int32_t OffsetOrSmallConst = read<int32_t>(&SMData);
+      Locs.push_back({StorageClass(Where), Size, RegNum, OffsetOrSmallConst});
+    }
+
+    alignTo(&SMData, 8);     // Pad if necessary.
+    read<uint16_t>(&SMData); // Skip reserved.
+
+    // Liveouts.
+    uint16_t NumLiveOuts = read<uint16_t>(&SMData);
+    vector<SMLiveOut> LiveOuts;
+    for (uint64_t I = 0; I < NumLiveOuts; I++) {
+      uint16_t RegNum = read<uint16_t>(&SMData);
+      read<uint8_t>(&SMData); // Skip reserved.
+      uint8_t Size = read<uint8_t>(&SMData);
+      LiveOuts.push_back({RegNum, Size});
+    }
+
+    alignTo(&SMData, 8); // Pad if necessary.
+
+    Recs.insert({ID, {InstrOff, Locs, LiveOuts}});
+  }
+}
+
+SMRec *StackMapParser::getRecord(uint64_t ID) {
+  map<uint64_t, SMRec>::iterator It = Recs.find(ID);
+  if (It == Recs.end())
+    return nullptr;
+  return &It->second;
+}
+
+string getStorageClassName(StorageClass C) {
+  switch (C) {
+  case Reg:
+    return "Register";
+  case Direct:
+    return "Direct";
+  case Indirect:
+    return "Indirect";
+  case Const:
+    return "Constant";
+  case ConstIndex:
+    return "ConstIndex";
+  default:
+    errx(EXIT_FAILURE, "unreachable");
+  }
+}

MultiSource/UnitTests/Stackmaps/input_x86_64.ll

+declare void @sm_set_inspect_sizes(i32, ...)
+declare void @sm_inspect()
+declare void @llvm.experimental.patchpoint.void(i64, i32, i8*, i32, ...)
+
+define void @integer_tests(i64 %test_input) noinline {
+  %fptr = bitcast void()* @sm_inspect to i8*
+
+  ; Test constant integers.
+  call void (i32, ...) @sm_set_inspect_sizes(i32 4, i64 1, i64 2, i64 3, i64 4);
+  call void(i64, i32, i8*, i32, ...) @llvm.experimental.patchpoint.void(
+    i64 0, i32 16, i8* %fptr, i32 0,
+    i8 50, i16 51, i32 52, i64 53)
+    ret void
+}
+
+; Test integers in registers.
+define void @integer_tests2(i64 %test_input) noinline {
+  %fptr = bitcast void()* @sm_inspect to i8*
+  %test_input_plus1 = add i64 %test_input, 1
+  %test_input_plus2 = add i64 %test_input, 2
+  %test_input_plus3 = add i64 %test_input, 3
+  %arg8 = trunc i64 %test_input_plus1 to i8
+  %arg16 = trunc i64 %test_input_plus2 to i16
+  %arg32 = trunc i64 %test_input_plus3 to i32
+  call void (i32, ...) @sm_set_inspect_sizes(i32 4, i64 1, i64 2, i64 4, i64 8);
+  call void(i64, i32, i8*, i32, ...) @llvm.experimental.patchpoint.void(
+    i64 1, i32 16, i8* %fptr, i32 0,
+    i8 %arg8, i16 %arg16, i32 %arg32, i64 %test_input)
+
+  ret void
+}
+
+; Test integers on the stack.
+define void @integer_tests3(i64 %test_input) noinline {
+  %fptr = bitcast void()* @sm_inspect to i8*
+
+  %test_input_plus1 = add i64 %test_input, 1
+  %test_input_plus2 = add i64 %test_input, 2
+  %test_input_plus3 = add i64 %test_input, 3
+  %arg8 = trunc i64 %test_input_plus1 to i8
+  %arg16 = trunc i64 %test_input_plus2 to i16
+  %arg32 = trunc i64 %test_input_plus3 to i32
+
+  ; Force local variables to be spilled.
+  call void asm sideeffect "", "~{rax},~{rdx},~{rcx},~{rbx},~{rsi},~{rdi},~{rbp},~{rsp},~{r8},~{r9},~{r10},~{r11},~{r12},~{r13},~{r14},~{r15}"()
+
+  call void (i32, ...) @sm_set_inspect_sizes(i32 4, i64 1, i64 2, i64 4, i64 8);
+  call void(i64, i32, i8*, i32, ...) @llvm.experimental.patchpoint.void(
+    i64 2, i32 16, i8* %fptr, i32 0,
+    i8 %arg8, i16 %arg16, i32 %arg32, i64 %test_input)
+
+  ret void
+}
+
+define void @frame_tests() noinline {
+  %fptr = bitcast void()* @sm_inspect to i8*
+
+  %a8 = alloca i8
+  %a16 = alloca i16
+  %a32 = alloca i32
+  %a64 = alloca i64
+  store i8 170, i8* %a8                     ; 0xaa
+  store i16 48059, i16* %a16                ; 0xbbbb
+  store i32 3435973836, i32* %a32           ; 0xcccccccc
+  store i64 15987178197214944733, i64* %a64 ; 0xdddddddddddddddd
+
+  call void (i32, ...) @sm_set_inspect_sizes(i32 4, i64 1, i64 2, i64 4, i64 8);
+  call void(i64, i32, i8*, i32, ...) @llvm.experimental.patchpoint.void(
+    i64 3, i32 16, i8* %fptr, i32 0, i8* %a8, i16* %a16, i32* %a32, i64* %a64)
+
+  ret void
+}
+
+define void @run_tests() noinline {
+  ; 0x8877665544332211
+  %in1 = call i64 asm sideeffect "nop", "=r,0"(i64 9833440827789222417)
+  call void @integer_tests(i64 %in1)
+
+  ; 0x1122334455667788
+  %in2 = call i64 asm sideeffect "", "=r,0"(i64 1234605616436508552)
+  call void @integer_tests2(i64 %in2)
+  call void @integer_tests3(i64 %in2)
+
+  call void @frame_tests()
+
+  ret void
+}

MultiSource/UnitTests/Stackmaps/stackmaps.reference_output.x86_64

+StackMap #0
+  Location #0
+    Storage:      Constant
+    Storage Size: 8
+    Inspect Size: 1
+    Bytes:        32
+  Location #1
+    Storage:      Constant
+    Storage Size: 8
+    Inspect Size: 2
+    Bytes:        33 00
+  Location #2
+    Storage:      Constant
+    Storage Size: 8
+    Inspect Size: 3
+    Bytes:        34 00 00
+  Location #3
+    Storage:      Constant
+    Storage Size: 8
+    Inspect Size: 4
+    Bytes:        35 00 00 00
+
+StackMap #1
+  Location #0
+    Storage:      Register
+    Storage Size: 1
+    Inspect Size: 1
+    Bytes:        89
+  Location #1
+    Storage:      Register
+    Storage Size: 2
+    Inspect Size: 2
+    Bytes:        8a 77
+  Location #2
+    Storage:      Register
+    Storage Size: 4
+    Inspect Size: 4
+    Bytes:        8b 77 66 55
+  Location #3
+    Storage:      Register
+    Storage Size: 8
+    Inspect Size: 8
+    Bytes:        88 77 66 55 44 33 22 11
+
+StackMap #2
+  Location #0
+    Storage:      Indirect
+    Storage Size: 1
+    Inspect Size: 1
+    Bytes:        89
+  Location #1
+    Storage:      Indirect
+    Storage Size: 2
+    Inspect Size: 2
+    Bytes:        8a 77
+  Location #2
+    Storage:      Indirect
+    Storage Size: 4
+    Inspect Size: 4
+    Bytes:        8b 77 66 55
+  Location #3
+    Storage:      Indirect
+    Storage Size: 8
+    Inspect Size: 8
+    Bytes:        88 77 66 55 44 33 22 11
+
+StackMap #3
+  Location #0
+    Storage:      Direct
+    Storage Size: 8
+    Inspect Size: 1
+    Bytes:        aa
+  Location #1
+    Storage:      Direct
+    Storage Size: 8
+    Inspect Size: 2
+    Bytes:        bb bb
+  Location #2
+    Storage:      Direct
+    Storage Size: 8
+    Inspect Size: 4
+    Bytes:        cc cc cc cc
+  Location #3
+    Storage:      Direct
+    Storage Size: 8
+    Inspect Size: 8
+    Bytes:        dd dd dd dd dd dd dd dd
+
+exit 0

cmake/modules/SingleMultiSource.cmake

if(NOT NO_REFERENCE_OUTPUT)
     if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${name}.reference_output.${ENDIAN}-endian.${SIZE_SUFFIX})
       set(REFERENCE_OUTPUT ${name}.reference_output.${ENDIAN}-endian.${SIZE_SUFFIX})
     elseif(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${name}.reference_output.${SIZE_SUFFIX})
       set(REFERENCE_OUTPUT ${name}.reference_output.${SIZE_SUFFIX})
     elseif(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${name}.reference_output.${ENDIAN}-endian)
       set(REFERENCE_OUTPUT ${name}.reference_output.${ENDIAN}-endian)
     elseif(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${name}.reference_output.${TARGET_OS})
       set(REFERENCE_OUTPUT ${name}.reference_output.${TARGET_OS})
+    elseif(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${name}.reference_output.${CMAKE_SYSTEM_PROCESSOR})
+      set(REFERENCE_OUTPUT ${name}.reference_output.${CMAKE_SYSTEM_PROCESSOR})
     elseif(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${name}.reference_output)
       set(REFERENCE_OUTPUT ${name}.reference_output)
     else()
       message("-- No reference output found for test ${name}")
     endif()
   endif()
 
   if(REFERENCE_OUTPUT)