CMake: Подключение riscv-arch-test для тестирования имплементации rv32

При написании своей VM для RISC-V возникла необходимость в тестировании.

Сначала я пытался писать юнит-тесты самостоятельно, но выходило, что я просто копирую логику из основной.

И по сути тестирую не соответствие спецификации, а соответствие моему пониманию.

Через некоторое время я наткнулся на официальный набор тестов для RISC-V и решил их использовать.

Это помогло найти несколько багов в моём коде.

Что ж.

Смотрим в репозиторий и огорчаемся — поддержки cmake там нет.

Ну она особо и не нужна, а нужны исходники тестов.

Ищем как в cmake скачать репозиторий -> ExternalProject -> ExternalProject_Add

В настройках нужно указать команды конфигурации и сборки(RTFM, please) но сейчас нужны только данные, по этому отключаем.

Тесты не всегда нужны, поэтому ввел настройку:

option(YETI_ENABLE_ARCH_TESTS "Build riscv-arch-tests tests" ON)

Подключаем данные:

if (YETI_ENABLE_ARCH_TESTS)     enable_testing()      ExternalProject_Add(riscv_arch_test             GIT_REPOSITORY https://github.com/riscv-non-isa/riscv-arch-test.git             GIT_TAG fc32e41d49480fd99ba0a192dfff9c3319b44873 # 3.10.0             GIT_PROGRESS ON             SOURCE_DIR "${DOWNLOAD_BASE_DIR}/riscv-arch-test"             CONFIGURE_COMMAND ""             BUILD_COMMAND ""             INSTALL_COMMAND ""             BUILD_IN_SOURCE ON     )      add_subdirectory(tests/arch-tests) endif ()

Теперь нужно создать «запускатор» тестов и скомпилировать сами тесты под RV32IM

Тесты требуют определенной настройки под тестируемую архитектуру — создание model_test.h.
В нем описываются макросы для тестирования а-ля assert
У меня вышло следующее:

// config for https://github.com/riscv-non-isa/riscv-arch-test/ // docs: https://github.com/riscv-non-isa/riscv-arch-test/releases  #ifndef YETI_VM_MODEL_H #define YETI_VM_MODEL_H  // Supports rv32 #define XLEN 32 // float32 #define FLEN 32  #define ALIGNMENT 2  #define TEST_CASE_1  // startup code #define RVMODEL_BOOT \     RVMODEL_IO_INIT  \  // stop code #define RVMODEL_HALT \ .do_exit:            \     li a7, 10;       \     ecall;           \     .global _assert_failed; \     _assert_failed: ebreak; \     j _assert_failed;\  #define RVMODEL_DATA_BEGIN \     .align 4;              \     .global begin_signature; \     begin_signature:  #define RVMODEL_DATA_END \     .align 4;            \     .global end_signature; \     end_signature:  #define RVMODEL_IO_INIT #define RVMODEL_IO_WRITE_STR(_R, _STR) #define RVMODEL_IO_CHECK()  // asserts: testreg, destreg, correctval // store values in "DEV" memory // generic purpose registers: #define LBL_OK(_S, _R, _I, _L) .assert_ok ## _L  #define RVMODEL_IO_ASSERT_GPR_EQ_IMPL(_S, _R, _I, _L) \     LI(_S, _I);                               \     beq _S, _R, LBL_OK(_S, _R, _I, _L);          \     LA(_S, __dev_start);                     \     sw zero, 0(_S);                          \     sw _R, 4(_S);                            \     LI(_R, _I);                              \     sw _R, 8(_S);                            \     LI(_R, _L);                              \     sw _R, 12(_S);                                    \     j  _assert_failed;                                \     LBL_OK(_S, _R, _I, _L):                           \  #define RVMODEL_IO_ASSERT_GPR_EQ(_S, _R, _I) \     RVMODEL_IO_ASSERT_GPR_EQ_IMPL(_S, _R, _I, __LINE__); \  // float32 registers #define RVMODEL_IO_ASSERT_SFPR_EQ(_F, _R, _I) // float64 registers #define RVMODEL_IO_ASSERT_DFPR_EQ(_D, _R, _I)  // machine-mode interrupts // use default behavior - end test // TODO: learn about it //#define RVMODEL_SET_MSW_INT //#define RVMODEL_CLEAR_MSW_INT //#define RVMODEL_CLEAR_MTIMER_INT //#define RVMODEL_CLEAR_MEXT_INT  #endif // YETI_VM_MODEL_H 

В качестве запускатора служит код:

#include <yeti-vm/vm_basic.hxx>  #include <iostream> #include <cstring>  namespace vm::yeti_runner { struct Runner: protected vm::basic_vm {     bool initProgram(int testIdx, char ** argv)     {         bool isa_ok = init_isa();         bool mem_ok = init_memory();         mem_ok = mem_ok && add_memory(std::make_shared<DeviceMemory>(this));          bool init_ok = isa_ok && mem_ok;         init_ok = init_ok && initSysCalls();          auto code = vm::parse_hex(argv[testIdx]);         init_ok = init_ok && code.has_value();         init_ok = init_ok && set_program(code.value());          return init_ok;     }     bool initSysCalls()     {         syscall_should_throw(false);         using call = vm::syscall_functor;         auto& sys = get_syscalls();         bool ok = sys.register_handler(                 call::create(10, "exit"                              , [this](vm::MachineInterface* m)                              { return do_exit(m); }));          return ok;     }     void do_exit(vm::MachineInterface*)     {         basic_vm::halt();     }      bool exec(bool debug = false)     {         enable_debugging(debug);         start();         try         {             run();         }         catch (std::exception& e)         {             std::cerr << std::endl << "Exception: " << e.what() << std::endl;             dump_state(std::cerr);             return false;         }         return !set_dev; // no failures     } protected:     void debug() override     {         if (set_dev)         {             dump_state(std::cerr);             auto fill_c = std::cerr.fill();             std::cerr << std::dec;             std::cerr << "set_dev == true " << std::endl;             std::cerr << "DEV MEM: " << std::endl;             for(auto v: dev_mem)             {                 std::cerr << "\t" << std::hex << std::setfill('0') << std::setw(8) << v << std::endl;             }             std::cerr << "\t:DEV MEM" << std::endl;             std::cerr << std::dec << std::setfill(fill_c);             halt();         }         return basic_vm::debug();     }     void assert_set(uint32_t idx, uint32_t v)     {         dev_mem[idx] = v;         set_dev = true;     }     bool set_dev = false;     std::array<uint32_t, 4> dev_mem{}; protected:     struct DeviceMemory final: public vm::memory_block     {         explicit DeviceMemory(Runner* runner)             : vm::memory_block{def_data_base + def_data_size, def_data_size}             , runner{runner} {}          [[nodiscard]]         bool load(address_type address, void *dest, size_type size) const final         {             std::memset(dest, 0, size);             return true;         }          [[nodiscard]]         bool store(memory_block::address_type address, const void *source, memory_block::size_type size) final         {             runner->set_dev = true;             if (size != 4) return false;             auto offset = (address - get_start_address()) / 4;             if (offset >= runner->dev_mem.size()) return false;             runner->assert_set(offset, *reinterpret_cast<const uint32_t*>(source));             return true;         }      protected:         [[nodiscard]]         const void *get_ro(address_type address, size_type size) const final         {             return nullptr;         }          [[nodiscard]]         void *get_rw(address_type address, size_type size) final         {             return nullptr;         }     private:         Runner* runner = nullptr;     }; }; } // vm::yeti_runner  int main(int argc, char ** argv) {     int numFails = 0;     for (int testIdx = 1; testIdx < argc; ++testIdx)     {         vm::yeti_runner::Runner yetiVM;         if (!yetiVM.initProgram(testIdx, argv))         {             std::cerr << "Unable init: " << std::dec << testIdx << " " << argv[testIdx] << std::endl;             return EXIT_FAILURE;         }         if (!yetiVM.exec(argc == 2)) // single file - enable debug output         {             std::cerr << "Fail: " << std::dec << testIdx << " " << argv[testIdx] << std::endl;             ++numFails;         }     }     return numFails; } 

В нем используется memory-mapped device, которое обслуживает событие «завершение работы»

Для компиляции тестов нужен toolchain riscv64-unknown-elf

Для поиска используется функция find_riscv_toolchain

Собственно для компиляции и запуска тестов используется код

# use POST_BUILD step to compile tests block()     set(_out_dir "${CMAKE_CURRENT_BINARY_DIR}")     foreach (_subset IN LISTS ARCH_TEST_SUBSETS)         set(_subset_dir "${ARCH_TEST_SUITE_RV32}/${_subset}/src/")         file(GLOB _subset_tests RELATIVE "${_subset_dir}" "${_subset_dir}/*.S")         message(DEBUG "Dir: ${_subset_dir} ... tests: ${_subset_tests}")          set(_tests_to_run)          foreach (_test_asm IN LISTS _subset_tests)             get_filename_component(_test_name "${_test_asm}" NAME_WLE)             set(_test_id "${_subset}/${_test_name}")             message(DEBUG "Add test ${_test_id}")             set(_input_file "${_subset_dir}/${_test_asm}")             set(_elf_file "${_out_dir}/${_subset}_${_test_name}.elf")             set(_hex_file "${_out_dir}/${_subset}_${_test_name}.hex")             list(APPEND _build_args                     "${YETI_VM_ARCH_ARGS}"                     "${ARCH_TEST_INCLUDE_DIRS}"                     -T "${CMAKE_CURRENT_LIST_DIR}/config/link.ld"                     "${_input_file}"                     -o "${_elf_file}"             )             add_custom_command(TARGET yeti-runner POST_BUILD                     COMMENT "Build ${_test_id}"                     COMMAND rv_tools::_gcc                     ARGS "${_build_args}"                     DEPENDS "${_input_file}"                         "${CMAKE_CURRENT_LIST_DIR}/config/link.ld"                         "${CMAKE_CURRENT_LIST_DIR}/config/model_test.h"                     BYPRODUCTS "${_elf_file}"                     COMMAND_EXPAND_LISTS             )             add_custom_command(TARGET yeti-runner POST_BUILD                     COMMENT "Make hex file ${_test_id}"                     COMMAND rv_tools::_objcopy                     ARGS -O ihex "${_elf_file}" "${_hex_file}"                     DEPENDS "${_elf_file}"                     BYPRODUCTS "${_hex_file}"             )              list(APPEND _tests_to_run "${_hex_file}")              unset(_input_file)             unset(_elf_file)             unset(_hex_file)             unset(_build_args)         endforeach ()          add_test(NAME "RV32_ISA_${_subset}"                 COMMAND yeti-runner "${_tests_to_run}"                 COMMAND_EXPAND_LISTS                 )         unset(_subset_dir)         unset(_tests_to_run)     endforeach ()     unset(_subset)     unset(_out_dir) endblock()

В котором для каждого теста из выбранного набора происходит компиляция, преобразование в ihex и добавление команды для «запускатора»