diff --git a/.gitea/workflows/abstract-machine-build.yml b/.gitea/workflows/abstract-machine-build.yml new file mode 100644 index 0000000..af10d43 --- /dev/null +++ b/.gitea/workflows/abstract-machine-build.yml @@ -0,0 +1,21 @@ +name: Build abstract machine with nix +on: [push] + +jobs: + build-abstract-machine: + runs-on: nix + steps: + - uses: https://github.com/cachix/cachix-action@v14 + with: + name: ysyx + signingKey: '${{ secrets.CACHIX_SIGNING_KEY }}' + - uses: actions/checkout@v4 + with: + submodules: true + - name: Build abstract-machine + run: | + nix build .#abstract-machine + - name: Build nemu + run: | + nix build .#nemu + diff --git a/.gitignore b/.gitignore index 4ed3ed8..44a51ce 100644 --- a/.gitignore +++ b/.gitignore @@ -10,4 +10,5 @@ !init.sh /fceux-am /nvboard -/am-kernels +**/.cache +**/result diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..3d834b3 --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "am-kernels"] + path = am-kernels + url = https://git.xinyang.life/xin/am-kernels.git diff --git a/abstract-machine/.gitignore b/abstract-machine/.gitignore index 84c3ed2..bcba0ab 100644 --- a/abstract-machine/.gitignore +++ b/abstract-machine/.gitignore @@ -1,19 +1,6 @@ -* -!*/ -!*.h -!*.c -!*.cc -!*.S -!*.ld -!*.sh -!*.py -!*.mk -!Makefile -!README -!LICENSE -.* -_* -*~ -build/ -!.gitignore -.vscode \ No newline at end of file +**/.direnv/ +**/build/ +**/.envrc +**/.cache +.vscode +compile_commands.json diff --git a/abstract-machine/CMakeLists.txt b/abstract-machine/CMakeLists.txt new file mode 100644 index 0000000..508bc68 --- /dev/null +++ b/abstract-machine/CMakeLists.txt @@ -0,0 +1,87 @@ +cmake_minimum_required(VERSION 3.22) + +project(abstract-machine) +enable_language(CXX C ASM) +set(CMAKE_C_STANDARD 11) +set(CMAKE_CXX_STANDARD 11) + +include(CMakeDependentOption) +include(CMakePackageConfigHelpers) # Used to find libcheck +include(CTest) + +# -- General options +set(ISA CACHE STRING "Target ISA") +set_property(CACHE ISA PROPERTY STRINGS "riscv" "x86" "x86_64" "native") +string(TOUPPER ${ISA} ISA_UPPER) + +cmake_dependent_option( + __PLATFORM_NEMU__ "Run on NEMU" + ON "ISA MATCHES \"(riscv | x86)\"" OFF) +cmake_dependent_option( + __PLATFORM_NATIVE__ "Run on native" + ON "ISA MATCHES native" OFF) + +# -- Set PLATFORM according to options +set(MATCH_PLATFORM_PATTERN "^__PLATFORM_([A-Z]*)__") +get_cmake_property(CACHE_VARS CACHE_VARIABLES) + +message(STATUS "ISA: ${ISA}") +foreach(VAR IN LISTS CACHE_VARS) + if(VAR MATCHES ${MATCH_PLATFORM_PATTERN}) + # Retrieve the value of the cache variable + get_property(VAR_VALUE CACHE ${VAR} PROPERTY VALUE) + set(PLATFORM_UPPER ${CMAKE_MATCH_1}) + string(TOLOWER ${PLATFORM_UPPER} PLATFORM) + message(STATUS "Variable: ${VAR}=${VAR_VALUE}, Platform: ${PLATFORM}") + endif() +endforeach() + +if(${PLATFORM} MATCHES "native") +set(ARCH "native") +else() +set(ARCH ${ISA}-${PLATFORM}) +endif() +string(TOUPPER ${ARCH} ARCH_UPPER) + +# -- Target specific options +cmake_dependent_option( + NATIVE_USE_KLIB "Use Klib even if on native" + ON "NOT __ISA_NATIVE__" OFF) + +# -- Add compile definitions based on options +add_compile_definitions( + $ + __ISA_${ISA_UPPER}__ + __PLATFORM_${PLATFORM_UPPER}__ +) + +add_compile_definitions( + $<$:__NATIVE_USE_KLIB__> +) + +# -- Required compiler flags +add_compile_options( + # -Werror + -Wno-main + -fno-asynchronous-unwind-tables + -fno-builtin + -fno-stack-protector + -U_FORTIFY_SOURCE + $<$:-fno-exceptions> + $<$:-ffreestanding> + $<$:-fno-rtti>) + +add_link_options( + -znoexecstack +) + +# -- Include linker script here. Use this linker script at link time if INCLUDE_LINKER_SCRIPT is set to true +set(LINKER_SCRIPT linker.ld) + +list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake") + +add_compile_options(-march=rv32if -mabi=ilp32) +add_link_options(-march=rv32if -mabi=ilp32) + +add_subdirectory(klib) +add_subdirectory(am) diff --git a/abstract-machine/CMakePresets.json b/abstract-machine/CMakePresets.json new file mode 100644 index 0000000..d14c0b6 --- /dev/null +++ b/abstract-machine/CMakePresets.json @@ -0,0 +1,29 @@ +{ + "version": 6, + "configurePresets": [ + { + "name": "native", + "displayName": "Native", + "generator": "Unix Makefiles", + "binaryDir": "${sourceDir}/out/build/${presetName}", + "cacheVariables": { + "CMAKE_BUILD_TYPE": "Debug", + "ISA": "native", + "__PLATFORM_NATIVE__": true, + "NATIVE_USE_KLIB": true + } + }, + { + "name": "riscv-nemu", + "displayName": "Riscv32 NEMU", + "generator": "Unix Makefiles", + "binaryDir": "${sourceDir}/out/build/${presetName}", + "installDir": "/home/xin/repo/ysyx-workbench/abstract-machine/out/install", + "cacheVariables": { + "CMAKE_BUILD_TYPE": "Debug", + "ISA": "riscv", + "__PLATFORM_NEMU__": true + } + } + ] +} \ No newline at end of file diff --git a/abstract-machine/Makefile b/abstract-machine/Makefile index 3a5d60a..1377857 100644 --- a/abstract-machine/Makefile +++ b/abstract-machine/Makefile @@ -47,33 +47,32 @@ endif ### Create the destination directory (`build/$ARCH`) WORK_DIR = $(shell pwd) -DST_DIR = $(WORK_DIR)/build/$(ARCH) +BUILD_DIR ?= $(WORK_DIR)/build +DST_DIR = $(BUILD_DIR)/$(ARCH) $(shell mkdir -p $(DST_DIR)) ### Compilation targets (a binary image or archive) -IMAGE_REL = build/$(NAME)-$(ARCH) +IMAGE_REL = $(DST_DIR)/$(NAME)-$(ARCH) IMAGE = $(abspath $(IMAGE_REL)) -ARCHIVE = $(WORK_DIR)/build/$(NAME)-$(ARCH).a +ARCHIVE = $(BUILD_DIR)/$(NAME)-$(ARCH).a ### Collect the files to be linked: object files (`.o`) and libraries (`.a`) OBJS = $(addprefix $(DST_DIR)/, $(addsuffix .o, $(basename $(SRCS)))) LIBS := $(sort $(LIBS) am klib) # lazy evaluation ("=") causes infinite recursions LINKAGE = $(OBJS) \ - $(addsuffix -$(ARCH).a, $(join \ - $(addsuffix /build/, $(addprefix $(AM_HOME)/, $(LIBS))), \ - $(LIBS) )) + $(addsuffix -$(ARCH).a, $(addprefix $(BUILD_DIR)/, $(LIBS))) ## 3. General Compilation Flags ### (Cross) compilers, e.g., mips-linux-gnu-g++ -AS = $(CROSS_COMPILE)gcc -CC = $(CROSS_COMPILE)gcc -CXX = $(CROSS_COMPILE)g++ -LD = $(CROSS_COMPILE)ld -AR = $(CROSS_COMPILE)ar -OBJDUMP = $(CROSS_COMPILE)objdump -OBJCOPY = $(CROSS_COMPILE)objcopy -READELF = $(CROSS_COMPILE)readelf +AS ?= $(CROSS_COMPILE)gcc +CC ?= $(CROSS_COMPILE)gcc +CXX ?= $(CROSS_COMPILE)g++ +LD ?= $(CROSS_COMPILE)ld +AR ?= $(CROSS_COMPILE)ar +OBJDUMP ?= $(CROSS_COMPILE)objdump +OBJCOPY ?= $(CROSS_COMPILE)objcopy +READELF ?= $(CROSS_COMPILE)readelf ### Compilation flags INC_PATH += $(WORK_DIR)/include $(addsuffix /include/, $(addprefix $(AM_HOME)/, $(LIBS))) diff --git a/abstract-machine/am/CMakeLists.txt b/abstract-machine/am/CMakeLists.txt new file mode 100644 index 0000000..b0462e4 --- /dev/null +++ b/abstract-machine/am/CMakeLists.txt @@ -0,0 +1,10 @@ +include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include) + +add_library(am_interface INTERFACE) +target_include_directories(am_interface INTERFACE + $ + $) + +add_subdirectory(src) + +install(DIRECTORY include/ DESTINATION include/abstract-machine) diff --git a/abstract-machine/am/src/CMakeLists.txt b/abstract-machine/am/src/CMakeLists.txt new file mode 100644 index 0000000..533dd3b --- /dev/null +++ b/abstract-machine/am/src/CMakeLists.txt @@ -0,0 +1,53 @@ +if(ISA MATCHES "native") +set(SOURCEDIR "./${PLATFORM}") +else() +set(SOURCEDIR "./${ISA}/${PLATFORM}") +endif() + +add_subdirectory(${SOURCEDIR}) + +target_include_directories(am-${ARCH} + PRIVATE ${CMAKE_CURRENT_SOURCE_DIR} + PUBLIC + $ + $) +target_link_libraries(am-${ARCH} + PUBLIC klib_interface + INTERFACE m) + +# TODO: Check +target_link_options(am-${ARCH} INTERFACE + $ + $) + +# Interface compile flags +target_link_options(am-${ARCH} INTERFACE + -znoexecstack) + +target_compile_options(am-${ARCH} INTERFACE + -fno-asynchronous-unwind-tables + -fno-builtin + -fno-stack-protector + -U_FORTIFY_SOURCE + $<$:-fno-exceptions> + $<$:-ffreestanding> + $<$:-fno-rtti>) + +install(TARGETS am-${ARCH} klib_interface am_interface + EXPORT amTargets + LIBRARY DESTINATION lib) + +install(EXPORT amTargets + FILE amTargets.cmake + DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/am-${ARCH}) + +configure_package_config_file(${CMAKE_SOURCE_DIR}/cmake/am-config.cmake.in + ${CMAKE_CURRENT_BINARY_DIR}/am-${ARCH}-config.cmake + INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/am-${ARCH}) + +install(FILES ${CMAKE_CURRENT_BINARY_DIR}/am-${ARCH}-config.cmake + DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/am-${ARCH}) + +# TODO: check +install(FILES ${CMAKE_SOURCE_DIR}/scripts/${LINKER_SCRIPT} + DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/am-${ARCH}) diff --git a/abstract-machine/am/src/native/CMakeLists.txt b/abstract-machine/am/src/native/CMakeLists.txt new file mode 100644 index 0000000..e3c9303 --- /dev/null +++ b/abstract-machine/am/src/native/CMakeLists.txt @@ -0,0 +1,26 @@ +include(CheckPIESupported) +check_pie_supported() + +set(SOURCES + trap.S + cte.c + ioe.c + mpe.c + platform.c + trm.c + vme.c + ioe/audio.c + ioe/disk.c + ioe/gpu.c + ioe/input.c + ioe/timer.c +) +add_library(am-native ${SOURCES}) + +# FIXME: get free(): invalid address when user program compiled without pie +set_target_properties(am-native PROPERTIES + POSITION_INDEPENDENT_CODE TRUE + INTERFACE_POSITION_INDEPENDENT_CODE TRUE) + +find_package(SDL2 REQUIRED) +target_link_libraries(am-${ARCH} PUBLIC SDL2::SDL2) diff --git a/abstract-machine/am/src/riscv/nemu/CMakeLists.txt b/abstract-machine/am/src/riscv/nemu/CMakeLists.txt new file mode 100644 index 0000000..a6992db --- /dev/null +++ b/abstract-machine/am/src/riscv/nemu/CMakeLists.txt @@ -0,0 +1,34 @@ +include(nemu-settings) +include(riscv-settings) + +add_library(am-${ISA}-nemu + cte.c + start.S + trap.S + vme.c + ${NEMU_SOURCES} +) + +target_compile_options(am-${ISA}-nemu PRIVATE + ${NEMU_COMPILE_OPTIONS} + ${RISCV_COMPILE_OPTIONS}) +target_link_options(am-${ISA}-nemu PRIVATE + ${NEMU_LINK_OPITIONS} + ${RISCV_LINK_OPTIONS}) +target_include_directories(am-${ISA}-nemu PRIVATE + ${NEMU_INCLUDE_DIRECTORIES}) +target_link_options(am-${ISA}-nemu INTERFACE + LINKER:--defsym=_pmem_start=0x80000000 + LINKER:--defsym=_entry_offset=0x0 + LINKER:--gc-sections + LINKER:-e _start + -nostartfiles) + +target_compile_definitions(am-${ISA}-nemu PUBLIC + ARCH_H="arch/riscv.h") +target_compile_definitions(am-${ISA}-nemu PRIVATE + ISA_H="riscv/riscv.h") + +set_target_properties(am-${ISA}-nemu PROPERTIES + POSITION_INDEPENDENT_CODE OFF + INTERFACE_POSITION_INDEPENDENT_CODE OFF) diff --git a/abstract-machine/cmake/am-config.cmake.in b/abstract-machine/cmake/am-config.cmake.in new file mode 100644 index 0000000..f2fbb32 --- /dev/null +++ b/abstract-machine/cmake/am-config.cmake.in @@ -0,0 +1,9 @@ +@PACKAGE_INIT@ + +include(CMakeFindDependencyMacro) +if(${ARCH} MATCHES "native") +find_dependency(SDL2 REQUIRED) +endif() + +# Include the targets file +include("${CMAKE_CURRENT_LIST_DIR}/amTargets.cmake") diff --git a/abstract-machine/cmake/klib-config.cmake.in b/abstract-machine/cmake/klib-config.cmake.in new file mode 100644 index 0000000..6b57e7f --- /dev/null +++ b/abstract-machine/cmake/klib-config.cmake.in @@ -0,0 +1,6 @@ +@PACKAGE_INIT@ + +include(CMakeFindDependencyMacro) + +# Include the targets file +include("${CMAKE_CURRENT_LIST_DIR}/klibTargets.cmake") diff --git a/abstract-machine/cmake/nemu-settings.cmake b/abstract-machine/cmake/nemu-settings.cmake new file mode 100644 index 0000000..910cdcf --- /dev/null +++ b/abstract-machine/cmake/nemu-settings.cmake @@ -0,0 +1,11 @@ +set(NEMU_COMPILE_OPTIONS -fdata-sections -ffunction-sections) +set(NEMU_LINK_OPTIONS + --defsym=_pmem_start=0x80000000 + --defsym=_entry_offset=0x0 + --gc-sections + -e _start) +set(NEMU_INCLUDE_DIRECTORIES + ${CMAKE_SOURCE_DIR}/am/src/platform/nemu/include) +file(GLOB_RECURSE NEMU_SOURCES + ${CMAKE_SOURCE_DIR}/am/src/platform/nemu/*.[cS]) +set(INCLUDE_LINKER_SCRIPT ON) diff --git a/abstract-machine/cmake/riscv-settings.cmake b/abstract-machine/cmake/riscv-settings.cmake new file mode 100644 index 0000000..1286e4c --- /dev/null +++ b/abstract-machine/cmake/riscv-settings.cmake @@ -0,0 +1,2 @@ +set(RISCV_COMPILE_OPTIONS) +set(RISCV_LINK_OPTIONS) diff --git a/abstract-machine/default.nix b/abstract-machine/default.nix new file mode 100644 index 0000000..1f1f67d --- /dev/null +++ b/abstract-machine/default.nix @@ -0,0 +1,26 @@ +{ stdenv, + lib, + cmake, + SDL2, + isa ? "native", + platform ? "NEMU" +}: +stdenv.mkDerivation { + pname = "abstract-machine"; + version = "2024.02.18"; + + src = ./.; + + cmakeFlags = [ + (lib.cmakeFeature "ISA" isa) + (lib.cmakeBool "__PLATFORM_${lib.strings.toUpper platform}__" true) + ]; + + nativeBuildInputs = [ + cmake + ]; + + buildInputs = [ + + ] ++ (if platform=="native" then [ SDL2 ] else [ ]); +} diff --git a/abstract-machine/klib/CMakeLists.txt b/abstract-machine/klib/CMakeLists.txt new file mode 100644 index 0000000..2cf4a78 --- /dev/null +++ b/abstract-machine/klib/CMakeLists.txt @@ -0,0 +1,12 @@ +include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include) + +add_library(klib_interface INTERFACE) +target_include_directories(klib_interface + INTERFACE + $ + $) + +add_subdirectory(src) +# add_subdirectory(tests) + +install(DIRECTORY include/ DESTINATION include/abstract-machine) diff --git a/abstract-machine/klib/include/klib.h b/abstract-machine/klib/include/klib.h index ecb24c8..48d63e9 100644 --- a/abstract-machine/klib/include/klib.h +++ b/abstract-machine/klib/include/klib.h @@ -35,6 +35,7 @@ int atoi (const char *nptr); int printf (const char *format, ...); int sprintf (char *str, const char *format, ...); int snprintf (char *str, size_t size, const char *format, ...); +int vprintf (const char *format, va_list ap); int vsprintf (char *str, const char *format, va_list ap); int vsnprintf (char *str, size_t size, const char *format, va_list ap); diff --git a/abstract-machine/klib/src/CMakeLists.txt b/abstract-machine/klib/src/CMakeLists.txt new file mode 100644 index 0000000..bf7e136 --- /dev/null +++ b/abstract-machine/klib/src/CMakeLists.txt @@ -0,0 +1,33 @@ +# find_package(FLEX) +# find_package(BISON) + +# FLEX_TARGET(fmt_scanner fmt_scanner.l fmt_scanner.c) + +set(SOURCES + cpp.c + int64.c + stdio.c + stdlib.c + string.c + # ${FLEX_fmt_scanner_OUTPUTS} +) + +add_library(klib ${SOURCES}) +target_include_directories(klib PUBLIC $) +target_compile_definitions(klib PUBLIC $) + +install(TARGETS klib + EXPORT klibTargets + LIBRARY DESTINATION lib) + +install(EXPORT klibTargets + FILE klibTargets.cmake + DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/klib) + +configure_package_config_file(${CMAKE_SOURCE_DIR}/cmake/klib-config.cmake.in + ${CMAKE_CURRENT_BINARY_DIR}/klib-config.cmake + INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/klib) + +install(FILES ${CMAKE_CURRENT_BINARY_DIR}/klib-config.cmake + DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/klib) + diff --git a/abstract-machine/klib/src/stdio.c b/abstract-machine/klib/src/stdio.c index 1b19953..fec63bc 100644 --- a/abstract-machine/klib/src/stdio.c +++ b/abstract-machine/klib/src/stdio.c @@ -5,8 +5,20 @@ #if !defined(__ISA_NATIVE__) || defined(__NATIVE_USE_KLIB__) +int vprintf(const char *fmt, va_list ap) { + const char *p = fmt; + while(*p != '\0') { + putch(*p); + } + return 0; +} + int printf(const char *fmt, ...) { - panic("Not implemented"); + va_list args; + va_start(args, fmt); + vprintf(fmt, args); + va_end(args); + return 0; } int vsprintf(char *out, const char *fmt, va_list ap) { diff --git a/abstract-machine/klib/src/string.c b/abstract-machine/klib/src/string.c index f1a1f22..931e7dd 100644 --- a/abstract-machine/klib/src/string.c +++ b/abstract-machine/klib/src/string.c @@ -5,43 +5,115 @@ #if !defined(__ISA_NATIVE__) || defined(__NATIVE_USE_KLIB__) size_t strlen(const char *s) { - panic("Not implemented"); + const char *p = s; + size_t len = 0; + while(*(p++) != '\0') len++; + return len; } char *strcpy(char *dst, const char *src) { - panic("Not implemented"); + char *p_dst = dst; + const char *p_src = src; + for(; *p_src != '\0'; p_src++, p_dst++) { + *p_dst = *p_src; + } + *p_dst = '\0'; + return dst; } char *strncpy(char *dst, const char *src, size_t n) { - panic("Not implemented"); + int i = 0; + for(; i < n && src[i] != '\0'; i++) { + dst[i] = src[i]; + } + for(; i < n; i++) { + dst[i] = '\0'; + } + return dst; } char *strcat(char *dst, const char *src) { - panic("Not implemented"); + char *p_dst = dst; + const char *p_src = src; + while(*p_dst != '\0') p_dst++; + for(; *p_src != '\0'; p_src++, p_dst++) { + *p_dst = *p_src; + } + *p_dst = '\0'; + return dst; } int strcmp(const char *s1, const char *s2) { - panic("Not implemented"); + const char *p_s1 = s1, *p_s2 = s2; + for(; *p_s1 == *p_s2; p_s1++, p_s2++) { + if(*p_s1 == '\0' || *p_s2 == '\0') { + break; + } + } + return *p_s1 - *p_s2; } int strncmp(const char *s1, const char *s2, size_t n) { - panic("Not implemented"); + const char *p_s1 = s1, *p_s2 = s2; + int i = 0; + for(i = 0; i < n - 1; i++) { + if(s1[i] == '\0' || s2[i] == '\0') + break; + } + return s1[i] - s2[i]; } void *memset(void *s, int c, size_t n) { - panic("Not implemented"); + uint8_t *p = s; + for(int i = 0; i < n; i++) { + p[i] = c; + } + return s; } void *memmove(void *dst, const void *src, size_t n) { - panic("Not implemented"); + if (src + n > dst && src < dst) { + size_t len = dst - src; + void *p_dst = (void *)src + n; + const void *p_src = src + n - len; + while(p_dst >= dst) { + memcpy(p_dst, p_src, len); + p_src -= len; + p_dst -= len; + } + if(n % len) memcpy(dst, src, n % len); + } else if (dst < src && dst + n > src) { + size_t len = src - dst; + void *p_dst = dst; + const void *p_src = src; + while(p_src < src + n) { + memcpy(p_dst, p_src, len); + p_src += len; + p_dst += len; + } + if(n % len) memcpy(p_dst, p_src, n % len); + } else { + memcpy(dst, src, n); + } + + return dst; } void *memcpy(void *out, const void *in, size_t n) { - panic("Not implemented"); + for (size_t i = 0 ; i < n ; i++) { + *(uint8_t *)(out + i) = *(uint8_t *)(in + i); + } + return out; } int memcmp(const void *s1, const void *s2, size_t n) { - panic("Not implemented"); + const uint8_t *p1 = s1, *p2 = s2; + for (int i = 0; i < n; i++) { + if(*p1 != *p2) + return p1 - p2; + p1++; p2++; + } + return 0; } #endif diff --git a/abstract-machine/klib/tests/CMakeLists.txt b/abstract-machine/klib/tests/CMakeLists.txt new file mode 100644 index 0000000..f72c555 --- /dev/null +++ b/abstract-machine/klib/tests/CMakeLists.txt @@ -0,0 +1,17 @@ +set(TEST_SOURCES + stdio + string +) + +foreach(TEST IN LISTS TEST_SOURCES) + add_executable(${TEST} ${TEST}.c) + target_link_libraries(${TEST} am-${ARCH} klib m) + target_include_directories(${TEST} + PRIVATE $ + PRIVATE $ + ) + # TODO: Run tests in other configurations + if(__PLATFORM_NATIVE__) + add_test(NAME ${TEST} COMMAND ${TEST}) + endif() +endforeach() diff --git a/abstract-machine/klib/tests/stdio.c b/abstract-machine/klib/tests/stdio.c new file mode 100644 index 0000000..7287e83 --- /dev/null +++ b/abstract-machine/klib/tests/stdio.c @@ -0,0 +1,5 @@ +#include + +int main(void) { + return 0; +} \ No newline at end of file diff --git a/abstract-machine/klib/tests/string.c b/abstract-machine/klib/tests/string.c new file mode 100644 index 0000000..640f2d6 --- /dev/null +++ b/abstract-machine/klib/tests/string.c @@ -0,0 +1,75 @@ +#include +#include +#include + +void test_strcpy() { + char b[32]; + char *s; + b[16]='a'; b[17]='b'; b[18]='c'; b[19]=0; + panic_on((s = strcpy(b, b+16)) != b, "strcpy wrong return value"); + panic_on(strcmp(s, "abc") != 0, "strcpy gave incorrect string"); + panic_on((s = strcpy(b+1, b+16)) != b+1, "strcpy wrong return value"); + panic_on(strcmp(s, "abc") != 0, "strcpy gave incorrect string"); + + panic_on((s = strcpy(b+1, b+17)) != b+1, "strcpy wrong return value"); + panic_on(strcmp(s, "bc") != 0, "strcpy gave incorrect string"); +} + +void test_strncpy() { + char b[32]; + char *s; + int i; + b[3] = 'x'; b[4] = 0; + panic_on((s = strncpy(b, "abc", 3)) != b, "strncpy wrong return value"); + panic_on(b[2] != 'c', "strncpy fails to copy last byte"); + panic_on(b[3] != 'x', "strncpy overruns buffer to null-terminate"); +} + +void test_strncmp() { + panic_on(strncmp("abcd", "abce", 3) != 0, "strncmp compares past n"); + panic_on(strncmp("abc", "abd", 3) == 0, "strncmp fails to compare n-1st byte"); +} + +void test_memset() { + uint8_t arr[128]; + arr[120] = 0xd; + panic_on(memset(arr, 0xf, 120) != arr, "memset wrong return value"); + panic_on(arr[7] != 0xf, "memset fails to set value in range"); + panic_on(arr[120] != 0xd, "memset set value past n"); +} + +void test_memcpy() { + const uint8_t src[] = { 0x0, 0x0, 0x1, 0x2, 0x3, 0x4, 0x0, 0x0 }; + uint8_t dst[8] = {0}; + memcpy(dst, src, 8); + panic_on(memcmp(dst, src, 8) != 0, "memcpy fails to copy memory"); +} + +void test_memmove() { + const uint8_t ref[] = { 0x0, 0x0, 0x1, 0x2, 0x3, 0x4, 0x0, 0x0 }; + uint8_t dst[8] = {0}; + const uint8_t ans1[] = { 0x1, 0x2, 0x3, 0x4, 0x3, 0x4, 0x0, 0x0 }; + const uint8_t ans2[] = { 0x1, 0x2, 0x2, 0x3, 0x4, 0x3, 0x0, 0x0 }; + const uint8_t ans3[] = { 0x1, 0x2, 0x2, 0x1, 0x2, 0x2, 0x3, 0x4 }; + memmove(dst, ref, 8); + panic_on(memcmp(dst, ref, 8) != 0, "memmove fails to copy non-overlapping memory"); + + memmove(dst, dst + 2, 4); + panic_on(memcmp(dst, ans1, 8) != 0, "memmove fails to copy overlapping memory (dst < src)"); + + memmove(dst + 2, dst + 1, 4); + panic_on(memcmp(dst, ans2, 8) != 0, "memmove fails to copy overlapping memory (src < dst)"); + + memmove(dst + 3, dst, 5); + panic_on(memcmp(dst, ans3, 8) != 0, "memmove fails to copy overlapping memory (src < dst)"); +} + +int main(void) { + test_strcpy(); + test_strncpy(); + test_strncmp(); + test_memset(); + test_memcpy(); + test_memmove(); + return 0; +} diff --git a/abstract-machine/out/install/lib/libklib.a b/abstract-machine/out/install/lib/libklib.a new file mode 100644 index 0000000..5023a30 Binary files /dev/null and b/abstract-machine/out/install/lib/libklib.a differ diff --git a/am-kernels b/am-kernels new file mode 160000 index 0000000..2f55982 --- /dev/null +++ b/am-kernels @@ -0,0 +1 @@ +Subproject commit 2f559823a63cf6909d5a9e32dee47d6891caf553 diff --git a/nemu/flake.lock b/flake.lock similarity index 54% rename from nemu/flake.lock rename to flake.lock index 5c64744..36b9a39 100644 --- a/nemu/flake.lock +++ b/flake.lock @@ -5,11 +5,11 @@ "systems": "systems" }, "locked": { - "lastModified": 1701680307, - "narHash": "sha256-kAuep2h5ajznlPMD9rnQyffWG8EM/C73lejGofXvdM8=", + "lastModified": 1709126324, + "narHash": "sha256-q6EQdSeUZOG26WelxqkmR7kArjgWCdw5sfJVHPH/7j8=", "owner": "numtide", "repo": "flake-utils", - "rev": "4022d587cbbfd70fe950c1e2083a02621806a725", + "rev": "d465f4819400de7c8d874d50b982301f28a84605", "type": "github" }, "original": { @@ -20,11 +20,11 @@ }, "nixpkgs": { "locked": { - "lastModified": 1704722960, - "narHash": "sha256-mKGJ3sPsT6//s+Knglai5YflJUF2DGj7Ai6Ynopz0kI=", + "lastModified": 1709237383, + "narHash": "sha256-cy6ArO4k5qTx+l5o+0mL9f5fa86tYUX3ozE1S+Txlds=", "owner": "NixOS", "repo": "nixpkgs", - "rev": "317484b1ead87b9c1b8ac5261a8d2dd748a0492d", + "rev": "1536926ef5621b09bba54035ae2bb6d806d72ac8", "type": "github" }, "original": { @@ -34,31 +34,10 @@ "type": "github" } }, - "nur-xin": { - "inputs": { - "nixpkgs": [ - "nixpkgs" - ] - }, - "locked": { - "lastModified": 1704680562, - "narHash": "sha256-ffec3HL8OgbHB/TvLHILvC3ylou6N+KDtrn4qYVV+U4=", - "ref": "refs/heads/master", - "rev": "8adf33b6fdd113c645d83feda28622a0b1ef9f83", - "revCount": 144, - "type": "git", - "url": "https://git.xinyang.life/xin/nur.git" - }, - "original": { - "type": "git", - "url": "https://git.xinyang.life/xin/nur.git" - } - }, "root": { "inputs": { "flake-utils": "flake-utils", - "nixpkgs": "nixpkgs", - "nur-xin": "nur-xin" + "nixpkgs": "nixpkgs" } }, "systems": { diff --git a/flake.nix b/flake.nix new file mode 100644 index 0000000..3a07d79 --- /dev/null +++ b/flake.nix @@ -0,0 +1,59 @@ +{ + inputs = { + nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable"; + flake-utils.url = "github:numtide/flake-utils"; + }; + + outputs = { self, ... }@inputs: with inputs; + flake-utils.lib.eachDefaultSystem (system: + let + pkgs = nixpkgs.legacyPackages.${system}; + crossPkgs = import nixpkgs { + localSystem = system; + crossSystem = { + config = "riscv32-none-elf"; + gcc = { + abi = "ilp32"; + arch = "rv32if"; + }; + }; + }; + in + { + packages.nemu = pkgs.callPackage ./nemu { am-kernels = self.packages.${system}.am-kernels; }; + packages.abstract-machine = crossPkgs.callPackage ./abstract-machine { isa = "riscv"; platform = "nemu"; }; + + packages.am-kernels = crossPkgs.stdenv.mkDerivation rec { + pname = "am-kernels-cmake"; + version = "2024.02.18"; + + src = ./am-kernels; + + nativeBuildInputs = [ + pkgs.cmake + ]; + + cmakeFlags = [ + (pkgs.lib.cmakeFeature "ISA" "riscv") + (pkgs.lib.cmakeFeature "PLATFORM" "nemu") + (pkgs.lib.cmakeFeature "CMAKE_INSTALL_DATADIR" "share") + ]; + + buildInputs = [ + # SDL2 + self.packages.${system}.abstract-machine + ]; + }; + + devShells.nemu = pkgs.mkShell { + packages = with pkgs; [ + clang-tools + gdb + ]; + inputsFrom = [ + self.packages.${system}.nemu + ]; + }; + } + ); +} diff --git a/nemu/Kconfig b/nemu/Kconfig index a1ed68e..ae1921f 100644 --- a/nemu/Kconfig +++ b/nemu/Kconfig @@ -143,14 +143,54 @@ config TRACE_END config ITRACE depends on TRACE && TARGET_NATIVE_ELF && ENGINE_INTERPRETER - bool "Enable instruction tracer" + bool "Enable instruction tracing" default y + help + Instraction tracing will log past instructions into a ring buffer + and print them when NEMU exit unexpectedly. config ITRACE_COND depends on ITRACE string "Only trace instructions when the condition is true" default "true" +config ITRACE_BUFFER + depends on ITRACE + int "Buffer size for intruction trace (unit: number of instructions)" + default 10 + +config MTRACE + depends on TRACE && TARGET_NATIVE_ELF && ENGINE_INTERPRETER + bool "Enable memory tracing" + default n + +config MTRACE_RANGE + depends on MTRACE + string "Memory trace active range" + default "0x0-0xfffffff" + help + Memory tracer will only print memory access in these ranges. + Use comma to seperate between ranges. + +config MTRACE_RANGE_MAX + depends on MTRACE + int "Max range count in MTRACE_RANGE" + default 10 + +config FTRACE + depends on TRACE && TARGET_NATIVE_ELF && ENGINE_INTERPRETER + bool "Enable function tracing" + default y + +config FTRACE_STACK_SIZE + depends on FTRACE + int "Max function track stack size" + default 100 + +config FTRACE_LOG + depends on FTRACE + bool "Print log when entering a funciton" + default n config DIFFTEST depends on TARGET_NATIVE_ELF diff --git a/nemu/Makefile b/nemu/Makefile index 0f360fe..e5e5838 100644 --- a/nemu/Makefile +++ b/nemu/Makefile @@ -64,12 +64,34 @@ include $(NEMU_HOME)/scripts/native.mk endif include $(NEMU_HOME)/tests/Makefile -all-tests: TEST_OBJS = $(filter-out $(OBJ_DIR)/src/nemu-main.o, $(OBJS)) -all-tests: CFLAGS += $(shell pkg-config --cflags check) -all-tests: LDFLAGS += $(shell pkg-config --libs check) -all-tests: $(TEST_SRCS:%.c=$(OBJ_DIR)/%) +unit-tests: TEST_OBJS = $(filter-out $(OBJ_DIR)/src/nemu-main.o, $(OBJS)) +unit-tests: CFLAGS += $(shell pkg-config --cflags check) +unit-tests: LDFLAGS += $(shell pkg-config --libs check) +unit-tests: $(TEST_SRCS:%.c=$(OBJ_DIR)/%) -test: all-tests - @$(OBJ_DIR)/tests/expr_test +IMAGES = $(patsubst %.bin, %, $(shell find $(IMAGES_PATH) -type f -name '*.bin')) -.PHONY: test \ No newline at end of file +COLOR_RED = \033[1;31m +COLOR_GREEN = \033[1;32m +COLOR_BLUE = \033[1;34m +COLOR_NONE = \033[0m + +RESULT = .result.tmp +$(shell > $(RESULT)) # Clear result file + +$(IMAGES): %: %.bin $(BINARY) + @echo + TEST $(notdir $<) + @$(BINARY) -b $< >/dev/null 2>&1 || printf "\t%14s\n" $(notdir $<) >> $(RESULT) + +integration-tests: $(IMAGES) + @printf "$(COLOR_BLUE)INTEGRATION TEST:$(COLOR_NONE)\n\tALL: %s\n\tFAILED: %s\n" $(words $(IMAGES)) $(shell wc -l $(RESULT) | cut -f1 -d' ') + @test ! -s $(RESULT) || printf "$(COLOR_RED)FAILED:$(COLOR_NONE)\n" + @cat $(RESULT) + @test ! -s $(RESULT); \ + r=$$?; \ + $(RM) $(RESULT); \ + test $$r -eq 0 + +test: unit-tests integration-tests + +.PHONY: test unit-tests integration-tests diff --git a/nemu/default.nix b/nemu/default.nix new file mode 100644 index 0000000..d3d5a70 --- /dev/null +++ b/nemu/default.nix @@ -0,0 +1,63 @@ +{ pkgs, + lib, + stdenv, + am-kernels, + dtc +}: + +stdenv.mkDerivation rec { + pname = "nemu"; + version = "2024-03-02"; + + src = ./.; + + nativeBuildInputs = with pkgs; [ + gnumake + pkg-config + flex + bison + dtc + ]; + + buildInputs = with pkgs; [ + readline + libllvm + ]; + + checkInputs = [ + pkgs.check + am-kernels + ]; + + configurePhase = '' + export NEMU_HOME=$(pwd) + make alldefconfig + ''; + + buildPhase = '' + make + ''; + + doCheck = true; + checkPhase = '' + export IMAGES_PATH=${am-kernels}/share/binary + make test + ''; + + installPhase = '' + mkdir -p $out/bin + make PREFIX=$out install + ''; + + shellHook = '' + export NEMU_HOME=$(pwd) + export IMAGES_PATH=${am-kernels}/share/binary + ''; + + meta = with lib; { + description = "NJU EMUlator, a full system x86/mips32/riscv32/riscv64 emulator for teaching"; + homepage = "https://github.com/NJU-ProjectN/nemu.git"; + license = with licenses; [ ]; + maintainers = with maintainers; [ ]; + }; +} diff --git a/nemu/flake.nix b/nemu/flake.nix deleted file mode 100644 index 325421f..0000000 --- a/nemu/flake.nix +++ /dev/null @@ -1,80 +0,0 @@ -{ - inputs = { - nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable"; - flake-utils.url = "github:numtide/flake-utils"; - nur-xin = { - url = "git+https://git.xinyang.life/xin/nur.git"; - inputs.nixpkgs.follows = "nixpkgs"; - }; - }; - - outputs = { self, ... }@inputs: with inputs; - flake-utils.lib.eachDefaultSystem (system: - let - pkgs = nixpkgs.legacyPackages.${system} // - { nur.xin = nur-xin.legacyPackages.${system}; }; - in - { - devShells.default = with pkgs; mkShell { - packages = [ - clang-tools - rnix-lsp - bear - - gdb - jre - - gtkwave - ]; - - inputsFrom = [ self.packages.${system}.nemu ]; - }; - - packages.nemu = with pkgs; stdenv.mkDerivation rec { - pname = "nemu"; - version = "2024-01-02"; - - src = ./.; - - nativeBuildInputs = [ - gnumake - flex - bison - pkg-config - python3 # for testing - ]; - - buildInputs = [ - check - readline - libllvm - ]; - - configurePhase = '' - echo NEMU_HOME=$NEMU_HOME - echo pwd=$(pwd) - mkdir -p $(pwd)/kconfig - WORK_DIR=$(pwd) obj=$(pwd)/kconfig make --trace -e -f scripts/config.mk WORK_DIR=$(pwd) obj=$(pwd)/kconfig rv32_defconfig - ''; - - installPhase = '' - BUILD_DIR=$out make install - ''; - - checkPhase = '' - BUILD_DIR=$out make test - ''; - - NEMU_HOME = src; - - meta = with lib; { - description = "NJU EMUlator, a full system x86/mips32/riscv32/riscv64 emulator for teaching"; - homepage = "https://github.com/NJU-ProjectN/nemu.git"; - license = with licenses; [ ]; - maintainers = with maintainers; [ ]; - }; - }; - } - ); -} - diff --git a/nemu/include/common.h b/nemu/include/common.h index fbffaa5..08a46e5 100644 --- a/nemu/include/common.h +++ b/nemu/include/common.h @@ -17,12 +17,12 @@ #define __COMMON_H__ #include -#include #include #include #include #include +#include #ifdef CONFIG_TARGET_AM #include @@ -31,23 +31,6 @@ #include #endif -#if CONFIG_MBASE + CONFIG_MSIZE > 0x100000000ul -#define PMEM64 1 -#endif - -typedef MUXDEF(CONFIG_ISA64, uint64_t, uint32_t) word_t; -typedef MUXDEF(CONFIG_ISA64, int64_t, int32_t) sword_t; -static const word_t WORD_T_MAX = MUXDEF(CONFIG_ISA64, UINT64_MAX, UINT32_MAX); -static const sword_t SWORD_T_MAX = MUXDEF(CONFIG_ISA64, INT64_MAX, INT32_MAX); -static const sword_t SWORD_T_MIN = MUXDEF(CONFIG_ISA64, INT64_MIN, INT32_MIN); -#define WORD_BYTES MUXDEF(CONFIG_ISA64, 8, 4) -#define FMT_WORD MUXDEF(CONFIG_ISA64, "0x%016" PRIx64, "0x%08" PRIx32) - -typedef word_t vaddr_t; -typedef MUXDEF(PMEM64, uint64_t, uint32_t) paddr_t; -#define FMT_PADDR MUXDEF(PMEM64, "0x%016" PRIx64, "0x%08" PRIx32) -typedef uint16_t ioaddr_t; - #include #endif diff --git a/nemu/include/cpu/decode.h b/nemu/include/cpu/decode.h index 915bcf2..a17c888 100644 --- a/nemu/include/cpu/decode.h +++ b/nemu/include/cpu/decode.h @@ -23,7 +23,6 @@ typedef struct Decode { vaddr_t snpc; // static next pc vaddr_t dnpc; // dynamic next pc ISADecodeInfo isa; - IFDEF(CONFIG_ITRACE, char logbuf[128]); } Decode; // --- pattern matching mechanism --- diff --git a/nemu/include/debug.h b/nemu/include/debug.h index 087da4d..329c64a 100644 --- a/nemu/include/debug.h +++ b/nemu/include/debug.h @@ -16,9 +16,14 @@ #ifndef __DEBUG_H__ #define __DEBUG_H__ -#include #include #include +#include + +IFDEF(CONFIG_ITRACE, void log_itrace_print()); + +#define Trace(format, ...) \ + _Log("[TRACE] " format "\n", ## __VA_ARGS__) #define Log(format, ...) \ _Log(ANSI_FMT("[INFO] %s:%d %s() ", ANSI_FG_BLUE) format "\n", \ @@ -38,6 +43,7 @@ MUXDEF(CONFIG_TARGET_AM, printf(ANSI_FMT(format, ANSI_FG_RED) "\n", ## __VA_ARGS__), \ (fflush(stdout), fprintf(stderr, ANSI_FMT(format, ANSI_FG_RED) "\n", ## __VA_ARGS__))); \ IFNDEF(CONFIG_TARGET_AM, extern FILE* log_fp; fflush(log_fp)); \ + IFDEF(CONFIG_ITRACE, log_itrace_print()); \ extern void assert_fail_msg(); \ assert_fail_msg(); \ assert(cond); \ diff --git a/nemu/include/ftrace.h b/nemu/include/ftrace.h new file mode 100644 index 0000000..9fcf28a --- /dev/null +++ b/nemu/include/ftrace.h @@ -0,0 +1,18 @@ +#ifndef __FUNC_DEF_H__ +#define __FUNC_DEF_H__ +#include + +#ifdef CONFIG_FTRACE +typedef struct { + vaddr_t start; + vaddr_t len; + char * name; +} func_t; + +extern func_t *func_table; +void ftrace_call(vaddr_t, vaddr_t); +void ftrace_return(vaddr_t, vaddr_t); +// const char *get_func_name(vaddr_t addr); +#endif + +#endif \ No newline at end of file diff --git a/nemu/include/macro.h b/nemu/include/macro.h index 8aa38f8..47f11b0 100644 --- a/nemu/include/macro.h +++ b/nemu/include/macro.h @@ -92,6 +92,8 @@ #define PG_ALIGN __attribute((aligned(4096))) +#define FAILED_GOTO(tag, exp) do {if((exp)) goto tag;} while(0) + #if !defined(likely) #define likely(cond) __builtin_expect(cond, 1) #define unlikely(cond) __builtin_expect(cond, 0) diff --git a/nemu/include/types.h b/nemu/include/types.h new file mode 100644 index 0000000..364f2ed --- /dev/null +++ b/nemu/include/types.h @@ -0,0 +1,21 @@ +#ifndef __TYPES_H__ +#define __TYPES_H__ +#include +#include +#if CONFIG_MBASE + CONFIG_MSIZE > 0x100000000ul +#define PMEM64 1 +#endif + +typedef MUXDEF(CONFIG_ISA64, uint64_t, uint32_t) word_t; +typedef MUXDEF(CONFIG_ISA64, int64_t, int32_t) sword_t; +static const word_t WORD_T_MAX = MUXDEF(CONFIG_ISA64, UINT64_MAX, UINT32_MAX); +static const sword_t SWORD_T_MAX = MUXDEF(CONFIG_ISA64, INT64_MAX, INT32_MAX); +static const sword_t SWORD_T_MIN = MUXDEF(CONFIG_ISA64, INT64_MIN, INT32_MIN); +#define WORD_BYTES MUXDEF(CONFIG_ISA64, 8, 4) +#define FMT_WORD MUXDEF(CONFIG_ISA64, "0x%016" PRIx64, "0x%08" PRIx32) + +typedef word_t vaddr_t; +typedef MUXDEF(PMEM64, uint64_t, uint32_t) paddr_t; +#define FMT_PADDR MUXDEF(PMEM64, "0x%016" PRIx64, "0x%08" PRIx32) +typedef uint16_t ioaddr_t; +#endif \ No newline at end of file diff --git a/nemu/include/utils.h b/nemu/include/utils.h index 2cd1561..f974584 100644 --- a/nemu/include/utils.h +++ b/nemu/include/utils.h @@ -16,7 +16,7 @@ #ifndef __UTILS_H__ #define __UTILS_H__ -#include +#include // ----------- state ----------- diff --git a/nemu/scripts/config.mk b/nemu/scripts/config.mk index 0525ee3..01b9d1f 100644 --- a/nemu/scripts/config.mk +++ b/nemu/scripts/config.mk @@ -48,6 +48,9 @@ menuconfig: $(MCONF) $(CONF) $(FIXDEP) savedefconfig: $(CONF) $(Q)$< $(silent) --$@=configs/defconfig $(Kconfig) +alldefconfig: $(CONF) $(FIXDEP) + $(Q)$(CONF) $(silent) --$@ $(Kconfig) + %defconfig: $(CONF) $(FIXDEP) $(Q)$< $(silent) --defconfig=configs/$@ $(Kconfig) $(Q)$< $(silent) --syncconfig $(Kconfig) @@ -60,7 +63,7 @@ help: @echo ' savedefconfig - Save current config as configs/defconfig (minimal config)' distclean: clean - -@rm -rf $(rm-distclean) + -rm -rf $(rm-distclean) .PHONY: help distclean diff --git a/nemu/src/cpu/cpu-exec.c b/nemu/src/cpu/cpu-exec.c index 1f2940f..1e402ab 100644 --- a/nemu/src/cpu/cpu-exec.c +++ b/nemu/src/cpu/cpu-exec.c @@ -13,6 +13,7 @@ * See the Mulan PSL v2 for more details. ***************************************************************************************/ +#include #include #include #include @@ -29,15 +30,17 @@ CPU_state cpu = {}; uint64_t g_nr_guest_inst = 0; static uint64_t g_timer = 0; // unit: us static bool g_print_step = false; +IFDEF(CONFIG_ITRACE, extern char logbuf[CONFIG_ITRACE_BUFFER][128]); +IFDEF(CONFIG_ITRACE, extern int logbuf_rear); void device_update(); bool wp_eval_all(); static void trace_and_difftest(Decode *_this, vaddr_t dnpc) { #ifdef CONFIG_ITRACE_COND - if (ITRACE_COND) { log_write("%s\n", _this->logbuf); } + if (ITRACE_COND) { log_write("%s\n", logbuf[logbuf_rear]); } #endif - if (g_print_step) { IFDEF(CONFIG_ITRACE, puts(_this->logbuf)); } + if (g_print_step) { IFDEF(CONFIG_ITRACE, puts(logbuf[logbuf_rear])); } IFDEF(CONFIG_DIFFTEST, difftest_step(_this->pc, dnpc)); } @@ -47,8 +50,9 @@ static void exec_once(Decode *s, vaddr_t pc) { isa_exec_once(s); cpu.pc = s->dnpc; #ifdef CONFIG_ITRACE - char *p = s->logbuf; - p += snprintf(p, sizeof(s->logbuf), FMT_WORD ":", s->pc); + logbuf_rear = (logbuf_rear + 1) % CONFIG_ITRACE_BUFFER; + char *p = logbuf[logbuf_rear]; + p += snprintf(p, sizeof(logbuf), FMT_WORD ":", s->pc); int ilen = s->snpc - s->pc; int i; uint8_t *inst = (uint8_t *)&s->isa.inst.val; @@ -64,7 +68,7 @@ static void exec_once(Decode *s, vaddr_t pc) { #ifndef CONFIG_ISA_loongarch32r void disassemble(char *str, int size, uint64_t pc, uint8_t *code, int nbyte); - disassemble(p, s->logbuf + sizeof(s->logbuf) - p, + disassemble(p, logbuf[logbuf_rear] + sizeof(logbuf[logbuf_rear]) - p, MUXDEF(CONFIG_ISA_x86, s->snpc, s->pc), (uint8_t *)&s->isa.inst.val, ilen); #else p[0] = '\0'; // the upstream llvm does not support loongarch32r @@ -79,7 +83,7 @@ static void execute(uint64_t n) { g_nr_guest_inst ++; trace_and_difftest(&s, cpu.pc); if (wp_eval_all()) { - puts(s.logbuf); + puts(logbuf[logbuf_rear]); break; } if (nemu_state.state != NEMU_RUNNING) break; @@ -121,13 +125,16 @@ void cpu_exec(uint64_t n) { switch (nemu_state.state) { case NEMU_RUNNING: nemu_state.state = NEMU_STOP; break; - case NEMU_END: case NEMU_ABORT: + case NEMU_END: case NEMU_ABORT: { Log("nemu: %s at pc = " FMT_WORD, (nemu_state.state == NEMU_ABORT ? ANSI_FMT("ABORT", ANSI_FG_RED) : (nemu_state.halt_ret == 0 ? ANSI_FMT("HIT GOOD TRAP", ANSI_FG_GREEN) : ANSI_FMT("HIT BAD TRAP", ANSI_FG_RED))), nemu_state.halt_pc); - // fall through + if(nemu_state.halt_ret != 0) { + log_itrace_print(); + } + } // fall through case NEMU_QUIT: statistic(); } } diff --git a/nemu/src/isa/riscv32/difftest/dut.c b/nemu/src/isa/riscv32/difftest/dut.c index c5ebf13..06748ce 100644 --- a/nemu/src/isa/riscv32/difftest/dut.c +++ b/nemu/src/isa/riscv32/difftest/dut.c @@ -18,7 +18,10 @@ #include "../local-include/reg.h" bool isa_difftest_checkregs(CPU_state *ref_r, vaddr_t pc) { - return false; + for(int i = 0; i < MUXDEF(CONFIG_RVE, 16, 32); i++) { + if(!difftest_check_reg(reg_name(i), pc, ref_r->gpr[i], gpr(i))) return false; + } + return true; } void isa_difftest_attach() { diff --git a/nemu/src/isa/riscv32/inst.c b/nemu/src/isa/riscv32/inst.c index cb0c44e..1c41c63 100644 --- a/nemu/src/isa/riscv32/inst.c +++ b/nemu/src/isa/riscv32/inst.c @@ -1,29 +1,33 @@ /*************************************************************************************** -* Copyright (c) 2014-2022 Zihao Yu, Nanjing University -* -* NEMU is licensed under Mulan PSL v2. -* You can use this software according to the terms and conditions of the Mulan PSL v2. -* You may obtain a copy of Mulan PSL v2 at: -* http://license.coscl.org.cn/MulanPSL2 -* -* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, -* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, -* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. -* -* See the Mulan PSL v2 for more details. -***************************************************************************************/ + * Copyright (c) 2014-2022 Zihao Yu, Nanjing University + * + * NEMU is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan + *PSL v2. You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY + *KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO + *NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. + * + * See the Mulan PSL v2 for more details. + ***************************************************************************************/ +#include #include "local-include/reg.h" +#include "macro.h" #include #include #include +#include +#include #define R(i) gpr(i) #define Mr vaddr_read #define Mw vaddr_write enum { - TYPE_I, TYPE_U, TYPE_S, + TYPE_R, TYPE_I, TYPE_I_SHIFT, TYPE_U, TYPE_S, TYPE_B, TYPE_J, TYPE_N, // none }; @@ -31,20 +35,45 @@ enum { #define src2R() do { *src2 = R(rs2); } while (0) #define immI() do { *imm = SEXT(BITS(i, 31, 20), 12); } while(0) #define immU() do { *imm = SEXT(BITS(i, 31, 12), 20) << 12; } while(0) -#define immS() do { *imm = (SEXT(BITS(i, 31, 25), 7) << 5) | BITS(i, 11, 7); } while(0) +#define immS() do { *imm = SEXT(BITS(i, 31, 25), 7) << 5 | BITS(i, 11, 7); } while(0) +#define immB() do { *imm = SEXT(BITS(i, 31, 31), 1) << 12 | BITS(i, 30, 25) << 5 | BITS(i, 11, 8) << 1 | BITS(i, 7, 7) << 11; } while(0) +#define immJ() do { *imm = SEXT(BITS(i, 31, 31), 1) << 20 | BITS(i, 30, 21) << 1 | BITS(i, 20, 20) << 11 | BITS(i, 19, 12) << 12; } while(0) -static void decode_operand(Decode *s, int *rd, word_t *src1, word_t *src2, word_t *imm, int type) { +static void decode_operand(Decode *s, int *rd, word_t *src1, word_t *src2, + word_t *imm, int type) { uint32_t i = s->isa.inst.val; int rs1 = BITS(i, 19, 15); int rs2 = BITS(i, 24, 20); *rd = BITS(i, 11, 7); switch (type) { + case TYPE_R: src1R(); src2R(); break; case TYPE_I: src1R(); immI(); break; case TYPE_U: immU(); break; + case TYPE_J: immJ(); break; case TYPE_S: src1R(); src2R(); immS(); break; + case TYPE_B: src1R(); src2R(); immB(); break; } } +static void do_branch(Decode *s, bool condition, word_t offset) { + if (condition) { + // puts(s->logbuf[s->logbuf_rear]); + s->dnpc = s->pc + offset; + } +} + +#ifdef CONFIG_FTRACE +static void ftrace_jalr(Decode *s, int rd, vaddr_t dst) { + uint32_t i = s->isa.inst.val; + int rs1 = BITS(i, 19, 15); + if(rs1 == 1 && rd == 0) { + ftrace_return(s->pc, dst); + } else { + ftrace_call(s->pc, dst); + } +} +#endif + static int decode_exec(Decode *s) { int rd = 0; word_t src1 = 0, src2 = 0, imm = 0; @@ -57,11 +86,63 @@ static int decode_exec(Decode *s) { } INSTPAT_START(); + INSTPAT("??????? ????? ????? ??? ????? 01101 11", lui , U, R(rd) = imm); INSTPAT("??????? ????? ????? ??? ????? 00101 11", auipc , U, R(rd) = s->pc + imm); + + INSTPAT("??????? ????? ????? ??? ????? 11011 11", jal , J, do { + s->dnpc = s->pc + imm; R(rd) = s->pc + 4; + IFDEF(CONFIG_FTRACE, ftrace_call(s->pc, s->pc + imm)); } while(0)); + INSTPAT("??????? ????? ????? ??? ????? 11001 11", jalr , I, do { + s->dnpc = src1 + imm; R(rd) = s->pc + 4; + IFDEF(CONFIG_FTRACE, ftrace_jalr(s, rd, src1 + imm)); } while(0)); + INSTPAT("??????? ????? ????? 000 ????? 11000 11", beq , B, do_branch(s, src1 == src2, imm)); + INSTPAT("??????? ????? ????? 001 ????? 11000 11", bne , B, do_branch(s, src1 != src2, imm)); + INSTPAT("??????? ????? ????? 100 ????? 11000 11", blt , B, do_branch(s, (sword_t)src1 < (sword_t)src2, imm)); + INSTPAT("??????? ????? ????? 101 ????? 11000 11", bge , B, do_branch(s, (sword_t)src1 >= (sword_t)src2, imm)); + INSTPAT("??????? ????? ????? 110 ????? 11000 11", bltu , B, do_branch(s, src1 < src2, imm)); + INSTPAT("??????? ????? ????? 111 ????? 11000 11", bgeu , B, do_branch(s, src1 >= src2, imm)); + + INSTPAT("??????? ????? ????? 000 ????? 00000 11", lb , I, R(rd) = SEXT(Mr(src1 + imm, 1), 8)); + INSTPAT("??????? ????? ????? 001 ????? 00000 11", lh , I, R(rd) = SEXT(Mr(src1 + imm, 2), 16)); + INSTPAT("??????? ????? ????? 010 ????? 00000 11", lw , I, R(rd) = SEXT(Mr(src1 + imm, 4), 32)); INSTPAT("??????? ????? ????? 100 ????? 00000 11", lbu , I, R(rd) = Mr(src1 + imm, 1)); + INSTPAT("??????? ????? ????? 101 ????? 00000 11", lhu , I, R(rd) = Mr(src1 + imm, 2)); INSTPAT("??????? ????? ????? 000 ????? 01000 11", sb , S, Mw(src1 + imm, 1, src2)); + INSTPAT("??????? ????? ????? 001 ????? 01000 11", sh , S, Mw(src1 + imm, 2, src2)); + INSTPAT("??????? ????? ????? 010 ????? 01000 11", sw , S, Mw(src1 + imm, 4, src2)); + + INSTPAT("??????? ????? ????? 000 ????? 00100 11", addi , I, R(rd) = src1 + imm); + INSTPAT("??????? ????? ????? 010 ????? 00100 11", slti , I, R(rd) = (sword_t)src1 < (sword_t)imm ? 1 : 0); + INSTPAT("??????? ????? ????? 011 ????? 00100 11", sltiu , I, R(rd) = src1 < imm ? 1 : 0); + INSTPAT("??????? ????? ????? 100 ????? 00100 11", xori , I, R(rd) = src1 ^ imm); + INSTPAT("??????? ????? ????? 110 ????? 00100 11", ori , I, R(rd) = src1 | imm); + INSTPAT("??????? ????? ????? 111 ????? 00100 11", andi , I, R(rd) = src1 & imm); + INSTPAT("0000000 ????? ????? 001 ????? 00100 11", slli , I, R(rd) = src1 << imm); + INSTPAT("0000000 ????? ????? 101 ????? 00100 11", srli , I, R(rd) = src1 >> imm); + INSTPAT("0100000 ????? ????? 101 ????? 00100 11", srai , I, R(rd) = (sword_t)src1 >> (imm & 0x01F)); + INSTPAT("0000000 ????? ????? 000 ????? 01100 11", add , R, R(rd) = src1 + src2); + INSTPAT("0100000 ????? ????? 000 ????? 01100 11", sub , R, R(rd) = src1 - src2); + INSTPAT("0000000 ????? ????? 001 ????? 01100 11", sll , R, R(rd) = src1 << src2); + INSTPAT("0000000 ????? ????? 010 ????? 01100 11", slt , R, R(rd) = (sword_t)src1 < (sword_t)src2 ? 1 : 0); + INSTPAT("0000000 ????? ????? 011 ????? 01100 11", sltu , R, R(rd) = src1 < src2 ? 1 : 0); + INSTPAT("0000000 ????? ????? 100 ????? 01100 11", xor , R, R(rd) = src1 ^ src2); + INSTPAT("0000000 ????? ????? 101 ????? 01100 11", srl , R, R(rd) = src1 >> src2); + INSTPAT("0100000 ????? ????? 101 ????? 01100 11", sra , R, R(rd) = (sword_t)src1 >> (src2 & 0x01F)); + INSTPAT("0000000 ????? ????? 110 ????? 01100 11", or , R, R(rd) = src1 | src2); + INSTPAT("0000000 ????? ????? 111 ????? 01100 11", and , R, R(rd) = src1 & src2); INSTPAT("0000000 00001 00000 000 00000 11100 11", ebreak , N, NEMUTRAP(s->pc, R(10))); // R(10) is $a0 + + // "M" + INSTPAT("0000001 ????? ????? 000 ????? 01100 11", mul , R, R(rd) = src1 * src2); + INSTPAT("0000001 ????? ????? 001 ????? 01100 11", mulh , R, R(rd) = (int64_t)(sword_t)src1 * (sword_t)src2 >> 32); + INSTPAT("0000001 ????? ????? 010 ????? 01100 11", mulhsu , R, R(rd) = (int64_t)(sword_t)src1 * (uint64_t)src2 >> 32); + INSTPAT("0000001 ????? ????? 011 ????? 01100 11", mulhu , R, R(rd) = (uint64_t)src1 * (uint64_t)src2 >> 32); + INSTPAT("0000001 ????? ????? 100 ????? 01100 11", div , R, R(rd) = (sword_t)src1 / (sword_t)src2); + INSTPAT("0000001 ????? ????? 101 ????? 01100 11", divu , R, R(rd) = src1 / src2); + INSTPAT("0000001 ????? ????? 110 ????? 01100 11", rem , R, R(rd) = (sword_t)src1 % (sword_t)src2); + INSTPAT("0000001 ????? ????? 111 ????? 01100 11", remu , R, R(rd) = src1 % src2); + INSTPAT("??????? ????? ????? ??? ????? ????? ??", inv , N, INV(s->pc)); INSTPAT_END(); diff --git a/nemu/src/memory/paddr.c b/nemu/src/memory/paddr.c index ee30e70..437debd 100644 --- a/nemu/src/memory/paddr.c +++ b/nemu/src/memory/paddr.c @@ -13,6 +13,8 @@ * See the Mulan PSL v2 for more details. ***************************************************************************************/ +#include "common.h" +#include "debug.h" #include #include #include @@ -23,6 +25,11 @@ static uint8_t *pmem = NULL; #else // CONFIG_PMEM_GARRAY static uint8_t pmem[CONFIG_MSIZE] PG_ALIGN = {}; #endif +#ifdef CONFIG_MTRACE +static word_t mtrace_start[CONFIG_MTRACE_RANGE_MAX] = {0}; +static word_t mtrace_end[CONFIG_MTRACE_RANGE_MAX] = {0}; +static int range_count = 0; +#endif uint8_t* guest_to_host(paddr_t paddr) { return pmem + paddr - CONFIG_MBASE; } paddr_t host_to_guest(uint8_t *haddr) { return haddr - pmem + CONFIG_MBASE; } @@ -41,23 +48,58 @@ static void out_of_bound(paddr_t addr) { addr, PMEM_LEFT, PMEM_RIGHT, cpu.pc); } +#ifdef CONFIG_MTRACE +static void mtrace_print(char type, word_t addr, int len, word_t data) { + for (int i = 0; i < range_count; i++) + if (addr <= mtrace_end[i] && addr >= mtrace_start[i] ) { + Trace("Mem %c " FMT_PADDR "%d D " FMT_PADDR, type, addr, len, data); + break; + } +} +#endif + void init_mem() { #if defined(CONFIG_PMEM_MALLOC) pmem = malloc(CONFIG_MSIZE); assert(pmem); +#endif +#ifdef CONFIG_MTRACE + char range[sizeof(CONFIG_MTRACE_RANGE)] = CONFIG_MTRACE_RANGE; + char *saveptr, *ptr; + ptr = strtok_r(range, ",", &saveptr); + for (range_count = 0; range_count < CONFIG_MTRACE_RANGE_MAX; ) { + word_t start, end; + Assert(sscanf(ptr, FMT_PADDR "-" FMT_PADDR, &start, &end) == 2, "Config option MTRACE_RANGE has wrong format"); + mtrace_start[range_count] = start; + mtrace_end[range_count] = end; + + range_count++; + ptr = strtok_r(NULL, ",", &saveptr); + if (!ptr) break; + } + Trace("MTRACE ranges: "); + for (int i = 0; i < range_count; i++) { + Trace("[0x%x, 0x%x]", mtrace_start[i], mtrace_end[i]); + } #endif IFDEF(CONFIG_MEM_RANDOM, memset(pmem, rand(), CONFIG_MSIZE)); Log("physical memory area [" FMT_PADDR ", " FMT_PADDR "]", PMEM_LEFT, PMEM_RIGHT); } word_t paddr_read(paddr_t addr, int len) { - if (likely(in_pmem(addr))) return pmem_read(addr, len); - IFDEF(CONFIG_DEVICE, return mmio_read(addr, len)); + word_t result = 0; + if (likely(in_pmem(addr))) { result = pmem_read(addr, len); goto mtrace;} + IFDEF(CONFIG_DEVICE, result = mmio_read(addr, len); goto mtrace) out_of_bound(addr); - return 0; + +mtrace: + IFDEF(CONFIG_MTRACE, mtrace_print('R', addr, len, result)); + + return result; } void paddr_write(paddr_t addr, int len, word_t data) { + IFDEF(CONFIG_MTRACE, mtrace_print('W', addr, len, data)); if (likely(in_pmem(addr))) { pmem_write(addr, len, data); return; } IFDEF(CONFIG_DEVICE, mmio_write(addr, len, data); return); out_of_bound(addr); diff --git a/nemu/src/monitor/monitor.c b/nemu/src/monitor/monitor.c index 2279ca0..0154208 100644 --- a/nemu/src/monitor/monitor.c +++ b/nemu/src/monitor/monitor.c @@ -15,6 +15,7 @@ #include #include +#include void init_rand(); void init_log(const char *log_file); @@ -40,6 +41,7 @@ static void welcome() { void sdb_set_batch_mode(); static char *log_file = NULL; +static char *elf_file = NULL; static char *diff_so_file = NULL; static char *img_file = NULL; static int difftest_port = 1234; @@ -72,6 +74,7 @@ static int parse_args(int argc, char *argv[]) { {"log" , required_argument, NULL, 'l'}, {"diff" , required_argument, NULL, 'd'}, {"port" , required_argument, NULL, 'p'}, + {"elf" , required_argument, NULL, 'f'}, {"help" , no_argument , NULL, 'h'}, {0 , 0 , NULL, 0 }, }; @@ -82,6 +85,7 @@ static int parse_args(int argc, char *argv[]) { case 'p': sscanf(optarg, "%d", &difftest_port); break; case 'l': log_file = optarg; break; case 'd': diff_so_file = optarg; break; + case 'f': elf_file = optarg; break; case 1: img_file = optarg; return 0; default: printf("Usage: %s [OPTION...] IMAGE [args]\n\n", argv[0]); @@ -89,6 +93,7 @@ static int parse_args(int argc, char *argv[]) { printf("\t-l,--log=FILE output log to FILE\n"); printf("\t-d,--diff=REF_SO run DiffTest with reference REF_SO\n"); printf("\t-p,--port=PORT run DiffTest with port PORT\n"); + printf("\t-f,--elf=FILE elf file with debug info\n"); printf("\n"); exit(0); } @@ -126,6 +131,16 @@ void init_monitor(int argc, char *argv[]) { /* Initialize the simple debugger. */ init_sdb(); + // printf("elf_file: %s\n", elf_file); + if(elf_file != NULL) { +#ifdef CONFIG_FTRACE + void init_elf(const char *path); + init_elf(elf_file); +#else + Warning("Elf file provided, but ftrace not turned on. Ignoring elf file."); +#endif + } + #ifndef CONFIG_ISA_loongarch32r IFDEF(CONFIG_ITRACE, init_disasm( MUXDEF(CONFIG_ISA_x86, "i686", diff --git a/nemu/src/monitor/sdb/addrexp.y b/nemu/src/monitor/sdb/addrexp.y index 8e7df9a..4094e0b 100644 --- a/nemu/src/monitor/sdb/addrexp.y +++ b/nemu/src/monitor/sdb/addrexp.y @@ -7,6 +7,7 @@ } %{ #include + #include #include #include #include diff --git a/nemu/src/utils/ftrace.c b/nemu/src/utils/ftrace.c new file mode 100644 index 0000000..ea2f2b6 --- /dev/null +++ b/nemu/src/utils/ftrace.c @@ -0,0 +1,124 @@ +#include +#include +#include +#include +#include + +// Put this into another file +#ifdef CONFIG_FTRACE +static vaddr_t ftrace_stack[CONFIG_FTRACE_STACK_SIZE] = {0}; +static vaddr_t ftrace_stack_len = 0; +func_t *func_table = NULL; +int func_table_len = 0, func_table_size = 8; + +static int cmp_func_t(const void *a, const void *b) { + return ((func_t *)a)->start > ((func_t *)b)->start; +} + +static func_t *get_func(vaddr_t addr) { + int l = 0, r = func_table_len - 1; + while(l <= r) { + int mid = (l + r) / 2; + if(func_table[mid].start <= addr) l = mid + 1; + else r = mid - 1; + } + return l == 0 ? NULL : &func_table[l - 1]; +} + +void init_elf(const char *path) { + FILE *elf_file = fopen(path, "rb"); + Elf32_Ehdr header; + Elf32_Shdr section_header[200], *psh; + + func_table = (func_t *)calloc(func_table_size, sizeof(func_t)); + assert(func_table); + + FAILED_GOTO(failed_header, fread(&header, sizeof(Elf32_Ehdr), 1, elf_file) <= 0); + FAILED_GOTO(failed_header, fseek(elf_file, header.e_shoff, SEEK_SET) != 0); + FAILED_GOTO(failed_header, fread(section_header, header.e_shentsize, header.e_shnum, elf_file) <= 0); + + char *shstrtab = calloc(1, section_header[header.e_shstrndx].sh_size); + FAILED_GOTO(failed_shstrtab, fseek(elf_file, section_header[header.e_shstrndx].sh_offset, SEEK_SET) != 0); + FAILED_GOTO(failed_shstrtab, fread(shstrtab, section_header[header.e_shstrndx].sh_size, 1, elf_file) <= 0); + + Elf32_Shdr *symtab = NULL, *strtab = NULL; + for(int i = 0; i < header.e_shnum; i++) { + psh = section_header + i; + if (psh->sh_type == SHT_SYMTAB) { + symtab = psh; + } else if (psh->sh_type == SHT_STRTAB && strncmp(shstrtab + psh->sh_name, ".strtab", 8) == 0) { + strtab = psh; + } + } + + int sym_length = symtab->sh_size / sizeof(Elf32_Sym); + Elf32_Sym *sym = calloc(sym_length, sizeof(Elf32_Sym)); + assert(sym); + FAILED_GOTO(failed_funcname, fseek(elf_file, symtab->sh_offset, SEEK_SET) != 0); + FAILED_GOTO(failed_funcname, fread(sym, sizeof(Elf32_Sym), sym_length, elf_file) <= 0); + + for(int j = 0; j < sym_length; j++) { + if(ELF32_ST_TYPE(sym[j].st_info) != STT_FUNC) continue; + // Only read function type symbol + func_t *f = &func_table[func_table_len]; + char *func = (char *)malloc(30); + FAILED_GOTO(failed_funcname, fseek(elf_file, strtab->sh_offset + sym[j].st_name, SEEK_SET) != 0); + FAILED_GOTO(failed_funcname, fgets(func, 30, elf_file) <= 0); + f->start = sym[j].st_value; + f->len = sym[j].st_size; + f->name = func; + ++func_table_len; + if(func_table_len >= func_table_size) { + Assert(func_table_size * 2 > func_table_size, "Function table exceed memory limit"); + func_table_size *= 2; + func_table = realloc(func_table, func_table_size * sizeof(func_t)); + Assert(func_table, "Function table exceed memory limit"); + } + } + qsort(func_table, func_table_len, sizeof(func_t), cmp_func_t); + goto success; + +success: + free(sym); + free(shstrtab); + return; + +failed_funcname: + free(sym); +failed_shstrtab: + free(shstrtab); +failed_header: + for(int i = 0; i < func_table_len; i++) { + func_t *f = &func_table[i]; + if(f->name) { free(f->name); } + } + free(func_table); + Error("Failed reading elf file"); + return; +} + +void ftrace_call(vaddr_t pc, vaddr_t addr) { + func_t *f = get_func(addr); + Assert(ftrace_stack_len < CONFIG_FTRACE_STACK_SIZE, + "Ftrace stack exceed size limit, consider turn off ftrace or increase " + "FTRACE_STACK_SIZE."); + ftrace_stack[ftrace_stack_len] = pc + 4; + Trace("%*s0x%x call 0x%x <%s+0x%x>", ftrace_stack_len, "", pc, addr, + f == NULL ? "???" : f->name, addr - f->start); + ftrace_stack_len++; +} + +void ftrace_return(vaddr_t pc, vaddr_t addr) { + --ftrace_stack_len; + for (; addr != ftrace_stack[ftrace_stack_len] && ftrace_stack_len >= 0; + ftrace_stack_len--) { + vaddr_t tco_addr = ftrace_stack[ftrace_stack_len]; + func_t *f = get_func(tco_addr); + Trace("%*s0x%x ret 0x%x <%s+0x%x> (TCO)", ftrace_stack_len, "", pc, tco_addr, + f == NULL ? "???" : f->name, tco_addr - f->start); + } + func_t *f = get_func(addr); + Trace("%*s0x%x ret 0x%x <%s+0x%x>", ftrace_stack_len, "", pc, addr, + f == NULL ? "???" : f->name, addr - f->start); +} +#endif diff --git a/nemu/src/utils/log.c b/nemu/src/utils/log.c index a9bb9a7..a041a2d 100644 --- a/nemu/src/utils/log.c +++ b/nemu/src/utils/log.c @@ -14,6 +14,7 @@ ***************************************************************************************/ #include +#include extern uint64_t g_nr_guest_inst; @@ -35,3 +36,18 @@ bool log_enable() { (g_nr_guest_inst <= CONFIG_TRACE_END), false); } #endif + +IFDEF(CONFIG_ITRACE, char logbuf[CONFIG_ITRACE_BUFFER][128]); +IFDEF(CONFIG_ITRACE, int logbuf_rear); + +#ifdef CONFIG_ITRACE +void log_itrace_print() { + puts("ITRACE buffer:"); + for (int i = (logbuf_rear + 1) % CONFIG_ITRACE_BUFFER; i != logbuf_rear; i = (i + 1) % CONFIG_ITRACE_BUFFER) { + if (logbuf[i][0] == '\0') continue; + puts(logbuf[i]); + } + puts("Current command:"); + puts(logbuf[logbuf_rear]); +} +#endif diff --git a/nemu/tests/Makefile b/nemu/tests/Makefile index 6804b41..2e8c784 100644 --- a/nemu/tests/Makefile +++ b/nemu/tests/Makefile @@ -7,3 +7,4 @@ $(OBJ_DIR)/%: %.c $(TEST_OBJS) app @$(CC) $(CFLAGS) -o $@.o -c $< @echo + LD $@ @$(LD) $(LIBS) $(LDFLAGS) -o $@ $(TEST_OBJS) $@.o + @$@ diff --git a/npc/core/build.sbt b/npc/core/build.sbt index 792a764..16f31f3 100644 --- a/npc/core/build.sbt +++ b/npc/core/build.sbt @@ -6,10 +6,11 @@ val chiselVersion = "5.1.0" lazy val root = (project in file(".")) .settings( - name := "ChiselLearning", + name := "flow", libraryDependencies ++= Seq( "org.chipsalliance" %% "chisel" % chiselVersion, - "edu.berkeley.cs" %% "chiseltest" % "5.0.2" % "test" + "edu.berkeley.cs" %% "chiseltest" % "5.0.2" % "test", + "com.chuusai" %% "shapeless" % "2.3.3" ), scalacOptions ++= Seq( "-language:reflectiveCalls", diff --git a/npc/core/src/main/scala/Main.scala b/npc/core/src/main/scala/Main.scala index c06bc8e..95b9e61 100644 --- a/npc/core/src/main/scala/Main.scala +++ b/npc/core/src/main/scala/Main.scala @@ -2,8 +2,10 @@ package npc import chisel3._ import chisel3.util.{MuxLookup, Fill, Decoupled, Counter, Queue, Reverse} +import chisel3.util.{SRAM} import chisel3.stage.ChiselOption -import npc.util.KeyboardSegController +import npc.util.{ KeyboardSegController, RegisterFile } +import flowpc.components.ProgramCounter class Switch extends Module { val io = IO(new Bundle { @@ -31,3 +33,12 @@ class Keyboard extends Module { io.segs := seg_handler.io.segs } +<<<<<<< Updated upstream +======= +class Flowpc extends Module { + val io = IO(new Bundle { }) + val register_file = new RegisterFile(readPorts = 2); + val pc = new ProgramCounter(32); + val adder = new SRAM() +} +>>>>>>> Stashed changes diff --git a/npc/core/src/main/scala/ProgramCounter.scala b/npc/core/src/main/scala/ProgramCounter.scala new file mode 100644 index 0000000..0687f9a --- /dev/null +++ b/npc/core/src/main/scala/ProgramCounter.scala @@ -0,0 +1,11 @@ +package flowpc.components +import chisel3._ +import chisel3.util.{Valid} + +class ProgramCounter (width: Int) extends Module { + val io = new Bundle { + val next_pc = Input(Flipped(Valid(UInt(width.W)))) + val pc = Output(UInt(width.W)) + } + io.pc := Mux(io.next_pc.valid, io.next_pc.bits, io.pc) +} diff --git a/npc/core/src/main/scala/RegisterFile.scala b/npc/core/src/main/scala/RegisterFile.scala index fbf8a94..a6c5a62 100644 --- a/npc/core/src/main/scala/RegisterFile.scala +++ b/npc/core/src/main/scala/RegisterFile.scala @@ -1,25 +1,73 @@ -package npc.util +package flowpc.components import chisel3._ +import chisel3.util.log2Ceil +import chisel3.util.UIntToOH +import chisel3.util.MuxLookup -class RegisterFile(readPorts: Int) extends Module { - require(readPorts >= 0) - val io = IO(new Bundle { - val writeEnable = Input(Bool()) - val writeAddr = Input(UInt(5.W)) - val writeData = Input(UInt(32.W)) - val readAddr = Input(Vec(readPorts, UInt(5.W))) - val readData = Output(Vec(readPorts, UInt(32.W))) - }) +class RegControl extends Bundle { + val writeEnable = Input(Bool()) - val regFile = RegInit(VecInit(Seq.fill(32)(0.U(32.W)))) - for (i <- 1 until 32) { - regFile(i) := regFile(i) + object WriteSelect extends ChiselEnum { + val rAluOut, rMemOut = Value + } + val writeSelect = Input(WriteSelect()) +} + +class RegFileData[T <: Data](size:Int, tpe: T, numReadPorts: Int, numWritePorts: Int) extends Bundle { + val write = new Bundle { + val addr = Input(UInt(size.W)) + val data = Vec(numWritePorts, Input(tpe)) + } + val read = Vec(numReadPorts, new Bundle { + val rs = Input(UInt(size.W)) + val src = Output(tpe) + }) +} + +class RegFileInterface[T <: Data](size: Int, tpe: T, numReadPorts: Int, numWritePorts: Int) extends Bundle { + val control = new RegControl + val data = new RegFileData(size, tpe, numReadPorts, numWritePorts) +} + +class RegisterFileCore[T <: Data](size: Int, tpe: T, numReadPorts: Int) extends Module { + require(numReadPorts >= 0) + val writePort = IO(new Bundle { + val enable = Input(Bool()) + val addr = Input(UInt(log2Ceil(size).W)) + val data = Input(tpe) + }) + val readPorts = IO(Vec(numReadPorts, new Bundle { + val addr = Input(UInt(log2Ceil(size).W)) + val data = Output(tpe) + })) + + val regFile = RegInit(VecInit(Seq.fill(size)(0.U(tpe.getWidth.W)))) + val writeAddrOH = UIntToOH(writePort.addr) + for ((reg, i) <- regFile.zipWithIndex.tail) { + reg := Mux(writeAddrOH(i) && writePort.enable, writePort.data, reg) } - regFile(io.writeAddr) := Mux(io.writeEnable, io.writeData, regFile(io.writeAddr)) regFile(0) := 0.U - for (i <- 0 until readPorts) { - io.readData(i) := regFile(io.readAddr(i)) + for (readPort <- readPorts) { + readPort.data := regFile(readPort.addr) + } +} + +object RegisterFile { + def apply[T <: Data](size: Int, tpe: T, numReadPorts: Int, numWritePorts: Int): RegFileInterface[T] = { + val core = Module(new RegisterFileCore(size, tpe, numReadPorts)) + val _out = Wire(new RegFileInterface(size, tpe, numReadPorts, numWritePorts)) + val clock = core.clock + for (i <- 0 until numReadPorts) { + core.readPorts(i).addr := _out.data.read(i).rs + _out.data.read(i).src := core.readPorts(i).data + } + core.writePort.addr := _out.data.write.addr + core.writePort.data := MuxLookup(_out.control.writeSelect, 0.U)( + _out.control.WriteSelect.all.map(x => (x -> _out.data.write.data(x.asUInt).asUInt)) + ) + core.writePort.enable := _out.control.writeEnable + _out } } diff --git a/npc/core/src/test/scala/RegisterFile.scala b/npc/core/src/test/scala/RegisterFile.scala new file mode 100644 index 0000000..87be171 --- /dev/null +++ b/npc/core/src/test/scala/RegisterFile.scala @@ -0,0 +1,63 @@ +package flowpc + +import chisel3._ +import chiseltest._ +import org.scalatest.freespec.AnyFreeSpec +import chiseltest.simulator.WriteVcdAnnotation + +import flowpc.components._ +class RegisterFileSpec extends AnyFreeSpec with ChiselScalatestTester { + "RegisterFileCore" - { + "register 0 is always 0" in { + test(new RegisterFileCore(32, UInt(32.W), 2)) { c => + c.readPorts(0).addr.poke(0) + c.readPorts(1).addr.poke(0) + c.writePort.enable.poke(true) + c.writePort.addr.poke(0) + c.writePort.data.poke(0x1234) + + c.readPorts(0).data.expect(0) + c.readPorts(1).data.expect(0) + c.clock.step(2) + c.readPorts(0).data.expect(0) + c.readPorts(1).data.expect(0) + } + } + "register other than 0 can be written" in { + test(new RegisterFileCore(32, UInt(32.W), 2)) { c => + import scala.util.Random + val r = new Random() + for (i <- 1 until 32) { + val v = r.nextLong() & 0xFFFFFFFFL + c.readPorts(0).addr.poke(i) + c.writePort.enable.poke(true) + c.writePort.addr.poke(i) + c.writePort.data.poke(v) + + c.clock.step(1) + c.readPorts(0).data.expect(v) + } + } + } + } + "RegisterInterface" - { + "worked" in { + class Top extends Module { + val io = IO(new RegFileInterface(32, UInt(32.W), 2, 2)) + val rf = RegisterFile(32, UInt(32.W), 2, 2) + io :<>= rf + } + test(new Top).withAnnotations(Seq(WriteVcdAnnotation)) { c => + import c.io.control.WriteSelect._ + val writePort = rAluOut.litValue.toInt + c.io.control.writeEnable.poke(true) + c.io.control.writeSelect.poke(rAluOut) + c.io.data.write.addr.poke(5) + c.io.data.write.data(writePort).poke(0xcdef) + c.io.data.read(0).rs.poke(5) + c.clock.step(1) + c.io.data.read(0).src.expect(0xcdef) + } + } + } +}